Su desafío es escribir un programa que muestre el color de un cuadrado dado del tablero de ajedrez. Así es como se ve un tablero de ajedrez:

Puedes ver que el cuadrado a1 es oscuro y h1 es un cuadrado claro. Su programa necesita salida darko light, cuando se le da un cuadrado. Algunos ejemplos:

STDIN:  b1
STDOUT: light

STDIN:  g6
STDOUT: light

STDIN:  d4
STDOUT: dark

Las normas:

• Debe proporcionar un programa completo que utilice STDIN y STDOUT para generar darko light.
• Suponga que la entrada siempre es válida ( [a-h][1-8])
• Este es el código de golf , por lo que gana la menor cantidad de bytes.

Marcador

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

El código fuente usa la codificación CP437 . Pruébalo en línea!

Verificación

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

Cómo 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 gracias a Mego por el entrelazado de cadenas

Toma entrada como "g6". Eso es claro y oscuro entrelazado.

Hexagonía , 34 32 bytes

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

Desplegado y con rutas de ejecución anotadas:

^{Diagrama generado con el sorprendente HexagonyColorer de Timwi .}

La ruta púrpura es la ruta inicial que lee dos caracteres, calcula su diferencia y toma el módulo 2. <Luego actúa como una rama, donde se 1imprime la ruta gris oscuro (resultado ) darky se imprime la ruta gris claro (resultado 0) light.

En cuanto a cómo calculo la diferencia y el módulo, aquí hay un diagrama de la cuadrícula de memoria (con valores tomados para la entrada a1):

^{Diagrama generado con el IDE esotérico aún más sorprendente de Timwi (que tiene un depurador visual para Hexagony).}

El puntero de memoria comienza en la fila etiquetada en el borde , donde leemos el carácter. }se mueve al borde etiquetado como col , donde leemos el dígito. "se mueve al borde etiquetado como diff donde -calcula la diferencia de los dos. 'se mueve a la celda sin marcar donde colocamos el 2, y se {=mueve a la celda etiquetada como mod donde calculamos el módulo %.

Esto podría ser golfable por unos pocos bytes reutilizando algunos de los ;, pero dudo que se pueda jugar mucho, ciertamente no hasta la longitud lateral 3.

CJam, 18 bytes

r:-)"lightdark"5/=

Demostración en línea

Disección

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

Explicación

s/[1357aceg]//gelimina todas las coordenadas indexadas impares. El búfer de patrón resultante tiene una longitud de 1 para "claro" o una longitud de 0 o 2 para "oscuro". /^.$/coincide con los patrones de 1 longitud, ccuelga el patrón para "iluminar" y quits. De lo contrario, el patrón se ccuelga a "oscuro".

Pyth, 18 bytes

@c2"lightdark"iz35

Interprete la entrada como un número base 35, corte lightdarkpor la mitad, imprima.

ShadyAsFuck, 91 bytes / BrainFuck, 181 bytes

Mi primer programa BrainFuck real, gracias a Mego por la ayuda y por señalarme al archivo de algoritmos. (Eso significa que realmente no lo hice por mi cuenta, sino que copié algunos algoritmos existentes. Todavía una experiencia =)

NKnmWs3mzhe5aAh=heLLp5uR3WPPPPagPPPPsuYnRsuYgGWRzPPPPlMlk_PPPPPP4LS5uBYR2MkPPPPPPPP_MMMkLG]

Esta es, por supuesto, la traducción de mis respuestas brainfuck:

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

Desarrollado con este intérprete / depurador .

Robé dos fragmentos de código para divmody if/elsedesde aquí. (¡Gracias a @Mego!)

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

Ahora tenemos la configuración de celdas >sum 2, ahora realizamos el algoritmo divmod:

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

La salida del divmod se ve así, 0 d-n%d >n%d n/dpero también ponemos a cero d-n%dla siguiente celda:

>[-]

Rellene una celda hasta el valor 100para una salida más fácil:

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

Ahora la configuración es >cond 0 100y para aplicar el if/elsealgoritmo necesitamos dos variables temporales, así que elegimos la configuracióntemp0 >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". Pruébalo en línea

En serio , 19 bytes

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

Toma entrada como "a1"

Pruébelo en línea (deberá ingresar manualmente la entrada; a los enlaces permanentes no les gustan las comillas)

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

Usando la sintaxis de la tabla de reglas definida aquí.

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

Probado en una calculadora TI-84 +.

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

Aquí hay una variación más interesante en la tercera línea, que lamentablemente es exactamente del mismo tamaño:

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

Uno pensaría que TI-BASIC sería decente en este desafío, ya que involucra el módulo 2. No lo es; Estas soluciones parecen ser las más cortas posibles.

Gastamos muchos bytes para obtener ambos caracteres en la cadena, pero lo que realmente cuesta son las trece letras minúsculas de dos bytes.

Befunge-93 , 39 37 33 31 bytes

Todo el crédito a Linus que sugirió esta solución de 31 bytes:

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

Pruébelo con este intérprete .

Explicación

<        v%2-~~

Al <principio, envía el puntero de instrucciones a la izquierda, donde se ajusta a la derecha. Luego lee dos caracteres de la entrada como ASCII, los resta y hace un módulo por 2. Como ay 1son ambos impares (en términos de código ASCII), esto funciona. El vvuelve a dirigir el puntero de instrucción a la baja ...

"^"light"_"krad

... en el _, que envía el puntero de instrucciones a la izquierda si la parte superior de la pila es 0 y a la derecha de lo contrario. Los caracteres de "claro" u "oscuro", respectivamente, se introducen en la pila en orden inverso. Ambas rutas golpean ^a la izquierda, lo que envía el puntero de instrucciones hacia arriba ...

 >:#,_@

... al segmento de salida. :duplica la parte superior de la pila, #salta sobre ,y hacia el _, lo que envía el puntero de instrucciones a la derecha si la parte superior de la pila es 0 y se deja de lo contrario. Cuando la pila está vacía, la parte superior de la pila (después :) es 0, por lo que el puntero de instrucción golpea el @que detiene la ejecución. De lo contrario, golpea el ,, que genera la parte superior de la pila como un personaje, y luego lo #salta sobre :y sobre el >, lo que inicia el proceso nuevamente.

Japt , 23 22 bytes

Japt es una versión abreviada de Ja vaScri pt . Interprete

Un19 %2?"dark":"light"

Cómo 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 la nueva versión 0.1.3 (lanzada el 22 de noviembre), esto se convierte en 17 bytes , más corto que todos menos GS2:

Un19 %2?`»rk:¦ght

O, alternativamente, una 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"

Lamentablemente las cuerdas darky lightno se pueden comprimir.

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

Pruébalo en línea

Gracias DigitalTrauma por muchos consejos de golf.

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

Aquí está con los diferentes segmentos de ruta resaltados:

(Los caracteres que no están en el espacio no resaltados sirven como argumentos para las instrucciones ey S, cada una de estas instrucciones usa el símbolo a la izquierda (en relación con la dirección de desplazamiento del 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)))

• Leemos en una línea de stdin con (read-line)
• Luego, analice la cadena en un valor entero en base 35 utilizando una llamada a un método JVM
• Tomar mod del resultado 2 nos dice si es par o impar
• Utilice el resultado devuelto por la función de módulo como índice de la secuencia e imprímalo

Ahorro unos dignos 2 bytes citando "claro" y "oscuro" con una comilla simple para que Clojure lo tome como un literal, en lugar de envolver cada palabra entre comillas. También guardo algunos bytes usando pr en lugar de println.

Alguna información sobre citas en Clojure

Minkolang 0.12 , 28 24 bytes

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

Pruébalo aquí

Explicación

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 un entorno donde ints se almacenan little-endian, y son al menos dos bytes.

Explicación

ces decir argc, inicialmente contiene 01 00 00 00. getsleerá dos caracteres, diga a (0x61)y 1 (0x31), y los almacenará c, que ahora es

61 31 00 00

representando el número 0x3161, o 12641.

Esencialmente, en este problema, dado c = x + 256*y, queremos calcular (x + y) mod 2e imprimir una cadena en consecuencia. Para hacer esto, podría haber escrito c % 255 % 2, como entonces

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

Sin embargo, 37también funciona:

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

xestá en el rango 49-57 inclusive (dígitos 1-8), entonces x % 37 == x - 37.

yestá en el rango 97-104 inclusive (minúscula ah), entonces y % 37 == y - 74.

Esto significa que podemos simplificar a

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

y simplemente voltee las cuerdas para corregir la paridad.

Haz , 127 bytes

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

Una explicación Azul claro: lea un carácter desde la entrada en el haz, guarde el valor del haz en la tienda, lea un carácter desde la entrada en el haz.

Azul oscuro: agrega la tienda a la viga disminuyendo la tienda a 0 mientras incrementa la viga

Verde claro: una construcción de prueba incluso impar. El bucle saldrá hacia la izquierda si el haz es par o hacia la derecha si es impar.

Verde oscuro: salidas oscuras

Tan - Emite luz

O , 22 17 bytes

i # 2% "light'dark"?

Esto hace lo que debe hacer, sin beneficios adicionales.

Laberinto , 48 46 45 42 bytes

Gracias a Sp3000 por guardar dos bytes.

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

Pruébalo en línea!

Explicación

El comienzo del código es un callejón sin salida divertido. Recuerde que Labyrinth asume un número infinito de ceros cuando requiere operandos en la parte inferior de la pila. El código comienza uno a la -derecha, que intenta restar dos números, por lo que la pila se convierte en:

[ ... 0 ]

Luego ,lee el primer personaje, adiga:

[ ... 0 97 ]

El "es un no-op, pero también es un callejón sin salida, por lo que el puntero de instrucciones gira y comienza a ir hacia la izquierda. Luego `lee el otro personaje, 2diga:

[ ... 0 97 50 ]

Esta vez, -resta esos dos números:

[ ... 0 47 ]

La IP ahora sigue la curva del "corredor". El #obtiene la profundidad de la pila, haciendo caso omiso de los ceros implícitas, que convenientemente pasa a ser 2:

[ ... 0 47 2 ]

Y %calcula el módulo:

[ ... 0 1 ]

En este punto, la IP está en un cruce. Si la parte superior de la pila es cero, se moverá hacia adelante, donde se 100.97.114.107.@imprime dark. Pero si la parte superior de la pila no es cero (específicamente, 1), se moverá hacia la derecha, donde se 0:::8.5.3.4.116.@imprime light(tenga en cuenta que podemos omitir el inicio 1, porque ya hay una 1en la pila, y podemos guardar en el repetido 10en 108, 105, 103, 104al hacer unas cuantas copias de la 10cuando nos llegar allí).

Matlab, 51 bytes

No creo que esto necesite ninguna explicación =)

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

> <> , 31 bytes

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

Aquí estoy pensando "tiene que haber una mejor manera ..."

Perl, 29 27 bytes

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

Este código requiere el -pinterruptor, que he contado como 1 byte.

Pruébelo en línea en Ideone .

Cómo funciona

• Debido al -pcambio, Perl lee una línea de entrada y la almacena $_.

• /./es una expresión regular que coincide con un caracter. Esto tiene dos implicaciones:

  • Como el partido es exitoso, /./devuelve 1 .

  • El post-partido (segundo carácter de entrada) se almacena en $'.

• $'+ordagrega el entero que representa el segundo carácter de entrada al punto de código ( ord) del primer carácter de la variable implícita $_.

• &toma el AND bit a bit del valor de retorno de /./y la suma $'+ord, devolviendo 1 es la suma si es impar, 0 si es par.

• ?light:darkdevuelve claro si la expresión anterior devolvió 1 y oscuro de lo contrario.

• Finalmente $_=asigna el resultado $_, que Perl imprime automáticamente, debido al -p cambio.