Sfida

Recentemente sono entrato nei computer a 8 bit e sono affascinato dal funzionamento di loro e di altri; quindi l'obiettivo di questo codice golf è replicare una parte del Woz Monitor, progettato da Steve Wozniak per Apple I.

Devi memorizzare un array di 22 valori esadecimali con una larghezza di due byte, (valore minimo $ 10 , valore massimo $ FF ), e quindi prendere n -ammontare di input. (Normalmente due; lingue come Brainfuck potrebbero avere difficoltà).
Gli input faranno riferimento a dove nell'array iniziare la stampa e dove fermarsi; un input con comportamento definito avrà il suo valore iniziale inferiore o uguale al valore finale. Il programma deve quindi essere in grado di stampare tutti i valori esadecimali compresi e compresi i valori esadecimali immessi.

Un esempio di questo:

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

Ora la parte interessante di questo esercizio è che puoi usare qualunque cosa tu voglia controllare i limiti dell'input degli utenti. Input di persona helloe il tuo programma ha un comportamento indefinito? Si chiude senza preavviso? Sono entrambi validi.

Le uniche regole sono:

1. Prima di iniziare è necessario includere i valori dei 22 valori esadecimali come parte del programma (non è possibile richiedere input all'utente).
2. L'output dei valori esadecimali deve seguire il formato esatto: gli 00 FF 00 FF 00spazi, le schede o le linee finali sono OK. I personaggi non lo sono.
3. Il programma non deve richiedere gli input con un messaggio. Lascia il "messaggio" vuoto se lo desideri. L'utente deve tuttavia inserire i limiti esadecimali.
4. Come per i valori dei 22 esadecimali che decidi tu, devi creare un programma che recuperi effettivamente i valori dalla memoria, invece di imitare un programma semplicemente stampando i valori. (come un elenco di $ 00 ).
5. n-quantità di input, si riferisce alla quantità di input richiesti per la lingua scelta per riconoscere un esadecimale di due byte di larghezza. per esempio. (Brainfuck richiederà due input per esagono, rendendolo quattro per i due).

Sentiti libero di commentare se hai bisogno di chiarimenti.

Questo è il codice golf, quindi la risposta più breve nel numero di byte è il vincitore.

Classifica

Ecco una classifica che genera frammenti per gentile concessione di Martin Ender .

Per assicurarti che la tua risposta venga visualizzata, ti preghiamo di iniziare la risposta con un titolo, utilizzando il seguente modello Markdown:

# Language Name, N bytes

dov'è Nla dimensione del tuo invio. Se si migliora il punteggio, è possibile mantenere i vecchi punteggi nel titolo, colpendoli. Per esempio:

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

Gelatina , 24 21 byte

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

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

TryItOnline

Se il secondo ingresso è inferiore al primo, emette la sequenza inversa.
Il comportamento fuori dai limiti non è definito (ad es. "Pippo", "14" restituisce 38 valori, molti dei quali non sono nemmeno nella matrice e molti dei quali non sono di lunghezza 2)

Come?

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 102 81 81 byte

Salvato 1 byte grazie a ETHproductions

Valori scelti:

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

• Richiede il limite inferiore, quindi il limite superiore (ad es. 0x04/ 0x0f).
• Un limite inferiore non valido verrà interpretato come 0x00(valore minimo).
• Un limite superiore non valido verrà interpretato come 0x15(valore massimo).
• Non genera nulla se il limite inferiore è maggiore del limite superiore.

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

Versione precedente (97 byte)

Generazione di un elenco pseudo-casuale di valori esadecimali "veri":

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

Sequenza:

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 byte

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

Valori scelti:

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

ingressi:

• Il formato di input è 0x14
• Se qualsiasi input è negativo o il 1o input è maggiore del 2o: InternalError: too much recursion
• Stampa NaNper fuori limite.

Soluzioni precedenti:
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 byte, soluzione non valida (input mancanti):

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 byte

Salvataggio di 1 byte grazie a @JonathanAllan Salvataggio di
1 byte di nuovo su @JonathanAllan

Ha anche cambiato la base del codice, molto più bello ora.

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

Valori scelti: 00per tutto.

Stessa idea della mia risposta C. Questa volta, tuttavia, il codice riceve un singolo input dall'utente, che richiede uno spazio tra entrambi i valori, li divide, li cast su valori esadecimali e stampa ogni esagono nella lmatrice compresi e tra i due valori immessi. Poiché Python ha un magnifico sistema di rilevazione degli errori, non sono presenti buffer overflow e il codice è quindi molto più sicuro. Il programma è al sicuro da comportamenti indefiniti, nel senso che non verrà eseguito quando viene inviato un valore più alto prima di un valore più basso.

Questo dovrebbe funzionare su Python 2.xe 3.x; Per favore, correggimi se sbaglio, poiché non ho accesso ad entrambi gli interpreti a causa del mio sistema che non supporta entrambi.

C ++, 98 95 93 byte

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

I miei valori scelti sono tutti 0

Perl, 79 45 41 byte

"valore minimo $ 10" - l'esempio ha un minimo di $ 00- è un errore di battitura?

Ecco una risposta perl piuttosto noiosa in 41 byte (era 46 e poi ho continuato a vedere spazi, parentesi che potevo eludere). Accetta input in due righe.

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

I dati sono un elenco 04..1A

Prima ero troppo intelligente con pack & unpack. I suoi byte di input vengono immessi contemporaneamente smistati insieme, ad es. "020E" stamperà le voci dal 2 ° al 14 °

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

Potrei provare a giocare a golf di più usando tutti gli 0 substr, e printf'%*vX'... no, questo sta allungando la mia risposta. 48 caratteri (usando una stringa di ascii '7', esadecimale 37 come dati)

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

CJam, 22 byte

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

Valori scelti:

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

Provalo online

Scala, 45 byte

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

Ungolfed:

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

Usi 00a FFcome valori, ma funziona fino a 2147483647.

C, 176 175 161 byte

Risparmio di 1 byte grazie a @JonathanAllan
Un enorme aiuto grazie a @Downvoter per avermi salvato 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++;}}

Provalo online!

Valori scelti: 00per tutto.

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

Il trucco di questo è prendere due input e tentare di convertirli in stringhe esadecimali e quindi eseguire il cast in numeri interi. Poiché non esiste un controllo degli errori o qualcosa di simile, un comportamento indefinito è semplicemente lanciare errori e interrompere il programma. L'utente deve inserire due input, tuttavia il mio compilatore CDT Eclipse sembra lasciarmi inserire entrambi sulla stessa riga con uno spazio tra.

Devono essere nell'ordine corretto, poiché la richiesta di un valore più grande prima che un valore più piccolo non esegua affatto while-loop.

Il fatto è che non esiste nemmeno una protezione da buffer overflow, quindi posso semplicemente richiedere qualcosa di assurdo come un intervallo da $ 0 a $ FFFF e otterrò tutto nella memoria del mio computer dall'inizio dell'assegnazione della memoria per l' a[44]array , fino a 65536 valori in seguito.

GNU sed, 209 + 1 (flag r) = 210 byte

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

Provalo online!Nell'output è presente uno spazio principale, spero sia consentito.

Esegui esempi:

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

Spiegazione: i 22 valori esadecimali memorizzati sono gli stessi dell'esempio del 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

Gli indici di inizio e fine vengono letti su righe separate. L'output è una riga singola con i valori della tabella in quell'intervallo di indice (incluso). L'input non definito scriverà più righe di output non valido.

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

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

o

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

Corri con php -nr '<code>' <lowindex> <highindex>; sfuggire alle virgolette singole nel codice.
... o provalo online .

dechex interpreta l'input come stringhe esadecimali nella misura in cui i caratteri sono cifre esadecimali,
0 se l'input inizia con qualcos'altro.

non stampa nulla se il primo valore è maggiore del secondo.

valori scelti:

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

(primi 22 codici ASCII del codice eseguito)

o

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

con questi valori:

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 

Assemblaggio Apple II 6502, 75 byte

Codice byte:

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

Smontaggio:

  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

Forma un array in memoria che assomiglia all'output. I valori scelti sono:

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

L'utente preme quattro tasti per impostare gli ingressi.