Herausforderung

Ich habe mich vor kurzem mit 8-Bit-Computern beschäftigt und bin fasziniert von deren und anderen Funktionen. Ziel dieses Codegolfs ist es daher, einen Teil des Woz-Monitors zu kopieren, der von Steve Wozniak für den Apple I entworfen wurde.

Sie müssen ein Array mit 22 hexadezimalen Werten mit einer Breite von zwei Bytes (min. Wert $ 10 , max. Wert $ FF ) speichern und anschließend eine n- Anzahl von Eingaben eingeben. (Normalerweise zwei; Sprachen wie Brainfuck könnten es schwer haben).
Die Eingaben beziehen sich auf die Position im Array, von der aus der Druckvorgang gestartet werden soll, und auf die Position, an der angehalten werden soll. Bei einer Eingabe mit definiertem Verhalten ist der Startwert kleiner oder gleich dem Endwert. Ihr Programm muss dann in der Lage sein, jeden Hexadezimalwert zwischen und einschließlich der eingegebenen Hexadezimalwerte zu drucken.

Ein Beispiel dafür:

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

Der interessante Teil dieser Übung besteht nun darin, dass Sie nach Belieben die Grenzen der Benutzereingaben überprüfen können. Personeneingaben hellound Ihr Programm hat undefiniertes Verhalten? Es wird ohne Vorankündigung beendet? Sie sind beide gültig.

Die einzigen Regeln sind:

1. Sie müssen die Werte der 22 Hexadezimalwerte als Teil Ihres Programms angeben, bevor es gestartet wird (der Benutzer kann keine Eingaben anfordern).
2. Die Ausgabe der Hexadezimalwerte muss genau dem Format entsprechen: 00 FF 00 FF 00Nachgestellte Leerzeichen, Tabulatoren oder Zeilen sind in Ordnung. Charaktere sind nicht.
3. Das Programm muss nicht mit einer Meldung nach den Eingaben fragen. Lassen Sie die "Nachricht" leer, wenn Sie möchten. Der Benutzer muss jedoch die Hex-Grenzen eingeben.
4. Wie bei den Werten der 22 Hexadezimalzahlen zu entscheiden ist, müssen Sie ein Programm erstellen, das die Werte tatsächlich aus dem Speicher abruft, anstatt ein Programm durch einfaches Drucken von Werten nachzuahmen . (wie eine Liste von $ 00 ).
5. n-Anzahl der Eingaben bezieht sich auf die Anzahl der Eingaben, die für die Sprache Ihrer Wahl erforderlich sind, um ein Hexadezimal mit einer Breite von zwei Bytes zu erkennen. z.B. (Brainfuck benötigt zwei Eingänge pro Hex, also vier für die beiden).

Fühlen Sie sich frei zu kommentieren, wenn Sie Klarstellung benötigen.

Dies ist Codegolf, daher ist die kürzeste Antwort in der Anzahl der Bytes der Gewinner.

Bestenliste

Hier ist eine Rangliste mit freundlicher Genehmigung von Martin Ender .

Um sicherzustellen, dass Ihre Antwort angezeigt wird, beginnen Sie Ihre Antwort mit einer Überschrift. Verwenden Sie dazu die folgende Markdown-Vorlage:

# Language Name, N bytes

Wo Nist die Größe Ihres Beitrags? Wenn Sie Ihren Score zu verbessern, Sie können alte Rechnungen in der Überschrift halten, indem man sich durch das Anschlagen. Zum Beispiel:

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

Jelly , 24 21 Bytes

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

Gewählte Werte: [00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 1F 10 11 12 13 14 15]

TryItOnline

Wenn der zweite Eingang kleiner als der erste ist, wird die umgekehrte Reihenfolge ausgegeben.
Out-of-bounds-Verhalten ist undefiniert (z. B. "foo", "14" gibt 38 Werte zurück, von denen sich die meisten nicht einmal im Array befinden und viele nicht die Länge 2 haben)

Wie?

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 Byte

Dank ETHproductions 1 Byte gespart

Gewählte Werte:

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

• Fordert zur Eingabe der unteren und dann der oberen Grenze auf (z . B. 0x04/ 0x0f).
• Eine ungültige Untergrenze wird als 0x00(Mindestwert) interpretiert .
• Eine ungültige Obergrenze wird als 0x15(Maximalwert) interpretiert .
• Gibt nichts aus, wenn die Untergrenze größer als die Obergrenze ist.

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

Vorherige Version (97 Bytes)

Generieren einer Pseudozufallsliste mit "wahren" Hexadezimalwerten:

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

Reihenfolge:

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 Bytes

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

Gewählte Werte:

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

Eingänge:

• Eingabeformat ist 0x14
• Wenn ein Eingang negativ ist oder der erste Eingang größer als der zweite ist: InternalError: too much recursion
• Wird NaNfür außerhalb der Grenzen gedruckt .

Bisherige Lösungen:
152 Byte:

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 Bytes, ungültige Lösung (Eingaben fehlen):

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 Bytes

1 Byte speichern dank @JonathanAllan
1 Byte speichern wieder zu @JonathanAllan

Auch die Basis des Codes geändert, jetzt viel schöner.

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

Gewählte Werte: 00für alles.

Gleiche Idee wie meine C-Antwort. Dieses Mal nimmt der Code jedoch eine einzelne Eingabe vom Benutzer entgegen, wobei ein Leerzeichen zwischen beiden Werten erforderlich ist. Teilen Sie diese auf, wandeln Sie sie in hexadezimale Werte um und drucken Sie jedes hexadezimale Zeichen im lArray, einschließlich und zwischen den beiden eingegebenen Werten. Da Python über ein hervorragendes System zum Auffinden von Fehlern verfügt, sind keine Pufferüberläufe vorhanden und der Code ist daher viel sicherer. Das Programm ist vor undefiniertem Verhalten in dem Sinne sicher, dass es nicht ausgeführt wird, wenn ein höherer Wert vor einem niedrigeren Wert übergeben wird.

Dies sollte auf Python 2.x und 3.x funktionieren. Bitte korrigieren Sie mich, wenn ich falsch liege, da ich nicht auf beide Dolmetscher zugreifen kann, da mein System beide nicht unterstützt.

C ++, 98 95 93 Bytes

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

Meine gewählten Werte sind alle Nullen

Perl, 79 45 41 Bytes

"min value $ 10" - das Beispiel hat mindestens $ 00 - ist das ein Tippfehler?

Hier ist eine ziemlich langweilige Perl-Antwort in 41 Bytes. Nimmt Eingaben in zwei Zeilen vor.

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

Die Daten sind eine Liste 04..1A

Vorher war ich zu schlau beim Packen und Auspacken. Die eingegebenen Bytes werden sofort zusammengefasst, z. B. "020E" gibt die 2.-14. Einträge aus

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

Könnte versuchen, es mehr mit allen Nullen zu spielen substr, und printf'%*vX'... nein, das macht meine Antwort länger. 48 Zeichen (unter Verwendung einer Zeichenfolge von ASCII '7', Hex 37 als Daten)

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

CJam, 22 Bytes

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

Gewählte Werte:

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

Probieren Sie es online aus

Scala, 45 Bytes

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

Ungolfed:

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

Anwendungen 00zu FFals Werte, sondern Werke bis zu 2147483647.

C, 176 175 161 Bytes

1 Byte sparen dank @JonathanAllan
Massive Hilfe dank @Downvoter für das Speichern von 14 Byte!

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

Probieren Sie es online!

Gewählte Werte: 00für alles.

Antwort ohne Golf:

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

Der Trick dabei ist, zwei Eingaben aufzunehmen und zu versuchen, sie in hexadezimale Zeichenfolgen umzuwandeln und dann in Ganzzahlen umzuwandeln. Da es keine Fehlerprüfung oder ähnliches gibt, wirft undefiniertes Verhalten einfach Fehler und bricht das Programm ab. Der Benutzer muss zwei Eingaben eingeben, mein Eclipse CDT-Compiler scheint jedoch zuzulassen, dass ich beide in derselben Zeile mit einem Leerzeichen dazwischen eingebe.

Sie müssen in der richtigen Reihenfolge vorliegen, da das Anfordern eines größeren Werts, bevor ein kleinerer Wert die while-loop überhaupt nicht ausführt.

Die Sache ist, dass es auch keinen Pufferüberlaufschutz gibt, so dass ich einfach etwas Absurdes wie einen Bereich von $ 0 bis $ FFFF anfordern kann und von Beginn der Speicherzuweisung für das a[44]Array an alles in den Speicher meines Computers bekomme bis zu 65536 Werten später.

GNU sed, 209 + 1 (r Flag) = 210 Bytes

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

Probieren Sie es online!Ein führendes Leerzeichen ist in der Ausgabe vorhanden, ich hoffe, es ist zulässig.

Beispiele ausführen:

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

Erläuterung: Die 22 gespeicherten Hexadezimalwerte stimmen mit denen aus dem OP-Beispiel überein

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

Der Start- und der Endindex werden in separaten Zeilen gelesen. Die Ausgabe ist eine einzelne Zeile mit den Tabellenwerten in diesem Indexbereich (einschließlich). Nicht definierte Eingaben schreiben mehrere Zeilen mit ungültiger Ausgabe.

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

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

oder

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

Laufen mit php -nr '<code>' <lowindex> <highindex>; Entfliehen Sie den einfachen Anführungszeichen im Code.
... oder online testen .

dechex interpretiert Eingaben als hexadezimale Zeichenfolgen, sofern es sich bei den Zeichen um Hexadezimalziffern handelt,
0 sofern es sich bei den sofern die Eingabe mit etwas anderem beginnt.

Gibt nichts aus, wenn der erste Wert größer als der zweite ist.

gewählte Werte:

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

(die ersten 22 ASCII-Codes des ausgeführten Codes)

oder

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

mit diesen Werten:

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-Assembly, 75 Byte

Byte-Code:

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

Demontage:

  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

Es bildet ein Array im Speicher, das der Ausgabe ähnelt. Die gewählten Werte sind:

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

Der Benutzer drückt vier Tasten, um die Eingaben festzulegen.