Ваша задача - написать программу, которая выводит цвет данного квадрата с шахматной доски. Вот как выглядит шахматная доска:

Вы можете видеть, что квадрат a1 темный, а h1 - светлый квадрат. Ваша программа должна выводить darkили light, если дан квадрат. Некоторые примеры:

STDIN:  b1
STDOUT: light

STDIN:  g6
STDOUT: light

STDIN:  d4
STDOUT: dark

Правила:

• Вам необходимо предоставить полную программу, которая использует STDIN и использует STDOUT для вывода darkили light.
• Предположим, что ввод всегда действителен ( [a-h][1-8])
• Это код-гольф , поэтому выигрывает самое короткое количество байтов!

Табло

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 байт

de♦dark•light♠5

Исходный код использует кодировку CP437 . Попробуйте онлайн!

верификация

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

Как это устроено

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 байт

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

3 байта благодаря Mego для чередования строк

Принимает участие как "g6". Это свет и тьма переплетаются.

Гексагония , 34 32 байта

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

Развернутый и с аннотированными путями выполнения:

^{Диаграмма, созданная с помощью потрясающего HexagonyColorer Тимви .}

Фиолетовый путь - это начальный путь, который считывает два символа, вычисляет их разность и принимает его по модулю 2. Затем <он действует как ветвь, где 1печатаются темно-серый путь (результат ) darkи светло-серый путь (результат 0) light.

Что касается того, как я вычисляю разницу и по модулю, вот диаграмма сетки памяти (со значениями, взятыми для ввода a1):

^{Диаграмма, созданная с помощью еще более удивительной Esoteric IDE Тимви (в которой есть визуальный отладчик для Hexagony).}

Указатель памяти начинается с края, обозначенного строкой , где мы читаем символ. }перемещается к краю с надписью col , где мы читаем цифру. "перемещается к краю с надписью diff, где -вычисляет разницу между ними. 'перемещается в ячейку без метки, в которую мы помещаем 2, и {=перемещается в ячейку, помеченную как мод, где мы вычисляем по модулю %.

Это может быть пригодно для игры в гольф на несколько байтов путем повторного использования некоторых из них ;, но я сомневаюсь, что это может быть сделано в гольф многими, конечно, не до длины стороны 3.

CJam, 18 байт

r:-)"lightdark"5/=

Онлайн демо

рассечение

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"

Сед, 37

s/[1357aceg]//g
/^.$/{clight
q}
cdark

объяснение

s/[1357aceg]//gудаляет все нечетные координаты. Полученный шаблонный буфер имеет длину 1 для «светлого» или длину 0 или 2 для «темного». /^.$/соответствует шаблонам 1 длины, cпередает шаблон на «свет» и qиспользует. В противном случае рисунок cповешен до «темного».

Pyth, 18 байт

@c2"lightdark"iz35

Интерпретировать ввод как основную цифру 35, разрезать lightdarkпополам, распечатать.

ShadyAsFuck, 91 байт / BrainFuck, 181 байт

Моя первая настоящая программа BrainFuck, спасибо Мего за помощь и за указание на архив алгоритмов. (Это означает, что я действительно не делал это самостоятельно, но скопировал некоторые существующие алгоритмы. Все еще опыт =)

NKnmWs3mzhe5aAh=heLLp5uR3WPPPPagPPPPsuYnRsuYgGWRzPPPPlMlk_PPPPPP4LS5uBYR2MkPPPPPPPP_MMMkLG]

Это, конечно, перевод из моих ответов мозговой команды:

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

Разработано с использованием этого интерпретатора / отладчика .

Я украл два фрагмента кода для divmodи if/elseот сюда. (Спасибо @Mego!)

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

Теперь у нас есть конфигурация ячеек, >sum 2теперь мы выполняем алгоритм divmod:

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

Вывод divmod выглядит следующим образом, 0 d-n%d >n%d n/dно мы обнулили d-n%dи также обнуляем следующую ячейку:

>[-]

Заполните одну ячейку до значения 100для облегчения вывода:

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

Теперь конфигурация >cond 0 100и для применения if/elseалгоритма нам нужны две временные переменные, поэтому мы выбираем конфигурациюtemp0 >c temp1 100

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

Python 2, 45 байт

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

Принимает участие как "a1". Попробуйте онлайн

Серьезно , 19 байтов

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

Принимает вход как "a1"

Попробуйте онлайн (вам нужно будет вручную ввести ввод; постоянные ссылки не любят кавычки)

Машинный код Тьюринга, 235 байтов

Используя синтаксис таблицы правил, определенный здесь.

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 байт

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

TI-BASIC, 66 байтов

Проверено на калькуляторе TI-84 +.

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

Вот более интересный вариант третьей строки, который, к сожалению, точно такого же размера:

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

Вы могли бы подумать, что TI-BASIC будет приличным в этом вызове, поскольку он включает в себя модуль 2. Это не так; эти решения кажутся кратчайшими.

Мы тратим много байтов, чтобы получить оба символа в строке, но на самом деле стоит тринадцать двухбайтовых строчных букв.

Befunge-93 , 39 37 33 31 байт

Вся благодарность Линусу, который предложил это 31-байтовое решение:

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

Проверьте это с помощью этого интерпретатора .

объяснение

<        v%2-~~

В <начале отправляет указатель инструкции влево, где он оборачивается вправо. Затем он считывает из входных данных два символа как ASCII, вычитает их и делает по модулю значение 2. Поскольку aи 1оба являются нечетными (с точки зрения кода ASCII), это работает. vПеренаправляет указатель инструкции вниз ...

"^"light"_"krad

... на _, который отправляет указатель инструкции влево, если вершина стека равна 0, и вправо в противном случае. Символы «светлый» или «темный», соответственно, помещаются в стек в обратном порядке. Оба пути попадают ^слева, что отправляет указатель инструкции вверх ...

 >:#,_@

... в выходной сегмент. :дублирует вершину стека, #перепрыгивает через ,и на _, что отправляет указатель инструкции вправо, если вершина стека равна 0, и в противном случае остается влево. Когда стек пуст, вершина стека (после :) равна 0, поэтому указатель инструкции достигает значения, @которое останавливает выполнение. В противном случае он попадает в ,, который выводит вершину стека как символ, а затем #перепрыгивает его через :и в >, что снова запускает процесс.

Джапт , 23 22 байта

Japt - это сокращенная версия Ja vaScri pt . переводчик

Un19 %2?"dark":"light"

Как это устроено

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

При использовании новой версии 0.1.3 (выпущенной 22 ноября) это становится на 17 байт короче, чем у всех, кроме GS2:

Un19 %2?`»rk:¦ght

Или, альтернативно, волшебная формула: (26 байт)

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 байтов

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

TeaScript , 23 байта

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

К сожалению строки darkи lightне могут быть сжаты.

Рубин, вычеркнуто 44 36 байт

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

C, 55 байтов

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

Попробуйте онлайн

Спасибо DigitalTrauma за множество советов по игре в гольф

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

Вот это с различными выделенными сегментами пути:

(Любой не-пробельные символы не выделенные служить в качестве аргументов для eи Sinstructions- каждого из этих команд используют символ влево ( по отношению к направлению бота движения) в качестве аргумента)

𝔼𝕊𝕄𝕚𝕟, 26 символов / 34 байта

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

Try it here (Firefox only).

C, 49 байтов

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

Clojure, 63 байта

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

• Читаем в строке из stdin с (read-line)
• Затем разберите строку в целочисленное значение в базе 35 с помощью вызова метода JVM
• Принимая мод результата 2 говорит нам, если он четный или нечетный
• Используйте результат, возвращенный функцией modulo, в качестве индекса последовательности и распечатайте его

Я сохраняю 2 достойных байта, заключая в кавычки слова «светлые» и «темные», чтобы Clojure воспринимал их как литерал, а не заключал каждое слово в кавычки. Я также экономлю несколько байтов, используя pr, а не println.

Некоторая информация о цитировании в Clojure

Минколанг 0,12 , 28 24 байта

on+2%t"dark"t"light"t$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 байтов

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

Ожидается среда, в которой ints хранится в порядке байтов и имеет размер не менее двух байтов.

объяснение

cесть argc, поэтому изначально он содержит 01 00 00 00. getsпрочитает два символа, скажем a (0x61)и 1 (0x31), и сохранит их c, что сейчас

61 31 00 00

представляющий число 0x3161 или 12641.

По сути, в данной задаче c = x + 256*yмы хотим вычислить (x + y) mod 2и вывести соответствующую строку. Для этого я мог бы написать c % 255 % 2, как тогда

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

Тем не менее, 37также работает:

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

xнаходится в диапазоне 49-57 включительно (цифры 1-8), т x % 37 == x - 37.

yнаходится в диапазоне 97-104 включительно (строчные ах), т y % 37 == y - 74.

Это означает, что мы можем упростить

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

и просто переверните строки, чтобы исправить соотношение.

Луч , 127 байт

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

Объяснение Голубой - считывание символа с входа в луч, сохранение значения луча в хранилище, чтение символа с ввода в луч.

Темно-синий - добавляет магазин к лучу, уменьшая магазин до 0 при увеличении луча

Светло-зеленый - четная нечетная тестовая конструкция. Цикл выйдет влево, если луч четный, или вправо, если нечетный.

Темно-зеленый - выходы темные

Tan - выход света

О , 22 17 байт

я # 2% "light'dark"?

Это делает то, что требуется, без каких-либо дополнительных преимуществ.

Лабиринт , 48 46 45 42 байта

Спасибо Sp3000 за сохранение двух байтов.

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

Попробуйте онлайн!

объяснение

Начало кода - забавный тупик. Помните, что Лабиринт предполагает бесконечное число нулей, когда он требует операндов в нижней части стека. Код начинается с -правильного хода, который пытается вычесть два числа, поэтому стек становится:

[ ... 0 ]

Затем ,читает первый символ, aскажите:

[ ... 0 97 ]

Параметр "no-op, но это также тупик, поэтому указатель инструкций поворачивается и начинает идти влево. Затем `читает другой персонаж, 2скажите:

[ ... 0 97 50 ]

На этот раз -вычитает эти два числа:

[ ... 0 47 ]

IP теперь следует за поворотом «коридора». #Получает глубину стека, игнорируя скрытые нули, которые удобно случается 2:

[ ... 0 47 2 ]

И %вычисляет по модулю:

[ ... 0 1 ]

На данный момент IP находится на стыке. Если вершина стека равна нулю, он будет двигаться прямо вперед, где 100.97.114.107.@печатаетdark . Но если вершина стека отлична от нуля (в частности, 1), она переместится вправо, где 0:::8.5.3.4.116.@печатает light(обратите внимание, что мы можем опустить ведущий 1, потому что 1в стеке уже есть , и мы можем сэкономить на повторном 10в 108, 105, 103, 104сделав несколько копий , 10когда мы сначала получить там).

Matlab, 51 байт

Я не думаю, что это нуждается в каких-либо объяснениях =)

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

> <> , 31 байт

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

Здесь я думаю, что "должен быть лучший способ ..."

Perl, 29 27 байт

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

Для этого кода требуется -pпереключатель, который я посчитал 1 байтом.

Попробуйте онлайн на Ideone .

Как это устроено

• Благодаря -pпереключателю Perl читает одну строку ввода и сохраняет ее в $_.

• /./является регулярным выражением, которое соответствует одному символу. Это имеет два значения:

  • Поскольку совпадение прошло успешно, /./возвращается 1 .

  • Пост-матч (второй входной символ) сохраняется в $'.

• $'+ordдобавляет целое число, которое представляет второй входной символ, к коду point ( ord) первого символа неявной переменной $_.

• &принимает побитовое И возвращаемого значения /./и суммы $'+ord, возвращая 1 - это сумма, если она нечетная, 0, если она четная.

• ?light:darkвозвращает свет, если предыдущее выражение вернуло 1 и темно противном случае.

• Наконец, $_=присваивает результат $_, который Perl печатает автоматически, благодаря -p переключателю.