Déterminer la couleur d'un carré d'échecs


59

Votre défi consiste à écrire un programme qui affiche la couleur d’un carré donné sur l’échiquier. Voici à quoi ressemble un échiquier:

entrez la description de l'image ici

Vous pouvez voir que le carré a1 est sombre et que h1 est un carré clair. Votre programme doit sortir darkou light, quand on lui donne un carré. Quelques exemples:

STDIN:  b1
STDOUT: light

STDIN:  g6
STDOUT: light

STDIN:  d4
STDOUT: dark

Les règles:

  • Vous devez fournir un programme complet qui utilise STDIN et utilise STDOUT pour la sortie darkou light.
  • Supposons que l'entrée est toujours valide ( [a-h][1-8])
  • C'est du , donc le plus petit nombre d'octets gagne!

Tableau de bord

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
Pourquoi personne n'a essayé <> ^ poisson?
ghosts_in_the_code

Réponses:


46

GS2 , 17 à 15 octets

de♦dark•light♠5

Le code source utilise le codage CP437 . Essayez-le en ligne!

Vérification

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

Comment ça fonctionne

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
C'est incroyable! Avec 9 octets inévitables, Pyth et CJam sur 3 octets sont incroyables.
isaacg

29
Bon Dieu, les gars, GS2 est le nouveau Pyth! Quelqu'un a compris comment l'utiliser bien avant Denni ... ça ne fait rien.
ETHproductions

56

Python 2, 41 38 octets

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

3 octets grâce à Mego pour l'entrelacement de chaînes

Prend les entrées comme "g6". C'est la lumière et l'obscurité entrelacées.


C'est juste magnifique avec l'entrelacement de la chaîne.
Wayne Werner

5
En fait, je dirais que int(input(),35)c'est la partie la plus brillante. J'ai pensé à l'entrelacement des chaînes, mais votre méthode d'entrée enregistre le plus grand nombre d'octets.
mbomb007

26

Hexagonie , 34 32 octets

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

Déplié et avec des chemins d'exécution annotés:

entrez la description de l'image ici
Diagramme généré avec l' incroyable HexagonyColorer de Timwi .

Le chemin violet est le chemin initial qui lit deux caractères, calcule leur différence et le prend modulo 2. Il <agit alors comme une branche, où le chemin gris foncé (résultat 1) est imprimé darket le chemin gris clair (résultat 0) light.

Pour ce qui est de la façon dont je calcule la différence et le modulo, voici un diagramme de la grille de mémoire (avec les valeurs prises pour l’entrée a1):

entrez la description de l'image ici
Diagramme généré avec l' IDE Esoteric encore plus étonnant de Timwi (qui a un débogueur visuel pour Hexagony).

Le pointeur de mémoire commence sur le bord étiqueté ligne , où nous lisons le caractère. }se déplace vers le bord étiqueté col , où nous lisons le chiffre. "se déplace vers le bord nommé diff-calcule la différence entre les deux. 'se déplace vers la cellule non étiquetée où nous mettons la 2, et {=se déplace vers la cellule étiquetée mod où nous calculons le modulo avec %.

Cela pourrait être golfable de quelques octets en réutilisant une partie de la ;, mais je doute qu’on puisse jouer au golf beaucoup, certainement pas jusqu’à la longueur de côté 3.


7
Ooh, jolies couleurs!
Celeo

1
Ce langage est nouveau pour moi, mais je suis étonné de votre capacité à proposer quelque chose de plus artificiel que je ne le pensais possible
Qwr

18
Je ne comprends vraiment pas toutes ces langues de golf.
juniorRubyist

4
@ codeSwift4Life Hexagony est loin d’être une langue de golf. Pour des tâches aussi simples que celle-ci, il peut être relativement compétitif, car il comporte des commandes à caractère unique, mais c’est une nécessité commune à de nombreux autres langages 2D , notamment Befunge, Piet,> <>. Toute tâche non triviale nécessitera de très grandes quantités de code et des programmes compliqués, en raison du modèle de mémoire étrange de Hexagony. Il ne s'agit en aucun cas d'un langage concis, mais plutôt d'un langage exotique et étrange, explorant la programmation sur des grilles hexagonales.
Martin Ender

3
@qwr Je pensais qu'être artificiel était le but des esolangs. ;)
Martin Ender

21

CJam, 18 octets

r:-)"lightdark"5/=

Démo en ligne

Dissection

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
votre code est souriant:-)
Bouton de porte

8
J'ai aussi jugé efficace:^)
Peter Taylor

2
S'il vous plaît pouvez-vous expliquer comment cela fonctionne.
Fogmeister

@Fogmeister, ajout d'une explication.
Peter Taylor

17

sed, 37

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

Explication

s/[1357aceg]//gsupprime toutes les coordonnées impaires indexées. Le tampon de motif résultant a alors une longueur de 1 pour "clair" ou de 0 ou 2 pour "sombre". /^.$/correspond aux motifs 1-longueur, cHanges le motif à « lumière » et quits. Sinon, le motif est cpendu à "sombre".


Le qest redondant, et vous pouvez vérifier d' abord au lieu sombre avec /../, tio.run/##K05N@f@/WD/a0NjUPDE5NT1WXz@dS19PTz85JbEomys5JzM9o@T//...
Kritixi Lithos

14

Pyth, 18 octets

@c2"lightdark"iz35

Interprétez l’entrée comme un numéro de base, coupez-la lightdarken deux, imprimez.


13

ShadyAsFuck, 91 octets / BrainFuck, 181 octets

Mon premier vrai programme BrainFuck, remercie Mego pour son aide et pour m'avoir dirigé vers l'archive d'algorithmes. (Cela signifie que je ne l'ai pas vraiment fait moi-même, mais que j'ai copié certains algorithmes existants. Encore une expérience =)

NKnmWs3mzhe5aAh=heLLp5uR3WPPPPagPPPPsuYnRsuYgGWRzPPPPlMlk_PPPPPP4LS5uBYR2MkPPPPPPPP_MMMkLG]

C’est bien sûr la traduction de mes réponses stupides:

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

Développé à l'aide de cet interpréteur / débogueur .

J'ai volé deux extraits de code pour divmodet à if/elsepartir d' ici. (Merci à @Mego!)

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

Maintenant que nous avons la configuration des cellules, >sum 2nous effectuons maintenant l'algorithme divmod:

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

La sortie du divmod ressemble à ceci, 0 d-n%d >n%d n/dmais nous avons également mis à d-n%dzéro la cellule suivante:

>[-]

Remplissez une cellule jusqu'à la valeur 100pour faciliter la sortie:

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

Maintenant, la configuration est >cond 0 100et pour appliquer l’ if/elsealgorithme nous avons besoin de deux variables temporaires, nous avons donc choisi la configuration.temp0 >c temp1 100

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

12

Python 2, 45 octets

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

Prend les entrées comme "a1". Essayez-le en ligne


Cela ne fonctionnerait pas dans Python 3 en raison du manque de parens pour l’impression.
isaacg

Je ne peux pas tester pour le moment, mais quelque chose comme "ldiagrhgt"[expression::2]devrait fonctionner tout en sauvegardant un octet ou deux
FryAmTheEggman


10

Code de la machine de Turing, 235 octets

Utilisation de la syntaxe de la table de règles définie ici.

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
C'est peut-être la chose la plus étonnante que j'ai jamais vue lol
Lucas

10

JavaScript (ES6), 45 octets

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

chemin à parcourir pour utiliser une base! +1 FTW ...
WallyWest

9

TI-BASIC, 66 octets

Testé sur une calculatrice TI-84 +.

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

Voici une variation plus intéressante sur la troisième ligne, qui a malheureusement exactement la même taille:

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

On pourrait penser que TI-BASIC serait décent face à ce défi, puisqu'il implique le modulo 2. Ce n'est pas le cas; ces solutions semblent être les plus courtes possibles.

Nous passons beaucoup d'octets pour obtenir les deux caractères dans la chaîne, mais ce qui coûte réellement, ce sont les treize lettres minuscules à deux octets.


9

Befunge-93 , 39 37 33 31 octets

Tout crédit à Linus qui a suggéré cette solution à 31 octets:

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

Testez-le avec cet interprète .

Explication

<        v%2-~~

Au <début, le pointeur d'instruction est envoyé à gauche, où il tourne à droite. Il lit ensuite deux caractères de l'entrée en tant qu'ASCII, les soustrait et effectue un modulo de 2. Comme aet 1sont tous les deux impairs (en termes de code ASCII), cela fonctionne. Le vredirige le pointeur d'instruction vers le bas ...

"^"light"_"krad

... sur le _, ce qui envoie le pointeur d'instruction à gauche si le haut de la pile est à 0 et à droite sinon. Les caractères de "clair" ou "sombre", respectivement, sont poussés sur la pile dans l'ordre inverse. Les deux chemins atteignent la ^gauche, ce qui envoie le pointeur d'instruction vers le haut ...

 >:#,_@

... au segment de sortie. :duplique le haut de la pile, #saute par-dessus le ,et sur le _, ce qui envoie le pointeur d'instruction à droite si le haut de la pile est à 0 et à gauche sinon. Lorsque la pile est vide, le haut de la pile (après :) est égal à 0. Le pointeur d'instruction frappe alors le @qui arrête l'exécution. Sinon, il frappe le ,, qui affiche le haut de la pile sous forme de caractère, puis le #saute par dessus le :et sur le >, ce qui relance le processus.


enregistrer un octet en utilisant rad"v>"ksans espace?
Linus

@ Linus: "L'espace est nécessaire car sinon la sortie serait dar k." Essayez-le dans l'interprète en ligne lié.
El'endia Starman

1
Tu as raison. Quoi qu'il en soit, j'allais le faire dans befunge mais je ne peux obtenir que 2 octets sous vous ... <>:#,_@ v%2-~~\n"^"light"_"krad, corrigez la nouvelle ligne.
Linus

@ Linus: C'est brillant. Merci!
El'endia Starman

@ JamesHolderness, pas de rancune. Vous avez raison de dire que cela ne fonctionne pas dans l'interprète original Befunge-93, la spécification actuelle concerne un tore de 80x25. Vous voudrez peut-être publier votre version car c'est sa propre réponse et expliquer la différence. Je pense au moins que ce serait plus pratique que de débattre avec moi d'un code de loisir d'un an.
Linus

8

Japt , 23 22 octets

Japt est une version abrégée de Ja vaScri pt . Interprète

Un19 %2?"dark":"light"

Comment ça fonctionne

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

Avec la nouvelle version 0.1.3 (publiée le 22 novembre), cela devient 17 octets , plus court que tout sauf GS2:

Un19 %2?`»rk:¦ght

Ou, alternativement, une formule magique: (26 octets)

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 octets

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

Vous pouvez utiliser une interface comme celle-ci: interface i{static void mainpuisque tout dans une interface est public par défaut
Yassin Hajaj


7

Ruby, rayé de 44 36 octets

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

Vous pouvez enregistrer un octet en le remplaçant puts par $><<(sans espace).
Lynn

@Mauris Je sais, mais j'aime bien ma nouvelle ligne terminale
daniero

Vous pouvez économiser 3 octets en changeant putspourp
Cyoce

7

C, 55 octets

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

Essayez-le en ligne

Merci DigitalTrauma pour beaucoup de conseils de golf


Je pense que vous avez un extra (aprèsputs
Level River St

Ce 55: s;main(){puts(strtol(gets(&s),0,19)&1?"light":"dark");}. Suppose que la largeur de l’entier est suffisamment grande pour contenir 3 caractères de chaîne. Vous devriez également pouvoir le faire main(s){puts(strtol(gets(&s),0,19)&1?"light":"dark");}pour 54 ans, bien que pour une raison quelconque, gets () retourne garbage ssi ce n’est pas global, il segfafaults.
Digital Trauma

oh wow, base-19. intelligent.
moelleux

7

Moteur Bot , 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
     ^   <

La voici avec les différents segments de chemin mis en évidence:

entrez la description de l'image ici

(Tous les caractères non-espace non surlignés servent d'arguments pour les instructions eet - Schacune de ces instructions utilise le symbole situé à gauche (par rapport à la direction de déplacement du bot) comme argument)


7

, 26 caractères / 34 octets

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

Try it here (Firefox only).


1
Je n’appellerais pas cela "compression" si cela prend plus d’ octets: P
lirtosiast

1
Je suis plus inquiet pour les caractères que pour les octets à ce stade. J'ai complètement renoncé à essayer de jouer au golf en octets en ...
Mama Fun Roll

1
Nous marquons toujours octets, et s'il est souvent intéressant d'optimiser un objectif secondaire, n'oubliez pas que le moins d'octets l'emporte toujours.
lirtosiast

Oui, je comprends ça. Cependant, je ne cherche pas vraiment à gagner autant.
Mama Fun Roll

7

C, 49 octets

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

Non, ça ne compile pas.
xsot

Oh mon dieu, j'avais tripoté autre chose. La sortie est fausse, cependant . Je pense que tu voulais faire gets(&c)%256+c/256?
Lynn

Oh, bonne prise. Bien qu'à ce stade, ma solution soit strictement pire que la vôtre, car nous utilisons la même technique. On dirait que j'ai beaucoup à apprendre.
xsot

Il s’avère que la mauvaise sortie a été provoquée par la valeur de retour de gets(&c). J'ai mis à jour ma soumission en conséquence.
xsot

7

Clojure, 63 octets

(pr (['light 'dark] (mod (Integer/parseInt (read-line) 35) 2)))
  • Nous lisons dans une ligne de stdin avec (read-line)
  • Puis analyser la chaîne dans une valeur entière en base 35 en utilisant un appel à une méthode JVM
  • Prendre mod du résultat 2 nous dit si c'est pair ou impair
  • Utilisez le résultat renvoyé par la fonction modulo comme index de la séquence et imprimez-le.

J'économise 2 octets dignes en citant "clair" et "sombre" avec une seule citation afin que Clojure le prenne comme un littéral, par opposition à l'encapsulation de chaque mot entre deux guillemets. Je sauve aussi quelques octets en utilisant pr plutôt que println.

Quelques infos sur la cotation à Clojure


Bienvenue dans Programmation Puzzles et Code Golf! C'est une belle première réponse. :) Je ne connais pas trop Clojure; cela vous dérangerait-il d'ajouter une explication?
Alex A.

Absolument! Voilà. Faites moi savoir si vous avez des questions!
MONODA43

5

Minkolang 0.12 , 28 24 octets

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

Essayez ici.

Explication

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 octets

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

Attend un environnement où ints sont stockés en little-endian et ont au moins deux octets.

Explication

cest argc, donc initialement il contient 01 00 00 00. getslira deux caractères, dire a (0x61)et 1 (0x31), et les stocker dans c, qui est maintenant

61 31 00 00

représentant le nombre 0x3161 ou 12641.

Essentiellement, dans ce problème, étant donné c = x + 256*y, nous voulons calculer (x + y) mod 2et imprimer une chaîne en conséquence. Pour ce faire, j'aurais pu écrire c % 255 % 2, comme alors

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

Cependant, 37fonctionne également:

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

xest compris entre 49 et 57 inclus (chiffres 1-8), donc x % 37 == x - 37.

yse situe dans la plage 97-104 inclus (minuscule ah), donc y % 37 == y - 74.

Cela signifie que nous pouvons simplifier

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

et retournez simplement les chaînes pour corriger la parité.


5

Faisceau , 127 octets

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

Une explication entrez la description de l'image ici Bleu clair - lit un caractère depuis l’entrée dans le faisceau, sauvegarde la valeur du faisceau dans la mémoire, lit un caractère de l’entrée dans le faisceau.

Bleu foncé - Ajoute magasin à faisceau en décrémentant magasin à 0 tout en incrémentant le faisceau

Vert clair - Une construction de test encore impaire. La boucle sortira à gauche si le faisceau est pair ou à droite si elle est impaire.

Vert foncé - Sorties sombres

Tan - Émet la lumière


5

O , 22 17 octets

i # 2% "light'dark"?

Cela fait ce qu'il est nécessaire de faire, sans avantages supplémentaires.


5

Labyrinth , 48 46 45 42 bytes

Merci à Sp3000 pour la sauvegarde de deux octets.

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

Essayez-le en ligne!

Explication

Le début du code est une impasse amusante. N'oubliez pas que Labyrinth suppose un nombre infini de zéros lorsqu'il nécessite des opérandes au bas de la pile. Le code commence par la -droite, qui tente de soustraire deux nombres, ainsi la pile devient:

[ ... 0 ]

Puis ,lit le premier caractère, adites:

[ ... 0 97 ]

Le "est un non-op, mais c'est aussi une impasse donc le pointeur d'instruction se retourne et commence à aller à la gauche. Puis `lit l'autre personnage, 2dites:

[ ... 0 97 50 ]

Cette fois, -soustrait ces deux nombres:

[ ... 0 47 ]

La propriété intellectuelle suit maintenant la courbe du "corridor". La #obtient la profondeur de la pile, en ignorant les zéros implicites, ce qui arrive facilement à être 2:

[ ... 0 47 2 ]

Et %calcule le modulo:

[ ... 0 1 ]

À ce stade, l'IP est à une jonction. Si le sommet de la pile est à zéro, il se déplacera tout droit, où les 100.97.114.107.@impressions dark. Mais si le sommet de la pile est différent de zéro (en particulier, 1), il se déplacera à droite, où est 0:::8.5.3.4.116.@imprimé light(notez que nous pouvons omettre le premier 1, car il y en a déjà un 1sur la pile et nous pouvons économiser sur la répétition. 10dans 108, 105, 103, 104en faisant quelques exemplaires du 10quand nous avons y arriver).


4

Matlab, 51 octets

Je ne pense pas que cela nécessite aucune explication =)

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

4

> <> , 31 octets

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

Ici, je pense "il doit y avoir un meilleur moyen ..."


4

Perl, 29 à 27 octets

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

Ce code nécessite le -pcommutateur, que j'ai compté comme 1 octet.

Essayez-le en ligne sur Ideone .

Comment ça fonctionne

  • A cause du -pcommutateur, Perl lit une ligne d’entrée et la stocke $_.

  • /./est une expression régulière qui correspond à un caractère. Cela a deux implications:

    • Puisque la correspondance est réussie, /./renvoie 1 .

    • La post-correspondance (deuxième caractère saisi) est stockée dans $'.

  • $'+ordajoute le nombre entier représenté par le deuxième caractère saisi au point de code ( ord) du premier caractère de la variable implicite $_.

  • &prend le bit AND ET de la valeur de retour de /./et de la somme $'+ord, renvoyer 1 est la somme si impair, 0 si elle est paire.

  • ?light:darkretourne clair si l'expression précédente a retourné 1 et sombre sinon.

  • Enfin, $_=assigne le résultat à $_, que Perl imprime automatiquement à cause du -p commutateur.

En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.