Нарисуйте суанпанские счеты

32

Напишите самую короткую программу, которая принимает одно целое число в качестве входных данных и распечатывает счеты Suanpan

Testcases

Входные данные:

314159

Выход:

|\======================================/|
||  (__)  (__)  (__)  (__)  (__)  (__)  ||
||  (__)  (__)  (__)  (__)   ||    ||   ||
||   ||    ||    ||    ||    ||    ||   ||
||   ||    ||    ||    ||   (__)  (__)  ||
|<======================================>|
||  (__)  (__)  (__)  (__)   ||   (__)  ||
||  (__)   ||   (__)   ||    ||   (__)  ||
||  (__)   ||   (__)   ||    ||   (__)  ||
||   ||    ||   (__)   ||    ||   (__)  ||
||   ||    ||    ||    ||    ||    ||   ||
||   ||    ||    ||    ||   (__)   ||   ||
||   ||   (__)   ||   (__)  (__)   ||   ||
||   ||   (__)   ||   (__)  (__)   ||   ||
||  (__)  (__)   ||   (__)  (__)   ||   ||
||  (__)  (__)  (__)  (__)  (__)  (__)  ||
|/======================================\|

Входные данные:

6302715408

Выход:

|\==============================================================/|
||  (__)  (__)  (__)  (__)  (__)  (__)  (__)  (__)  (__)  (__)  ||
||   ||   (__)  (__)  (__)   ||   (__)   ||   (__)  (__)   ||   ||
||   ||    ||    ||    ||    ||    ||    ||    ||    ||    ||   ||
||  (__)   ||    ||    ||   (__)   ||   (__)   ||    ||   (__)  ||
|<==============================================================>|
||  (__)  (__)   ||   (__)  (__)  (__)   ||   (__)   ||   (__)  ||
||   ||   (__)   ||   (__)  (__)   ||    ||   (__)   ||   (__)  ||
||   ||   (__)   ||    ||    ||    ||    ||   (__)   ||   (__)  ||
||   ||    ||    ||    ||    ||    ||    ||   (__)   ||    ||   ||
||   ||    ||    ||    ||    ||    ||    ||    ||    ||    ||   ||
||   ||    ||   (__)   ||    ||    ||   (__)   ||   (__)   ||   ||
||  (__)   ||   (__)   ||    ||   (__)  (__)   ||   (__)   ||   ||
||  (__)   ||   (__)  (__)  (__)  (__)  (__)   ||   (__)   ||   ||
||  (__)  (__)  (__)  (__)  (__)  (__)  (__)   ||   (__)  (__)  ||
||  (__)  (__)  (__)  (__)  (__)  (__)  (__)  (__)  (__)  (__)  ||
|/==============================================================\|
code-golf ascii-art gnibbler
источник
Можно ли указать номер в командной строке?
Джои
Какие-либо ограничения на длину ввода?
Джои
Похоже на golf.shinh.org/p.rb?Soroban+ Исправлено, если кому-то нужны идеи о том, как играть в гольф больше.
Набб
1
Таким образом, верхний ряд и нижний ряд всегда полностью заполнены? Почему они изобрели такие избыточные счеты? :)
Тимви
@ Тимви, те же счеты можно использовать для шестнадцатеричной. При использовании для десятичной дроби дополнительные строки чаще всего используются при выполнении умножений и делений
gnibbler

Ответы:

14

J, 126 124 121 119 116 115 113 105 116 115 112 символов

'|'s":(' 's[:,.(_6[\'  ||   (__)'){~(,-.))&.>,.(|:@(1,.<&5);((i.5)</5|]))".,.1!:1[1[(s=:[,.~,.)9!:7'\=/<=>/=\|='

Принимает ввод с клавиатуры. Пример:

   '|'s":(' 's[:,.(_6[\'  ||   (__)'){~(,-.))&.>,.(|:@(1,.<&5);((i.5)</5|]))".,.1!:1[1[(s=:[,.~,.)9!:7'\=/<=>/=\|='
6302715408
|\==============================================================/|
||  (__)  (__)  (__)  (__)  (__)  (__)  (__)  (__)  (__)  (__)  ||
||   ||   (__)  (__)  (__)   ||   (__)   ||   (__)  (__)   ||   ||
||   ||    ||    ||    ||    ||    ||    ||    ||    ||    ||   ||
||  (__)   ||    ||    ||   (__)   ||   (__)   ||    ||   (__)  ||
|<==============================================================>|
||  (__)  (__)   ||   (__)  (__)  (__)   ||   (__)   ||   (__)  ||
||   ||   (__)   ||   (__)  (__)   ||    ||   (__)   ||   (__)  ||
||   ||   (__)   ||    ||    ||    ||    ||   (__)   ||   (__)  ||
||   ||    ||    ||    ||    ||    ||    ||   (__)   ||    ||   ||
||   ||    ||    ||    ||    ||    ||    ||    ||    ||    ||   ||
||   ||    ||   (__)   ||    ||    ||   (__)   ||   (__)   ||   ||
||  (__)   ||   (__)   ||    ||   (__)  (__)   ||   (__)   ||   ||
||  (__)   ||   (__)  (__)  (__)  (__)  (__)   ||   (__)   ||   ||
||  (__)  (__)  (__)  (__)  (__)  (__)  (__)   ||   (__)  (__)  ||
||  (__)  (__)  (__)  (__)  (__)  (__)  (__)  (__)  (__)  (__)  ||
|/==============================================================\|

Основным трюком здесь является злоупотребление боксом J путем переопределения используемых им символов. Он использует глобальный параметр -9!:7 . Может быть, есть место для дальнейшего игры в гольф, но, честно говоря, я был просто рад получить что-то работающее, что должно компенсировать мою последнюю попытку в этом вопросе .

Вписывается в твит с достаточным количеством персонажей, чтобы сказать «Газ сделал это» :-).

Изменить: 3 символа сбережений из-за заимствования 2 6$' || (__)'у Джесси Милликана ответа .

Дальнейшее редактирование: Потерянные 11 символов, добавляющие лишние пробелы с обеих сторон, которых я не заметил, отсутствовали.

Объяснение:

Код состоит из трех основных разделов:

1) Настройка

[(s=:[,.~,.)9!:7'\=/<=>/=\|='

Это само по себе в двух частях.
9!:7'\=/<=>/=\|='переопределяет символы, которые J будет использовать для отображения полей. Бокс J обычно выглядит так:

   2 2$<"0[1 2 3 4
┌─┬─┐
│1│2│
├─┼─┤
│3│4│
└─┴─┘

но после переопределения это выглядит так:

   2 2$<"0[1 2 3 4
\===/
|1|2|
<===>
|3|4|
/===\

(s=:[,.~,.)определяет глагол, который я собираюсь использовать пару раз позже. Это оказывается лучшим местом, чтобы объявить это. Он принимает символ слева и массив символов справа и помещает массив между символом. Например:

   3 5$'abcdefghijklmno'
abcde
fghij
klmno

   '-' s 3 5$'abcdefghijklmno'
-abcde-
-fghij-
-klmno-

Финал [ просто служит для отделения установки от следующей части.

2) Ввод и представление

,.(|:@(1,.<&5);((i.5)</5|]))".,.1!:1[1

".,.1!:1[1 берет ввод с клавиатуры и разделяет его на отдельные цифры:

   ".,.1!:1[1
314159
3 1 4 1 5 9

((i.5)</5|]) создает нули и единичное представление нижней части счёта:

   ((i.5)</5|]) 3 1 4 1 5 9
1 1 1 1 0 1
1 0 1 0 0 1
1 0 1 0 0 1
0 0 1 0 0 1
0 0 0 0 0 0

|:@(1,.<&5) создает нулевые и единичные представления верхней части счёта:

   |:@(1,.<&5) 3 1 4 1 5 9
1 1 1 1 1 1
1 1 1 1 0 0

Эти две части упакованы вместе, используя ;:

   (|:@(1,.<&5);((i.5)</5|])) 3 1 4 1 5 9
\=======================/
|1 1 1 1 1 1|1 1 1 1 0 1|
|1 1 1 1 0 0|1 0 1 0 0 1|
|           |1 0 1 0 0 1|
|           |0 0 1 0 0 1|
|           |0 0 0 0 0 0|
/=======================\

Затем ящики помещают друг на друга, чтобы сформировать основу счёта, давая:

   ,.(|:@(1,.<&5);((i.5)</5|]))".,.1!:1[1
314159
\===========/
|1 1 1 1 1 1|
|1 1 1 1 0 0|
<===========>
|1 1 1 1 0 1|
|1 0 1 0 0 1|
|1 0 1 0 0 1|
|0 0 1 0 0 1|
|0 0 0 0 0 0|
/===========\

3) Выход

'|'s":(' 's[:,.(_6[\'  ||   (__)'){~(,-.))&.>

&.>означает, что то, что следует, будет работать на обеих коробках по очереди.
(,-.)это ловушка, которая отменяет ввод и затем добавляет его в конец оригинала:

   2 5$1 0 1 0 1
1 0 1 0 1
1 0 1 0 1

   (,-.) 2 5$1 0 1 0 1
1 0 1 0 1
1 0 1 0 1
0 1 0 1 0
0 1 0 1 0

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

   (,-.)&.>,.(|:@(1,.<&5);((i.5)</5|]))".,.1!:1[1
314159
\===========/
|1 1 1 1 1 1|
|1 1 1 1 0 0|
|0 0 0 0 0 0|
|0 0 0 0 1 1|
<===========>
|1 1 1 1 0 1|
|1 0 1 0 0 1|
|1 0 1 0 0 1|
|0 0 1 0 0 1|
|0 0 0 0 0 0|
|0 0 0 0 1 0|
|0 1 0 1 1 0|
|0 1 0 1 1 0|
|1 1 0 1 1 0|
|1 1 1 1 1 1|
/===========\

[:,.(_6[\' || (__)'){~ Нули и единицы теперь используются для выбора строки для представления бусинки или ее отсутствия:

   ([:,.(_6[\'  ||   (__)'){~(,-.))&.>,.(|:@(1,.<&5);((i.5)</5|]))".,.1!:1[1
314159
\====================================/
| (__)  (__)  (__)  (__)  (__)  (__) |
| (__)  (__)  (__)  (__)   ||    ||  |
|  ||    ||    ||    ||    ||    ||  |
|  ||    ||    ||    ||   (__)  (__) |
<====================================>
| (__)  (__)  (__)  (__)   ||   (__) |
| (__)   ||   (__)   ||    ||   (__) |
| (__)   ||   (__)   ||    ||   (__) |
|  ||    ||   (__)   ||    ||   (__) |
|  ||    ||    ||    ||    ||    ||  |
|  ||    ||    ||    ||   (__)   ||  |
|  ||   (__)   ||   (__)  (__)   ||  |
|  ||   (__)   ||   (__)  (__)   ||  |
| (__)  (__)   ||   (__)  (__)   ||  |
| (__)  (__)  (__)  (__)  (__)  (__) |
/====================================\

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

   (' 's[:,.(_6[\'  ||   (__)'){~(,-.))&.>,.(|:@(1,.<&5);((i.5)</5|]))".,.1!:1[1
314159
\======================================/
|  (__)  (__)  (__)  (__)  (__)  (__)  |
|  (__)  (__)  (__)  (__)   ||    ||   |
|   ||    ||    ||    ||    ||    ||   |
|   ||    ||    ||    ||   (__)  (__)  |
<======================================>
|  (__)  (__)  (__)  (__)   ||   (__)  |
|  (__)   ||   (__)   ||    ||   (__)  |
|  (__)   ||   (__)   ||    ||   (__)  |
|   ||    ||   (__)   ||    ||   (__)  |
|   ||    ||    ||    ||    ||    ||   |
|   ||    ||    ||    ||   (__)   ||   |
|   ||   (__)   ||   (__)  (__)   ||   |
|   ||   (__)   ||   (__)  (__)   ||   |
|  (__)  (__)   ||   (__)  (__)   ||   |
|  (__)  (__)  (__)  (__)  (__)  (__)  |
/======================================\

Сделав это, все, что осталось, - это преобразовать это в строку, используя ее, ":чтобы мы могли поместить ее между двумя столбцами |:

   '|'s":(' 's[:,.(_6[\'  ||   (__)'){~(,-.))&.>,.(|:@(1,.<&5);((i.5)</5|]))".,.1!:1[1
314159
|\======================================/|
||  (__)  (__)  (__)  (__)  (__)  (__)  ||
||  (__)  (__)  (__)  (__)   ||    ||   ||
||   ||    ||    ||    ||    ||    ||   ||
||   ||    ||    ||    ||   (__)  (__)  ||
|<======================================>|
||  (__)  (__)  (__)  (__)   ||   (__)  ||
||  (__)   ||   (__)   ||    ||   (__)  ||
||  (__)   ||   (__)   ||    ||   (__)  ||
||   ||    ||   (__)   ||    ||   (__)  ||
||   ||    ||    ||    ||    ||    ||   ||
||   ||    ||    ||    ||   (__)   ||   ||
||   ||   (__)   ||   (__)  (__)   ||   ||
||   ||   (__)   ||   (__)  (__)   ||   ||
||  (__)  (__)   ||   (__)  (__)   ||   ||
||  (__)  (__)  (__)  (__)  (__)  (__)  ||
|/======================================\|
Gareth
источник
Я чувствовал, что с вашим выводом было что-то «не так», но мне потребовалось некоторое время, чтобы распознать: вы опускаете пустой столбец в левой и правой части дисплея (третий и третий-последний столбец ascii).
Говард
@ Говард Вау, хорошее место. Я этого не заметил. Я посмотрю, как это исправить.
Гарет
@Howard Исправлена ​​стоимость 11 символов. Жаль, я подумал, что у меня может быть шанс опуститься ниже 100. :-(
Гарет
Хорошо сделано. Похоже, у @Ховарда много работы, чтобы наверстать упущенное
gnibbler
У Баунти осталось 3 дня. Я пометил этот как принятый в настоящее время.
Гнибблер
14

Ruby 1.9, 154 символа

puts'|\%s/|'%$r=?=*(2+6*gets.size),(0..14).map{|a|a==4?"|<#$r>|":"|| #{$_.gsub(/./){(5*a+n=$&.hex)/10!=1&&(a-n%5)/5!=1?' (__) ':'  ||  '}} ||"},"|/#$r\\|"

Предполагается, что вход не завершается переводом строки.

Интересный факт: из-за того, как я превращаю входные цифры в числа ( $&.hexна один байт короче $&.to_i), эти счеты фактически работают с шестнадцатеричными цифрами до e:

$ echo -n "0123456789abcdef" | ruby suanpan.rb
|\==================================================================================================/|
||  (__)  (__)  (__)  (__)  (__)  (__)  (__)  (__)  (__)  (__)   ||    ||    ||    ||    ||    ||   ||
||  (__)  (__)  (__)  (__)  (__)   ||    ||    ||    ||    ||    ||    ||    ||    ||    ||   (__)  ||
||   ||    ||    ||    ||    ||    ||    ||    ||    ||    ||   (__)  (__)  (__)  (__)  (__)  (__)  ||
||   ||    ||    ||    ||    ||   (__)  (__)  (__)  (__)  (__)  (__)  (__)  (__)  (__)  (__)  (__)  ||
|<==================================================================================================>|
||   ||   (__)  (__)  (__)  (__)   ||   (__)  (__)  (__)  (__)   ||   (__)  (__)  (__)  (__)   ||   ||
||   ||    ||   (__)  (__)  (__)   ||    ||   (__)  (__)  (__)   ||    ||   (__)  (__)  (__)   ||   ||
||   ||    ||    ||   (__)  (__)   ||    ||    ||   (__)  (__)   ||    ||    ||   (__)  (__)   ||   ||
||   ||    ||    ||    ||   (__)   ||    ||    ||    ||   (__)   ||    ||    ||    ||   (__)   ||   ||
||   ||    ||    ||    ||    ||    ||    ||    ||    ||    ||    ||    ||    ||    ||    ||    ||   ||
||  (__)   ||    ||    ||    ||   (__)   ||    ||    ||    ||   (__)   ||    ||    ||    ||   (__)  ||
||  (__)  (__)   ||    ||    ||   (__)  (__)   ||    ||    ||   (__)  (__)   ||    ||    ||   (__)  ||
||  (__)  (__)  (__)   ||    ||   (__)  (__)  (__)   ||    ||   (__)  (__)  (__)   ||    ||   (__)  ||
||  (__)  (__)  (__)  (__)   ||   (__)  (__)  (__)  (__)   ||   (__)  (__)  (__)  (__)   ||   (__)  ||
||  (__)  (__)  (__)  (__)  (__)  (__)  (__)  (__)  (__)  (__)  (__)  (__)  (__)  (__)  (__)  (__)  ||
|/==================================================================================================\|

Для 0xf третий шарик волшебным образом появляется в верхней половине.

При разрешении дополнительных флагов во время вызова скрипта их можно сократить до 152 байтов (149 байтов кода + 3 байта дополнительных флагов вызова):

puts'|\%s/|'%$r=?=*(2+6*~/$/),(0..14).map{|a|a==4?"|<#$r>|":"|| #{$_.gsub(/./){(5*a+n=$&.hex)/10!=1&&(a-n%5)/5!=1?' (__) ':'  ||  '}} ||"},"|/#$r\\|"

Беги с ruby -n suanpan.rb.

Ventero
источник
12

Perl (151 символ)

( 168 163 158 157 156 154 )

$i=<>;$c.=$_-4?"
||  $i||":"
|<$m>|",$m='==',$c=~s!\d!$m.='='x6;($_-$&%5)/5%2|(5*$_+$&)/10%7==1?' ||   ':'(__)  '!eg for 0..14;print"|\\$m/|$c
|/$m\\|"

объяснение

# Read the number from STDIN.
$i = <>;

# for statement starts here...

    # Append to $c a line containing either the horizontal dividing bar (in row #4)
    # or the current abacus row with the digits in place of the pegs.
    # This relies on the fact that $m will have been computed after at least one iteration.
    $c .= $_-4 ? "\n||  $i||" : "\n|<$m>|",

    # Notice that $m is redundantly recomputed from scratch in each iteration.
    $m = '==',

    # Substitute the correct pegs for the digit characters.
    $c =~ s!\d!
        $m .= '=' x 6;

        # Weird expression for the abacus function.
        # I have to use “% 7” because otherwise the division is floating-point...
        # Notice that $_ is the row and $& is the digit.
        ($_ - $& % 5)/5 % 2 | (5*$_ + $&)/10 % 7 == 1
        ? ' ||   '
        : '(__)  '
    !eg
for 0..14;

# Could shorten further by using “say” if you don’t mind excluding the “-E” from the count...
print "|\\$m/|$c\n|/$m\\|"

Правки

  • (154 → 151) Изменены три \nс на новые символы новой строки. Не могу поверить, я не думал об этом раньше!
Timwi
источник
1
Это просто ... круто!
german_guy
8

Windows PowerShell, 191

$y='='*(2+6*($i=[char[]]"$input").Count)
filter f($v){"|| $((' (__)','  || ')[($i|%{iex $_%$v})])  ||"}"|\$y/|"
f 1
f 10-ge5
f 1+1
f 10-lt5
"|<$y>|"
1..5|%{f 5-lt$_}
1..5|%{f 5-ge$_}
"|/$y\|"

История:

  • 2011-03-11 23:54 (340) Начальная попытка.
  • 2011-03-12 00:21 (323) Использование интерполяции строк по всему коду.
  • 2011-03-12 00:21 (321) встроенный$l .
  • 2011-03-12 01:07 (299) Использовал функцию для более повторяющихся частей, а также строку формата.
  • 2011-03-12 01:19 (284) Немного изменили аргументы функции. Ура для режима разбора команд.
  • 2011-03-12 01:22 (266) Больше переменных для повторяющихся выражений.
  • 2011-03-12 01:28 (246) Теперь каждая строка генерируется функцией.
  • 2011-03-12 01:34 (236) Так как я использую символы только в интерполяции строк, я могу смело игнорировать то, %что делает числа из цифр.
  • 2011-03-12 01:34 (234) Немного оптимизирована генерация индекса массива в функции.
  • 2011-03-12 1:42 (215) Я больше не нужны $rи $b. И $aтоже устарел. Как есть$l .
  • 2011-03-12 01:46 (207) Не нужно устанавливать, $OFSесли мне это нужно только один раз.
  • 2011-03-12 01:49 (202) Встроенный $f.
  • 2011-03-12 01:57 (200) Строка формата больше не нужна. Строковая интерполяция работает просто отлично.
  • 2011-03-12 02:00 (198) Немного оптимизирована генерация отдельных строк (переупорядочение конвейера и индекса массива).
  • 2011-03-12 02:09 (192) Не нужно, -joinпотому что мы действительно можем использовать дополнительное пространство для хорошего эффекта.
детеныш
источник
5

Хаскель, 243 персонажа

z x|x=" (__) ";z _="  ||  "
h[a,b]d f w='|':a:replicate(2+6*length d)'='++b:"|\n"++q z++q(z.not)
 where q b=w>>=(\v->"|| "++(d>>=b.(>v).f)++" ||\n")
s d=h"\\/"d(5-)[-9,0]++h"><"d(`mod`5)[0..4]++h"/\\"d id[]
main=interact$s.map(read.(:[])).init

Не особо умно. Я уверен, что это может быть сокращено как-то ...

  • Изменить: (246 -> 243) принял предложение @ FUZxxl использовать интерактив
MtnViewMark
источник
Как насчет использованияinteract
FUZxxl
Первая строка может быть сокращена до z x|x=" (__) "|0<1=" || ".
FUZxxl
Ваша альтернативная первая строка только короче, потому что вы отбросили два пробела, которые необходимы!
MtnViewMark
К сожалению! Вы конечно правы.
FUZxxl
4

Дельфы, 348

Эта версия создает строку для записи только один раз; Цифры обрабатываются отдельной функцией, которая работает через digit modulo m >= valueконструкцию (отрицается, если значение <0).

var d,s,o,p:string;c:Char;i:Int8;function g(m,v:Int8):string;begin p:='|| ';for c in d do p:=p+Copy('  ||   (__) ',1+6*Ord(((Ord(c)+2)mod m>=Abs(v))=(v>0)),6);g:=p+' ||'^J;end;begin ReadLn(d);s:=StringOfChar('=',2+6*Length(d));for i:=1to 5do o:=g(5,6-i)+o+g(5,-i);Write('|\'+s+'/|'^J+g(1,-1)+g(10,-5)+g(1,1)+g(10,5)+'|<'+s+'>|'^J+o+'|/'+s+'\|')end.

Дельфи, 565

Первая попытка : 

var _:array[0..6]of string=('  ||  ',' (  ) ','======','|\==/|','||  ||','|/==\|','|<==>|');m:array[0..186]of Byte;o:array[0..16]of string;i,j,c,f,l:Word;begin for i:=0to 9do begin f:=i*17;m[f+1]:=1;m[f+2]:=Ord(i<5);m[f+3]:=0;m[f+4]:=Ord(i>4);for j:=6to 10do m[f+j]:=Ord(i mod 5>j-6);for j:=11to 15do m[f+j]:=Ord(i mod 5<=j-11);m[f]:=2;m[5+f]:=2;m[16+f]:=2;end;f:=170;m[f]:=3;for i:=1to 15do m[f+i]:=4;m[f+5]:=6;m[f+16]:=5;repeat for i:=0to 16do Insert(_[m[f+i]],o[i],l);Read(PChar(@c)^);c:=c-48;f:=c*17;l:=Length(o[0])-2;until c>9;for i:=0to 16do WriteLn(o[i])end.

Это использует 3 массива; одна для 7 строк, которые можно различить, одна для выходных строк и одна для отображения 7 строк в 11 столбцах (10 цифр и 1 начальный столбец).

PatrickvL
источник
3

GolfScript, 139 символов

0+17'|':Q*:R'\<||'4Q**'/'+@{48-.5<)[1]*2,2*$+4<\5%[1]*2,5*$+10<+`{{1$=}%+2>'=='1/*5/('='+\+}+'     (|_|_ )'2//}/;;;;'/>||'4Q**'\\'+R]zip n*

Пока не много в гольфе, но он вписывается в твит (только с ASCII). Попробуй это здесь .

Говард
источник
2

J 225

Пройдено два заданных теста, должно работать не менее нескольких сотен цифр.

c=:2 6$'   ||   (__)'
f=:(2{.[),('='#~2+6*#@]),2}.[
d=:'||',"1'  ||',~"1,"2&(c{~|:)
g=:('|\/|'&f,d&(1,.-.,.0,.])&(4&<),'|<>|'&f,d&(5($!.0"1)0,~"(1)1#~"0|~&5),|.&d&(5($!.0"1)1#~"0(5-5|])),'|/\|'&f)
4(1!:2)~LF,"1 g"."0}:(1!:1)3

Во-первых, да, да, могилы. Второе: это просто смущающе долго. Ну что ж. Я еще не решил, следует ли играть в гольф дальше или свернуться калачиком в позе плода. (Или оба!)

Вот небольшое объяснение вместо более короткой программы:

  • c - это таблица пустых ячеек 2x6, ячейка для рендеринга.
  • f выводит строку '=' с четырьмя внешними символами в качестве левого аргумента.
  • d отображает строку счёта, переводя матрицы 0/1 в ячейки с бусинами, дополненные ||
  • g принимает цифры и вертикально компилирует строки символов, используя f для «форматирования» строк и d для строк счётов.
  • Последняя строка получает данные, разбивается на символы и преобразует их в числа, передает их в g и затем печатает.
Джесси Милликен
источник
2

С 277 274 символов

Вы знаете, мне кажется, что у нас просто не хватает решений, которые бы действительно использовали преимущества препроцессора Си. Отчасти это потому, что они на #defineсамом деле занимают немало места. Но тем не менее, есть такой большой потенциал. Я чувствую необходимость устранить этот недостаток.

#define L(x,z)for(printf("|"x),p=b;*p||puts(#z)<0;++p)printf(
#define F(x,y,z)L(#x,==z|)"======",y);
#define T(y)L("|  ",||)*p-47 y?"(__)  ":" ||   ");
i;char*p,b[99];main(j){gets(b);F(\\,0,/)T()T(<6)T(<1)T(>5)F(<,*p>52?*p-=5:0,>)
for(;++i<6;)T(>i)for(;++j<7;)T(<j)F(/,0,\\)}

Так-то лучше.

Хлебница
источник
2

Mathematica 281

w@n_:= Module[{t=Table,f,g},
 f@d_:=ReplacePart["O"~t~{7},{2-Quotient[d,5]-> "|",3+Mod[d,5]-> "|"}];
 g@k_:=IntegerDigits@n~PadLeft~10;
 Grid[Insert[Insert[(f/@g@n)T,"=="~t~{10},{{1},{3},{8}}]T,""~t~{10},{{1},{11}}]T]]

пример

w[6302715408]

счеты

DavidC
источник
Поздравляю на 10к! :-D
Дверная ручка
@Дверная ручка. Благодарность! Поздравляю вас тоже!
DavidC
1

С 548

#define p(a) printf(a);
#define F(x,m) for(x=0;x<m;x++)
#define I(x) {p("||")F(j,l)if(b[l*(i+x)+j]){p("  (__)")}else{p("   || ")}p("  ||\n")}
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
int main(int a,char* c[]){int i,j,l,m,*b;l=strlen(c[1]);b=(int*)malloc(l*56);m=6*l;F(i,14*l)b[i]=0;
F(j,l){b[j]=1;if(c[1][j]<53){b[l+j]=1;}else{b[3*l+j]=1;c[1][j]-=5;}F(i,5){if(i<c[1][j]-'0'){
b[(i+5)*l+j]=1;}else{b[(i+9)*l+j]=1;}}}p("|\\=")F(i,m)p("=")p("=/|\n")F(i,4)I(0)p("|<=")F(i,m)
p("=")p("=>|\n")F(i,9)I(5)p("|/=")F(i,m)p("=")p("=\\|\n")}

Первая версия, пока немного игры в гольф.

schnaader
источник
1

Скала (489 символов)

def a(i:String){val b=" (__) ";val n="  ||  ";1 to 17 map{l=>;{print(l match{case 1=>"|\\=";case 6=>"|<=";case 17=>"|/=";case _=>"|| "});print(l match{case 1|6|17=>"======"*i.size;case 2|16=>b*i.size;case 4|11=>n*i.size;case 3=>i flatMap{d=>{if(d.asDigit<5)b else n}};case 5=>i flatMap{d=>{if(d.asDigit>4)b else n}};case _=>i flatMap{d=>{if(l<11)if(d.asDigit%5<l-6)n else b else if(d.asDigit%5>l-12)n else b}}});;print(l match{case 1=>"=/|";case 6=>"=>|";case 17=>"=\\|";case _=>" ||"})}}}

Довольно дурацкая попытка на самом деле.

Gareth
источник
1

Sclipting , 77 символов

Щедрость относится к твитам , а Твиттер подсчитывает символы (не байты). :)

꿓뤽꿓뤽①長復標독렽꿐②껷렊밃겠上❶가侔是丟돃렽꿐②꿧렊不돇렠글⓶①各❷❷걐剩減갰減갰分❸⓷걀大加增增감右與꺅뭟꺒갠⓵긇롼긂갠嗎⓶終丟돇렊終終돂묽꿐②뇇렊

Я действительно написал это несколько лет назад (когда был опубликован этот вызов), но никогда не публиковал его, потому что изобрел Sclipting после того, как этот вызов был впервые опубликован. Если вы чувствуете, что это делает его неприемлемым, я понимаю.

объяснение

꿓뤽꿓뤽①長復 | let x = "======" times the length of the input string
標 | mark
독렽꿐②껷렊 | "|\\==" + x + "/|\n"
밃겠上 | for row in [-4 .. 10]
    ❶가侔是 | if row == 0
        丟돃렽꿐②꿧렊 | "|<==" + x + ">|\n"
    不 | else
        돇렠글 | "||  "
        ⓶①各 | foreach char c in input
            | ((r-(c%5)-3)/3 & ((r + (c>4?3:2)) >> 1)) ? "(__) " : " ||   "
            ❷❷걐剩減갰減갰分❸⓷걀大加增增감右與꺅뭟꺒갠⓵긇롼긂갠嗎⓶
        終丟
        돇렊 | "||\n"
    終
終
돂묽꿐②뇇렊 | "|/==" + x + "\\|\n"
Timwi
источник
Спасибо за ваш интересный ответ. Я согласен с тем, что лучше придерживаться правила, согласно которому только те языки, которые опубликованы до вопроса, должны быть приемлемы. Я не верю, что вы намеренно разработали свой язык, чтобы победить в этом испытании, но в то же время я не думаю, что это справедливо по отношению к другим ответчикам, и мы не хотим открывать шлюзы для недавно изобретенных языков на старых вопросы, так как мы знаем, что произойдет ...
gnibbler
@gnibbler: Конечно, я в порядке с этим. Я думаю, что это правило является важным.
Тимви,
1

Python, 309 301 288 символов

Компактная версия:

q=p,b="  ||  "," (__) "
t="|| %s ||\n"
a=lambda h:t%"".join(q[i]for i in h)
n=[int(d)for d in str(input())]
c=len(n)
e="="*(c*6+2)
h="|\\"+e+"/|"
print h+"\n"+t%(b*c)+a(d<5 for d in n)+t%(p*c)+a(d>4 for d in n)+"|<"+e+">|\n"+"".join(a((d%5>i%5)^(i>4)for d in n)for i in range(10))+h[::-1]

Чистая версия:

bead = " (__) "
pole = "  ||  "
template = "|| %s ||\n"
output = ""
def addline(hasbeads):
    global output
    output += template % "".join([bead if item else pole for item in hasbeads])

digits = [int(d) for d in str(input())]
count = len(digits)
equalsigns = "=" * (count * 6 + 2)
output = ""
header = "|\\" + equalsigns + "/|"
output += header + "\n"
output += template % (bead * count)
addline([d < 5 for d in digits])
output += template % (pole * count)
addline([d > 4 for d in digits])
output += "|<" + equalsigns + ">|\n"
for i in range(5):
    addline([d % 5 > i for d in digits])
for i in range(5):
    addline([d % 5 <= i for d in digits])
output += header[::-1]
print output

Обратите внимание, что для компактификации переменные были переименованы в одну букву, а списочные значения были изменены на генераторы, которые не требуют дополнительных скобок.

Nayuki
источник