Disegna un abaco Suanpan

32

Scrivi il programma più breve che accetta come input un singolo intero e stampa un abaco di Suanpan

Casi test

Ingresso:

314159

Produzione:

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

Ingresso:

6302715408

Produzione:

|\==============================================================/|
||  (__)  (__)  (__)  (__)  (__)  (__)  (__)  (__)  (__)  (__)  ||
||   ||   (__)  (__)  (__)   ||   (__)   ||   (__)  (__)   ||   ||
||   ||    ||    ||    ||    ||    ||    ||    ||    ||    ||   ||
||  (__)   ||    ||    ||   (__)   ||   (__)   ||    ||   (__)  ||
|<==============================================================>|
||  (__)  (__)   ||   (__)  (__)  (__)   ||   (__)   ||   (__)  ||
||   ||   (__)   ||   (__)  (__)   ||    ||   (__)   ||   (__)  ||
||   ||   (__)   ||    ||    ||    ||    ||   (__)   ||   (__)  ||
||   ||    ||    ||    ||    ||    ||    ||   (__)   ||    ||   ||
||   ||    ||    ||    ||    ||    ||    ||    ||    ||    ||   ||
||   ||    ||   (__)   ||    ||    ||   (__)   ||   (__)   ||   ||
||  (__)   ||   (__)   ||    ||   (__)  (__)   ||   (__)   ||   ||
||  (__)   ||   (__)  (__)  (__)  (__)  (__)   ||   (__)   ||   ||
||  (__)  (__)  (__)  (__)  (__)  (__)  (__)   ||   (__)  (__)  ||
||  (__)  (__)  (__)  (__)  (__)  (__)  (__)  (__)  (__)  (__)  ||
|/==============================================================\|
code-golf  ascii-art 
— gnibbler
fonte
È possibile fornire il numero sulla riga di comando?
— Joey,
Eventuali restrizioni sulla lunghezza dell'input?
— Joey,
Simile a golf.shinh.org/p.rb?Soroban+ Risolto se qualcuno ha bisogno di idee su come giocare di più a golf.
— Nabb,
1
Quindi la riga superiore e la riga inferiore sono sempre completamente riempite? Perché hanno inventato un tale abbaco ridondante? :)
— Timwi
@ Timwi, lo stesso abaco può essere usato per esadecimali. Se utilizzate per i decimali, le righe extra vengono utilizzate principalmente quando si eseguono moltiplicazioni e divisioni
— gnibbler

Risposte:

14

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

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

Riceve input dalla tastiera. Esempio:

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

Il trucco principale qui è l'abuso della boxe di J ridefinendo i personaggi che usa. Usa un parametro globale - 9!:7- per fare questo. Potrebbe esserci spazio per ulteriori golf, ma ad essere sincero, sono stato contento di far funzionare qualcosa che avrebbe compensato il mio ultimo tentativo con questa domanda .

Si inserisce in un tweet con abbastanza personaggi rimasti per dire "Gaz ha fatto questo" :-).

Edit: 3 personaggi di risparmi sono dovuti a prestito il 2 6$' || (__)'da Jesse Millikan risposta.

Ulteriore modifica: persi 11 caratteri aggiungendo spazi extra su entrambi i lati che non avevo notato non erano presenti.

Spiegazione:

Il codice è in tre sezioni principali:

1) Installazione

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

Questo è esso stesso in due parti.
9!:7'\=/<=>/=\|='ridefinisce i caratteri che J utilizzerà per visualizzare le caselle. La boxe di J normalmente si presenta così:

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

ma dopo aver ridefinito sembra così:

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

(s=:[,.~,.)definisce un verbo che userò un paio di volte dopo. Questo risulta essere il posto migliore per dichiararlo. Prende un personaggio a sinistra e una serie di personaggi a destra e inserisce la matrice tra il personaggio. Per esempio:

   3 5$'abcdefghijklmno'
abcde
fghij
klmno

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

Il finale [serve solo a separare l'installazione dalla parte successiva.

2) Input e rappresentazione

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

".,.1!:1[1 prende l'input dalla tastiera e lo separa in singole cifre:

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

((i.5)</5|]) crea uno zero e una rappresentazione della parte inferiore dell'abaco:

   ((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 uno zero e una rappresentazione della parte superiore dell'abaco:

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

Queste due parti sono inscatolate insieme 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|
/=======================\

Quindi le scatole vengono posizionate una sopra l'altra per formare la base dell'abaco, 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) Uscita

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

&.>significa che quanto segue funzionerà a turno su entrambe le caselle.
(,-.)questo è un hook che annullerà l'input e poi lo aggiungerà alla fine dell'originale:

   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

Questo fa davvero parte della rappresentazione, ma ai fini del golf è meglio averlo in questa sezione. Applicato all'input precedente:

   (,-.)&.>,.(|:@(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[\' || (__)'){~ Gli zeri e quelli vengono ora utilizzati per selezionare una stringa per rappresentare un cordone o l'assenza di uno:

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

Ma ora, come mi ha fatto notare Howard, c'è uno spazio corto su entrambi i lati delle perle. Quindi usiamo il sverbo predefinito per inserire il contenuto di ogni riquadro tra due colonne di spazi:

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

Fatto ciò, non resta che convertirlo in una stringa usando in ":modo da poterlo inserire tra due colonne di |:

   '|'s":(' 's[:,.(_6[\'  ||   (__)'){~(,-.))&.>,.(|:@(1,.<&5);((i.5)</5|]))".,.1!:1[1
314159
|\======================================/|
||  (__)  (__)  (__)  (__)  (__)  (__)  ||
||  (__)  (__)  (__)  (__)   ||    ||   ||
||   ||    ||    ||    ||    ||    ||   ||
||   ||    ||    ||    ||   (__)  (__)  ||
|<======================================>|
||  (__)  (__)  (__)  (__)   ||   (__)  ||
||  (__)   ||   (__)   ||    ||   (__)  ||
||  (__)   ||   (__)   ||    ||   (__)  ||
||   ||    ||   (__)   ||    ||   (__)  ||
||   ||    ||    ||    ||    ||    ||   ||
||   ||    ||    ||    ||   (__)   ||   ||
||   ||   (__)   ||   (__)  (__)   ||   ||
||   ||   (__)   ||   (__)  (__)   ||   ||
||  (__)  (__)   ||   (__)  (__)   ||   ||
||  (__)  (__)  (__)  (__)  (__)  (__)  ||
|/======================================\|
— Gareth
fonte
Ho sentito che c'era qualcosa di "sbagliato" nel tuo output, ma mi ci è voluto un po 'di tempo per riconoscerlo: hai omesso una colonna vuota all'estrema sinistra e a destra del display (terza e terza ultima colonna ASCII).
— Howard,
@Howard Woah, buon posto. Non me ne sono accorto. Vedrò come risolverlo.
— Gareth,
@Howard Risolto al costo di 11 caratteri. Peccato, ho pensato di avere una possibilità di scendere sotto i 100. :-(
— Gareth,
Bel lavoro. Sembra che @Howard abbia molto lavoro da fare per recuperare il ritardo
— Gnibbler,
Bounty ha ancora 3 giorni. Ho contrassegnato questo come accettato per il momento.
— Gnibbler,
14

Ruby 1.9, 154 caratteri

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

Presuppone che l'input sia non sia terminato da una nuova riga.

Curiosità: a causa del modo in cui sto trasformando le cifre di input in numeri ( $&.hexè un byte più breve di $&.to_i), questo abaco funziona effettivamente con cifre esadecimali fino a e:

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

Infatti 0xf, un terzo tallone appare magicamente nella metà superiore.

Quando si consentono flag aggiuntivi durante l'invocazione di script, questo può essere abbreviato a 152 byte (149 byte di codice + 3 byte flag di invocazione aggiuntivi):

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

Corri con ruby -n suanpan.rb.

— Ventero
fonte
12

Perl (151 caratteri)

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

Spiegazione

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

Le modifiche

  • (154 → 151) Modificato tre \nsecondi in caratteri di nuova riga effettivi. Non riesco a credere che non ci abbia pensato prima!
— Timwi
fonte
1
Questo è semplicemente ... fantastico!
— 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\|"

Storia:

  • 2011-03-11 23:54 (340) Tentativo iniziale.
  • 12-03-2011 00:21 (323) Utilizzo dell'interpolazione di stringa in tutto il codice.
  • 12-03-2011 00:21 (321) Inline$l .
  • 12-03-2011 01:07 (299) Utilizzata una funzione per le parti più ripetitive e una stringa di formato.
  • 12-03-2011 01:19 (284) Modificati leggermente gli argomenti della funzione. Evviva la modalità di analisi dei comandi.
  • 12-03-2011 01:22 (266) Altre variabili per espressioni ricorrenti.
  • 12-03-2011 01:28 (246) Ora ogni riga è generata dalla funzione.
  • 12-03-2011 01:34 (236) Dato che utilizzo i caratteri solo nell'interpolazione di stringhe, posso tranquillamente ignorare il file% ciò che rende i numeri dalle cifre.
  • 12-03-2011 01:34 (234) Ottimizzata leggermente la generazione dell'indice di array nella funzione.
  • 2011-03-12 01:42 (215) Non ho più bisogno $re $b. Ed $aè anche obsoleto. Come è$l .
  • 2011-03-12 01:46 (207) Non è necessario impostare $OFSse ne ho bisogno solo una volta.
  • 12-03-2011 01:49 (202) Inline $f.
  • 12-03-2011 01:57 (200) Non è più necessaria la stringa di formato. L'interpolazione di stringhe funziona bene.
  • 2011-03-12 02:00 (198) Leggermente ottimizzato generando le singole righe (riordino della pipeline e dell'indice dell'array).
  • 2011-03-12 02:09 (192) Non è necessario -joinpoiché possiamo effettivamente utilizzare lo spazio aggiuntivo per ottenere buoni risultati.
— Joey
fonte
5

Haskell, 243 personaggi

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

Non particolarmente intelligente. Sono sicuro che può essere abbreviato in qualche modo ...

  • Modifica: (246 -> 243) ha preso il suggerimento di @ FUZxxl per usare interagire
— MtnViewMark
fonte
Che ne dici di usareinteract
— FUZxxl
La prima riga può essere abbreviata in z x|x=" (__) "|0<1=" || ".
— FUZxxl,
La tua prima riga alternativa è solo più corta perché hai lasciato cadere due spazi richiesti!
— MtnViewMark
Oops! Hai ovviamente ragione.
— FUZxxl
4

Delfi, 348

Questa versione crea una stringa da scrivere una sola volta; Le cifre sono gestite da una funzione separata che funziona tramite un digit modulo m >= valuecostrutto (negato se valore <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.

Delfi, 565

Primo tentativo : 

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.

Questo utilizza 3 array; uno per le 7 stringhe che possono essere individuate, uno per le righe di output e uno per mappare le 7 stringhe su 11 colonne (10 cifre e 1 colonna iniziale).

— PatrickvL
fonte
3

GolfScript, 139 caratteri

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*

Non c'è ancora molto da giocare a golf, ma si adatta a un tweet (con solo ASCII). Provalo qui .

— Howard
fonte
2

J, 225

Supera due prove, dovrebbe funzionare fino ad almeno alcune centinaia di cifre.

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

Prima di tutto: Sì, sì, beccando. Secondo: è solo lungamente imbarazzante. Oh bene. Non ho ancora deciso se giocare a golf ulteriormente o rannicchiarsi in posizione fetale e piangere. (O entrambi!)

Ecco un po 'di spiegazioni al posto di un programma più breve:

  • c è una tabella 2x6 di cella vuota, cella di perline per il rendering.
  • f rende una riga '=' con i quattro caratteri esterni come argomento sinistro.
  • d rende una riga di abaco traducendo matrici 0/1 in celle di perline riempite con ||
  • g prende le cifre e compila verticalmente le righe di caratteri usando f per "formattare" le righe e d per le righe dell'abaco.
  • L'ultima riga riceve input, si divide in caratteri e li converte in numeri, li inserisce in ge quindi stampa.
— Jesse Millikan
fonte
2

C, 277 274 caratteri

Sai, mi sembra che non abbiamo abbastanza soluzioni qui che sfruttino davvero il preprocessore C. In parte è perché quelli #defineoccupano davvero un bel po 'di spazio. Tuttavia, c'è così tanto potenziale. Sento la necessità di affrontare questa carenza.

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

Va meglio.

— breadbox
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]]

Esempio

w[6302715408]

abaco

— DavidC
fonte
Congratulazioni per 10k! MrGreen
— Maniglia della porta
@Maniglia. Grazie! Complimenti anche a te!
— 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")}

Prima versione, solo un po 'di golf finora.

— schnaader
fonte
1

Scala (489 caratteri)

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

Tentativo piuttosto scadente davvero.

— Gareth
fonte
1

Sclipting , 77 caratteri

La generosità si riferisce ai tweet e Twitter conta i caratteri (non i byte). :)

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

In realtà l'ho scritto anni fa (quando è stata pubblicata questa sfida), ma non l'ho mai pubblicato perché ho inventato Sclipting dopo che questa sfida è stata pubblicata per la prima volta. Se ritieni che ciò lo renda inammissibile, ho capito.

Spiegazione

꿓뤽꿓뤽①長復 | 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
Grazie per la tua risposta interessante. Concordo sul fatto che è meglio attenersi alla regola secondo cui solo le lingue pubblicate prima della domanda posta potrebbero essere ammissibili. Non credo che avresti deliberatamente progettato la tua lingua per vincere questa sfida, ma allo stesso tempo non penso che sia giusto per gli altri risponditori, e non vogliamo aprire le porte a nuove lingue inventate su vecchie domande dal momento che sappiamo cosa accadrà ...
— Gnibbler,
@gnibbler: Certo, sto bene. Penso che questa regola sia importante.
— Timwi,
1

Pitone, 309 301 288 caratteri

Versione compatta:

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]

Versione chiara:

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

Si noti che per la compactificazione, le variabili sono state rinominate in una singola lettera e la comprensione dell'elenco è stata modificata in generatori che non richiedono parentesi extra.

— Nayuki
fonte
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.