Dibuja un ábaco de Suanpan

32

Escriba el programa más corto que tome un solo entero como entrada e imprima un ábaco de Suanpan

Casos de prueba

Entrada:

314159

Salida:

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

Entrada:

6302715408

Salida:

|\==============================================================/|
||  (__)  (__)  (__)  (__)  (__)  (__)  (__)  (__)  (__)  (__)  ||
||   ||   (__)  (__)  (__)   ||   (__)   ||   (__)  (__)   ||   ||
||   ||    ||    ||    ||    ||    ||    ||    ||    ||    ||   ||
||  (__)   ||    ||    ||   (__)   ||   (__)   ||    ||   (__)  ||
|<==============================================================>|
||  (__)  (__)   ||   (__)  (__)  (__)   ||   (__)   ||   (__)  ||
||   ||   (__)   ||   (__)  (__)   ||    ||   (__)   ||   (__)  ||
||   ||   (__)   ||    ||    ||    ||    ||   (__)   ||   (__)  ||
||   ||    ||    ||    ||    ||    ||    ||   (__)   ||    ||   ||
||   ||    ||    ||    ||    ||    ||    ||    ||    ||    ||   ||
||   ||    ||   (__)   ||    ||    ||   (__)   ||   (__)   ||   ||
||  (__)   ||   (__)   ||    ||   (__)  (__)   ||   (__)   ||   ||
||  (__)   ||   (__)  (__)  (__)  (__)  (__)   ||   (__)   ||   ||
||  (__)  (__)  (__)  (__)  (__)  (__)  (__)   ||   (__)  (__)  ||
||  (__)  (__)  (__)  (__)  (__)  (__)  (__)  (__)  (__)  (__)  ||
|/==============================================================\|
code-golf  ascii-art 
— gnibbler
fuente
¿Se puede dar el número en la línea de comandos?
— Joey
¿Alguna restricción en la longitud de entrada?
— Joey
Similar a golf.shinh.org/p.rb?Soroban+Fixed si alguien necesita algunas ideas sobre cómo jugar más al golf.
— Nabb
1
Entonces, ¿la fila superior y la fila inferior siempre están completamente llenas? ¿Por qué inventaron un ábaco tan redundante? :)
— Timwi
@Timwi, se puede usar el mismo ábaco para hexadecimal. Cuando se usa para decimal, las filas adicionales se usan principalmente cuando se realizan multiplicaciones y divisiones
— gnibbler

Respuestas:

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'\=/<=>/=\|='

Toma entrada del teclado. Ejemplo:

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

El truco principal aquí es el abuso del boxeo de J redefiniendo los personajes que usa. Se utiliza un parámetro global - 9!:7- para hacer esto. Puede haber espacio para seguir jugando al golf, pero para ser honesto, me alegré de que algo funcionara para compensar mi último intento en esta pregunta .

Encaja en un tweet con suficientes caracteres para decir 'Gaz hizo esto' :-).

Editar: 3 caracteres de ahorro se deben al préstamo 2 6$' || (__)'de la respuesta de Jesse Millikan .

Edición adicional: Perdí 11 personajes agregando espacios adicionales a cada lado que no había notado que no estaban presentes.

Explicación:

El código está en tres secciones principales:

1) Configuración

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

Esto es en sí mismo en dos partes.
9!:7'\=/<=>/=\|='redefine los caracteres que J usará para mostrar cuadros. El boxeo de J normalmente se ve así:

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

pero después de redefinir se ve así:

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

(s=:[,.~,.)define un verbo que voy a usar un par de veces más tarde. Este resulta ser el mejor lugar para declararlo. Toma un carácter a la izquierda y una serie de caracteres a la derecha y empareja la matriz entre los caracteres. Por ejemplo:

   3 5$'abcdefghijklmno'
abcde
fghij
klmno

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

La final [solo sirve para separar la configuración de la siguiente parte.

2) Entrada y representación

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

".,.1!:1[1 toma la entrada del teclado y la separa en dígitos individuales:

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

((i.5)</5|]) crea una representación de ceros y unos de la parte inferior del á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) crea una representación de ceros y unos de la parte superior del ábaco:

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

Estas dos partes se encuadran juntas 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|
/=======================\

Luego, las cajas se colocan una encima de la otra para formar la base del á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) salida

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

&.>significa que lo que sigue operará en ambas cajas a su vez.
(,-.)este es un gancho que negará la entrada y luego lo agregará al final del 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

Esto es realmente parte de la representación, pero para fines de golf es mejor tenerlo en esta sección. Aplicado a la 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[\' || (__)'){~ Los ceros y unos ahora se usan para seleccionar una cadena para representar una cuenta o la ausencia de una:

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

Pero ahora, como Howard me señaló, hay un espacio corto a cada lado de las cuentas. Entonces usamos el sverbo predefinido para emparejar el contenido de cada cuadro entre dos columnas de espacios:

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

Una vez hecho eso, todo lo que queda es convertir esto en una cadena usando ":para que podamos emparedarlo entre dos columnas de |:

   '|'s":(' 's[:,.(_6[\'  ||   (__)'){~(,-.))&.>,.(|:@(1,.<&5);((i.5)</5|]))".,.1!:1[1
314159
|\======================================/|
||  (__)  (__)  (__)  (__)  (__)  (__)  ||
||  (__)  (__)  (__)  (__)   ||    ||   ||
||   ||    ||    ||    ||    ||    ||   ||
||   ||    ||    ||    ||   (__)  (__)  ||
|<======================================>|
||  (__)  (__)  (__)  (__)   ||   (__)  ||
||  (__)   ||   (__)   ||    ||   (__)  ||
||  (__)   ||   (__)   ||    ||   (__)  ||
||   ||    ||   (__)   ||    ||   (__)  ||
||   ||    ||    ||    ||    ||    ||   ||
||   ||    ||    ||    ||   (__)   ||   ||
||   ||   (__)   ||   (__)  (__)   ||   ||
||   ||   (__)   ||   (__)  (__)   ||   ||
||  (__)  (__)   ||   (__)  (__)   ||   ||
||  (__)  (__)  (__)  (__)  (__)  (__)  ||
|/======================================\|
— Gareth
fuente
Sentí que había algo "incorrecto" con su salida, pero me llevó un tiempo reconocerlo: omite una columna vacía a la izquierda y a la derecha de la pantalla (tercera y tercera última columna ASCII).
— Howard
@Howard Woah, buen lugar. No me di cuenta de eso. Voy a echar un vistazo para arreglarlo.
— Gareth
@Howard Corregido a un costo de 11 caracteres. Es una pena, pensé que podría tener la oportunidad de llegar a menos de 100. :-(
— Gareth
Buen trabajo. Parece que @Howard tiene mucho trabajo por hacer para ponerse al día
— gnibbler
A Bounty le quedan 3 días. He marcado este como aceptado por el momento.
— 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\\|"

Asume que la entrada no termina con una nueva línea.

Dato curioso: debido a la forma en que estoy convirtiendo los dígitos de entrada en números ( $&.hexes un byte más corto que $&.to_i), este ábaco en realidad funciona con dígitos hexadecimales hasta e:

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

Porque 0xf, un tercer cordón aparece mágicamente en la mitad superior.

Al permitir marcas adicionales durante la invocación del script, esto se puede acortar a 152 bytes (código de 149 bytes + banderas de invocación adicionales 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\\|"

Corre con ruby -n suanpan.rb.

— Ventero
fuente
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\\|"

Explicación

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

Ediciones

  • (154 → 151) Cambió tres \nsa caracteres de nueva línea reales. ¡No puedo creer que no haya pensado en eso antes!
— Timwi
fuente
1
Esto es simplemente ... ¡Impresionante!
— 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\|"

Historia:

  • 2011-03-11 23:54 (340) Intento inicial.
  • 2011-03-12 00:21 (323) Uso de la interpolación de cadenas en todo el código.
  • 2011-03-12 00:21 (321) En línea $l.
  • 2011-03-12 01:07 (299) Se utilizó una función para las partes más repetitivas, así como una cadena de formato.
  • 2011-03-12 01:19 (284) Cambió ligeramente los argumentos de la función. ¡Hurra por el modo de análisis de comandos!
  • 2011-03-12 01:22 (266) Más variables para expresiones recurrentes.
  • 2011-03-12 01:28 (246) Ahora cada fila es generada por la función.
  • 2011-03-12 01:34 (236) Dado que uso los caracteres solo en la interpolación de cadenas, puedo ignorar con seguridad los %números de los dígitos.
  • 2011-03-12 01:34 (234) Ligeramente optimizado la generación del índice de matriz en la función.
  • 2011-03-12 01:42 (215) Ya no necesito $ry $b. Y $atambién es obsoleto. Como es $l.
  • 2011-03-12 01:46 (207) No es necesario configurarlo $OFSsi lo necesito solo una vez.
  • 2011-03-12 01:49 (202) En línea $f.
  • 2011-03-12 01:57 (200) Ya no se necesita la cadena de formato. La interpolación de cadenas funciona bien.
  • 2011-03-12 02:00 (198) Ligeramente optimizado generando las filas individuales (reordenando la tubería y el índice de matriz).
  • 2011-03-12 02:09 (192) No es necesario -joinya que en realidad podemos usar el espacio adicional con buenos resultados.
— Joey
fuente
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

No particularmente inteligente. Estoy seguro de que se puede acortar de alguna manera ...

  • Editar: (246 -> 243) tomó la sugerencia de @ FUZxxl para usar interactuar
— MtnViewMark
fuente
¿Qué tal usarinteract
— FUZxxl
La primera línea se puede acortar a z x|x=" (__) "|0<1=" || ".
— FUZxxl
¡Su primera línea alternativa es más corta porque dejó caer dos espacios que son necesarios!
— MtnViewMark
¡Uy! Por supuesto que tienes razón.
— FUZxxl
4

Delfos, 348

Esta versión crea una cadena para escribir solo una vez; Los dígitos son manejados por una función separada que funciona a través de una digit modulo m >= valueconstrucción (negada si el valor <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.

Delfos, 565

Primer intento : 

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.

Esto usa 3 matrices; uno para las 7 cadenas que se pueden discernir, uno para las líneas de salida y otro para asignar las 7 cadenas a 11 columnas (10 dígitos y 1 columna inicial).

— PatrickvL
fuente
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*

Todavía no se juega mucho, pero cabe en un tweet (con solo ASCII). Probarlo aquí .

— Howard
fuente
2

J, 225

Pasa dos pruebas, debe funcionar hasta al menos varios cientos 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

Primero apagado: sí, sí, sepulturero. Segundo: eso es vergonzosamente largo. Oh bien. Todavía no he decidido si seguir jugando al golf o acurrucarme en posición fetal y llorar. (¡O ambos!)

Aquí hay un poco de explicación en lugar de un programa más corto:

  • c es una tabla 2x6 de celda vacía, celda de cuentas para renderizar.
  • f representa una fila '=' con los cuatro caracteres externos como argumento izquierdo.
  • d representa una fila de ábaco traduciendo matrices 0/1 en celdas de cuentas rellenadas con ||
  • g toma dígitos y compila verticalmente filas de caracteres usando f para 'formatear' filas yd para filas de ábaco.
  • La última fila recibe entrada, se divide en caracteres y los convierte en números, alimenta a gy luego imprime.
— Jesse Millikan
fuente
2

C, 277 274 caracteres

Sabes, me parece que simplemente no tenemos suficientes soluciones aquí que realmente aprovechen el preprocesador C. En parte, eso se debe a que esos #definerealmente ocupan un poco de espacio. Pero aún así, hay mucho potencial. Siento la necesidad de abordar esta deficiencia.

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

Eso es mejor.

— caja de pan
fuente
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]]

Ejemplo

w[6302715408]

ábaco

— DavidC
fuente
¡Felicidades por 10k! :-D
— Pomo de la puerta
@Perilla de la puerta. ¡Gracias! ¡Felicidades a ti también!
— DavidC
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")}

Primera versión, solo un poco de golf hasta ahora.

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

Intento bastante malo realmente.

— Gareth
fuente
1

Sclipting , 77 caracteres

La recompensa se refiere a los tweets y Twitter cuenta los caracteres (no los bytes). :)

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

De hecho, escribí esto hace años (cuando se publicó este desafío), pero nunca lo publiqué porque inventé Sclipting después de que este desafío se publicara por primera vez. Si cree que esto lo hace inelegible, lo entiendo.

Explicación

꿓뤽꿓뤽①長復 | 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
fuente
Gracias por tu interesante respuesta. Estoy de acuerdo en que es mejor cumplir con la regla de que solo los idiomas que se publican antes de la pregunta deben ser elegibles. No creo que haya diseñado deliberadamente su idioma para ganar este desafío, pero al mismo tiempo no creo que sea justo para los demás respondedores, y no queremos abrir las compuertas para los idiomas recién inventados en el antiguo preguntas ya que sabemos lo que sucederá ...
— gnibbler
@gnibbler: Claro, estoy bien con eso. Creo que esta regla es importante.
— Timwi
1

Pitón, 309 301 288 caracteres

Versión 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]

Versión 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

Tenga en cuenta que para la compactación, las variables se renombraron a una sola letra, y las comprensiones de la lista se cambiaron a generadores que no requieren corchetes adicionales.

— Nayuki
fuente
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.