Tantangan Anda adalah menulis program yang menampilkan warna kotak yang diberikan dari papan catur. Beginilah tampilan papan catur:

Anda dapat melihat bahwa kuadrat a1 gelap, dan h1 adalah kuadrat terang. Program Anda perlu menampilkan darkatau light, jika diberi kotak. Beberapa contoh:

STDIN:  b1
STDOUT: light

STDIN:  g6
STDOUT: light

STDIN:  d4
STDOUT: dark

Aturan:

• Anda perlu menyediakan program lengkap yang menggunakan STDIN dan menggunakan STDOUT untuk menghasilkan darkatau light.
• Asumsikan bahwa input selalu valid ( [a-h][1-8])
• Ini adalah kode-golf , jumlah byte terpendek yang menang!

Papan angka

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 byte

de♦dark•light♠5

Kode sumber menggunakan pengkodean CP437 . Cobalah online!

Verifikasi

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

Bagaimana itu bekerja

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 byte

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

3 byte berkat Mego untuk interlacing string

Mengambil input seperti "g6". Terang dan gelap terjalin.

Hexagony , 34 32 byte

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

Dibuka dan dengan jalur eksekusi beranotasi:

^{Diagram yang dihasilkan dengan Timwi ini menakjubkan HexagonyColorer .}

Jalur ungu adalah jalur awal yang membaca dua karakter, menghitung perbedaannya dan membawanya modulo 2. <Kemudian bertindak sebagai cabang, di mana jalur abu-abu gelap (hasil 1) dicetak darkdan jalur abu-abu terang (hasil 0) dicetak light.

Adapun cara saya menghitung perbedaan dan modulo, berikut adalah diagram dari kisi memori (dengan nilai yang diambil untuk input a1):

^{Diagram dihasilkan dengan Esoteric IDE Timwi yang lebih menakjubkan (yang memiliki debugger visual untuk Hexagony).}

Penunjuk memori dimulai pada baris berlabel tepi , tempat kita membaca karakter. }bergerak ke tepi berlabel col , di mana kita membaca angka. "bergerak ke tepi berlabel diff di mana -menghitung perbedaan keduanya. 'pindah ke sel yang tidak berlabel di mana kita meletakkannya 2, dan {=pindah ke sel yang berlabel mod tempat kita menghitung modulo %.

Ini mungkin golf dengan beberapa byte dengan menggunakan kembali beberapa ;, tapi saya ragu itu bisa golf dengan banyak, tentu saja tidak sampai ke sisi panjang 3.

CJam, 18 byte

r:-)"lightdark"5/=

Demo online

Pembedahan

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

Penjelasan

s/[1357aceg]//gmenghapus semua koordinat indeks ganjil. Buffer pola yang dihasilkan kemudian memiliki panjang 1 untuk "cahaya" atau panjang 0 atau 2 untuk "gelap". /^.$/cocok dengan pola 1-panjang, cgantung pola ke "cahaya" dan quits. Kalau tidak, polanya cdigantung ke "gelap".

Pyth, 18 byte

@c2"lightdark"iz35

Menginterpretasikan input sebagai nomor basis 35, memotong lightdarksetengah, mencetak.

ShadyAsFuck, 91 byte / BrainFuck, 181 byte

Program BrainFuck pertama saya yang sebenarnya, terima kasih Mego atas bantuannya dan karena telah menunjuk saya ke arsip algoritma. (Itu berarti saya tidak benar-benar melakukannya sendiri, tetapi menyalin beberapa algoritma yang ada. Masih pengalaman =)

NKnmWs3mzhe5aAh=heLLp5uR3WPPPPagPPPPsuYnRsuYgGWRzPPPPlMlk_PPPPPP4LS5uBYR2MkPPPPPPPP_MMMkLG]

Ini tentu saja merupakan terjemahan dari jawaban brainfuck saya:

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

Dikembangkan menggunakan juru bahasa / debugger ini .

Saya mencuri dua cuplikan kode untuk divmoddan if/elsedari sini. (Terima kasih kepada @Mego!)

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

Sekarang kita memiliki konfigurasi sel >sum 2sekarang kita melakukan algoritma divmod:

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

Output dari divmod terlihat seperti ini, 0 d-n%d >n%d n/dtetapi kami memusatkan perhatian pada d-n%ddan juga memusatkan sel berikutnya:

>[-]

Isi satu sel hingga nilai 100untuk menghasilkan yang lebih mudah:

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

Sekarang konfigurasinya >cond 0 100dan untuk menerapkan if/elsealgoritma kita memerlukan dua variabel temp, jadi kita memilih konfigurasitemp0 >c temp1 100

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

Python 2, 45 byte

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

Mengambil input seperti "a1". Cobalah online

Serius , 19 byte

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

Mengambil input seperti "a1"

Cobalah online (Anda harus memasukkan input secara manual; permalink tidak suka kutipan)

Kode Mesin Turing, 235 byte

Menggunakan sintaks tabel aturan yang didefinisikan di sini.

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 byte

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

TI-BASIC, 66 byte

Diuji pada kalkulator TI-84 +.

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

Berikut variasi yang lebih menarik pada baris ketiga, yang sayangnya ukurannya persis sama:

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

Anda akan berpikir TI-BASIC akan layak pada tantangan ini, karena ini melibatkan modulo 2. Tidak; solusi ini tampaknya menjadi yang sesingkat mungkin.

Kami menghabiskan banyak byte untuk mendapatkan kedua karakter dalam string, tetapi yang benar-benar biaya adalah tiga belas huruf kecil dua byte.

Befunge-93 , 39 37 33 31 byte

Semua kredit untuk Linus yang menyarankan solusi 31-byte ini:

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

Uji menggunakan penerjemah ini .

Penjelasan

<        v%2-~~

The <di awal mengirimkan pointer instruksi ke kiri, di mana ia membungkus ke kanan. Itu kemudian dibaca dalam dua karakter dari input sebagai ASCII, kurangi mereka, dan lakukan modulo oleh 2. As adan 1keduanya aneh (dalam hal kode ASCII), ini berfungsi. The vpengalihan instruksi pointer ke bawah ...

"^"light"_"krad

... ke atas _, yang mengirimkan penunjuk instruksi ke kiri jika puncak tumpukan adalah 0 dan ke kanan sebaliknya. Karakter "terang" atau "gelap", masing-masing, didorong ke tumpukan dengan urutan terbalik. Kedua jalur menekan ^di sebelah kiri, yang mengirimkan penunjuk instruksi ke atas ...

 >:#,_@

... ke segmen keluaran. :menduplikasi bagian atas tumpukan, #melompati ,dan ke atas _, yang mengirimkan penunjuk instruksi ke kanan jika bagian atas tumpukan adalah 0 dan meninggalkan sebaliknya. Ketika tumpukan kosong, bagian atas tumpukan (setelah :) adalah 0, sehingga penunjuk instruksi menyentuh @yang menghentikan eksekusi. Jika tidak, itu akan memukul ,, yang menampilkan bagian atas tumpukan sebagai karakter, dan kemudian #melompat ke atas :dan ke >, yang memulai proses lagi.

Japt , 23 22 byte

Japt adalah versi singkat dari Ja vaScri pt . Penerjemah

Un19 %2?"dark":"light"

Bagaimana itu bekerja

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

Menggunakan versi baru 0.1.3 (dirilis 22 November), ini menjadi 17 byte , lebih pendek dari semua kecuali GS2:

Un19 %2?`»rk:¦ght

Atau, sebagai alternatif, formula ajaib: (26 byte)

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 byte

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

TeaScript , 23 byte

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

Sayangnya senar darkdan lighttidak bisa dikompresi.

Ruby, dicoret 44 36 byte

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

C, 55 byte

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

Cobalah online

Terima kasih DigitalTrauma untuk banyak tips bermain 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
     ^   <

Ini dia dengan segmen jalur yang berbeda yang disorot:

(Setiap karakter non-spasi yang tidak disorot berfungsi sebagai argumen untuk edan Sinstruksi - masing-masing instruksi ini menggunakan simbol ke kiri (relatif terhadap arah perjalanan bot) sebagai argumennya)

𝔼𝕊𝕄𝕚𝕟, 26 karakter / 34 byte

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

Try it here (Firefox only).

C, 49 byte

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

Clojure, 63 byte

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

• Kami membaca dalam satu baris dari stdin with (read-line)
• Kemudian parsing string ke dalam nilai integer di basis 35 menggunakan panggilan ke metode JVM
• Mengambil mod dari hasil 2 memberitahu kita apakah itu genap atau ganjil
• Gunakan hasil yang dikembalikan dari fungsi modulo sebagai indeks ke urutan dan cetaklah

Saya menyimpan 2 byte yang layak dengan mengutip "terang" dan "gelap" dengan satu kutipan sehingga Clojure menganggapnya sebagai literal, bukan membungkus setiap kata dengan sepasang tanda kutip. Saya juga menyimpan beberapa byte dengan menggunakan pr daripada println.

Beberapa info tentang mengutip di Clojure

Minkolang 0,12 , 28 24 byte

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

Coba di sini.

Penjelasan

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 byte

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

Mengharapkan lingkungan tempat ints disimpan little-endian, dan setidaknya dua byte.

Penjelasan

cadalah argc, jadi awalnya isinya 01 00 00 00. getsakan membaca dua karakter, mengatakan a (0x61)dan 1 (0x31), dan menyimpannya c, yang sekarang

61 31 00 00

mewakili angka 0x3161, atau 12641.

Pada dasarnya, dalam masalah ini, diberikan c = x + 256*y, kami ingin menghitung (x + y) mod 2, dan mencetak string yang sesuai. Untuk melakukan ini, saya bisa menulis c % 255 % 2, seperti itu

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

Namun, 37juga berfungsi:

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

xberada dalam kisaran 49-57 inklusif (digit 1-8), jadi x % 37 == x - 37.

yberada di kisaran 97-104 inklusif (huruf kecil), jadi y % 37 == y - 74.

Ini berarti kita dapat menyederhanakannya

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

dan hanya membalik senar untuk memperbaiki paritas.

Beam , 127 byte

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

Penjelasan Biru terang - baca karakter dari input ke beam, simpan nilai beam ke dalam store, baca karakter dari input ke beam.

Biru tua - Menambahkan toko ke balok dengan mengurangi toko ke 0 sambil menambah balok

Hijau muda - Konstruk pengujian yang bahkan aneh. Lingkaran akan keluar ke kiri jika berkasnya rata atau kanan jika aneh.

Hijau tua - Output gelap

Tan - Lampu keluaran

O , 22 17 byte

i # 2% "light'dark"?

Ini melakukan apa yang harus dilakukan, tanpa manfaat tambahan.

Labyrinth , 48 46 45 42 byte

Terima kasih kepada Sp3000 untuk menghemat dua byte.

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

Cobalah online!

Penjelasan

Awal kode adalah jalan buntu yang lucu. Ingatlah bahwa Labyrinth mengasumsikan jumlah nol yang tidak terbatas ketika membutuhkan operan di bagian bawah tumpukan. Kode mulai satu arah -kanan, yang mencoba mengurangi dua angka, sehingga tumpukan menjadi:

[ ... 0 ]

Kemudian ,bacalah karakter pertama, akatakan:

[ ... 0 97 ]

Ini "adalah no-op, tetapi ini juga jalan buntu sehingga penunjuk instruksi berbalik dan mulai pergi ke kiri. Kemudian `bacalah karakter lainnya, 2katakan:

[ ... 0 97 50 ]

Kali ini, -kurangi dua angka itu:

[ ... 0 47 ]

IP sekarang mengikuti tikungan "koridor". The #mendapat kedalaman stack, mengabaikan nol implisit, yang mudah terjadi menjadi 2:

[ ... 0 47 2 ]

Dan %menghitung modulo:

[ ... 0 1 ]

Pada titik ini, IP berada di persimpangan. Jika bagian atas tumpukan adalah nol, ia akan bergerak lurus ke depan, tempat 100.97.114.107.@mencetak dark. Tetapi jika bagian atas tumpukan tidak nol (khusus, 1), ia akan bergerak ke kanan, di mana 0:::8.5.3.4.116.@cetakan light(perhatikan bahwa kita dapat menghilangkan yang memimpin 1, karena sudah ada 1di tumpukan, dan kita bisa menghemat yang diulang 10di 108, 105, 103, 104dengan membuat beberapa salinan dari 10ketika kita pertama kali sampai di sana).

Matlab, 51 byte

Saya tidak berpikir ini perlu penjelasan =)

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

> <> , 31 byte

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

Di sini saya berpikir "pasti ada cara yang lebih baik ..."

Perl, 29 27 byte

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

Kode ini membutuhkan -psakelar, yang telah saya hitung sebagai 1 byte.

Cobalah online di Ideone .

Bagaimana itu bekerja

• Karena -psaklar, Perl membaca satu baris input dan menyimpannya $_.

• /./adalah ekspresi reguler yang cocok dengan satu karakter. Ini memiliki dua implikasi:

  • Karena pertandingan berhasil, /./pengembalian 1 .

  • Pasca-pertandingan (karakter input kedua) disimpan di $'.

• $'+ordmenambahkan integer yang mewakili karakter input kedua ke titik kode ( ord) dari karakter pertama dari variabel implisit $_.

• &mengambil bitwise AND dari nilai pengembalian /./dan jumlah $'+ord, mengembalikan 1 adalah jumlah jika ganjil, 0 jika itu genap.

• ?light:darkmengembalikan cahaya jika ekspresi sebelumnya menghasilkan 1 dan gelap sebaliknya.

• Akhirnya $_=memberikan hasil $_, yang Perl cetak secara otomatis, karena -p saklar.