Seu desafio é escrever um programa que produza a cor de um determinado quadrado no tabuleiro de xadrez. É assim que um tabuleiro de xadrez se parece:

Você pode ver que o quadrado a1 é escuro e h1 é um quadrado claro. Seu programa precisa produzir darkou light, quando receber um quadrado. Alguns exemplos:

STDIN:  b1
STDOUT: light

STDIN:  g6
STDOUT: light

STDIN:  d4
STDOUT: dark

As regras:

• Você precisa fornecer um programa completo que use STDIN e use STDOUT para produzir darkou light.
• Suponha que a entrada seja sempre válida ( [a-h][1-8])
• Isso é código-golfe , e a menor quantidade de bytes ganha!

Placar

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 bytes

de♦dark•light♠5

O código-fonte usa a codificação CP437 . Experimente online!

Verificação

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

Como funciona

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 bytes

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

3 bytes graças ao Mego para entrelaçamento de strings

Toma entrada como "g6". Isso é claro e escuro entrelaçados.

Hexagonia , 34 32 bytes

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

Desdobrado e com caminhos de execução anotados:

^{Diagrama gerado com o incrível HexagonyColorer de Timwi .}

O caminho púrpura é o caminho inicial que lê dois caracteres, calcula a diferença e assume o módulo 2. Em <seguida, atua como um ramo, onde o caminho cinza escuro (resultado 1) é impresso darke o caminho cinza claro (resultado 0) é impresso light.

Quanto a como eu calculo a diferença e o módulo, aqui está um diagrama da grade de memória (com valores obtidos para a entrada a1):

^{Diagrama gerado com o IDE Esotérico ainda mais incrível do Timwi (que possui um depurador visual para Hexagony).}

O ponteiro de memória começa na linha rotulada pela borda , onde lemos o caractere. }move para a borda rotulada col , onde lemos o dígito. "move para a aresta denominada diff, onde -calcula a diferença dos dois. 'move-se para a célula não rotulada onde colocamos o 2e {=move-se para a célula rotulada mod onde computamos o módulo %.

Isso pode ser jogado por alguns bytes pela reutilização de alguns dos itens ;, mas duvido que possa ser jogado por muito, certamente não pelo lado 3.

CJam, 18 bytes

r:-)"lightdark"5/=

Demonstração online

Dissecação

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

Explicação

s/[1357aceg]//gremove todas as coordenadas com índices ímpares. O buffer padrão resultante possui comprimento 1 para "claro" ou comprimento 0 ou 2 para "escuro". /^.$/corresponde aos padrões de 1 comprimento, csuspende o padrão para "light" e quits. Caso contrário, o padrão é cpendurado em "escuro".

Pitão, 18 bytes

@c2"lightdark"iz35

Interprete a entrada como um número base 35, corte lightdarkao meio, imprima.

ShadyAsFuck, 91 bytes / BrainFuck, 181 bytes

Meu primeiro programa real do BrainFuck, agradeço à Mego pela ajuda e por me indicar o arquivo de algoritmos. (Isso significa que eu realmente não fiz isso sozinho, mas copiei alguns algoritmos existentes. Ainda é uma experiência =)

NKnmWs3mzhe5aAh=heLLp5uR3WPPPPagPPPPsuYnRsuYgGWRzPPPPlMlk_PPPPPP4LS5uBYR2MkPPPPPPPP_MMMkLG]

Esta é, obviamente, a tradução das minhas respostas brainfuck:

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

Desenvolvido usando este intérprete / depurador .

Roubei dois trechos de código para divmode if/elsedesde aqui. (Obrigado a @Mego!)

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

Agora temos a configuração das células >sum 2e agora executamos o algoritmo divmod:

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

A saída do divmod se parece com isso, 0 d-n%d >n%d n/dmas zeramos e zeramos d-n%da próxima célula também:

>[-]

Preencha uma célula até o valor 100para obter resultados mais fáceis:

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

Agora a configuração é >cond 0 100e, para aplicar o if/elsealgoritmo, precisamos de duas variáveis ​​temporárias, por isso escolhemos a configuraçãotemp0 >c temp1 100

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

Python 2, 45 bytes

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

Toma entrada como "a1". Experimente online

Sério , 19 bytes

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

Toma entrada como "a1"

Experimente on-line (você precisará inserir manualmente a entrada; os links permanentes não gostam de aspas)

Código da máquina de Turing, 235 bytes

Usando a sintaxe da tabela de regras definida aqui.

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 bytes

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

TI-BASIC, 66 bytes

Testado em uma calculadora TI-84 +.

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

Aqui está uma variação mais interessante na terceira linha, que infelizmente é exatamente do mesmo tamanho:

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

Você pensaria que o TI-BASIC seria decente nesse desafio, pois envolve o módulo 2. Não é; essas soluções parecem ser as mais curtas possíveis.

Gastamos muitos bytes para obter os dois caracteres na sequência, mas o que realmente custa são as treze letras minúsculas de dois bytes.

Befunge-93 , 39 37 33 31 bytes

Todo o crédito a Linus, que sugeriu esta solução de 31 bytes:

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

Teste-o usando este intérprete .

Explicação

<        v%2-~~

O <no início envia o ponteiro de instruções para a esquerda, onde ele envolve a direita. Ele então lê dois caracteres da entrada como ASCII, subtrai-os e faz um módulo por 2. Como ae 1são ambos ímpares (em termos de código ASCII), isso funciona. O vredireciona o ponteiro de instruções para baixo ...

"^"light"_"krad

... para o _, que envia o ponteiro de instrução para a esquerda, se o topo da pilha for 0, e para a direita, caso contrário. Os caracteres de "claro" ou "escuro", respectivamente, são inseridos na pilha na ordem inversa. Ambos os caminhos atingem o ^lado esquerdo, o que envia o ponteiro da instrução para cima ...

 >:#,_@

... para o segmento de saída. :duplica a parte superior da pilha, #pula sobre ,e na _, o que envia o ponteiro de instruções para a direita se a parte superior da pilha for 0 e deixada em contrário. Quando a pilha está vazia, o topo da pilha (depois :) é 0; portanto, o ponteiro da instrução atinge o @que interrompe a execução. Caso contrário, ele atinge o ,, que gera o topo da pilha como um caractere, e então o #pula sobre o :e para o >, o que inicia o processo novamente.

Japonês , 23 22 bytes

Japt é uma versão abreviada do Ja vaScri pt . Intérprete

Un19 %2?"dark":"light"

Como funciona

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

Usando a nova versão 0.1.3 (lançada em 22 de novembro), isso se torna 17 bytes , mais curto que todos, exceto o GS2:

Un19 %2?`»rk:¦ght

Ou, alternativamente, uma fórmula mágica: (26 bytes)

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 bytes

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

TeaScript , 23 bytes

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

Infelizmente as strings darke lightnão podem ser compactadas.

Ruby, riscado 44 36 bytes

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

C, 55 bytes

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

Experimente online

Obrigado DigitalTrauma por muitas dicas de golfe

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

Aqui está com os diferentes segmentos de caminho destacados:

(Quaisquer caracteres não espaciais não destacados servem como argumentos para as instruções ee - Scada uma dessas instruções usa o símbolo à esquerda (em relação à direção da viagem do bot) como argumento)

, 26 caracteres / 34 bytes

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

Try it here (Firefox only).

C, 49 bytes

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

Clojure, 63 bytes

(pr (['light 'dark] (mod (Integer/parseInt (read-line) 35) 2)))

• Lemos em uma linha de stdin com (linha de leitura)
• Em seguida, analise a sequência em um valor inteiro na base 35 usando uma chamada para um método JVM
• Tomando mod do resultado 2 nos diz se é par ou ímpar
• Use o resultado retornado da função módulo como um índice para a sequência e imprima-o

Eu economizo 2 bytes, citando "claro" e "escuro" com uma única citação, para que Clojure tome isso como literal, em vez de agrupar cada palavra entre aspas. Também guardo alguns bytes usando pr em vez de println.

Algumas informações sobre a citação no Clojure

Tamanho 0.12 , 28 24 bytes

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

Experimente aqui.

Explicação

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 bytes

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

Espera um ambiente em que ints sejam armazenados little-endian e tenham pelo menos dois bytes.

Explicação

cé argc, então inicialmente ele contém 01 00 00 00. getslerá dois caracteres, digamos a (0x61)e 1 (0x31), e os armazenará c, que agora é

61 31 00 00

representando o número 0x3161 ou 12641.

Essencialmente, neste problema, dado c = x + 256*y, queremos calcular (x + y) mod 2e imprimir uma string de acordo. Para fazer isso, eu poderia ter escrito c % 255 % 2, como então

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

No entanto, 37também funciona:

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

xestá no intervalo de 49 a 57 inclusive (dígitos 1 a 8), então x % 37 == x - 37.

yestá no intervalo de 97 a 104 inclusive (ah em minúsculas), então y % 37 == y - 74.

Isso significa que podemos simplificar para

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

e simplesmente gire as cordas para corrigir a paridade.

Feixe , 127 bytes

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

Uma explicação Azul claro - leia um caractere da entrada no feixe, salve o valor do feixe na loja, leia um caractere da entrada no feixe.

Azul escuro - Adiciona armazenamento ao feixe, diminuindo o armazenamento para 0 enquanto incrementa o feixe

Verde claro - Uma construção de teste ainda ímpar. O loop sairá para a esquerda se o feixe for par ou o direito se for ímpar.

Verde escuro - sai escuro

Bronzeado - Saída de luz

O , 22 17 bytes

eu # 2% "light'dark"?

Isso faz o que é necessário fazer, sem benefícios adicionais.

Labirinto , 48 46 45 42 bytes

Obrigado ao Sp3000 por salvar dois bytes.

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

Experimente online!

Explicação

O início do código é um beco sem saída engraçado. Lembre-se de que o Labyrinth assume um número infinito de zeros quando requer operandos na parte inferior da pilha. O código inicia um na ordem -correta, que tenta subtrair dois números, para que a pilha se torne:

[ ... 0 ]

Em seguida, ,lê o primeiro caractere, adiga:

[ ... 0 97 ]

O "é um no-op, mas também é um beco sem saída, então o ponteiro da instrução se vira e começa a ir para a esquerda. Então `lê o outro personagem, 2diga:

[ ... 0 97 50 ]

Desta vez, -subtrai esses dois números:

[ ... 0 47 ]

O IP agora segue a curva do "corredor". O #fica a profundidade da pilha, ignorando os zeros implícitas, que, convenientemente, passa a ser 2:

[ ... 0 47 2 ]

E %calcula o módulo:

[ ... 0 1 ]

Neste ponto, o IP está em uma junção. Se a parte superior da pilha for zero, ela seguirá em frente, onde será 100.97.114.107.@impressa dark. Mas se a parte superior da pilha for diferente de zero (especificamente 1), ela se moverá para a direita, onde será 0:::8.5.3.4.116.@impressa light(observe que podemos omitir a liderança 1, porque já existe uma 1na pilha e podemos economizar nas repetidas 10em 108, 105, 103, 104por fazer algumas cópias do 10quando chegar lá).

Matlab, 51 bytes

Eu não acho que isso precise de explicação =)

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

> <> , 31 bytes

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

Aqui eu estou pensando "tem que haver uma maneira melhor ..."

Perl, 29 27 bytes

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

Esse código requer a -popção, que contei como 1 byte.

Experimente online no Ideone .

Como funciona

• Por causa da -popção, o Perl lê uma linha de entrada e a armazena $_.

• /./é uma expressão regular que corresponde a um caractere. Isso tem duas implicações:

  • Como a partida foi bem-sucedida, /./retorna 1 .

  • A pós-correspondência (segundo caractere de entrada) é armazenada em $'.

• $'+ordadiciona o número inteiro que o segundo caractere de entrada representa ao ponto de código ( ord) do primeiro caractere da variável implícita $_.

• &toma o AND bit a bit do valor de retorno /./e da soma $'+ord, retornando 1 é a soma se ímpar, 0 se for par.

• ?light:darkretorna claro se a expressão anterior retornou 1 e escuro, caso contrário.

• Finalmente, $_=atribui o resultado ao $_qual Perl imprime automaticamente, por causa da -p opção.