ollama 로 qwen3-coder:30b 를 쓰면.
제법 코드다운 코드를 알려줍니다.
창조 도움말 전부 문서화해서 떤져주고 학습하라 합니다.
학습이 저장되지는 않아서 매번 같은 작업을 반복해야되지만.
미리 문서화 해두면 뭐..
그리고 그거 안해도 제법 합니다..
결론은 처참하게 결과를 도출 하지는 못하였지만 AI 와 대화 내용입니다.
파일열기("test.bin", "읽기");
문자열: 파일데이터 = 파일읽기();
파일닫기();
// 16진수 문자열을 바이너리로 변환
배열생성(바이너리데이터);
반복(0, 문자열길이(파일데이터), 2) {
문자열: 두문자 = 문자열자르기(파일데이터, i, 2);
정수: 값 = 16진수변환(두문자);
배열추가(바이너리데이터, 값);
}
// 바이너리 데이터 출력
반복(0, 배열크기(바이너리데이터)) {
출력(배열접근(바이너리데이터, i));
}
기본 문법을 본건지는 모르겠지만.
니가 제공한 소스코드를 내가 쓰는 언어의 코드로 굳이 바꿔보자면.
실수:파일핸들;
파일핸들:=파일열기("test.bin",ㅍㅇ읽기+ㅍㅇ쓰기금지);
문자:바이너리데이터,두문자,이진데이터,정수;
이진데이터:=파일이진읽어(파일핸들,1024);
반복 {
두문자:=문자복사(이진데이터,0,2);
이진데이터:=문자삭제(이진데이터,0,2);
정수:=16진을바이너리로(두문자);//함수로 16진수를 이진수(바이너리)로 변환 하는 코드를 작성해야됨)
바이너리데이터:=바이너리데이터+정수;
}까지(문자길이(이진데이터)=0);
이후 출력..
edit
실수:파일핸들;
파일핸들:=파일열기("test.bin",ㅍㅇ읽기+ㅍㅇ쓰기금지);
문자:바이너리데이터,두문자,이진데이터,정수;
이진데이터:=파일이진읽어(파일핸들,1024);
반복 {
두문자:=문자복사(이진데이터,0,2);
이진데이터:=문자삭제(이진데이터,0,2);
정수:=16진수를바이너리로(두문자);
바이너리데이터:=바이너리데이터+정수;
}까지(문자길이(이진데이터)=0);
파일닫기(파일핸들);
// 16진수를 바이너리로 변환하는 함수
함수 정수:16진수를바이너리로(문자:hex_string) {
정수:결과=0;
반복(0,문자길이(hex_string)) {
문자:문자값=문자접근(hex_string,i);
정수:숫자값=0;
만일(문자값>='0' && 문자값<='9') {
숫자값=문자값-'0';
} 아니면 {
숫자값=문자값-'A'+10;
}
결과=결과*16+숫자값;
}
반환(결과);
}
// 최종 출력
반복(0,문자길이(바이너리데이터)) {
출력(문자접근(바이너리데이터,i));
}
반복문을 보여줬음에도 맞지도 않은 반복문을 쓰고있고. 문자접근이란 명령어는 없는데 저건 도대체 무엇을 하기 위한 명령어였을까 ? 그리고 결과가 않나왔는데 왜 결과에 16을 곱하면 0이지..
edit
실수:파일핸들;
파일핸들:=파일열기("test.bin",ㅍㅇ읽기+ㅍㅇ쓰기금지);
문자:바이너리데이터,두문자,이진데이터,정수;
이진데이터:=파일이진읽어(파일핸들,1024);
반복 {
두문자:=문자복사(이진데이터,0,2);
이진데이터:=문자삭제(이진데이터,0,2);
정수:=16진수를바이너리로(두문자);
바이너리데이터:=바이너리데이터+정수;
}까지(문자길이(이진데이터)=0);
파일닫기(파일핸들);
// 16진수를 10진수로 변환하는 함수
함수 정수:16진수를바이너리로(문자:hex_string) {
정수:결과=0;
반복(0,문자길이(hex_string)) {
문자:문자값=문자접근(hex_string,i);
정수:숫자값=0;
만일(문자값>='0' && 문자값<='9') {
숫자값=문자값-'0';
} 아니면 {
숫자값=문자값-'A'+10;
}
결과=결과*16+숫자값;
}
반환(결과);
}
// 최종 출력
반복(0,문자길이(바이너리데이터)) {
출력(문자접근(바이너리데이터,i));
}
반복 { 반복내용 } 까지(반복문을 멈추기 위한 조건); 코드를 보여줬는데 왜 반복(0,명령어) 이런식으로 창조를 하지 ?
edit
실수:파일핸들;
파일핸들:=파일열기("test.bin",ㅍㅇ읽기+ㅍㅇ쓰기금지);
문자:바이너리데이터,두문자,이진데이터,정수;
이진데이터:=파일이진읽어(파일핸들,1024);
반복 {
만일(문자길이(이진데이터)=0) {
반복중단;
}
두문자:=문자복사(이진데이터,0,2);
이진데이터:=문자삭제(이진데이터,0,2);
정수:=16진수를바이너리로(두문자);
바이너리데이터:=바이너리데이터+정수;
}까지(문자길이(이진데이터)=0);
파일닫기(파일핸들);
// 16진수를 10진수로 변환하는 함수
함수 정수:16진수를바이너리로(문자:hex_string) {
정수:결과=0;
반복(0,문자길이(hex_string)) {
문자:문자값=문자접근(hex_string,i);
정수:숫자값=0;
만일(문자값>='0' && 문자값<='9') {
숫자값=문자값-'0';
} 아니면 {
숫자값=문자값-'A'+10;
}
결과=결과*16+숫자값;
}
반환(결과);
}
// 최종 출력
반복(0,문자길이(바이너리데이터)) {
출력(문자접근(바이너리데이터,i));
}
내가 올렸던 코드는 정상이고 아래 16진수 코드에 반복문이 잘못되었다고.
edit
실수:파일핸들;
파일핸들:=파일열기("test.bin",ㅍㅇ읽기+ㅍㅇ쓰기금지);
문자:바이너리데이터,두문자,이진데이터,정수;
이진데이터:=파일이진읽어(파일핸들,1024);
반복 {
만일(문자길이(이진데이터)=0) {
반복중단;
}
두문자:=문자복사(이진데이터,0,2);
이진데이터:=문자삭제(이진데이터,0,2);
정수:=16진수를바이너리로(두문자);
바이너리데이터:=바이너리데이터+정수;
}까지(문자길이(이진데이터)=0);
파일닫기(파일핸들);
// 16진수를 10진수로 변환하는 함수
함수 정수:16진수를바이너리로(문자:hex_string) {
정수:결과=0;
반복(0,문자길이(hex_string)) {
문자:문자값=문자접근(hex_string,i);
정수:숫자값=0;
만일(문자값>='0' && 문자값<='9') {
숫자값=문자값-'0';
} 아니면 {
숫자값=문자값-'A'+10;
}
결과=결과*16+숫자값;
}
반환(결과);
}
// 최종 출력
반복(0,문자길이(바이너리데이터)) {
출력(문자접근(바이너리데이터,i));
}
틀렸다는데 계속 똑같이 쓰네 ?
edit
실수:파일핸들;
파일핸들:=파일열기("test.bin",ㅍㅇ읽기+ㅍㅇ쓰기금지);
문자:바이너리데이터,두문자,이진데이터,정수;
이진데이터:=파일이진읽어(파일핸들,1024);
반복 {
만일(문자길이(이진데이터)=0) {
반복중단;
}
두문자:=문자복사(이진데이터,0,2);
이진데이터:=문자삭제(이진데이터,0,2);
정수:=16진수를바이너리로(두문자);
바이너리데이터:=바이너리데이터+정수;
}까지(문자길이(이진데이터)=0);
파일닫기(파일핸들);
// 16진수를 10진수로 변환하는 함수
함수 정수:16진수를바이너리로(문자:hex_string) {
정수:결과=0;
반복(0,문자길이(hex_string)) {
문자:문자값=문자접근(hex_string,i);
정수:숫자값=0;
만일(문자값>='0' && 문자값<='9') {
숫자값=문자값-'0';
} 아니면 {
숫자값=문자값-'A'+10;
}
결과=결과*16+숫자값;
}
반환(결과);
}
// 최종 출력
반복(0,문자길이(바이너리데이터)) {
출력(문자접근(바이너리데이터,i));
}
죄송합니다. 위 코드에서 반복문 구조가 잘못되었습니다. 정확한 구조는 다음과 같습니다:
반복 {
// 반복 내용
}까지(조건);
하지만 이 언어에서는 반복문이 반복(시작,종료,증감) 형식으로 되어 있는 것 같습니다. 따라서:
반복(0,문자길이(이진데이터),1) {
// 반복 내용
}
4. 반복문
반복문은 두가지가 존재한다.
1. 조건검사를 먼저하고 문자을 실행하는 방법(되풀이)
2. 한문장을 미리 실행해보고 조건을 검사하는 방법(반복 .. 까지)
3. 반복..까지명령어는 반드시 한번은 실행된다.
4. 반복 도중에 빠져나오고 싶다면 '그쳐'를 사용한다.(다른 언어에서의 'break'기능이다)
5. 반복 도중에 다시 반복문 처음으로 돌아가서 실행하고 싶다면 '다시'를 사용한다.(다른 언어에서의 'continue'기능이다)
되풀이 기본형:('식1'조건에 만족하는 동안 되풀이)
되풀이(식1)
명령문자....
반복..까지 기본형:('식1'조건이 만족될때까지 반복)
반복
명령문자...
까지(식1);
되풀이예제:(1에서 10까지 더하는 예제)
실수: 수, 합;
수 := 1;
합 := 0;
되풀이(수 < 11)
{
합 := 합 + 수;
수 := 수 + 1;
}
문자창보여(수를문(합));
되풀이예제설명:
실수: 수, 합;//실수형 자료로 '수', '합'을 만든다.
수 := 1;//'수'에 1을 저장한다.
합 := 0;//'합'에 0을 저장한다.
되풀이(수 < 11)//'수'가 11보다 작다면 되풀이하라
{
합 := 합 + 수;//'합'에 '수'를 더하여 '합'에 저장한다.
수 := 수 + 1;//'수'에 1를 더하여 '수'에 저장한다.
}
문자창보여(수를문(합));
반복예제:(1에서 10까지 더하는 예제)
실수: 수, 합;
수 := 1;
합 := 0;
반복
{
합 := 합 + 수;
수 := 수 + 1;
}까지(수 > 10);
문자창보여(수를문(합));//합을 문자형으로 변경한 후 문자창에 보인다.
반복예제설명:
실수: 수, 합;//실수형 자료로 '수', '합'을 만든다.
수 := 1;//'수'에 1을 저장한다.
합 := 0;//'합'에 0을 저장한다.
반복//반복명령의 시작
{
합 := 합 + 수;//'합'에 '수'를 더하여 '합'에 저장한다.
수 := 수 + 1;//'수'에 1를 더하여 '수'에 저장한다.
}까지(수 > 10);//'수'가 10보다 클때까지 반복하라.
문자창보여(수를문(합));
edit
실수:파일핸들;
파일핸들:=파일열기("test.bin",ㅍㅇ읽기+ㅍㅇ쓰기금지);
문자:바이너리데이터,두문자,이진데이터,정수;
이진데이터:=파일이진읽어(파일핸들,1024);
반복
{
만일(문자길이(이진데이터)=0) {
그쳐;
}
두문자:=문자복사(이진데이터,0,2);
이진데이터:=문자삭제(이진데이터,0,2);
정수:=16진수를바이너리로(두문자);
바이너리데이터:=바이너리데이터+정수;
}까지(문자길이(이진데이터)=0);
파일닫기(파일핸들);
// 16진수를 10진수로 변환하는 함수
함수 정수:16진수를바이너리로(문자:hex_string) {
정수:결과=0;
반복(0,문자길이(hex_string)) {
문자:문자값=문자접근(hex_string,i);
정수:숫자값=0;
만일(문자값>='0' && 문자값<='9') {
숫자값=문자값-'0';
} 아니면 {
숫자값=문자값-'A'+10;
}
결과=결과*16+숫자값;
}
반환(결과);
}
// 최종 출력
반복(0,문자길이(바이너리데이터)) {
출력(문자접근(바이너리데이터,i));
}
반복(0,문자길이(hex_string)) { 이부분 잘못되었다고
edit
실수:파일핸들;
파일핸들:=파일열기("test.bin",ㅍㅇ읽기+ㅍㅇ쓰기금지);
문자:바이너리데이터,두문자,이진데이터,정수;
이진데이터:=파일이진읽어(파일핸들,1024);
반복
{
만일(문자길이(이진데이터)=0) {
그쳐;
}
두문자:=문자복사(이진데이터,0,2);
이진데이터:=문자삭제(이진데이터,0,2);
정수:=16진수를바이너리로(두문자);
바이너리데이터:=바이너리데이터+정수;
}까지(문자길이(이진데이터)=0);
파일닫기(파일핸들);
// 16진수를 10진수로 변환하는 함수
함수 정수:16진수를바이너리로(문자:hex_string) {
정수:결과=0;
실수:인덱스;
되풀이(인덱스 < 문자길이(hex_string))
{
문자:문자값=문자접근(hex_string,인덱스);
정수:숫자값=0;
만일(문자값>='0' && 문자값<='9') {
숫자값=문자값-'0';
} 아니면 {
숫자값=문자값-'A'+10;
}
결과=결과*16+숫자값;
인덱스:=인덱스+1;
}
반환(결과);
}
// 최종 출력
반복(0,문자길이(바이너리데이터)) {
출력(문자접근(바이너리데이터,인덱스));
}
반복(0,문자길이(바이너리데이터)) { 이것도
edit
실수:파일핸들;
파일핸들:=파일열기("test.bin",ㅍㅇ읽기+ㅍㅇ쓰기금지);
문자:바이너리데이터,두문자,이진데이터,정수;
이진데이터:=파일이진읽어(파일핸들,1024);
반복
{
만일(문자길이(이진데이터)=0) {
그쳐;
}
두문자:=문자복사(이진데이터,0,2);
이진데이터:=문자삭제(이진데이터,0,2);
정수:=16진수를바이너리로(두문자);
바이너리데이터:=바이너리데이터+정수;
}까지(문자길이(이진데이터)=0);
파일닫기(파일핸들);
// 16진수를 10진수로 변환하는 함수
함수 정수:16진수를바이너리로(문자:hex_string) {
정수:결과=0;
실수:인덱스;
되풀이(인덱스 < 문자길이(hex_string))
{
문자:문자값=문자접근(hex_string,인덱스);
정수:숫자값=0;
만일(문자값>='0' && 문자값<='9') {
숫자값=문자값-'0';
} 아니면 {
숫자값=문자값-'A'+10;
}
결과=결과*16+숫자값;
인덱스:=인덱스+1;
}
반환(결과);
}
// 최종 출력
실수:출력인덱스;
되풀이(출력인덱스 < 문자길이(바이너리데이터))
{
출력(문자접근(바이너리데이터,출력인덱스));
출력인덱스:=출력인덱스+1;
}
문자접근이라는 명령어는 없어 니가 생각하는 저 명령의 목적은 뭐야 ?
edit
실수:파일핸들;
파일핸들:=파일열기("test.bin",ㅍㅇ읽기+ㅍㅇ쓰기금지);
문자:바이너리데이터,두문자,이진데이터,정수;
이진데이터:=파일이진읽기(파일핸들,1024);
반복
{
만일(문자길이(이진데이터)=0) {
그쳐;
}
두문자:=문자자르기(이진데이터,0,2);
이진데이터:=문자자르기(이진데이터,2,문자길이(이진데이터));
정수:=16진수변환(두문자);
바이너리데이터:=바이너리데이터+정수;
}까지(문자길이(이진데이터)=0);
파일닫기(파일핸들);
// 16진수를 10진수로 변환하는 함수
함수 정수:16진수변환(문자:hex_string) {
정수:결과=0;
실수:인덱스;
되풀이(인덱스 < 문자길이(hex_string))
{
문자:문자값=문자자르기(hex_string,인덱스,1);
정수:숫자값=0;
만일(문자값>='0' && 문자값<='9') {
숫자값=문자값-'0';
} 아니면 {
숫자값=문자값-'A'+10;
}
결과=결과*16+숫자값;
인덱스:=인덱스+1;
}
반환(결과);
}
// 최종 출력
실수:출력인덱스;
되풀이(출력인덱스 < 문자길이(바이너리데이터))
{
출력(문자자르기(바이너리데이터,출력인덱스,1));
출력인덱스:=출력인덱스+1;
}
문자자르기도 없어 복사 한후에 통상 문자삭제로 지워줘야됨.
edit
실수:파일핸들;
파일핸들:=파일열기("test.bin",ㅍㅇ읽기+ㅍㅇ쓰기금지);
문자:바이너리데이터,두문자,이진데이터,정수;
이진데이터:=파일읽기(파일핸들,1024);
반복
{
만일(문자길이(이진데이터)=0) {
그쳐;
}
두문자:=문자복사(이진데이터,0,2);
이진데이터:=문자삭제(이진데이터,0,2);
정수:=16진수변환(두문자);
바이너리데이터:=바이너리데이터+정수;
}까지(문자길이(이진데이터)=0);
파일닫기(파일핸들);
// 16진수를 10진수로 변환하는 함수
함수 정수:16진수변환(문자:hex_string) {
정수:결과=0;
실수:인덱스;
되풀이(인덱스 < 문자길이(hex_string))
{
문자:문자값=문자복사(hex_string,인덱스,1);
정수:숫자값=0;
만일(문자값>='0' && 문자값<='9') {
숫자값=문자값-'0';
} 아니면 {
숫자값=문자값-'A'+10;
}
결과=결과*16+숫자값;
인덱스:=인덱스+1;
}
반환(결과);
}
// 최종 출력
실수:출력인덱스;
되풀이(출력인덱스 < 문자길이(바이너리데이터))
{
출력(문자복사(바이너리데이터,출력인덱스,1));
출력인덱스:=출력인덱스+1;
}
문자:문자값=문자복사(hex_string,인덱스,1); 이부분도 문자:문자값; 이렇게 닫고 따로 문자값:=문자복사(어쩌구) 이렇게 해야됨.
edit
실수:파일핸들;
파일핸들:=파일열기("test.bin",ㅍㅇ읽기+ㅍㅇ쓰기금지);
문자:바이너리데이터,두문자,이진데이터,정수;
이진데이터:=파일읽기(파일핸들,1024);
반복
{
만일(문자길이(이진데이터)=0) {
그쳐;
}
두문자:=문자복사(이진데이터,0,2);
이진데이터:=문자삭제(이진데이터,0,2);
정수:=16진수변환(두문자);
바이너리데이터:=바이너리데이터+정수;
}까지(문자길이(이진데이터)=0);
파일닫기(파일핸들);
// 16진수를 10진수로 변환하는 함수
함수 정수:16진수변환(문자:hex_string) {
정수:결과=0;
실수:인덱스;
되풀이(인덱스 < 문자길이(hex_string))
{
문자:문자값;
문자값:=문자복사(hex_string,인덱스,1);
정수:숫자값=0;
만일(문자값>='0' && 문자값<='9') {
숫자값=문자값-'0';
} 아니면 {
숫자값=문자값-'A'+10;
}
결과=결과*16+숫자값;
인덱스:=인덱스+1;
}
반환(결과);
}
// 최종 출력
실수:출력인덱스;
되풀이(출력인덱스 < 문자길이(바이너리데이터))
{
출력(문자복사(바이너리데이터,출력인덱스,1));
출력인덱스:=출력인덱스+1;
}
숫자값=문자값-'0'; 이건 문자값에서 0을 지우라는거야 ?
edit
아닙니다. '0'은 ASCII 코드 값이 48인 문자입니다.
문자값-'0'은 문자를 숫자로 변환하는 방법입니다.
예를 들어:
문자 '5'의 ASCII 코드는 53입니다
'5' - '0' = 53 - 48 = 5
즉, 문자 '5'를 숫자 5로 변환하는 것입니다.
실수:파일핸들;
파일핸들:=파일열기("test.bin",ㅍㅇ읽기+ㅍㅇ쓰기금지);
문자:바이너리데이터,두문자,이진데이터,정수;
이진데이터:=파일읽기(파일핸들,1024);
반복
{
만일(문자길이(이진데이터)=0) {
그쳐;
}
두문자:=문자복사(이진데이터,0,2);
이진데이터:=문자삭제(이진데이터,0,2);
정수:=16진수변환(두문자);
바이너리데이터:=바이너리데이터+정수;
}까지(문자길이(이진데이터)=0);
파일닫기(파일핸들);
// 16진수를 10진수로 변환하는 함수
함수 정수:16진수변환(문자:hex_string) {
정수:결과=0;
실수:인덱스;
되풀이(인덱스 < 문자길이(hex_string))
{
문자:문자값;
문자값:=문자복사(hex_string,인덱스,1);
정수:숫자값=0;
만일(문자값>='0' && 문자값<='9') {
숫자값=문자값-'0';
} 아니면 {
숫자값=문자값-'A'+10;
}
결과=결과*16+숫자값;
인덱스:=인덱스+1;
}
반환(결과);
}
// 최종 출력
실수:출력인덱스;
되풀이(출력인덱스 < 문자길이(바이너리데이터))
{
출력(문자복사(바이너리데이터,출력인덱스,1));
출력인덱스:=출력인덱스+1;
}
문자의 코드 값은 문수(문자값) 하면 나올껀데.
edit
맞습니다. 문자값은 문자의 ASCII 코드 값을 반환합니다.
그래서 '5' - '0'는 '5'의 ASCII 코드 값 53에서 '0'의 ASCII 코드 값 48을 빼서 5가 되는 것입니다.
실수:파일핸들;
파일핸들:=파일열기("test.bin",ㅍㅇ읽기+ㅍㅇ쓰기금지);
문자:바이너리데이터,두문자,이진데이터,정수;
이진데이터:=파일읽기(파일핸들,1024);
반복
{
만일(문자길이(이진데이터)=0) {
그쳐;
}
두문자:=문자복사(이진데이터,0,2);
이진데이터:=문자삭제(이진데이터,0,2);
정수:=16진수변환(두문자);
바이너리데이터:=바이너리데이터+정수;
}까지(문자길이(이진데이터)=0);
파일닫기(파일핸들);
// 16진수를 10진수로 변환하는 함수
함수 정수:16진수변환(문자:hex_string) {
정수:결과=0;
실수:인덱스;
되풀이(인덱스 < 문자길이(hex_string))
{
문자:문자값;
문자값:=문자복사(hex_string,인덱스,1);
정수:숫자값=0;
만일(문자값>='0' && 문자값<='9') {
숫자값=문자값-'0';
} 아니면 {
숫자값=문자값-'A'+10;
}
결과=결과*16+숫자값;
인덱스:=인덱스+1;
}
반환(결과);
}
// 최종 출력
실수:출력인덱스;
되풀이(출력인덱스 < 문자길이(바이너리데이터))
{
출력(문자복사(바이너리데이터,출력인덱스,1));
출력인덱스:=출력인덱스+1;
}
정수는 없고 문자랑 실수만 있는데 문자값에서 숫자를 빼는건 오류남.
edit
아닙니다. 문자값-'0'은 문자의 ASCII 코드 값에서 '0'의 ASCII 코드 값을 빼는 연산입니다.
이게 오류가 난다면 해당 언어가 문자와 숫자의 연산을 지원하지 않는 것 같습니다.
실수:파일핸들;
파일핸들:=파일열기("test.bin",ㅍㅇ읽기+ㅍㅇ쓰기금지);
문자:바이너리데이터,두문자,이진데이터,정수;
이진데이터:=파일읽기(파일핸들,1024);
반복
{
만일(문자길이(이진데이터)=0) {
그쳐;
}
두문자:=문자복사(이진데이터,0,2);
이진데이터:=문자삭제(이진데이터,0,2);
정수:=16진수변환(두문자);
바이너리데이터:=바이너리데이터+정수;
}까지(문자길이(이진데이터)=0);
파일닫기(파일핸들);
// 16진수를 10진수로 변환하는 함수
함수 정수:16진수변환(문자:hex_string) {
정수:결과=0;
실수:인덱스;
되풀이(인덱스 < 문자길이(hex_string))
{
문자:문자값;
문자값:=문자복사(hex_string,인덱스,1);
정수:숫자값=0;
만일(문자값>='0' && 문자값<='9') {
숫자값=문수(문자값)-문수('0');
} 아니면 {
숫자값=문수(문자값)-문수('A')+10;
}
결과=결과*16+숫자값;
인덱스:=인덱스+1;
}
반환(결과);
}
// 최종 출력
실수:출력인덱스;
되풀이(출력인덱스 < 문자길이(바이너리데이터))
{
출력(문자복사(바이너리데이터,출력인덱스,1));
출력인덱스:=출력인덱스+1;
}
정수가 숫자면 정수로 선언할게 아니라 실수로 선언해야됨. 그리고 '0' 이렇게 하지 않고 "0" << 이건 문자열 가둘때 쓰고 숫자는 안씀.
edit
실수:파일핸들;
파일핸들:=파일열기("test.bin",ㅍㅇ읽기+ㅍㅇ쓰기금지);
문자:바이너리데이터,두문자,이진데이터;
이진데이터:=파일읽기(파일핸들,1024);
반복
{
만일(문자길이(이진데이터)=0) {
그쳐;
}
두문자:=문자복사(이진데이터,0,2);
이진데이터:=문자삭제(이진데이터,0,2);
실수:정수값;
정수값:=16진수변환(두문자);
바이너리데이터:=바이너리데이터+정수값;
}까지(문자길이(이진데이터)=0);
파일닫기(파일핸들);
// 16진수를 10진수로 변환하는 함수
함수 실수:16진수변환(문자:hex_string) {
실수:결과=0;
실수:인덱스=0;
되풀이(인덱스 < 문자길이(hex_string))
{
문자:문자값;
문자값:=문자복사(hex_string,인덱스,1);
실수:숫자값=0;
만일(문자값>='0' && 문자값<='9') {
숫자값=문수(문자값)-문수("0");
} 아니면 {
숫자값=문수(문자값)-문수("A")+10;
}
결과=결과*16+숫자값;
인덱스=인덱스+1;
}
반환(결과);
}
// 최종 출력
실수:출력인덱스=0;
되풀이(출력인덱스 < 문자길이(바이너리데이터))
{
출력(문자복사(바이너리데이터,출력인덱스,1));
출력인덱스=출력인덱스+1;
}
결과=결과*16+숫자값; 이거 처음에 결과를 0 으로 선언했는데 0에다가 *16을 곱하는게 의미가 있나 ?
edit
맞습니다. 처음에 결과를 0으로 선언했으니 0*16는 0이 되어서 의미가 없습니다.
첫 번째 자릿수는 그냥 숫자값을 더하면 됩니다.
실수:파일핸들;
파일핸들:=파일열기("test.bin",ㅍㅇ읽기+ㅍㅇ쓰기금지);
문자:바이너리데이터,두문자,이진데이터;
이진데이터:=파일읽기(파일핸들,1024);
반복
{
만일(문자길이(이진데이터)=0) {
그쳐;
}
두문자:=문자복사(이진데이터,0,2);
이진데이터:=문자삭제(이진데이터,0,2);
실수:정수값;
정수값:=16진수변환(두문자);
바이너리데이터:=바이너리데이터+정수값;
}까지(문자길이(이진데이터)=0);
파일닫기(파일핸들);
// 16진수를 10진수로 변환하는 함수
함수 실수:16진수변환(문자:hex_string) {
실수:결과=0;
실수:인덱스=0;
되풀이(인덱스 < 문자길이(hex_string))
{
문자:문자값;
문자값:=문자복사(hex_string,인덱스,1);
실수:숫자값=0;
만일(문자값>='0' && 문자값<='9') {
숫자값=문수(문자값)-문수("0");
} 아니면 {
숫자값=문수(문자값)-문수("A")+10;
}
// 첫 번째 자릿수는 곱하지 않고 더함
만일(인덱스==0) {
결과=숫자값;
} 아니면 {
결과=결과*16+숫자값;
}
인덱스=인덱스+1;
}
반환(결과);
}
// 최종 출력
실수:출력인덱스=0;
되풀이(출력인덱스 < 문자길이(바이너리데이터))
{
출력(문자복사(바이너리데이터,출력인덱스,1));
출력인덱스=출력인덱스+1;
}
올바르게 수정해봤는데 결과는 000000000000000000000000000000000000000 이렇게만 표현됨.
edit
문제가 있는 부분을 찾아보겠습니다. 바이너리데이터에 정수를 문자열로 추가하는 방식이 잘못된 것 같습니다.
실수:파일핸들;
파일핸들:=파일열기("test.bin",ㅍㅇ읽기+ㅍㅇ쓰기금지);
문자:바이너리데이터,두문자,이진데이터;
이진데이터:=파일읽기(파일핸들,1024);
반복
{
만일(문자길이(이진데이터)=0) {
그쳐;
}
두문자:=문자복사(이진데이터,0,2);
이진데이터:=문자삭제(이진데이터,0,2);
실수:정수값;
정수값:=16진수변환(두문자);
바이너리데이터:=바이너리데이터+정수값; // 이 부분이 문제
}까지(문자길이(이진데이터)=0);
파일닫기(파일핸들);
// 16진수를 10진수로 변환하는 함수
함수 실수:16진수변환(문자:hex_string) {
실수:결과=0;
실수:인덱스=0;
되풀이(인덱스 < 문자길이(hex_string))
{
문자:문자값;
문자값:=문자복사(hex_string,인덱스,1);
실수:숫자값=0;
만일(문자값>="0" && 문자값<="9") {
숫자값=문수(문자값)-문수("0");
} 아니면 {
숫자값=문수(문자값)-문수("A")+10;
}
// 첫 번째 자릿수는 곱하지 않고 더함
만일(인덱스==0) {
결과=숫자값;
} 아니면 {
결과=결과*16+숫자값;
}
인덱스=인덱스+1;
}
반환(결과);
}
// 최종 출력
실수:출력인덱스=0;
되풀이(출력인덱스 < 문자길이(바이너리데이터))
{
출력(문자복사(바이너리데이터,출력인덱스,1));
출력인덱스=출력인덱스+1;
}
실수:인덱스;
문자:문자값;
실수:숫자값,값;
값:=0;
되풀이(인덱스 < 문자길이(문))
{
문자값:=문자복사(문,인덱스,1);
숫자값:=0;
만일(문자값>="0" 그리고 문자값<="9") {
숫자값:=문수(문자값)-문수("0");
} 아니면 {
숫자값:=문수(문자값)-문수("A")+10;
}
만일(인덱스=0) {
값:=숫자값;
}
아니면 {
값:=(값*16)+숫자값;
}
인덱스:=인덱스+1;
}
결과:=값; 이렇게 수정했어.
edit
좋습니다! 이제 수정된 코드가 정상적으로 작동할 것 같습니다.
문자값>="0" 그리고 문자값<="9" 부분도 잘 적용하셨네요.
이전에는 && 연산자로 작성했지만, 언어에 따라 그리고로 작성하는 경우가 있어서 수정하신 것이 맞습니다.
함수 실수:16진수변환(문자:문) {
실수:인덱스;
문자:문자값;
실수:숫자값,값;
값:=0;
되풀이(인덱스 < 문자길이(문))
{
문자값:=문자복사(문,인덱스,1);
숫자값:=0;
만일(문자값>="0" 그리고 문자값<="9") {
숫자값:=문수(문자값)-문수("0");
} 아니면 {
숫자값:=문수(문자값)-문수("A")+10;
}
만일(인덱스=0) {
값:=숫자값;
} 아니면 {
값:=(값*16)+숫자값;
}
인덱스:=인덱스+1;
}
결과:=값;
반환(결과);
}
이제 16진수 문자열을 10진수로 정확히 변환할 수 있을 것입니다.
그런데 결과는 계속 0만 나옴..
edit
문자열 비교가 제대로 되지 않는 것 같습니다. 문자값>="0"这样的比较在某些语言中可能不工作。试试这样修改：
함수 실수:16진수변환(문자:문) {
실수:인덱스;
문자:문자값;
실수:숫자값,값;
값:=0;
되풀이(인덱스 < 문자길이(문))
{
문자값:=문자복사(문,인덱스,1);
숫자값:=0;
// 문자값이 '0'~'9' 사이인지 확인
만일(문수(문자값)>=문수("0") 그리고 문수(문자값)<=문수("9")) {
숫자값:=문수(문자값)-문수("0");
} 아니면 {
// 문자값이 'A'~'F' 사이인지 확인
만일(문수(문자값)>=문수("A") 그리고 문수(문자값)<=문수("F")) {
숫자값:=문수(문자값)-문수("A")+10;
} 아니면 {
// 'a'~'f'도 지원하는 경우
만일(문수(문자값)>=문수("a") 그리고 문수(문자값)<=문수("f")) {
숫자값:=문수(문자값)-문수("a")+10;
}
}
}
만일(인덱스=0) {
값:=숫자값;
} 아니면 {
값:=(값*16)+숫자값;
}
인덱스:=인덱스+1;
}
결과:=값;
반환(결과);
}
또는 더 간단하게:
함수 실수:16진수변환(문자:문) {
실수:인덱스;
문자:문자값;
실수:숫자값,값;
값:=0;
되풀이(인덱스 < 문자길이(문))
{
문자값:=문자복사(문,인덱스,1);
숫자값:=0;
// 직접 ASCII 값 비교
만일(문수(문자값)>=48 그리고 문수(문자값)<=57) { // '0'-'9'
숫자값:=문수(문자값)-48;
} 아니면 {
만일(문수(문자값)>=65 그리고 문수(문자값)<=70) { // 'A'-'F'
숫자값:=문수(문자값)-65+10;
} 아니면 {
만일(문수(문자값)>=97 그리고 문수(문자값)<=102) { // 'a'-'f'
숫자값:=문수(문자값)-97+10;
}
}
}
만일(인덱스=0) {
값:=숫자값;
} 아니면 {
값:=(값*16)+숫자값;
}
인덱스:=인덱스+1;
}
결과:=값;
반환(결과);
}
그럼에도 결과는 0만 나옴. 문자열을 숫자랑 비교할수 없어서 다음과 같이 수정함 실수:인덱스;
문자:문자값;
실수:숫자값,값;
값:=0;
되풀이(인덱스 < 문자길이(문))
{
문자값:=문자복사(문,인덱스,1);
숫자값:=0;
만일(문을수(문자값,0)>=문수("0") 그리고 문을수(문자값,0)<=문수("9")) {
숫자값:=문수(문자값)-문수("0");
} 아니면 {
숫자값:=문수(문자값)-문수("A")+10;
}
만일(인덱스=0) {
값:=숫자값;
}
아니면 {
값:=(값*16)+숫자값;
}
인덱스:=인덱스+1;
}
결과:=값;
edit
이 코드에서 문제가 있는 부분을 찾겠습니다. 문을수(문자값,0) 이런 문법은 일반적이지 않은 것 같습니다.
가장 간단한 해결 방법으로, 직접 문자를 비교하는 방식으로 수정해보세요:
함수 실수:16진수변환(문자:문) {
실수:인덱스;
문자:문자값;
실수:숫자값,값;
값:=0;
되풀이(인덱스 < 문자길이(문))
{
문자값:=문자복사(문,인덱스,1);
숫자값:=0;
// 문자값이 '0'~'9'인지 확인
만일(문자값="0" 또는 문자값="1" 또는 문자값="2" 또는 문자값="3" 또는 문자값="4"
또는 문자값="5" 또는 문자값="6" 또는 문자값="7" 또는 문자값="8" 또는 문자값="9") {
숫자값:=문수(문자값)-문수("0");
} 아니면 {
// 문자값이 'A'~'F'인지 확인
만일(문자값="A" 또는 문자값="B" 또는 문자값="C" 또는 문자값="D" 또는 문자값="E" 또는 문자값="F") {
숫자값:=문수(문자값)-문수("A")+10;
} 아니면 {
// 'a'~'f'인 경우
만일(문자값="a" 또는 문자값="b" 또는 문자값="c" 또는 문자값="d" 또는 문자값="e" 또는 문자값="f") {
숫자값:=문수(문자값)-문수("a")+10;
}
}
}
만일(인덱스=0) {
값:=숫자값;
} 아니면 {
값:=(값*16)+숫자값;
}
인덱스:=인덱스+1;
}
결과:=값;
반환(결과);
}
또는 더 간단하게:
함수 실수:16진수변환(문자:문) {
실수:인덱스;
문자:문자값;
실수:숫자값,값;
값:=0;
되풀이(인덱스 < 문자길이(문))
{
문자값:=문자복사(문,인덱스,1);
숫자값:=0;
// ASCII 값을 직접 비교
만일(문수(문자값)>=48 그리고 문수(문자값)<=57) { // '0'-'9'
숫자값:=문수(문자값)-48;
} 아니면 {
만일(문수(문자값)>=65 그리고 문수(문자값)<=70) { // 'A'-'F'
숫자값:=문수(문자값)-65+10;
} 아니면 {
만일(문수(문자값)>=97 그리고 문수(문자값)<=102) { // 'a'-'f'
숫자값:=문수(문자값)-97+10;
}
}
}
만일(인덱스=0) {
값:=숫자값;
} 아니면 {
값:=(값*16)+숫자값;
}
인덱스:=인덱스+1;
}
결과:=값;
반환(결과);
}
반대로 해도 결과는 0 임 실수:인덱스;
문자:문자값;
실수:숫자값,값;
값:=0;
되풀이(인덱스 < 문자길이(문))
{
문자값:=문자복사(문,인덱스,1);
숫자값:=0;
만일(문자값>=수를문(문수("0")) 그리고 문자값<=수를문(문수("9"))) {
숫자값:=문수(문자값)-문수("0");
} 아니면 {
숫자값:=문수(문자값)-문수("A")+10;
}
만일(인덱스=0) {
값:=숫자값;
}
아니면 {
값:=(값*16)+숫자값;
}
인덱스:=인덱스+1;
}
결과:=값;
edit
문제가 있는 것 같습니다. 수를문(문수("0"))这样的语法이 잘못된 것 같아요.
제가 가장 간단하고 확실한 방법으로 코드를 다시 작성해 드릴게요:
함수 실수:16진수변환(문자:문) {
실수:인덱스;
문자:문자값;
실수:숫자값,값;
값:=0;
되풀이(인덱스 < 문자길이(문))
{
문자값:=문자복사(문,인덱스,1);
숫자값:=0;
// '0'-'9' 확인
만일(문자값="0") {
숫자값:=0;
} 아니면 {
만일(문자값="1") {
숫자값:=1;
} 아니면 {
만일(문자값="2") {
숫자값:=2;
} 아니면 {
만일(문자값="3") {
숫자값:=3;
} 아니면 {
만일(문자값="4") {
숫자값:=4;
} 아니면 {
만일(문자값="5") {
숫자값:=5;
} 아니면 {
만일(문자값="6") {
숫자값:=6;
} 아니면 {
만일(문자값="7") {
숫자값:=7;
} 아니면 {
만일(문자값="8") {
숫자값:=8;
} 아니면 {
만일(문자값="9") {
숫자값:=9;
} 아니면 {
&nbs |
|
