Twoim wyzwaniem jest napisanie programu, który wypisuje kolor danego kwadratu z szachownicy. Tak wygląda szachownica:

Widać, że kwadrat a1 jest ciemny, a h1 to jasny kwadrat. Twój program musi generować dane wyjściowe darklub light, jeśli otrzyma kwadrat. Kilka przykładów:

STDIN:  b1
STDOUT: light

STDIN:  g6
STDOUT: light

STDIN:  d4
STDOUT: dark

Zasady:

• Musisz podać pełny program, który używa STDIN i używa STDOUT do wyjścia darklub light.
• Załóżmy, że dane wejściowe są zawsze prawidłowe ( [a-h][1-8])
• To jest golf golfowy , więc wygrywa najmniejsza ilość bajtów!

Tablica wyników

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 bajtów

de♦dark•light♠5

Kod źródłowy używa kodowania CP437 . Wypróbuj online!

Weryfikacja

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

Jak to działa

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 bajtów

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

3 bajty dzięki Mego do przeplotu łańcuchów

Przyjmuje dane wejściowe jak "g6". To jasne i ciemne splecione.

Sześciokąt , 34 32 bajty

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

Rozłożony iz adnotowanymi ścieżkami wykonania:

^{Schemat wygenerowany za pomocą niesamowitego HexagonyColorer Timwi .}

Purpurowa ścieżka jest początkową ścieżką, która odczytuje dwa znaki, oblicza ich różnicę i przyjmuje ją modulo 2. <Następnie działa jak gałąź, gdzie 1drukuje się ciemnoszara ścieżka (wynik ) darki jasnoszara ścieżka (wynik 0) light.

Jeśli chodzi o sposób obliczania różnicy i modulo, oto schemat siatki pamięci (z wartościami pobranymi na wejściu a1):

^{Schemat wygenerowany za pomocą jeszcze bardziej niesamowitego Esoteric IDE Timwi (który ma wizualny debugger dla Hexagony).}

Wskaźnik pamięci zaczyna się od wiersza oznaczonego na brzegu , w którym czytamy znak. }przesuwa się do krawędzi oznaczonej kol , gdzie czytamy cyfrę. "przenosi się do krawędzi oznaczony diff gdzie -oblicza różnicę pomiędzy nimi. 'przesuwa się do nieoznakowanej komórki, w której umieszczamy 2, i {=przechodzi do oznaczonego komórką modu, w którym obliczamy moduł %.

Może to być możliwe do gry w golfa o kilka bajtów poprzez ponowne użycie niektórych z ;, ale wątpię, że można grać w golfa o wiele, na pewno nie do boku 3.

CJam, 18 bajtów

r:-)"lightdark"5/=

Demo online

Sekcja

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

Wyjaśnienie

s/[1357aceg]//gusuwa wszystkie współrzędne o nieparzystym indeksie. Powstały bufor wzoru ma następnie długość 1 dla „jasnego” lub długość 0 lub 2 dla „ciemnego”. /^.$/pasuje do wzorów o długości 1, cdopasowuje wzór do „światła” i quits. W przeciwnym razie wzór zostanie cpowieszony na „ciemny”.

Pyth, 18 bajtów

@c2"lightdark"iz35

Interpretuj dane wejściowe jako liczbę podstawową 35, podziel lightdarkna pół, wydrukuj.

ShadyAsFuck, 91 bajtów / BrainFuck, 181 bajtów

Mój pierwszy prawdziwy program BrainFuck, dziękuję Mego za pomoc i za skierowanie mnie do archiwum algorytmów. (Oznacza to, że tak naprawdę nie zrobiłem tego sam, ale skopiowałem niektóre istniejące algorytmy. Nadal doświadczenie =)

NKnmWs3mzhe5aAh=heLLp5uR3WPPPPagPPPPsuYnRsuYgGWRzPPPPlMlk_PPPPPP4LS5uBYR2MkPPPPPPPP_MMMkLG]

To jest oczywiście tłumaczenie z moich pieprzonych mózgów odpowiedzi:

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

Opracowany przy użyciu tego interpretera / debuggera .

Wygrałem dwa fragmenty kodu do divmodi if/elseod tutaj. (Dzięki @Mego!)

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

Teraz mamy konfigurację komórek >sum 2, teraz wykonujemy algorytm divmod:

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

Wyjście divmod wygląda tak, 0 d-n%d >n%d n/dale wyzerowaliśmy d-n%di zerujemy również następną komórkę:

>[-]

Wypełnij jedną komórkę do wartości, 100aby ułatwić wyjście:

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

Teraz konfiguracja jest >cond 0 100i do zastosowania if/elsealgorytmu potrzebujemy dwóch zmiennych temp, więc wybieramy konfiguracjętemp0 >c temp1 100

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

Python 2, 45 bajtów

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

Przyjmuje dane wejściowe jak "a1". Wypróbuj online

Poważnie , 19 bajtów

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

Przyjmuje dane wejściowe jak "a1"

Wypróbuj online (będziesz musiał ręcznie wprowadzić dane wejściowe; permalinki nie lubią cudzysłowów)

Kod maszynowy Turinga, 235 bajtów

Korzystanie ze zdefiniowanej tutaj składni tabeli reguł .

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 bajtów

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

TI-BASIC, 66 bajtów

Testowany na kalkulatorze TI-84 +.

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

Oto bardziej interesująca odmiana trzeciej linii, która niestety ma dokładnie ten sam rozmiar:

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

Można by pomyśleć, że TI-BASIC byłby przyzwoity w tym wyzwaniu, ponieważ dotyczy modulo 2. Nie jest; rozwiązania te wydają się być możliwie najkrótsze.

Wydajemy dużo bajtów, aby uzyskać oba znaki w ciągu, ale tak naprawdę kosztuje trzynaście dwubajtowych małych liter.

Befunge-93 , 39 37 33 31 bajtów

Podziękowania dla Linusa, który zaproponował to 31-bajtowe rozwiązanie:

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

Przetestuj za pomocą tego interpretera .

Wyjaśnienie

<        v%2-~~

Na <początku wysyła wskaźnik instrukcji w lewo, a następnie zawija się w prawo. Następnie czyta w dwóch znaków z wejścia jako ASCII, odejmuje je i robi modulo przez 2. Jak ai 1to zarówno nieparzyste (jeśli chodzi o kodzie ASCII), to działa. vPrzekierowuje wskaźnik instrukcji w dół ...

"^"light"_"krad

... na _, który wysyła wskaźnik instrukcji w lewo, jeśli góra stosu wynosi 0, a w prawo w przeciwnym razie. Znaki odpowiednio „jasnego” lub „ciemnego” są wypychane na stos w odwrotnej kolejności. Obie ścieżki uderzają ^w lewą stronę, co wysyła wskaźnik instrukcji w górę ...

 >:#,_@

... do segmentu wyjściowego. :duplikuje górę stosu, #przeskakuje nad ,i na _, co wysyła wskaźnik instrukcji w prawo, jeśli wierzchołek stosu wynosi 0, a w przeciwnym razie lewy. Gdy stos jest pusty, górna część stosu (po :) ma wartość 0, więc wskaźnik instrukcji trafia w tę, @która zatrzymuje wykonywanie. W przeciwnym razie trafia w ,postać, która wypuszcza górę stosu jako postać, a następnie #przeskakuje ją nad :i na >, co ponownie rozpoczyna proces.

Japt , 23 22 bajtów

Japt to skrócona wersja Ja vaScri pt . Interpretator

Un19 %2?"dark":"light"

Jak to działa

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

Używając nowej wersji 0.1.3 (wydanej 22 listopada), staje się 17 bajtów , krótszych niż wszystkie oprócz GS2:

Un19 %2?`»rk:¦ght

Lub alternatywnie magiczna formuła: (26 bajtów)

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 bajtów

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

TeaScript , 23 bajty

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

Niestety łańcuchy darki lightnie można ich skompresować.

Ruby, wykreślono 44 36 bajtów

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

C, 55 bajtów

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

Wypróbuj online

Dzięki DigitalTrauma za wiele wskazówek golfowych

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

Oto wyróżnione różne segmenty ścieżki:

(Wszelkie niewyróżnione znaki spacji służą jako argumenty dla instrukcji ei - Skażda z tych instrukcji używa jako argumentu symbolu po lewej stronie (w stosunku do kierunku podróży bota)

𝔼𝕊𝕄𝕚𝕟, 26 znaków / 34 bajty

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

Try it here (Firefox only).

C, 49 bajtów

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

Clojure, 63 bajty

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

• Czytamy w wierszu od standardowego przy pomocy (read-line)
• Następnie parsuj łańcuch na wartość całkowitą w bazie 35 za pomocą wywołania metody JVM
• Biorąc mod wyniku 2 mówi nam, czy jest parzysty czy nieparzysty
• Użyj wyniku zwróconego z funkcji modulo jako indeksu sekwencji i wydrukuj go

Zapisuję godne 2 bajty, cytując słowa „jasne” i „ciemne” za pomocą pojedynczego cytatu, dzięki czemu Clojure przyjmuje je dosłownie, zamiast zawijać każde słowo w parę znaków cudzysłowu. Zapisuję też kilka bajtów, używając raczej pr niż println.

Kilka informacji na temat cytowania w Clojure

Minkolang 0,12 , 28 24 bajtów

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

Wypróbuj tutaj.

Wyjaśnienie

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 bajtów

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

Oczekuje środowiska, w którym ints są przechowywane little-endian i mają co najmniej dwa bajty.

Wyjaśnienie

cjest argc, więc początkowo zawiera 01 00 00 00. getsodczyta dwa znaki, powie a (0x61)i 1 (0x31)i zapisze je c, co jest teraz

61 31 00 00

reprezentujący liczbę 0x3161 lub 12641.

Zasadniczo, biorąc pod uwagę ten problem, c = x + 256*ychcemy obliczyć (x + y) mod 2i odpowiednio wydrukować ciąg. Aby to zrobić, mogłem napisać c % 255 % 2tak jak wtedy

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

37Działa jednak również:

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

xjest w zakresie 49–57 włącznie (cyfry 1-8), więc x % 37 == x - 37.

yjest w zakresie 97-104 włącznie (małe litery ah), więc y % 37 == y - 74.

Oznacza to, że możemy uprościć

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

i po prostu odwróć ciągi, aby poprawić parzystość.

Belka , 127 bajtów

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

Wyjaśnienie Jasnoniebieski - odczytaj znak z wejścia na wiązkę, zapisz wartość wiązki do sklepu, przeczytaj znak z wejścia na wiązkę.

Ciemnoniebieski - Dodaje pamięć do wiązki poprzez zmniejszenie pamięci do 0 podczas zwiększania wiązki

Jasnozielony - nawet dziwny konstrukt testowy. Pętla wyjdzie w lewo, jeśli wiązka jest parzysta, lub w prawo, jeśli jest nieparzysta.

Ciemnozielony - wyświetla ciemne

Tan - emituje światło

O , 22 17 bajtów

i # 2% „light'dark”?

Robi to, co jest wymagane, bez dodatkowych korzyści.

Labirynt , 48 46 45 42 bajtów

Dzięki Sp3000 za oszczędność dwóch bajtów.

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

Wypróbuj online!

Wyjaśnienie

Początek kodu to zabawny ślepy zaułek. Pamiętaj, że Labirynt przyjmuje nieskończoną liczbę zer, gdy wymaga operandów na dole stosu. Kod zaczyna się od -prawej, która próbuje odjąć dwie liczby, więc stos staje się:

[ ... 0 ]

Następnie ,czyta pierwszy znak, apowiedz:

[ ... 0 97 ]

"Jest no-op, ale to też jest ślepa więc wskaźnik instrukcji odwraca się i zaczyna chodzić do lewej. Następnie `czyta drugą postać, 2powiedz:

[ ... 0 97 50 ]

Tym razem -odejmuje te dwie liczby:

[ ... 0 47 ]

IP podąża teraz za zakrętem „korytarza”. #Dostaje głębokość stosu, ignorując ukryte zer, które łatwo się składa, że 2:

[ ... 0 47 2 ]

I %oblicza modulo:

[ ... 0 1 ]

W tym momencie adres IP jest na styku. Jeśli górna część stosu ma wartość zero, przesunie się na wprost, gdzie zostaną 100.97.114.107.@wydrukowane dark. Ale jeśli górna część stosu jest różna od zera (konkretnie 1), przesunie się w prawo, tam gdzie 0:::8.5.3.4.116.@drukuje light(pamiętaj, że możemy pominąć wiodące 1, ponieważ jest już 1na stosie i możemy zaoszczędzić na powtarzających się 10w 108, 105, 103, 104poprzez kilka kopie 10, kiedy pierwszy raz się tam dostać).

Matlab, 51 bajtów

Nie sądzę, że wymaga to wyjaśnienia =)

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

> <> , 31 bajtów

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

Tutaj myślę „musi być lepszy sposób ...”

Perl, 29 27 bajtów

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

Ten kod wymaga -pprzełącznika, który policzyłem jako 1 bajt.

Wypróbuj online na Ideone .

Jak to działa

• Z powodu -pprzełącznika Perl odczytuje jeden wiersz danych wejściowych i zapisuje je $_.

• /./jest wyrażeniem regularnym, które pasuje do jednego znaku. Ma to dwie konsekwencje:

  • Ponieważ mecz się powiódł, /./zwraca 1 .

  • Dopasowanie (drugi znak wejściowy) jest przechowywane w $'.

• $'+orddodaje liczbę całkowitą, którą drugi znak wejściowy reprezentuje do punktu kodowego ( ord) pierwszego znaku zmiennej niejawnej $_.

• &przyjmuje bitowe AND wartości zwracanej /./i sumy $'+ord, zwracając 1 jest sumą, jeśli jest nieparzysta, 0, jeśli jest parzysta.

• ?light:darkzwraca światło, jeśli poprzednie wyrażenie zwróciło 1, a ciemne w przeciwnym razie.

• Na koniec $_=przypisuje wynik $_, który Perl drukuje automatycznie, z powodu -p przełącznika.