도전

나는 최근 8 비트 컴퓨터에 들어갔고 그들과 다른 사람들의 작업에 매료되었다. 따라서이 코드 골프의 목표는 Steve Wozniak가 Apple I 용으로 디자인 한 Woz Monitor의 일부를 복제하는 것입니다.

너비가 2 바이트 (최소값 $ 10 , 최대 값 $ FF ) 인 22 개의 16 진 값 배열을 저장 한 다음 n 개의 입력량 을 가져 옵니다. (일반적으로 두 개; Brainfuck과 같은 언어는 어려움을 겪을 수 있습니다).
입력은 어레이에서 인쇄를 시작할 위치와 중지 할 위치를 나타냅니다. 동작 이 정의 된 입력 의 시작 값은 종료 값보다 작거나 같습니다. 그러면 프로그램은 입력 된 16 진수 사이 ( 포함)를 포함하여 모든 16 진수 값을 인쇄 할 수 있어야합니다 .

이것의 예 :

Array
00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F 10 11 12 13 14 15

Values
FF F4 B6 D7 40 00 00 A4 F0 00 FF 0D 9C 21 65 C4 02 28 90 E7 D6 A5

input first num:
04
input second num:
14
40 00 00 A4 F0 00 FF 0D 9C 21 65 C4 02 28 90 E7 D6

이제이 연습의 흥미로운 부분은 사용자 입력의 경계를 확인하려는 모든 것을 사용할 수 있다는 것입니다. 개인 입력 hello및 프로그램에 정의되지 않은 동작이 있습니까? 예고없이 종료 되나요? 둘 다 유효합니다.

유일한 규칙은 다음과 같습니다.

1. 프로그램을 시작하기 전에 22 16 진수 값을 프로그램의 일부로 포함시켜야합니다 (사용자에게 입력을 요청할 수 없음).
2. 16 진 값의 출력은 정확한 형식을 따라야합니다. 00 FF 00 FF 00후행 공백, 탭 또는 선은 정상입니다. 문자가 아닙니다.
3. 프로그램 은 메시지와 함께 입력을 요구할 필요 가 없습니다 . 원하는 경우 "메시지"를 비워 두십시오. 그러나 사용자는 16 진 경계를 입력해야합니다.
4. 22 개의 16 진수 값을 결정하는 것은 사용자가 결정하는 것이므로 단순히 값을 인쇄하여 프로그램 을 모방 하는 대신 저장소에서 값을 실제로 가져 오는 프로그램을 만들어야 합니다. (예 : $ 00 목록 ).
5. n-예. (Brainfuck은 16 진수마다 2 개의 입력이 필요하므로 2 개에 대해 4 개가됩니다). 입력의 수는 2 바이트 너비의 16 진수를 인식하기 위해 선택한 언어에 필요한 입력의 양을 나타냅니다.

설명이 필요하면 언제든지 의견을 말하십시오.

이것은 코드 골프이므로 바이트 수의 최단 답변이 승자입니다.

리더 보드

Martin Ender가 발췌 한 스 니펫을 생성 한 리더 보드 입니다.

답변이 표시되도록하려면 다음 마크 다운 템플릿을 사용하여 헤드 라인으로 답변을 시작하십시오.

# Language Name, N bytes

N제출물의 크기는 어디에 있습니까 ? 당신이 당신의 점수를 향상시킬 경우에, 당신은 할 수 있습니다 를 통해 눈에 띄는에 의해, 헤드 라인에 오래된 점수를 유지한다. 예를 들어 :

# Ruby, <s>104</s> <s>101</s> 96 bytes

function answersUrl(e){return"http://api.stackexchange.com/2.2/questions/95080/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function getAnswers(){$.ajax({url:answersUrl(page++),method:"get",dataType:"jsonp",crossDomain:true,success:function(e){answers.push.apply(answers,e.items);if(e.has_more)getAnswers();else process()}})}function shouldHaveHeading(e){var t=false;var n=e.body_markdown.split("\n");try{t|=/^#/.test(e.body_markdown);t|=["-","="].indexOf(n[1][0])>-1;t&=LANGUAGE_REG.test(e.body_markdown)}catch(r){}return t}function shouldHaveScore(e){var t=false;try{t|=SIZE_REG.test(e.body_markdown.split("\n")[0])}catch(n){}return t}function getAuthorName(e){return e.owner.display_name}function process(){answers=answers.filter(shouldHaveScore).filter(shouldHaveHeading);answers.sort(function(e,t){var n=+(e.body_markdown.split("\n")[0].match(SIZE_REG)||[Infinity])[0],r=+(t.body_markdown.split("\n")[0].match(SIZE_REG)||[Infinity])[0];return n-r});var e={};var t=0,c=0,p=-1;answers.forEach(function(n){var r=n.body_markdown.split("\n")[0];var i=$("#answer-template").html();var s=r.match(NUMBER_REG)[0];var o=(r.match(SIZE_REG)||[0])[0];var u=r.match(LANGUAGE_REG)[1];var a=getAuthorName(n);t++;c=p==o?c:t;i=i.replace("{{PLACE}}",c+".").replace("{{NAME}}",a).replace("{{LANGUAGE}}",u).replace("{{SIZE}}",o).replace("{{LINK}}",n.share_link);i=$(i);p=o;$("#answers").append(i);e[u]=e[u]||{lang:u,user:a,size:o,link:n.share_link}});var n=[];for(var r in e)if(e.hasOwnProperty(r))n.push(e[r]);n.sort(function(e,t){if(e.lang>t.lang)return 1;if(e.lang<t.lang)return-1;return 0});for(var i=0;i<n.length;++i){var s=$("#language-template").html();var r=n[i];s=s.replace("{{LANGUAGE}}",r.lang).replace("{{NAME}}",r.user).replace("{{SIZE}}",r.size).replace("{{LINK}}",r.link);s=$(s);$("#languages").append(s)}}var QUESTION_ID=49042;var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe";var answers=[],page=1;getAnswers();var SIZE_REG=/\d+(?=[^\d&]*(?:&lt;(?:s&gt;[^&]*&lt;\/s&gt;|[^&]+&gt;)[^\d&]*)*$)/;var NUMBER_REG=/\d+/;var LANGUAGE_REG=/^#*\s*([^,]+)/

body{text-align:left!important}#answer-list,#language-list{padding:10px;width:290px;float:left}table thead{font-weight:700}table td{padding:5px}

<script src=https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js></script><link rel=stylesheet type=text/css href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"><div id=answer-list><h2>Leaderboard</h2><table class=answer-list><thead><tr><td></td><td>Author<td>Language<td>Size<tbody id=answers></table></div><div id=language-list><h2>Winners by Language</h2><table class=language-list><thead><tr><td>Language<td>User<td>Score<tbody id=languages></table></div><table style=display:none><tbody id=answer-template><tr><td>{{PLACE}}</td><td>{{NAME}}<td>{{LANGUAGE}}<td>{{SIZE}}<td><a href={{LINK}}>Link</a></table><table style=display:none><tbody id=language-template><tr><td>{{LANGUAGE}}<td>{{NAME}}<td>{{SIZE}}<td><a href={{LINK}}>Link</a></table>

젤리 , 24 21 바이트

w@€ØHḅ⁴
ɠǵɠÇr@b⁴ịØHK

선택된 값 : [00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 1F 10 11 12 13 14 15]

TryItOnline

두 번째 입력이 첫 번째 입력보다 작 으면 역순으로 출력합니다.
범위를 벗어난 동작이 정의되지 않은 경우 (예 : "foo", "14"는 38 개의 값을 반환합니다.이 중 대부분은 배열에도없고 길이도 2가 아닙니다)

어떻게?

w@€ØHḅ⁴ - Link 1, parse a string as a 1-based hex value e.g. "14"
w@€      - first index (1-based) of each character in
   ØH    - hex digits: "0123456789ABCDEF"                   [2,5]
     ḅ⁴ - convert from base 16                                 37

ɠǵɠÇr@b⁴ịØHK - Main link
ɠ  ɠ          - read a line from stdin               e.g. "04"  "14"
 Ç  Ç         - call the last link (1) as a monad          21    37
  µ           - monadic chain separation
     r@       - inclusive range, with reversed arguments  [   21,   22,...,   36,   37] 
       b⁴     - convert to base 16                        [[1,5],[1,6],...,[2,4],[2,5]]
         ị    - index into
          ØH  - hex digits: "0123456789ABCDEF"            [ "04", "05",..., "13", "14"]
            K - join with spaces

자바 스크립트 (ES6) 118 115 112 102 82 81 바이트

ETH 프로덕션 덕분에 1 바이트 절약

선택된 값 :

00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f 10 11 12 13 14 15
-----------------------------------------------------------------
10 10 11 14 10 10 15 15 11 14 10 10 15 15 11 14 10 10 15 15 10 11

• 하한을 요구 한 다음 상한을 요구합니다 (예 : 0x04/ 0x0f).
• 유효하지 않은 하한은 0x00(최소값) 으로 해석됩니다 .
• 유효하지 않은 상한은 0x15(최대 값) 으로 해석됩니다 .
• 하한이 상한보다 큰 경우 아무것도 출력하지 않습니다.

alert((1/7+'789').replace(/./g,(v,i)=>i<a|i>b?'':(v|10)+' ',p=prompt,b=p(a=p())))

이전 버전 (97 바이트)

'true'16 진 값의 의사 난수 목록 생성 :

alert((1/7+'789').replace(/./g,(v,i)=>i<a|i>b?'':(v*7|16).toString(16)+' ',p=prompt,a=p(),b=p()))

순서:

10 10 17 1c 1e 38 33 31 17 1c 1e 38 33 31 17 1c 1e 38 33 31 38 3f

자바 스크립트 (ES6) 107 152 137 바이트

p=prompt,f=(a=+p(),b=+p(),[x,y,...s]='FFF4B6D7402011A4F0D0FF3D9C2165C4A22890E7D6A5')=>a?f(a-1,b-1,s):x+y+' '+(b?f(a,b-1,s):'');alert(f())

var
   p=prompt,f=(a=+p(),b=+p(),[x,y,...s]='FFF4B6D7402011A4F0D0FF3D9C2165C4A22890E7D6A5')=>a?f(a-1,b-1,s):x+y+' '+(b?f(a,b-1,s):'');alert(f())
;

//input 0x04 then 0x14 will print 40 to D6
//input 0x00 then 0x00 will print FF
//input 0x13 then 0x17 will print E7 D6 A5 NaN NaN

선택된 값 :

FF F4 B6 D7 40 20 11 A4 F0 D0 FF 3D 9C 21 65 C4 A2 28 90 E7 D6 A5

입력 :

• 입력 형식은 0x14
• 입력이 음수이거나 첫 번째 입력이 두 번째 입력보다 큰 경우 : InternalError: too much recursion
• NaN범위를 벗어난 경우 인쇄 합니다.

이전 솔루션 :
152 바이트 :

i=parseInt,p=prompt,f=(a=i(p()),b=i(p()),[x,y,...s]='FFF4B6D7402011A4F0D0FF3D9C2165C4A22890E7D6A5')=>a?f(a-1,b-1,s):x+y+' '+(b?f(a,b-1,s):'');alert(f())

107 바이트, 유효하지 않은 솔루션 (입력 누락) :

f=(a,b,[x,y,...s]='FFF4B6D7402011A4F0D0FF3D9C2165C4A22890E7D6A5')=>a?f(a-1,b-1,s):x+y+' '+(b?f(a,b-1,s):'')

파이썬, 88 87 86 바이트

@JonathanAllan 덕분에
1 바이트 저장 @JonathanAllan에 다시 1 바이트 저장

또한 코드의 기본을 변경하여 훨씬 멋지게 변경했습니다.

a,b=[int(x,16)for x in raw_input().split()];l=[0]*22
while a<=b:print"%02x"%l[a],;a+=1

선택한 값 : 00모든 것.

내 C 답변과 같은 아이디어. 그러나 이번에는 코드가 사용자로부터 단일 입력을 가져 와서 두 값 사이에 공백이 필요하며이를 분할하고 16 진 값으로 캐스트하고 l두 입력 된 값을 포함하여 그 사이에 배열의 모든 16 진수를 인쇄 합니다. 파이썬에는 웅장한 오류 포착 시스템이 있기 때문에 버퍼 오버플로가 없으며 코드가 훨씬 안전합니다. 이 프로그램은 더 높은 값이 낮은 값보다 먼저 제출 될 때 실행되지 않는다는 의미 에서 정의되지 않은 동작 으로부터 안전 합니다.

이것은 Python 2.x와 3.x에서 모두 작동합니다. 시스템이 두 가지를 모두 지원하지 않기 때문에 두 가지 통역사 모두에게 접근 할 수 없으므로 내가 틀렸다면 정정하십시오.

C ++, 98 95 93 바이트

#include <iostream>
int _[22],a,b;int main(){for(std::cin>>a>>b;b/a++;)printf("%02x ",_[a]);}

선택한 값은 모두 0입니다.

펄, 79 45 41 바이트

"최소값 $ 10"-이 예의 최소값은 $ 00입니다. 오타입니까?

여기에 41 바이트의 다소 지루한 펄 대답이 있습니다 (46 였지만 계속 공백을 보았습니다. 두 줄로 입력을받습니다.

printf'%02X ',$_ for(4..26)[hex<>..hex<>]

데이터는 04..1A 목록입니다

내가 팩 & 포장 풀기에 너무 영리하기 전에. 입력 바이트는 한 번에 함께 입력됩니다. 예를 들어 "020E"는 2-14 번째 항목을 인쇄합니다.

printf'%02X ',$_ for sub{(4..26)[shift..shift]}->(unpack'CC',pack'H4',<>)

내 대답을 더 길게 만드는 0 substr,, printf'%*vX'...을 사용하여 더 골프를 칠 수 있습니다. 48 자 (아스키 '7', 16 진수 37을 데이터로 사용)

printf'%*vX',' ',substr 7x22,$s=hex<>,1+hex<>-$s

CJam, 22 바이트

{r:~Gb}2*37m!s2/\)<>S*

선택된 값 :

00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F 10 11 12 13 14 15
-----------------------------------------------------------------
13 76 37 53 09 12 26 34 50 46 31 59 79 58 15 80 90 24 00 00 00 00

온라인으로 사용해보십시오

스칼라, 45 바이트

(_:Int)to(_:Int)map(x=>f"$x%02X")mkString " "

언 골프 드 :

(a:Int,b:Int)=>a.to(b).map(x=>f"$x%02X").mkString(" ")

00to FF를 값으로 사용 하지만 최대 2147483647까지 작동합니다.

C, 176 (175) 161 바이트

@JonathanAllan 덕분에 1 바이트 절약 14 바이트 를 절약 해 준 @Downvoter 덕분에 대규모 도움이되었습니다 !

int main(){int a[44]={0};char s[2];scanf("%s",s);int b=(int)strtol(s,0,16);scanf("%s",s);int c=(int)strtol(s,0,16);while(b<=c){printf("%d%d ",a[b],a[b+1]);b++;}}

온라인으로 사용해보십시오!

선택한 값 : 00모든 것.

무응답 :

int main() {
    int a[44] = {0};
    char s[2];
    scanf("%s", s);
    int b = (int) strtol(s, 0, 16);
    scanf("%s", s);
    int c = (int) strtol(s, 0, 16);
    while (b <= c) {
        printf("%d%d ", a[b], a[b+1]);
        b++;
    }
}

이것에 대한 트릭은 두 개의 입력을 받아서 16 진수 문자열로 변환 한 다음 정수로 캐스트하려고합니다. 오류 검사 또는 이와 유사한 것이 없기 때문에 정의되지 않은 동작 은 단순히 오류를 발생시키고 프로그램을 중단시키는 것입니다. 사용자는 두 개의 입력을 입력해야하지만 Eclipse CDT 컴파일러는 공백을 사용하여 동일한 줄에 입력 할 수있는 것으로 보입니다.

더 작은 값을 요청하기 전에 더 큰 값을 요청하면 while-loop 가 전혀 실행되지 않으므로 올바른 순서 여야합니다 .

버퍼 오버플로 방지 기능도 없기 때문에 $ 0에서 $ FFFF 사이의 범위와 같은 터무니없는 것을 간단히 요청할 수 있으며 a[44]배열에 대한 메모리 할당 시작부터 컴퓨터 메모리의 모든 것을 얻을 수 있습니다. , 나중에 65536 값까지.

GNU sed, 209 + 1 (r 플래그) = 210 바이트

1{h
s:.*:,00 FF,01 F4,02 B6,03 D7,04 40,05 00,06 00,07 A4,08 F0,09 00,0A FF,0B 0D,0C 9C,0D 21,0E 65,0F C4,10 02,11 28,12 90,13 E7,14 D6,15 A5:
H;d}
G;s:\n(.*)\n.*(,\1.*):\n\2:
s:(.*)\n(.*,\1 ..).*:\2:
s:,..::g

온라인으로 사용해보십시오! 출력에 하나의 선행 공간이 있습니다. 허용되기를 바랍니다.

예제를 실행하십시오.

me@LCARS:/PPCG$ echo -e "06\n0F" | sed -rf table_lookup.sed
 00 A4 F0 00 FF 0D 9C 21 65 C4
me@LCARS:/PPCG$ echo -e "13\n13" | sed -rf table_lookup.sed
 E7

설명 : 저장된 16 진수 값은 OP의 예와 동일합니다.

value | FF F4 B6 D7 40 00 00 A4 F0 00 FF 0D 9C 21 65 C4 02 28 90 E7 D6 A5
-------------------------------------------------------------------------
index | 00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F 10 11 12 13 14 15

시작 및 종료 색인은 별도의 행에서 읽습니다. 출력은 해당 인덱스 범위 (포함)의 테이블 값이있는 단일 행입니다. 정의되지 않은 입력은 여러 줄의 유효하지 않은 출력을 씁니다.

# store START index in hold space
1{h
# generate the table
s:.*:,INDEX1 VALUE1,INDEX2 VALUE2,°°°:
# append table to hold space and delete pattern space
H;d}
# read END index, append hold space (pattern space format is: END\nSTART\nTABLE)
G
# delete table entries up to, but excluding, the START index (END\nTABLE')
s:\n(.*)\n.*(,\1.*):\n\2:
# delete table entries starting from, but excluding, the END index (TABLE'')
s:(.*)\n(.*,\1 ..).*:\2:
# remove the indexes and print (implicitly) the resulting values
s:,..::g

PHP, 106105104 96 + 2 바이트

eval($s='for($a=a;$a++<c;)$$a=hexdec($argv[++$i]);while($b<=$c)printf("%02X ",ord($s[$b++]));');

또는

eval($s='for($a=a;$a++<c;)$$a=hexdec($argv[++$i]);');while($b<=$c)printf("%02X ",ord($s[$b++]));

로 실행 php -nr '<code>' <lowindex> <highindex>; 코드에서 작은 따옴표를 이스케이프 처리하십시오.
... 또는 온라인으로 테스트하십시오 .

dechex
0입력이 다른 것으로 시작하는 경우 문자가 16 진수 인 한 입력을 16 진 문자열로 해석 합니다.

첫 번째 값이 두 번째보다 큰 경우 아무것도 인쇄하지 않습니다.

선택된 값 :

00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f 10 11 12 13 14 15
-----------------------------------------------------------------
66 6F 72 28 24 61 3D 61 3B 24 61 2B 2B 3C 63 3B 29 24 24 61 3D 68

(실행 된 코드의 처음 22 개 ASCII 코드)

또는

for($a=a;$a++<c;)eval($s='$$a=hexdec($argv[++$i]);');while($b<=$c)printf("%02X ",ord($s[$b++]));

이 값으로

00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f 10 11 12 13 14 15
-----------------------------------------------------------------
24 24 61 3D 68 65 78 64 65 63 28 24 61 72 67 76 5B 2B 2B 24 69 5D 

Apple II 6502 어셈블리, 75 바이트

바이트 코드 :

A9 46 85 36 A9 10 85 37 A0 00 98 20 DA FD A9 A0 
20 ED FD C0 42 D0 F3 20 93 FE A2 FC 20 1B FD 9D 
04 01 E8 D0 F7 86 31 A9 8D 8D 04 02 20 A7 FF B5 
3C 0A 75 3C 95 3C CA 10 F6 A6 3D BD 05 02 20 ED 
FD E8 E4 3C D0 F5 99 05 02 C8 60

분해 :

  LDA    #<+
  STA    CSWL
  LDA    #>+
  STA    CSWH    ;redirect stdout
  LDY    #$00
- TYA
  JSR    PRBYTE  ;print number
  LDA    #$A0    ;space
  JSR    COUT    ;print space
  CPY    #$42    ;22*3
  BNE    -
  JSR    SETVID  ;restore stdout
  LDX    #$FC
- JSR    KEYIN   ;fetch a key
  STA    $0104,X ;store to $200+
  INX
  BNE    -       ;four keys
  STX    MODE    ;set internal flags
  LDA    #$8D
  STA    $0204   ;set key delimiter
  JSR    GETNUM  ;convert keys to hex values
- LDA    A1L,X   ;fetch value
  ASL
  ADC    A1L,X   ;multiply by 3
  STA    A1L,X   ;store value
  DEX
  BPL    -       ;both inputs
  LDX    A1H     ;first input
- LDA    $0205,X ;fetch from index
  JSR    COUT    ;print character
  INX
  CPX    A1L
  BNE    -       ;until second input
+ STA    $0205,Y ;fall through to save a byte
  INY
  RTS

출력처럼 보이는 메모리에 배열을 형성합니다. 선택된 값은 다음과 같습니다.

00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f 10 11 12 13 14 15
-----------------------------------------------------------------
00 03 06 09 0C 0F 12 15 18 1B 1E 21 24 27 2A 2D 30 33 36 39 3C 3F

사용자는 4 개의 키를 눌러 입력을 설정합니다.