Wyzwanie

Niedawno dostałem się do komputerów 8-bitowych i jestem zafascynowany ich działaniem i innymi; dlatego celem tego kodu golfowego jest odtworzenie części Monitora Woz, zaprojektowanego przez Steve'a Woźniaka dla Apple I.

Masz przechowywać tablicę 22 wartości szesnastkowych o szerokości dwóch bajtów (minimalna wartość 10 USD , maksymalna wartość $ FF ), a następnie weź n- ilość danych wejściowych. (Zwykle dwa; języki takie jak Brainfuck mogą mieć trudności).
Dane wejściowe będą odnosić się do miejsca w tablicy, od którego ma się rozpocząć drukowanie, i gdzie się zatrzymać; wejście o zdefiniowanym zachowaniu będzie miało wartość początkową mniejszą lub równą wartości końcowej. Twój program musi wtedy być w stanie wydrukować każdą wartość szesnastkową między wprowadzonymi wartościami szesnastkowymi włącznie .

Przykład tego:

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

Interesującą częścią tego ćwiczenia jest to, że możesz użyć wszystkiego, co chcesz, sprawdzić granice danych wejściowych użytkowników. Dane wejściowe od osoby helloi twój program ma niezdefiniowane zachowanie? Odchodzi bez uprzedzenia? Oba są ważne.

Jedyne zasady to:

1. Musisz włączyć wartości 22 wartości szesnastkowych jako część programu przed jego uruchomieniem (nie możesz poprosić użytkownika o dane wejściowe).
2. Dane wyjściowe wartości szesnastkowych muszą mieć dokładny format: 00 FF 00 FF 00spacje końcowe, tabulatory lub linie są w porządku. Znaki nie są.
3. Program nie musi pytać o dane wejściowe z komunikatem. Pozostaw „wiadomość” pustą, jeśli chcesz. Użytkownik musi jednak wprowadzić ograniczenia szesnastkowe.
4. Ponieważ w przypadku wartości 22 wartości szesnastkowych decyzję należy podjąć, należy stworzyć program, który faktycznie pobiera wartości z pamięci, a nie naśladuje program, po prostu drukując wartości. (np. lista 00 $ ).
5 n-ilość danych wejściowych, odnosi się do ilości danych wejściowych wymaganych dla wybranego języka do rozpoznania szesnastkowej o szerokości dwóch bajtów. na przykład. (Brainfuck wymaga dwóch danych wejściowych na heks, co daje cztery dla obu).

Jeśli potrzebujesz wyjaśnienia, możesz je komentować.

To jest kod golfowy, więc zwycięzcą jest najkrótsza odpowiedź w liczbie bajtów.

Tabela liderów

Oto tabela liderów generująca fragment dzięki uprzejmości Martina Endera .

Aby upewnić się, że twoja odpowiedź się pojawi, zacznij od nagłówka, korzystając z następującego szablonu Markdown:

# Language Name, N bytes

gdzie Njest rozmiar twojego zgłoszenia. Jeśli poprawić swój wynik, to może zachować stare porachunki w nagłówku, uderzając je przez. Na przykład:

# 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>

Galaretka , 24 21 bajtów

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

Wybrane wartości: [00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 1F 10 11 12 13 14 15]

TryItOnline

Jeśli drugie wejście jest mniejsze niż pierwsze, wyświetla odwróconą sekwencję.
Zachowanie poza zakresem jest niezdefiniowane (np. „Foo”, „14” zwraca 38 wartości, z których większość nie jest nawet w tablicy, a wiele z nich nie ma długości 2)

W jaki sposób?

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

JavaScript (ES6), 118 115 112 102 82 81 bajtów

Zaoszczędzono 1 bajt dzięki produktom ETH

Wybrane wartości:

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

• Monituje o dolną granicę, a następnie górną granicę (np. 0x04/ 0x0f).
• Nieprawidłowa dolna granica zostanie zinterpretowana jako 0x00(wartość minimalna).
• Nieprawidłowa górna granica zostanie zinterpretowana jako 0x15(wartość maksymalna).
• Nie wyprowadza nic, jeśli dolna granica jest większa niż górna granica.

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

Poprzednia wersja (97 bajtów)

Generowanie pseudolosowej listy „prawdziwych” wartości szesnastkowych:

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

Sekwencja:

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

JavaScript (ES6), 107 152 137 bajtów

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

Wybrane wartości:

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

Wejścia:

• Format wejściowy to 0x14
• Jeśli jakiekolwiek wejście jest ujemne lub 1. wejście jest większe niż 2. wejście: InternalError: too much recursion
• Wydrukuje NaNpoza limitem.

Poprzednie rozwiązania:
152 bajty:

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 bajtów, nieprawidłowe rozwiązanie (brak danych wejściowych):

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

Python, 88 87 86 bajtów

Zapis
1 bajt dzięki @JonathanAllan Zapis 1 bajt ponownie w @JonathanAllan

Zmieniłem także podstawę kodu, teraz znacznie ładniej.

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

Wybrane wartości: 00do wszystkiego.

Ten sam pomysł jak moja odpowiedź C. Tym razem jednak kod pobiera od użytkownika pojedyncze dane wejściowe, wymagając odstępu między obiema wartościami, dzieląc je, rzutując je na wartości szesnastkowe i drukując każdy hex w ltablicy, w tym i pomiędzy dwiema wprowadzonymi wartościami. Ponieważ Python ma wspaniały system wychwytywania błędów, nie występuje przepełnienie bufora, a zatem kod jest znacznie bezpieczniejszy. Program jest zabezpieczony przed niezdefiniowanym zachowaniem w takim sensie, że nie zostanie uruchomiony, gdy wyższa wartość zostanie przesłana przed niższą wartością.

Powinno to działać zarówno w Pythonie 2.x, jak i 3.x; Popraw mnie, jeśli się mylę, ponieważ nie mam dostępu do obu tłumaczy, ponieważ mój system nie obsługuje ich obu.

C ++, 98 95 93 bajtów

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

Moje wybrane wartości to 0

Perl, 79 45 41 bajtów

„minimalna wartość 10 $” - przykład ma minimum 00 $ - czy to literówka?

Oto dość nudna odpowiedź perla w 41 bajtach (miał 46 lat, a potem wciąż widziałem spacje, pareny, które mogłem wymknąć). Pobiera dane wejściowe w dwóch wierszach.

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

Dane są listą 04..1A

Wcześniej byłem zbyt sprytny przy pakowaniu i rozpakowywaniu. Jego bajty wejściowe są wprowadzane jednocześnie zetknięte razem, np. „020E” wydrukuje wpisy 2-14

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

Mogę spróbować zagrać w golfa bardziej, używając wszystkich zer substr, i printf'%*vX'... nie, to sprawia, że ​​moja odpowiedź jest dłuższa. 48 znaków (używając ciągu znaków ascii '7', hex 37 jako danych)

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

CJam, 22 bajty

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

Wybrane wartości:

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

Wypróbuj online

Scala, 45 bajtów

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

Nie golfowany:

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

Zastosowania 00do FFjak wartości, ale działa do 2147483647.

C, 176 175 161 bajtów

Oszczędzaj 1 bajt dzięki @JonathanAllan
Ogromna pomoc dzięki @Downvoter za uratowanie mnie 14 bajtów!

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++;}}

Wypróbuj online!

Wybrane wartości: 00do wszystkiego.

Odpowiedź bez gry w golfa:

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++;
    }
}

Sztuczka polega na tym, że pobiera dwa dane wejściowe i próbuje przekonwertować je na ciągi szesnastkowe, a następnie rzutować na liczby całkowite. Ponieważ nie ma sprawdzania błędów ani nic podobnego, niezdefiniowanym zachowaniem jest po prostu rzucanie błędów i łamanie programu. Użytkownik musi wprowadzić dwa dane wejściowe, ale wydaje mi się, że mój kompilator Eclipse CDT pozwala mi je wprowadzać w tym samym wierszu ze spacją między nimi.

Muszą być w odpowiedniej kolejności, ponieważ żądanie większej wartości, zanim mniejsza wartość w ogóle nie uruchomi whilepętli.

Chodzi o to, że nie ma również ochrony przed przepełnieniem bufora, więc mogę po prostu zażądać czegoś absurdalnego, takiego jak zakres od 0 $ do $ FFFF, a wszystko w pamięci komputera dostanę od początku przydzielania pamięci dla a[44]tablicy , aż do 65536 wartości później.

GNU sed, 209 + 1 (flaga r) = 210 bajtów

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

Wypróbuj online! Jedna wyjściowa przestrzeń jest obecna na wyjściu, mam nadzieję, że jest dozwolona.

Uruchom przykłady:

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

Objaśnienie: 22 zapisane wartości szesnastkowe są takie same jak te z przykładu PO

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

Indeksy początkowe i końcowe są odczytywane w osobnych wierszach. Dane wyjściowe to pojedynczy wiersz z wartościami tabeli w tym zakresie indeksu (włącznie). Niezdefiniowane wejście spowoduje zapisanie wielu wierszy nieprawidłowego wyjścia.

# 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, 106 105 104 96 + 2 bajty

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

lub

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

Uruchom z php -nr '<code>' <lowindex> <highindex>; unikaj pojedynczych cudzysłowów w kodzie.
... lub przetestuj online .

dechex interpretuje dane wejściowe jako ciągi szesnastkowe, o ile znaki są cyframi szesnastkowymi,
0 jeśli dane wejściowe zaczynają się od czegoś innego.

nie drukuje nic, jeśli pierwsza wartość jest większa niż druga.

wybrane wartości:

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

(pierwsze 22 kody ascii wykonanego kodu)

lub

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

z tymi wartościami:

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 

Zestaw Apple II 6502, 75 bajtów

Kod bajtowy:

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

Demontaż:

  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

Tworzy tablicę w pamięci, która wygląda jak wynik. Wybrane wartości to:

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

Użytkownik naciska cztery klawisze, aby ustawić wejścia.