Desenhe um ábaco de Suanpan

32

Escreva o programa mais curto que use um único número inteiro como entrada e imprima um ábaco de Suanpan

Casos de teste

Entrada:

314159

Saída:

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

Entrada:

6302715408

Saída:

|\==============================================================/|
||  (__)  (__)  (__)  (__)  (__)  (__)  (__)  (__)  (__)  (__)  ||
||   ||   (__)  (__)  (__)   ||   (__)   ||   (__)  (__)   ||   ||
||   ||    ||    ||    ||    ||    ||    ||    ||    ||    ||   ||
||  (__)   ||    ||    ||   (__)   ||   (__)   ||    ||   (__)  ||
|<==============================================================>|
||  (__)  (__)   ||   (__)  (__)  (__)   ||   (__)   ||   (__)  ||
||   ||   (__)   ||   (__)  (__)   ||    ||   (__)   ||   (__)  ||
||   ||   (__)   ||    ||    ||    ||    ||   (__)   ||   (__)  ||
||   ||    ||    ||    ||    ||    ||    ||   (__)   ||    ||   ||
||   ||    ||    ||    ||    ||    ||    ||    ||    ||    ||   ||
||   ||    ||   (__)   ||    ||    ||   (__)   ||   (__)   ||   ||
||  (__)   ||   (__)   ||    ||   (__)  (__)   ||   (__)   ||   ||
||  (__)   ||   (__)  (__)  (__)  (__)  (__)   ||   (__)   ||   ||
||  (__)  (__)  (__)  (__)  (__)  (__)  (__)   ||   (__)  (__)  ||
||  (__)  (__)  (__)  (__)  (__)  (__)  (__)  (__)  (__)  (__)  ||
|/==============================================================\|
code-golf ascii-art mordedor
fonte
O número pode ser fornecido na linha de comando?
Joey
Alguma restrição no comprimento da entrada?
Joey
Semelhante a golf.shinh.org/p.rb?Soroban+Fixed, se alguém precisar de algumas idéias sobre como jogar mais.
Nabb 12/03/11
11
Então a linha superior e a inferior são sempre completamente preenchidas? Por que eles inventaram um ábaco tão redundante? :)
Timwi
@ Timwi, o mesmo ábaco pode ser usado para hexidecimal. Quando usado para decimal as linhas extras são usados principalmente quando realizar multiplicações e divisões
gnibbler

Respostas:

14

J, 126 124 121 119 116 115 113 105 116 115 112 caracteres

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

Recebe entrada do teclado. Exemplo:

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

O principal truque aqui é o abuso do boxe de J, redefinindo os caracteres que ele usa. Ele usa um parâmetro global - 9!:7- para fazer isso. Pode haver espaço para mais golfe, mas, para ser sincero, fiquei feliz em trabalhar com algo que compensasse minha última tentativa nessa questão .

Cabe em um tweet com caracteres suficientes para dizer 'Gaz made this' :-).

Edit: 3 caracteres de poupança são devidos ao empréstimo da resposta 2 6$' || (__)'de Jesse Millikan .

Edição adicional: perdi 11 caracteres adicionando espaços extras em ambos os lados que eu não havia notado que não estavam presentes.

Explicação:

O código está em três seções principais:

1) Configuração

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

Isto é ele mesmo em duas partes.
9!:7'\=/<=>/=\|='redefine os caracteres que J usará para exibir caixas. O boxe de J normalmente se parece com isso:

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

mas depois de redefinir, fica assim:

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

(s=:[,.~,.)define um verbo que vou usar algumas vezes depois. Este é o melhor lugar para declará-lo. Ele pega um caractere à esquerda e uma matriz de caracteres à direita e imprensa a matriz entre o caractere. Por exemplo:

   3 5$'abcdefghijklmno'
abcde
fghij
klmno

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

A final [serve apenas para separar a configuração da próxima parte.

2) Entrada e Representação

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

".,.1!:1[1 pega a entrada do teclado e a separa em dígitos individuais:

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

((i.5)</5|]) cria uma representação em zeros e uns da parte inferior do ábaco:

   ((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) cria uma representação de zeros e uns da parte superior do ábaco:

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

Essas duas partes são encaixotadas usando ;:

   (|:@(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|
/=======================\

Em seguida, as caixas são colocadas uma em cima da outra para formar a base do ábaco, dando:

   ,.(|:@(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) Saída

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

&.>significa que o que se segue irá operar em ambas as caixas por sua vez.
(,-.)este é um gancho que nega a entrada e a adiciona ao final do original:

   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

Isso realmente faz parte da representação, mas para fins de golfe, é melhor tê-lo nesta seção. Aplicado à entrada anterior:

   (,-.)&.>,.(|:@(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[\' || (__)'){~ Os zeros e uns agora são usados ​​para selecionar uma sequência para representar um cordão ou a ausência de um:

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

Mas agora, como Howard me apontou, há um espaço curto de cada lado das contas. Portanto, usamos o sverbo predefinido para colocar o conteúdo de cada caixa entre duas colunas de espaços:

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

Feito isso, tudo o que resta é converter isso em uma string usando ":para que possamos colocar entre duas colunas de |:

   '|'s":(' 's[:,.(_6[\'  ||   (__)'){~(,-.))&.>,.(|:@(1,.<&5);((i.5)</5|]))".,.1!:1[1
314159
|\======================================/|
||  (__)  (__)  (__)  (__)  (__)  (__)  ||
||  (__)  (__)  (__)  (__)   ||    ||   ||
||   ||    ||    ||    ||    ||    ||   ||
||   ||    ||    ||    ||   (__)  (__)  ||
|<======================================>|
||  (__)  (__)  (__)  (__)   ||   (__)  ||
||  (__)   ||   (__)   ||    ||   (__)  ||
||  (__)   ||   (__)   ||    ||   (__)  ||
||   ||    ||   (__)   ||    ||   (__)  ||
||   ||    ||    ||    ||    ||    ||   ||
||   ||    ||    ||    ||   (__)   ||   ||
||   ||   (__)   ||   (__)  (__)   ||   ||
||   ||   (__)   ||   (__)  (__)   ||   ||
||  (__)  (__)   ||   (__)  (__)   ||   ||
||  (__)  (__)  (__)  (__)  (__)  (__)  ||
|/======================================\|
Gareth
fonte
Eu senti que havia algo "errado" na sua saída, mas demorei um pouco para reconhecer: você omite uma coluna vazia à esquerda e direita da tela (terceira e terceira coluna ascii).
Howard
@ Howard Woah, bom local. Eu não percebi isso. Vou dar uma olhada em consertá-lo.
Gareth
@ Howard Corrigido a um custo de 11 caracteres. Vergonha, eu pensei que poderia ter uma chance de ficar abaixo de 100. :-(
Gareth
Bom trabalho. Parece que @Howard tem muito trabalho a fazer para recuperar o atraso
gnibbler
Bounty tem 3 dias restantes. Marquei este como aceito por enquanto.
Gnibbler
14

Ruby 1.9, 154 caracteres

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\\|"

Supõe que a entrada não seja finalizada por uma nova linha.

Curiosidade: devido à maneira como estou transformando os dígitos de entrada em números ( $&.hexé um byte menor que $&.to_i), esse ábaco realmente funciona com dígitos hexadecimais até e:

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

Pois 0xf, um terceiro cordão aparece magicamente na metade superior.

Ao permitir sinalizadores adicionais durante a chamada de script, isso pode ser reduzido para 152 bytes (código de 149 bytes + sinalizadores de chamada adicionais de 3 bytes):

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\\|"

Corra com ruby -n suanpan.rb.

Ventero
fonte
12

Perl (151 caracteres)

( 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\\|"

Explicação

# 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\\|"

Edições

  • (154 → 151) Foram alterados três \ns para caracteres de nova linha reais. Não posso acreditar que não pensei nisso antes!
Timwi
fonte
11
Isto é apenas ... Incrível!
11134 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\|"

História:

  • 11-03-2011 23:54 (340) Tentativa inicial.
  • 2011-03-12 00:21 (323) Usando interpolação de string em todo o código.
  • 2011-03-12 00:21 (321) Inline $l.
  • 2011-03-12 01:07 (299) Usou uma função para as partes mais repetitivas, bem como uma string de formato.
  • 12/03/2011 01:19 (284) Alterados os argumentos para a função ligeiramente. Viva o modo de análise de comando.
  • 12-03-2011 01:22 (266) Mais variáveis ​​para expressões recorrentes.
  • 2011-03-12 01:28 (246) Agora todas as linhas são geradas pela função.
  • 2011-03-12 01:34 (236) Como uso os caracteres apenas na interpolação de cadeias, posso ignorar com segurança o %que gera números a partir dos dígitos.
  • 2011-03-12 01:34 (234) Otimizou levemente a geração do índice de matriz na função.
  • 2011-03-12 01:42 (215) Eu não preciso mais $re $b. E $atambém é obsoleto. Como está $l.
  • 2011-03-12 01:46 (207) Não há necessidade de definir $OFSse eu precisar apenas uma vez.
  • 12-03-2011 01:49 (202) Inline $f.
  • 12-03-2011 01:57 (200) Não há mais a seqüência de formato. A interpolação de strings funciona muito bem.
  • 2011-03-12 02:00 (198) Levemente otimizado, gerando linhas individuais (reordenando o pipeline e o índice de matriz).
  • 2011-03-12 02:09 (192) Não há necessidade, -joinpois podemos realmente usar o espaço adicional com bom efeito.
Joey
fonte
5

Haskell, 243 caracteres

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

Não é particularmente inteligente. Tenho certeza que pode ser reduzido de alguma forma ...

  • Edit: (246 -> 243) aceitou a sugestão de @ FUZxxl para usar o interact
MtnViewMark
fonte
Que tal usar #interact
FUZxxl
A primeira linha pode ser reduzida para z x|x=" (__) "|0<1=" || ".
FUZxxl 23/03
Sua primeira linha alternativa é apenas mais curta porque você soltou dois espaços necessários!
MtnViewMark
Opa! Você está certo, é claro.
FUZxxl
4

Delphi, 348

Esta versão cria uma string para escrever apenas uma vez; Os dígitos são manipulados por uma função separada que funciona por meio de uma digit modulo m >= valueconstrução (negada se o valor for <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.

Delphi, 565

Primeira tentativa : 

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.

Isso usa 3 matrizes; um para as 7 strings que poderiam ser discernidas, um para as linhas de saída e um para mapear as 7 strings para 11 colunas (10 dígitos e 1 coluna inicial).

PatrickvL
fonte
3

GolfScript, 139 caracteres

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*

Ainda não jogou muito, mas se encaixa em um tweet (apenas com ASCII). Experimente aqui .

Howard
fonte
2

J, 225

Passa em dois testes dados, deve trabalhar até pelo menos várias centenas de dígitos.

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

Primeiro: sim, sim, cavando. Segundo: Isso é apenas embaraçosamente longo. Ah bem. Ainda não decidi se vou jogar mais ou me enrolar na posição fetal e chorar. (Ou ambos!)

Aqui está uma explicação em vez de um programa mais curto:

  • c é 2x6 tabela de célula vazia, célula de esferas para renderização.
  • f renderiza uma linha '=' com os quatro caracteres externos como argumento à esquerda.
  • d renderiza uma linha do ábaco convertendo matrizes 0/1 em células de esferas preenchidas com ||
  • g pega dígitos e compila verticalmente linhas de caracteres usando f para 'formatar' linhas ed para linhas de ábaco.
  • A última linha obtém entrada, divide-se em caracteres e converte-os em números, alimenta g e depois imprime.
Jesse Millikan
fonte
2

C, 277 274 caracteres

Sabe, parece-me que simplesmente não temos soluções suficientes aqui que realmente tirem proveito do pré-processador C. Em parte, isso ocorre porque esses #defineespaços ocupam bastante espaço. Mas ainda assim, há muito potencial. Sinto a necessidade de resolver essa deficiência.

#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,\\)}

Isso é melhor.

caixa de pão
fonte
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]]

Exemplo

w[6302715408]

ábaco

DavidC
fonte
Parabéns por 10k! :-D
Maçaneta da porta
@Maçaneta. Obrigado! Parabéns a você também!
21414
1

C, 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")}

Primeira versão, apenas um pouco de golfe até agora.

schnaader
fonte
1

Scala (489 caracteres)

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 _=>" ||"})}}}

Tentativa de baixa qualidade realmente.

Gareth
fonte
1

Sclipting , 77 caracteres

A recompensa refere-se a tweets , e o Twitter conta caracteres (não bytes). :)

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

Na verdade, eu escrevi isso anos atrás (quando este desafio foi lançado), mas nunca o publiquei porque inventei o Sclipting depois que esse desafio foi lançado pela primeira vez. Se você acha que isso o torna inelegível, eu entendo.

Explicação

꿓뤽꿓뤽①長復 | 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
fonte
Obrigado pela sua resposta interessante. Concordo que é melhor seguir a regra de que apenas os idiomas publicados antes da pergunta ser elegível. Não acredito que você tenha deliberadamente projetado seu idioma para vencer esse desafio, mas, ao mesmo tempo, não acho justo com os outros respondentes, e não queremos abrir as comportas para idiomas recém-inventados no antigo perguntas, pois sabemos o que vai acontecer ...
gnibbler
@gnibbler: Claro, eu estou bem com isso. Eu acho que essa regra é importante.
Timwi
1

Python, 309 301 288 caracteres

Versão compacta:

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]

Versão clara:

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

Observe que, para compactar, as variáveis ​​foram renomeadas para uma única letra e as compreensões da lista foram alteradas para geradores que não exigem colchetes extras.

Nayuki
fonte