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

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 code-golf , 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>

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.

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.

Hexagonie , 34 32 octets

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

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

^{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):

^{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 où -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.

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"

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".

Pyth, 18 octets

@c2"lightdark"iz35

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

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

Python 2, 45 octets

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

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

Sérieusement , 19 octets

"dark""light"2,O+%I

Prend des entrées comme "a1"

Essayez-le en ligne (vous devrez entrer manuellement l'entrée; les permaliens n'aiment pas les guillemets)

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

JavaScript (ES6), 45 octets

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

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.

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.

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.

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");}}

TeaScript , 23 octets

®x,35)%2?"dark":"light"

Malheureusement , les chaînes darket lightne peuvent pas être compressés.

Ruby, rayé de 44 36 octets

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

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

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:

(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)

, 26 caractères / 34 octets

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

Try it here (Firefox only).

C, 49 octets

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

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

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.

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é.

Faisceau , 127 octets

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

Une explication 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

O , 22 17 octets

i # 2% "light'dark"?

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

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).

Matlab, 51 octets

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

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

> <> , 31 octets

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

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

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.