Zeichnen Sie einen Suanpan-Abakus

32

Schreiben Sie das kürzeste Programm, das eine einzelne Ganzzahl als Eingabe verwendet und einen Suanpan-Abakus ausgibt

Testfälle

Eingang:

314159

Ausgabe:

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

Eingang:

6302715408

Ausgabe:

|\==============================================================/|
||  (__)  (__)  (__)  (__)  (__)  (__)  (__)  (__)  (__)  (__)  ||
||   ||   (__)  (__)  (__)   ||   (__)   ||   (__)  (__)   ||   ||
||   ||    ||    ||    ||    ||    ||    ||    ||    ||    ||   ||
||  (__)   ||    ||    ||   (__)   ||   (__)   ||    ||   (__)  ||
|<==============================================================>|
||  (__)  (__)   ||   (__)  (__)  (__)   ||   (__)   ||   (__)  ||
||   ||   (__)   ||   (__)  (__)   ||    ||   (__)   ||   (__)  ||
||   ||   (__)   ||    ||    ||    ||    ||   (__)   ||   (__)  ||
||   ||    ||    ||    ||    ||    ||    ||   (__)   ||    ||   ||
||   ||    ||    ||    ||    ||    ||    ||    ||    ||    ||   ||
||   ||    ||   (__)   ||    ||    ||   (__)   ||   (__)   ||   ||
||  (__)   ||   (__)   ||    ||   (__)  (__)   ||   (__)   ||   ||
||  (__)   ||   (__)  (__)  (__)  (__)  (__)   ||   (__)   ||   ||
||  (__)  (__)  (__)  (__)  (__)  (__)  (__)   ||   (__)  (__)  ||
||  (__)  (__)  (__)  (__)  (__)  (__)  (__)  (__)  (__)  (__)  ||
|/==============================================================\|
code-golf  ascii-art 
— Knabberzeug
quelle
Kann die Nummer in der Befehlszeile angegeben werden?
— Joey
Irgendwelche Einschränkungen der Eingabelänge?
— Joey
Ähnlich wie bei golf.shinh.org/p.rb?Soroban+Fixed, wenn jemand weitere Ideen zum Golfspielen benötigt.
— Nabb
1
Die obere Reihe und die untere Reihe sind also immer vollständig gefüllt? Warum haben sie einen so überflüssigen Abakus erfunden? :)
— Timwi
@ Timwi, der gleiche Abakus kann für hexadezimal verwendet werden. Bei Verwendung als Dezimalzahl werden die zusätzlichen Zeilen meistens bei der Durchführung von Multiplikationen und Divisionen verwendet
— Gnibbler

Antworten:

14

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

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

Übernimmt Eingaben von der Tastatur. Beispiel:

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

Der Haupttrick dabei ist der Missbrauch von Js Boxen durch Neudefinition der verwendeten Zeichen. Es verwendet einen globalen Parameter - 9!:7- dies zu tun. Es mag Raum für weiteres Golfen geben, aber um ehrlich zu sein, war ich nur froh, dass etwas funktionierte, das meinen letzten Versuch mit dieser Frage kompensieren sollte .

Passt in einen Tweet mit genügend Zeichen, um "Gaz made this" zu sagen :-).

Bearbeiten: 3 Zeichen Einsparungen sind auf die Ausleihe 2 6$' || (__)'von Jesse Millikans Antwort zurückzuführen.

Weitere Bearbeitung: Es sind 11 Zeichen verloren gegangen, die zusätzliche Leerzeichen an beiden Seiten hinzugefügt haben, von denen ich nicht bemerkt habe, dass sie nicht vorhanden sind.

Erläuterung:

Der Code besteht aus drei Hauptabschnitten:

1) Setup

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

Dies ist selbst in zwei Teile.
9!:7'\=/<=>/=\|='Definiert die Zeichen, die J zum Anzeigen von Feldern verwendet, neu. Js Boxen sieht normalerweise so aus:

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

aber nach der Neudefinition sieht es so aus:

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

(s=:[,.~,.)definiert ein Verb, das ich später ein paar Mal verwenden werde. Dies erweist sich als der beste Ort, um es zu deklarieren. Es nimmt ein Zeichen auf der linken Seite und ein Array von Zeichen auf der rechten Seite und schiebt das Array zwischen die Zeichen. Beispielsweise:

   3 5$'abcdefghijklmno'
abcde
fghij
klmno

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

Das Finale [dient nur dazu, das Setup vom nächsten Teil zu trennen.

2) Eingabe und Darstellung

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

".,.1!:1[1 Nimmt die Eingabe von der Tastatur und trennt sie in einzelne Ziffern:

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

((i.5)</5|]) Erstellt eine Null- und eine Einsdarstellung des unteren Teils des Abakus:

   ((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) Erstellt eine Nullen- und Eine-Darstellung des oberen Teils des Abakus:

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

Diese beiden Teile sind wie folgt zusammengepackt ;:

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

Dann werden die Kästen übereinander gelegt, um die Basis des Abakus zu bilden, was ergibt:

   ,.(|:@(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) Ausgabe

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

&.>bedeutet, dass das Folgende abwechselnd auf beide Boxen angewendet wird.
(,-.)Dies ist ein Hook, der die Eingabe negiert und an das Ende des Originals anfügt:

   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

Dies ist wirklich ein Teil der Darstellung, aber für Golfzwecke ist es besser, es in diesem Abschnitt zu haben. Auf die vorherige Eingabe angewendet:

   (,-.)&.>,.(|:@(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[\' || (__)'){~ Die Nullen und Einsen werden nun verwendet, um eine Zeichenfolge auszuwählen, die eine Perle darstellt, oder um die Abwesenheit einer solchen Zeichenfolge zu kennzeichnen:

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

Aber jetzt, wie Howard mir sagte, ist auf beiden Seiten der Perlen ein Leerzeichen frei. Daher verwenden wir das vordefinierte sVerb, um den Inhalt jeder Box zwischen zwei Spalten mit Leerzeichen einzuschließen:

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

Nachdem Sie das getan haben, müssen Sie es nur noch in eine Zeichenfolge konvertieren, ":damit wir es zwischen zwei Spalten einbetten können |:

   '|'s":(' 's[:,.(_6[\'  ||   (__)'){~(,-.))&.>,.(|:@(1,.<&5);((i.5)</5|]))".,.1!:1[1
314159
|\======================================/|
||  (__)  (__)  (__)  (__)  (__)  (__)  ||
||  (__)  (__)  (__)  (__)   ||    ||   ||
||   ||    ||    ||    ||    ||    ||   ||
||   ||    ||    ||    ||   (__)  (__)  ||
|<======================================>|
||  (__)  (__)  (__)  (__)   ||   (__)  ||
||  (__)   ||   (__)   ||    ||   (__)  ||
||  (__)   ||   (__)   ||    ||   (__)  ||
||   ||    ||   (__)   ||    ||   (__)  ||
||   ||    ||    ||    ||    ||    ||   ||
||   ||    ||    ||    ||   (__)   ||   ||
||   ||   (__)   ||   (__)  (__)   ||   ||
||   ||   (__)   ||   (__)  (__)   ||   ||
||  (__)  (__)   ||   (__)  (__)   ||   ||
||  (__)  (__)  (__)  (__)  (__)  (__)  ||
|/======================================\|
— Gareth
quelle
Ich hatte das Gefühl, dass etwas mit Ihrer Ausgabe "nicht stimmt", aber ich habe einige Zeit gebraucht, um es zu erkennen: Sie lassen eine leere Spalte ganz links und rechts im Display weg (drittletzte und drittletzte ASCII-Spalte).
— Howard
@ Howard Woah, guter Ort. Das habe ich nicht bemerkt. Ich werde versuchen, das Problem zu beheben.
— Gareth
@Howard Bei einem Preis von 11 Zeichen behoben. Schade, ich dachte, ich könnte eine Chance haben, unter 100 zu kommen. :-(
— Gareth
Gute Arbeit. Sieht so aus, als ob @Howard eine Menge Arbeit zu tun hat, um aufzuholen
— Knabberer
Bounty hat noch 3 Tage Zeit. Ich habe diesen als zwischenzeitlich akzeptiert markiert.
— Gnibbler
14

Ruby 1.9, 154 Zeichen

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

Angenommen, die Eingabe wird nicht durch einen Zeilenumbruch beendet.

Unterhaltsame Tatsache: Aufgrund der Art und Weise, wie ich die eingegebenen Ziffern in Zahlen umwandle ( $&.hexist ein Byte kürzer als $&.to_i), funktioniert dieser Abakus tatsächlich mit Hexadezimalziffern bis zu e:

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

Denn 0xfin der oberen Hälfte erscheint auf magische Weise eine dritte Perle.

Wenn Sie zusätzliche Flags während des Skriptaufrufs zulassen, kann dies auf 152 Bytes verkürzt werden (149 Bytes Code + 3 Bytes zusätzliche Aufrufflags):

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

Laufen Sie mit ruby -n suanpan.rb.

— Ventero
quelle
12

Perl (151 Zeichen)

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

Erläuterung

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

Bearbeitungen

  • (154 → 151) Drei \ns wurden in tatsächliche Zeilenumbrüche geändert. Kann nicht glauben, dass ich früher nicht daran gedacht habe!
— Timwi
quelle
1
Das ist einfach ... Super!
— 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\|"

Geschichte:

  • 2011-03-11 23:54 (340) Anfänglicher Versuch.
  • 2011-03-12 00:21 (323) Verwenden der Zeichenfolgeninterpolation im gesamten Code.
  • 2011-03-12 00:21 (321) Inlined $l.
  • 2011-03-12 01:07 (299) Verwendete eine Funktion für sich wiederholende Teile sowie eine Formatzeichenfolge .
  • 2011-03-12 01:19 (284) Die Argumente für die Funktion wurden geringfügig geändert. Hurra für den Befehlsanalyse-Modus.
  • 2011-03-12 01:22 (266) Weitere Variablen für wiederkehrende Ausdrücke.
  • 2011-03-12 01:28 (246) Jetzt wird jede Zeile von der Funktion generiert.
  • 2011-03-12 01:34 (236) Da ich die Zeichen nur bei der Zeichenfolgeninterpolation verwende, kann ich das ignorieren %, das Zahlen aus den Ziffern erstellt.
  • 2011-03-12 01:34 (234) Die Array-Index-Generierung in der Funktion wurde leicht optimiert.
  • 2011-03-12 01:42 (215) Ich brauche $rund nicht mehr $b. Und $aist auch überholt. Wie ist $l.
  • 2011-03-12 01:46 (207) Muss nicht eingestellt werden, $OFSwenn ich es nur einmal brauche.
  • 2011-03-12 01:49 (202) Inlined $f.
  • 2011-03-12 01:57 (200) Die Formatzeichenfolge wird nicht mehr benötigt. String-Interpolation funktioniert einwandfrei.
  • 2011-03-12 02:00 (198) Die Erzeugung der einzelnen Zeilen wurde leicht optimiert (Neuordnung des Pipeline- und Array-Index).
  • 2011-03-12 02:09 (192) Keine Notwendigkeit, -joinda wir den zusätzlichen Platz effektiv nutzen können.
— Joey
quelle
5

Haskell, 243 Zeichen

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

Nicht besonders schlau. Ich bin sicher, es kann irgendwie verkürzt werden ...

  • Bearbeiten: (246 -> 243) hat den Vorschlag von @ FUZxxl angenommen, interact zu verwenden
— MtnViewMark
quelle
Wie wäre es mitinteract
— FUZxxl
Erste Zeile kann bis gekürzt werden z x|x=" (__) "|0<1=" || ".
— FUZxxl
Ihre alternative erste Zeile ist nur kürzer, weil Sie zwei Leerzeichen fallen gelassen haben, die erforderlich sind!
— MtnViewMark
Hoppla! Du hast natürlich recht.
— FUZxxl
4

Delphi, 348

Diese Version baut einen String auf, der nur einmal geschrieben werden kann. Die Ziffern werden von einer separaten Funktion verarbeitet, die über ein digit modulo m >= valueKonstrukt arbeitet (negiert, wenn der Wert <0 ist).

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

Erster Versuch : 

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.

Dies verwendet 3 Arrays; eine für die 7 zu erkennenden Zeichenfolgen, eine für die Ausgabezeilen und eine für die Zuordnung der 7 Zeichenfolgen zu 11 Spalten (10 Ziffern und 1 Anfangsspalte).

— PatrickvL
quelle
3

GolfScript, 139 Zeichen

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*

Noch nicht viel golfen, aber es passt in einen Tweet (nur mit ASCII). Probieren Sie es hier aus .

— Howard
quelle
2

J 225

Bestehen zwei Tests, sollten bis zu mehreren hundert Stellen funktionieren.

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

Zunächst einmal: Ja, ja, Totengräber. Zweitens: Das ist nur peinlich lang. Naja. Ich habe mich noch nicht entschieden, ob ich weiter Golf spielen oder mich in fötaler Position zusammenrollen und weinen soll. (Oder beides!)

Hier ist eine kurze Erklärung anstelle eines kürzeren Programms:

  • c ist 2x6 Tabelle der leeren Zelle, Perlenzelle zum Rendern.
  • f rendert eine '=' Zeile mit den vier äußeren Zeichen als linkes Argument.
  • d gibt eine Abakuszeile wieder, indem 0/1 Matrizen in mit || aufgefüllte Kügelchenzellen übersetzt werden
  • g nimmt Ziffern und kompiliert vertikal Zeichenzeilen, wobei f zum Formatieren von Zeilen und d für Abakuszeilen verwendet wird.
  • Die letzte Zeile wird eingegeben, in Zeichen aufgeteilt und in Zahlen konvertiert, in g eingespeist und dann gedruckt.
— Jesse Millikan
quelle
2

C, 277 274 Zeichen

Weißt du, es scheint mir, dass wir hier einfach nicht genug Lösungen haben, die den C-Präprozessor wirklich ausnutzen. Das liegt zum Teil daran, dass diese #definetatsächlich einiges an Platz einnehmen. Trotzdem gibt es so viel Potenzial. Ich habe das Bedürfnis, diesen Mangel anzugehen.

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

Das ist besser.

— Brot-Box
quelle
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]]

Beispiel

w[6302715408]

Abakus

— DavidC
quelle
Herzlichen Glückwunsch zu 10k! :-D
— Türklinke
@Türknauf. Vielen Dank! Herzlichen Glückwunsch auch an Sie!
— 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")}

Erste Version, nur ein bisschen Golfspielen.

— schnaader
quelle
1

Scala (489 Zeichen)

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

Ziemlich beschissener Versuch wirklich.

— Gareth
quelle
1

Sclipting , 77 Zeichen

Das Kopfgeld bezieht sich auf Tweets und Twitter zählt die Zeichen (nicht die Bytes). :)

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

Ich habe tatsächlich vor Jahren geschrieben (als diese Herausforderung veröffentlicht wurde), aber ich habe sie nie veröffentlicht, weil ich Sclipting erfunden habe, nachdem diese Herausforderung zum ersten Mal veröffentlicht wurde. Wenn Sie das Gefühl haben, dass dies nicht förderfähig ist, verstehe ich.

Erläuterung

꿓뤽꿓뤽①長復 | 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
quelle
Vielen Dank für Ihre interessante Antwort. Ich stimme zu, dass es am besten ist, sich an die Regel zu halten, dass nur Sprachen in Frage kommen sollten, die vor der gestellten Frage veröffentlicht wurden. Ich glaube nicht, dass Sie Ihre Sprache absichtlich entworfen haben, um diese Herausforderung zu gewinnen, aber gleichzeitig halte ich es nicht für fair gegenüber den anderen Antwortenden, und wir möchten nicht die Schleusen für neu erfundene Sprachen in alten Sprachen öffnen Fragen, da wir wissen, was passieren wird ...
— Knabberzeug
@ Gnibbler: Klar, ich bin damit einverstanden. Ich denke, diese Regel ist wichtig.
— Timwi
1

Python, 309 301 288 Zeichen

Kompakte Version:

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]

Klare Version:

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

Beachten Sie, dass zur Komprimierung die Variablen in einen einzelnen Buchstaben umbenannt wurden und das Listenverständnis in Generatoren geändert wurde, für die keine zusätzlichen Klammern erforderlich sind.

— Nayuki
quelle
Durch die Nutzung unserer Website bestätigen Sie, dass Sie unsere Cookie-Richtlinie und Datenschutzrichtlinie gelesen und verstanden haben.
Licensed under cc by-sa 3.0 with attribution required.