Determina il colore di un quadrato di scacchi


59

La tua sfida è scrivere un programma che emetta il colore di un determinato quadrato dalla scacchiera. Ecco come appare una scacchiera:

inserisci qui la descrizione dell'immagine

Puoi vedere che il quadrato a1 è scuro e h1 è un quadrato chiaro. Il tuo programma deve produrre darko light, quando viene dato un quadrato. Qualche esempio:

STDIN:  b1
STDOUT: light

STDIN:  g6
STDOUT: light

STDIN:  d4
STDOUT: dark

Le regole:

  • È necessario fornire un programma completo che utilizza STDIN e utilizza STDOUT per l'output darko light.
  • Supponiamo che l'input sia sempre valido ( [a-h][1-8])
  • Questo è , quindi vince il minor numero di byte!

tabellone segnapunti

var QUESTION_ID=63772,OVERRIDE_USER=8478;function answersUrl(e){return"http://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(e,s){return"http://api.stackexchange.com/2.2/answers/"+s.join(";")+"/comments?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){answers.push.apply(answers,e.items),answers_hash=[],answer_ids=[],e.items.forEach(function(e){e.comments=[];var s=+e.share_link.match(/\d+/);answer_ids.push(s),answers_hash[s]=e}),e.has_more||(more_answers=!1),comment_page=1,getComments()}})}function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){e.items.forEach(function(e){e.owner.user_id===OVERRIDE_USER&&answers_hash[e.post_id].comments.push(e)}),e.has_more?getComments():more_answers?getAnswers():process()}})}function getAuthorName(e){return e.owner.display_name}function process(){var e=[];answers.forEach(function(s){var r=s.body;s.comments.forEach(function(e){OVERRIDE_REG.test(e.body)&&(r="<h1>"+e.body.replace(OVERRIDE_REG,"")+"</h1>")});var a=r.match(SCORE_REG);a&&e.push({user:getAuthorName(s),size:+a[2],language:a[1],link:s.share_link})}),e.sort(function(e,s){var r=e.size,a=s.size;return r-a});var s={},r=1,a=null,n=1;e.forEach(function(e){e.size!=a&&(n=r),a=e.size,++r;var t=jQuery("#answer-template").html();t=t.replace("{{PLACE}}",n+".").replace("{{NAME}}",e.user).replace("{{LANGUAGE}}",e.language).replace("{{SIZE}}",e.size).replace("{{LINK}}",e.link),t=jQuery(t),jQuery("#answers").append(t);var o=e.language;/<a/.test(o)&&(o=jQuery(o).text()),s[o]=s[o]||{lang:e.language,user:e.user,size:e.size,link:e.link}});var t=[];for(var o in s)s.hasOwnProperty(o)&&t.push(s[o]);t.sort(function(e,s){return e.lang>s.lang?1:e.lang<s.lang?-1:0});for(var c=0;c<t.length;++c){var i=jQuery("#language-template").html(),o=t[c];i=i.replace("{{LANGUAGE}}",o.lang).replace("{{NAME}}",o.user).replace("{{SIZE}}",o.size).replace("{{LINK}}",o.link),i=jQuery(i),jQuery("#languages").append(i)}}var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk",answers=[],answers_hash,answer_ids,answer_page=1,more_answers=!0,comment_page;getAnswers();var SCORE_REG=/<h\d>\s*([^\n,]*[^\s,]),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/,OVERRIDE_REG=/^Override\s*header:\s*/i;
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><td>Language</td><td>Size</td></tr></thead> <tbody id="answers"> </tbody> </table> </div><div id="language-list"> <h2>Winners by Language</h2> <table class="language-list"> <thead> <tr><td>Language</td><td>User</td><td>Score</td></tr></thead> <tbody id="languages"> </tbody> </table> </div><table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table> <table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table>


1
Perché nessuno ha provato <> ^ Fish?
ghosts_in_the_code

Risposte:


46

GS2 , 17 15 byte

de♦dark•light♠5

Il codice sorgente utilizza la codifica CP437 . Provalo online!

Verifica

$ xxd -r -ps <<< 6465046461726b076c696768740635 > chess.gs2
$ wc -c chess.gs2 
15 chess.gs2
$ gs2 chess.gs2 <<< b1
light

Come funziona

d               Add the code points of the input characters.
 e              Compute the sum's parity.
  ♦             Begin a string literal.
   dark
       •        String separator.
        light
             ♠  End the string literal; push as an array of strings.
              5 Select the element that corresponds to the parity.

8
È stupefacente! Con 9 byte inevitabili, 3 byte superano Pyth e CJam è sorprendente.
isaacg,

29
Vacca santa, ragazzi, GS2 è il nuovo Pyth! Qualcuno ha capito come usarlo molto prima di Denni ... non importa.
ETHproductions

56

Python 2, 41 38 byte

print'ldiagrhkt'[int(input(),35)%2::2]

3 byte grazie a Mego per l'interlacciamento delle stringhe

Accetta input come "g6". È chiaro e scuro intrecciato.


È semplicemente meraviglioso con l'intreccio di stringhe.
Wayne Werner,

5
Direi che questa int(input(),35)è la parte geniale. Ho pensato all'intreccio di stringhe, ma il tuo metodo di input salva la maggior parte dei byte.
mbomb007,

26

Esagonia , 34 32 byte

,},";h;g;;d/;k;-'2{=%<i;\@;trl;a

Spiegato e con percorsi di esecuzione annotati:

inserisci qui la descrizione dell'immagine
Diagramma generato con l' incredibile HexagonyColorer di Timwi .

Il percorso viola è il percorso iniziale che legge due caratteri, calcola la loro differenza e lo prende modulo 2. L' <agente quindi funge da ramo, dove vengono 1stampati il percorso grigio grigio (risultato ) darke il percorso grigio chiaro (risultato 0) light.

Per quanto riguarda il modo in cui computo la differenza e il modulo, ecco un diagramma della griglia di memoria (con valori presi per l'input a1):

inserisci qui la descrizione dell'immagine
Diagramma generato con l' IDE esoterico ancora più sorprendente di Timwi (che ha un debugger visivo per Hexagony).

Il puntatore della memoria inizia sulla riga con l' etichetta del bordo , dove leggiamo il carattere. }si sposta sul bordo etichettato col , dove leggiamo la cifra. "si sposta sul bordo etichettato diff dove -calcola la differenza dei due. 'si sposta nella cella senza etichetta in cui inseriamo il modello 2e si {=sposta nella cella con etichetta mod dove calcoliamo il modulo %.

Questo potrebbe essere giocabile a golf di alcuni byte riutilizzando alcuni dei ;, ma dubito che possa essere golfato da molto, sicuramente non fino alla lunghezza laterale 3.


7
Ooh, bei colori!
Celeo,

1
Questa lingua è nuova per me, ma sono stupito dalla tua capacità di inventare qualcosa di più inventato di quanto pensassi possibile
qwr

18
Davvero non capisco tutte queste lingue da golf.
juniorRubyist,

4
@ codeSwift4Life Hexagony è lungi dall'essere un linguaggio da golf. Per compiti banali come questo potrebbe essere ragionevolmente competitivo, perché ha comandi a carattere singolo, ma è più una necessità condivisa da molti altri linguaggi 2D , tra cui Befunge, Piet,> <>. Qualsiasi attività non banale richiederà grandi quantità di codice e programmi complicati, a causa dello strano modello di memoria di Hexagony. Non intende in alcun modo essere un linguaggio conciso, ma piuttosto un linguaggio esotico e strano, che esplora la programmazione su griglie esagonali.
Martin Ender,

3
@qwr Pensavo che essere inventato fosse il punto di esolang. ;)
Martin Ender,

21

CJam, 18 byte

r:-)"lightdark"5/=

Demo online

Dissezione

r               e# Read a token of input
:-              e# Fold -, giving the difference between the two codepoints
)               e# Increment, changing the parity so that a1 is odd
"lightdark"5/   e# Split the string to get an array ["light" "dark"]
=               e# Index with wrapping, so even => "light" and odd => "dark"

34
il tuo codice sorride:-)
Manopola

8
Ho considerato ugualmente efficace:^)
Peter Taylor il

2
Per favore, puoi spiegare come funziona.
Nebbia

@Fogmeister, aggiunta spiegazione.
Peter Taylor,

17

sed, 37

s/[1357aceg]//g
/^.$/{clight
q}
cdark

Spiegazione

s/[1357aceg]//grimuove tutte le coordinate indicizzate in modo dispari. Il buffer di pattern risultante ha quindi una lunghezza di 1 per "chiaro" o una lunghezza di 0 o 2 per "scuro". /^.$/corrisponde ai motivi a 1 lunghezza, cappende il motivo a "luce" e funziona q. Altrimenti il ​​motivo viene cappeso a "scuro".


Il qè ridondante, e si può verificare la presenza di buio prima, invece, con /../, tio.run/##K05N@f@/WD/a0NjUPDE5NT1WXz@dS19PTz85JbEomys5JzM9o@T//...
Kritixi Lithos

14

Pyth, 18 byte

@c2"lightdark"iz35

Interpretare l'input come un numero di base 35, tagliare lightdarka metà, stampare.


13

ShadyAsFuck, 91 byte / BrainFuck, 181 byte

Il mio primo vero programma BrainFuck, grazie a Mego per l'aiuto e per avermi indicato l'archivio degli algoritmi. (Ciò significa che non l'ho fatto davvero da solo, ma ho copiato alcuni algoritmi esistenti. Ancora un'esperienza =)

NKnmWs3mzhe5aAh=heLLp5uR3WPPPPagPPPPsuYnRsuYgGWRzPPPPlMlk_PPPPPP4LS5uBYR2MkPPPPPPPP_MMMkLG]

Questa è ovviamente la traduzione delle mie risposte brainfuck:

,>,[<+>-]++<[->-[>+>>]>[+[-<+>]>+>>]<<<<<]>[-]>>[-]++++++++++[>++++++++++<-]<[<+>>+<-]<[>+<-]+>>[>++++++++.---.--.+.++++++++++++.<<<->>[-]]<<[>>>.---.+++++++++++++++++.-------.<<<-]

Sviluppato usando questo interprete / debugger .

Ho rubato due frammenti di codice per divmode if/elseda qui. (Grazie a @Mego!)

,>,               read input
[<+>-]            add
++<               set second cell to 2 

Ora abbiamo la configurazione delle celle >sum 2e ora eseguiamo l'algoritmo divmod:

[->-[>+>>]>[+[-<+>]>+>>]<<<<<]>
[-]>

L'output del divmod è simile a questo, 0 d-n%d >n%d n/dma abbiamo azzerato d-n%de stiamo azzerando anche la cella successiva:

>[-]

Riempi una cella fino al valore 100per un output più facile:

++++++++++[>++++++++++<-]< 

Ora la configurazione è >cond 0 100e per applicare l' if/elsealgoritmo abbiamo bisogno di due variabili temporanee, quindi scegliamo la configurazionetemp0 >c temp1 100

c[<temp0+>>temp1+<c-]<temp0[>c+<temp0-]+
>>temp1[
 #>++++++++.---.--.+.++++++++++++.<         outputs light
 <<temp0-
>>temp1[-]]
<<temp0[
 #>>>.---.+++++++++++++++++.-------.<<<     outputs dark
temp0-]

12

Python 2, 45 byte

print'dlairgkh t'[sum(map(ord,input()))%2::2]

Accetta input come "a1". Provalo online


Questo non funzionerebbe in Python 3 a causa della mancanza di parentesi per la stampa.
isaacg,

Impossibile "ldiagrhgt"[expression::2]
eseguire il


10

Codice di Turing Machine, 235 byte

Utilizzando la sintassi della tabella delle regole qui definita .

0 a _ r 1
0 c _ r 1
0 e _ r 1
0 g _ r 1
0 * _ r 2
1 2 _ r 3
1 4 _ r 3
1 6 _ r 3
1 8 _ r 3
2 1 _ r 3
2 3 _ r 3
2 5 _ r 3
2 7 _ r 3
* * _ r 4
3 _ l r A
A _ i r B
B _ g r C
C _ h r D
D _ t r halt
4 _ d r E
E _ a r F
F _ r r G
G _ k r halt

1
Questa è forse la cosa più sorprendente che abbia mai visto lol
Lucas,

10

JavaScript (ES6), 45 byte

alert(parseInt(prompt(),35)%2?"dark":"light")

strada da fare per usare un radix! +1 FTW ...
WallyWest,

9

TI-BASIC, 66 byte

Testato su una calcolatrice TI-84 +.

Input Str1
"light
If inString("bdfh",sub(Str1,1,1)) xor fPart(.5expr(sub(Str1,2,1
"dark
Ans

Ecco una variante più interessante sulla terza riga, che purtroppo ha esattamente le stesse dimensioni:

Input Str1
"dark
If variance(not(seq(inString("bdfh2468",sub(Str1,X,1)),X,1,2
"light
Ans

Penseresti che TI-BASIC sarebbe decente in questa sfida, dal momento che coinvolge il modulo 2. Non lo è; queste soluzioni sembrano essere le più brevi possibili.

Spendiamo molti byte per ottenere entrambi i caratteri nella stringa, ma ciò che costa davvero sono le tredici lettere minuscole a due byte.


9

Befunge-93 , 39 37 33 31 byte

Tutto il merito a Linus che ha suggerito questa soluzione a 31 byte:

<>:#,_@  v%2-~~
"^"light"_"krad

Provalo usando questo interprete .

Spiegazione

<        v%2-~~

<L'all'inizio invia il puntatore istruzioni a sinistra, dove si avvolge intorno a destra. Quindi legge due caratteri dall'input come ASCII, li sottrae e fa un modulo di 2. Come ae 1sono entrambi dispari (in termini di codice ASCII), questo funziona. Il vreindirizza il puntatore all'istruzione verso il basso ...

"^"light"_"krad

... su _, che invia il puntatore dell'istruzione a sinistra se la parte superiore dello stack è 0 e a destra altrimenti. I personaggi di "chiaro" o "scuro", rispettivamente, vengono inseriti nella pila in ordine inverso. Entrambi i percorsi colpiscono ^a sinistra, il che invia il puntatore dell'istruzione verso l'alto ...

 >:#,_@

... al segmento di uscita. :duplica la parte superiore dello stack, #salta sopra ,e su _, il che invia il puntatore dell'istruzione a destra se la parte superiore dello stack è 0 e lasciata altrimenti. Quando lo stack è vuoto, la parte superiore dello stack (dopo :) è 0, quindi il puntatore dell'istruzione colpisce il @quale interrompe l'esecuzione. Altrimenti, colpisce il ,, che emette la parte superiore dello stack come personaggio, quindi lo #salta sopra :e sul >, il che avvia nuovamente il processo.


salvare un byte usando rad"v>"ksenza spazio?
Linus,

@Linus: "Lo spazio è necessario perché altrimenti sarebbe l'output dar k." Provalo nell'interprete online collegato.
El'endia Starman,

1
Destra. Ad ogni modo, stavo per farlo in befunge ma posso avere solo 2 byte sotto di te ... <>:#,_@ v%2-~~\n"^"light"_"krad, aggiustare la nuova riga.
Linus,

@Linus: è geniale. Grazie!
El'endia Starman,

@JamesHolderness, Nessun duro sentimento. Hai ragione a sottolineare che questo non funziona nell'interprete originale di Befunge-93, le specifiche effettive sono per un toro 80x25. Potresti voler pubblicare la tua versione come risposta propria e spiegare la differenza. Penso che almeno sarebbe più pratico che discutere con me del codice hobby di un anno.
Linus,

8

Japt , 23 22 byte

Japt è una versione abbreviata di Ja vaScri pt . Interprete

Un19 %2?"dark":"light"

Come funziona

          // Implicit: U = input string
Un19      // Convert U from a base 19 number to decimal.
%2        // Take its modulo by 2.
?"dark"   // If this is 1, return "dark".
:"light"  // Else, return "light".
          // Implicit: output last expression

Utilizzando la nuova versione 0.1.3 (rilasciata il 22 novembre), questo diventa 17 byte , più corto di tutti tranne GS2:

Un19 %2?`»rk:¦ght

O, in alternativa, una formula magica: (26 byte)

Un19 %2*22189769+437108 sH
Un19 %2                    // Convert input to base 19 and modulo by 2.
       *22189769+437108    // Where the magic happens (top secret)
                        sH // Convert to a base 32 string.

8

Java, 157 127 124 byte

interface L{static void main(String[]a){System.out.print(new java.util.Scanner(System.in).nextInt(35)%2>0?"dark":"light");}}

Potresti usare un'interfaccia come questa: interface i{static void maindal momento che tutto in un'interfaccia è pubblico per impostazione predefinita
Yassin Hajaj


7

Rubino, cancellato 44 36 byte

puts %w[light dark][gets.to_i(19)%2]

È possibile salvare un byte sostituendolo puts con $><<(nessuno spazio).
Lynn,

@Mauris Lo so, ma mi piace la mia nuova riga finale
daniero

Puoi salvare 3 byte cambiando putsperp
Cyoce

7

C, 55 byte

s;main(){puts(strtol(gets(&s),0,19)&1?"light":"dark");}

Provalo online

Grazie DigitalTrauma per molti suggerimenti sul golf


Penso che tu abbia un extra (dopoputs
Level River St

Questo per 55: s;main(){puts(strtol(gets(&s),0,19)&1?"light":"dark");}. Presuppone che la larghezza intera sia abbastanza grande da contenere 3 caratteri di stringa. Dovresti anche essere in grado di farlo main(s){puts(strtol(gets(&s),0,19)&1?"light":"dark");}per 54, anche se per qualche motivo get () sta restituendo spazzatura sse non globale, quindi segfault.
Trauma digitale

oh wow, base-19. intelligente.
soffice

7

BotEngine , 165 14x11 = 154

v acegbdfh
>ISSSSSSSS
 v<<<<>v<<P
vS1   vS2ke
vS3   vS4re
vS5   vS6ae
vS7   vS8de
>     >   ^
>     >  v
^S2   ^S1el
^S4   ^S3ei
^S6  P^S5eg
^S8 te^S7eh
     ^   <

Eccolo qui evidenziato con i diversi segmenti del percorso:

inserisci qui la descrizione dell'immagine

(Tutti i caratteri non spaziali non evidenziati servono come argomenti per le istruzioni ee - Sognuna di queste istruzioni utilizza il simbolo a sinistra (rispetto alla direzione di viaggio del bot) come argomento)


7

𝔼𝕊𝕄𝕚𝕟, 26 caratteri / 34 byte

ô(שǀ(ï,ḣ)%2?`dark`:`light”

Try it here (Firefox only).


1
Non la chiamerei "compressione" se impiega più byte: P
lirtosiast

1
A questo punto sono più preoccupato per i caratteri che per i byte. Ho completamente rinunciato a cercare di ridurre il numero di byte in 𝔼𝕊𝕄𝕚𝕟 ...
Mama Fun Roll

1
Facciamo sempre un punteggio per byte e mentre è spesso interessante ottimizzare per un obiettivo secondario, ricorda che vince sempre il minor numero di byte.
Lirtosiast

Sì, lo capisco. In realtà non sto mirando a vincere tanto.
Mama Fun Roll,

7

C, 49 byte

main(c){gets(&c);puts(c+c/256&1?"light":"dark");}

No, non si compila.
xsot,

Oh, mio ​​Dio, avevo armeggiato con qualcos'altro. L'output è sbagliato, però . Penso che volevi fare gets(&c)%256+c/256?
Lynn,

Oh, buona cattura. Anche se a questo punto, la mia soluzione è strettamente peggiore della tua poiché stiamo usando la stessa tecnica. Sembra che ho molto da imparare.
xsot,

Si è scoperto che l'output errato è stato causato dal valore restituito di gets(&c). Ho aggiornato la mia richiesta di conseguenza.
xsot,

7

Clojure, 63 byte

(pr (['light 'dark] (mod (Integer/parseInt (read-line) 35) 2)))
  • Leggiamo in una riga da stdin con (read-line)
  • Quindi analizzare la stringa in un valore intero nella base 35 utilizzando una chiamata a un metodo JVM
  • Prendere mod del risultato 2 ci dice se è pari o dispari
  • Utilizzare il risultato restituito dalla funzione modulo come indice della sequenza e stamparlo

Risparmio 2 byte meritevoli citando "chiaro" e "scuro" con una singola virgoletta in modo che Clojure la prenda letteralmente, invece di racchiudere ogni parola in una coppia di virgolette. Inoltre, salvo alcuni byte usando pr anziché println.

Alcune informazioni sulla citazione in Clojure


Benvenuti in Puzzle di programmazione e Code Golf! Questa è una bella prima risposta. :) Non ho troppa familiarità con Clojure; ti dispiacerebbe aggiungere una spiegazione?
Alex A.

Assolutamente! Ecco qua Fatemi sapere se avete domande!
MONODA43,

5

Minkolang 0,12 , 28 24 byte

on+2%t"dark"t"light"t$O.

Provalo qui.

Spiegazione

o                   Take character from input
n                   Take integer from input
+                   Add
2%                  Modulo by 2
t      t       t    Ternary; runs first half if top of stack is 0, second half otherwise
 "dark" "light"     Pushes the string "dark" or "light", depending.
$O.                 Output the whole stack as characters and stop.

5

C, 46 byte

main(c){gets(&c);puts(c%37%2?"light":"dark");}

Si aspetta un ambiente in cui intsono memorizzati little-endian e sono almeno due byte.

Spiegazione

cè argc, quindi inizialmente contiene 01 00 00 00. getsleggerà due caratteri, diciamo a (0x61)e 1 (0x31), e li memorizzerà c, che è ora

61 31 00 00

che rappresenta il numero 0x3161 o 12641.

Essenzialmente, in questo problema, dato c = x + 256*y, vogliamo calcolare (x + y) mod 2e stampare una stringa di conseguenza. Per fare questo, avrei potuto scrivere c % 255 % 2, come allora

  (x + 256 * y) % 255 % 2
= (x % 255 + y % 255) % 2      since 256 ≡ 1 (mod 255)
= (x + y) % 2                  since 0 < x, y < 255

Tuttavia, 37funziona anche:

  (x + 256 * y) % 37 % 2
= (x % 37 - 3 * (y % 37)) % 2  since 256 ≡ -3 (mod 37)

xè compreso nell'intervallo 49-57 (cifre 1-8), quindi x % 37 == x - 37.

yè compreso nell'intervallo 97-104 compreso (ah minuscolo), quindi y % 37 == y - 74.

Ciò significa che possiamo semplificare

= (x - 3 * y + 185) % 2
= (x + y + 1) % 2              since -3 ≡ 185 ≡ 1 (mod 2)

e capovolgi semplicemente le stringhe per correggere la parità.


5

Beam , 127 byte

rSr>`+v
   ^  )
n(`)nS<
    >L'''''>`+++++)S>`+++)@---@'''>`+++++)++@-------@H
>L'''''>`+++)S>`++++++)+++@---@--@+@'''>`++++)@H

Una spiegazione inserisci qui la descrizione dell'immagine Blu chiaro: leggi un carattere dall'ingresso nel raggio, salva il valore del raggio nel negozio, leggi un carattere dall'ingresso nel raggio.

Blu scuro - Aggiunge il punto vendita al raggio decrementando il punto vendita a 0 aumentando il raggio

Verde chiaro - Un costrutto di prova dispari. Il loop uscirà a sinistra se il raggio è pari o a destra se dispari.

Verde scuro - Emette scuro

Tan - Emette luce


5

O , 22 17 byte

i # 2% "light'dark"?

Questo fa quello che è necessario fare, senza ulteriori vantaggi.


5

Labyrinth , 48 46 45 42 byte

Grazie a Sp3000 per il salvataggio di due byte.

-,"
#
%0:::8.5.3.4.116.@
1
00.97.114.107.@

Provalo online!

Spiegazione

L'inizio del codice è un vicolo cieco divertente. Ricorda che Labyrinth assume un numero infinito di zeri quando richiede operandi nella parte inferiore dello stack. Il codice inizia uno -a destra, che tenta di sottrarre due numeri, quindi lo stack diventa:

[ ... 0 ]

Quindi ,legge il primo carattere, ad aesempio:

[ ... 0 97 ]

Il "è un no-op, ma anche questo è un vicolo cieco in modo che i giri puntatore all'istruzione intorno e inizia andando a sinistra. Quindi `legge l'altro personaggio, di ' 2:

[ ... 0 97 50 ]

Questa volta -sottrae quei due numeri:

[ ... 0 47 ]

L'IP ora segue la curva del "corridoio". Il #ottiene la profondità dello stack, ignorando gli zeri implicite, il che avviene convenientemente essere 2:

[ ... 0 47 2 ]

E %calcola il modulo:

[ ... 0 1 ]

A questo punto, l'IP è a un incrocio. Se la parte superiore della pila è zero, si sposterà in avanti, dove vengono 100.97.114.107.@stampate dark. Ma se la parte superiore della pila è diversa da zero (in particolare, 1), si sposterà a destra, dove 0:::8.5.3.4.116.@stampa light(nota che possiamo omettere il comando iniziale 1, perché c'è già una 1pila, e possiamo salvare su quella ripetuta 10in 108, 105, 103, 104facendo alcune copie del 10quando abbiamo prima ci arriviamo).


4

Matlab, 51 byte

Non penso che questo abbia bisogno di alcuna spiegazione =)

a={'light','dark'};disp(a(2-mod(sum(input('')),2)))

4

> <> , 31 byte

ii+2%?\"krad"oooo;
l"oc0.\"thgi

Qui sto pensando "deve esserci un modo migliore ..."


4

Perl, 29 27 byte

$_=/./&($'+ord)?light:dark

Questo codice richiede lo -pswitch, che ho contato come 1 byte.

Provalo online su Ideone .

Come funziona

  • A causa -pdell'opzione, Perl legge una riga di input e la memorizza in $_.

  • /./è un'espressione regolare che corrisponde a un carattere. Ciò ha due implicazioni:

    • Poiché la partita ha esito positivo, /./restituisce 1 .

    • Il post-match (secondo carattere di input) è memorizzato in $'.

  • $'+ordaggiunge il numero intero che il secondo carattere di input rappresenta al punto di codice ( ord) del primo carattere della variabile implicita $_.

  • &prende il bit bit AND del valore di ritorno di /./e la somma $'+ord, restituendo 1 è la somma se dispari, 0 se è pari.

  • ?light:darkrestituisce luce se l'espressione precedente ha restituito 1 e scuro altrimenti.

  • Infine $_=assegna il risultato a $_cui Perl stampa automaticamente, a causa del -p passaggio.

Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.