Narysuj liczydło Suanpan

32

Napisz najkrótszy program, który pobiera jedną liczbę całkowitą jako dane wejściowe i wypisuje liczydło Suanpan

Przypadki testowe

Wkład:

314159

Wydajność:

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

Wkład:

6302715408

Wydajność:

|\==============================================================/|
||  (__)  (__)  (__)  (__)  (__)  (__)  (__)  (__)  (__)  (__)  ||
||   ||   (__)  (__)  (__)   ||   (__)   ||   (__)  (__)   ||   ||
||   ||    ||    ||    ||    ||    ||    ||    ||    ||    ||   ||
||  (__)   ||    ||    ||   (__)   ||   (__)   ||    ||   (__)  ||
|<==============================================================>|
||  (__)  (__)   ||   (__)  (__)  (__)   ||   (__)   ||   (__)  ||
||   ||   (__)   ||   (__)  (__)   ||    ||   (__)   ||   (__)  ||
||   ||   (__)   ||    ||    ||    ||    ||   (__)   ||   (__)  ||
||   ||    ||    ||    ||    ||    ||    ||   (__)   ||    ||   ||
||   ||    ||    ||    ||    ||    ||    ||    ||    ||    ||   ||
||   ||    ||   (__)   ||    ||    ||   (__)   ||   (__)   ||   ||
||  (__)   ||   (__)   ||    ||   (__)  (__)   ||   (__)   ||   ||
||  (__)   ||   (__)  (__)  (__)  (__)  (__)   ||   (__)   ||   ||
||  (__)  (__)  (__)  (__)  (__)  (__)  (__)   ||   (__)  (__)  ||
||  (__)  (__)  (__)  (__)  (__)  (__)  (__)  (__)  (__)  (__)  ||
|/==============================================================\|
code-golf  ascii-art 
— gnibbler
źródło
Czy numer można podać w wierszu polecenia?
— Joey,
Jakieś ograniczenia dotyczące długości wejściowej?
— Joey,
Podobny do golf.shinh.org/p.rb?Soroban+ Naprawiono, jeśli ktoś potrzebuje pomysłów na więcej gry w golfa.
— Nabb,
1
Czy więc górny i dolny rząd są zawsze całkowicie wypełnione? Dlaczego wymyślili tak zbędny liczydło? :)
— Timwi
@Timwi, ten sam liczydło może być użyty w systemie szesnastkowym. W przypadku dziesiętnego dodatkowe wiersze są najczęściej używane podczas mnożenia i dzielenia
— gnibbler

Odpowiedzi:

14

J, 126 124 121 119 116 115 113 105 116 115 112 znaków

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

Pobiera dane z klawiatury. Przykład:

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

Główną sztuczką jest nadużywanie boksu J. poprzez redefiniowanie używanych przez niego znaków. W tym celu wykorzystuje parametr globalny - 9!:7-. Może być miejsce na dalszą grę w golfa, ale szczerze mówiąc cieszyłem się, że dostałem coś, co zrekompensuje moją ostatnią próbę tego pytania .

Pasuje do tweeta z wystarczającą liczbą znaków, by powiedzieć „Gaz to zrobił” :-).

Edycja: 3 postacie oszczędności wynikają z pożyczenia odpowiedzi 2 6$' || (__)'od Jesse Millikana .

Dalsza edycja: Straciłem 11 znaków dodając dodatkowe spacje po obu stronach, których nie zauważyłem, nie były obecne.

Wyjaśnienie:

Kod składa się z trzech głównych części:

1) Konfiguracja

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

To samo składa się z dwóch części.
9!:7'\=/<=>/=\|='redefiniuje znaki, których J użyje do wyświetlenia pól. Boks J zwykle wygląda tak:

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

ale po przedefiniowaniu wygląda to tak:

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

(s=:[,.~,.)definiuje czasownik, którego zamierzam użyć kilka razy później. To okazuje się najlepszym miejscem do zadeklarowania tego. Pobiera znak po lewej stronie i tablicę znaków po prawej stronie i umieszcza tablicę między postacią. Na przykład:

   3 5$'abcdefghijklmno'
abcde
fghij
klmno

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

Finał [służy jedynie do oddzielenia konfiguracji od następnej części.

2) Dane wejściowe i reprezentacja

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

".,.1!:1[1 pobiera dane z klawiatury i dzieli je na poszczególne cyfry:

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

((i.5)</5|]) tworzy reprezentację zer i jedynek dolnej części liczydła:

   ((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) tworzy reprezentację zer i jedynek górnej części liczydła:

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

Te dwie części są zapakowane razem za pomocą ;:

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

Następnie pudełka są umieszczane jeden na drugim, tworząc podstawę liczydła, dając:

   ,.(|:@(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) Wyjście

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

&.>oznacza, że ​​poniższe elementy będą działać kolejno na obu polach.
(,-.)jest to haczyk, który zaneguje dane wejściowe, a następnie doda je na końcu oryginału:

   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

To naprawdę część reprezentacji, ale dla celów golfowych lepiej jest mieć ją w tej sekcji. Zastosowano do poprzedniego wejścia:

   (,-.)&.>,.(|:@(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[\' || (__)'){~ Zera i jedynki są teraz używane do wyboru łańcucha reprezentującego koralik lub jego brak:

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

Ale teraz, jak wskazał mi Howard, po jednej stronie kulek jest jedno wolne miejsce. Tak więc używamy predefiniowanego sczasownika do umieszczenia zawartości każdego pola między dwiema kolumnami spacji:

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

Po tym, wszystko, co pozostało, to przekonwertować to na ciąg za pomocą ":, abyśmy mogli umieścić go między dwiema kolumnami |:

   '|'s":(' 's[:,.(_6[\'  ||   (__)'){~(,-.))&.>,.(|:@(1,.<&5);((i.5)</5|]))".,.1!:1[1
314159
|\======================================/|
||  (__)  (__)  (__)  (__)  (__)  (__)  ||
||  (__)  (__)  (__)  (__)   ||    ||   ||
||   ||    ||    ||    ||    ||    ||   ||
||   ||    ||    ||    ||   (__)  (__)  ||
|<======================================>|
||  (__)  (__)  (__)  (__)   ||   (__)  ||
||  (__)   ||   (__)   ||    ||   (__)  ||
||  (__)   ||   (__)   ||    ||   (__)  ||
||   ||    ||   (__)   ||    ||   (__)  ||
||   ||    ||    ||    ||    ||    ||   ||
||   ||    ||    ||    ||   (__)   ||   ||
||   ||   (__)   ||   (__)  (__)   ||   ||
||   ||   (__)   ||   (__)  (__)   ||   ||
||  (__)  (__)   ||   (__)  (__)   ||   ||
||  (__)  (__)  (__)  (__)  (__)  (__)  ||
|/======================================\|
— Gareth
źródło
Czułem, że coś jest „nie tak” z twoimi wynikami, ale zajęło mi to trochę czasu, aby rozpoznać: pomijasz pustą kolumnę po lewej i prawej stronie wyświetlacza (trzecia i trzecia kolumna ascii).
— Howard
@Howard Woah, dobre miejsce. Nie zauważyłem tego. Spróbuję to naprawić.
— Gareth,
@Howard Naprawiono koszt 11 znaków. Szkoda, pomyślałem, że mogę mieć szansę na osiągnięcie poziomu poniżej 100. :-(
— Gareth
Dobra robota. Wygląda na to, że @Howard ma dużo pracy do nadrobienia
— gnibbler
Bounty pozostało 3 dni. Tymczasem oznaczyłem ten jako przyjęty.
— gnibbler
14

Ruby 1.9, 154 znaków

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

Zakłada, że ​​wejście nie jest zakończone znakiem nowej linii.

Ciekawostka: Ze względu na sposób, w jaki zamieniam cyfry wejściowe na liczby ( $&.hexjest o jeden bajt krótszy niż $&.to_i), liczydło faktycznie działa z cyframi szesnastkowymi do e:

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

Bo 0xfw górnej połowie magicznie pojawia się trzeci koralik.

Gdy zezwalasz na dodatkowe flagi podczas wywoływania skryptu, można to skrócić do 152 bajtów (kod 149 bajtów + 3 bajty dodatkowych flag wywołania):

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

Uruchom z ruby -n suanpan.rb.

— Ventero
źródło
12

Perl (151 znaków)

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

Wyjaśnienie

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

Edycje

  • (154 → 151) Zmieniono trzy \ns na rzeczywiste znaki nowej linii. Nie mogę uwierzyć, że nie myślałem o tym wcześniej!
— Timwi
źródło
1
To jest po prostu ... Niesamowite!
— 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) Pierwsza próba.
  • 2011-03-12 00:21 (323) Korzystanie z interpolacji ciągów w całym kodzie.
  • 2011-03-12 00:21 (321) Inline $l.
  • 2011-03-12 01:07 (299) Użyto funkcji dla bardziej powtarzalnych części, a także łańcucha formatu.
  • 2011-03-12 01:19 (284) Lekko zmieniono argumenty na funkcję. Brawo dla trybu analizy poleceń.
  • 2011-03-12 01:22 (266) Więcej zmiennych dla wyrażeń cyklicznych.
  • 2011-03-12 01:28 (246) Teraz każdy wiersz jest generowany przez funkcję.
  • 2011-03-12 01:34 (236) Ponieważ znaki używam tylko do interpolacji łańcuchów, mogę bezpiecznie zignorować znaki, %które tworzą cyfry z cyfr.
  • 2011-03-12 01:34 (234) Nieznacznie zoptymalizowano generowanie indeksu tablicowego w funkcji.
  • 2011-03-12 01:42 (215) Nie potrzebuję już $ri $b. I $ajest również przestarzały. Jak jest $l.
  • 2011-03-12 01:46 (207) Nie trzeba ustawiać, $OFSjeśli potrzebuję go tylko raz.
  • 2011-03-12 01:49 (202) Inline $f.
  • 2011-03-12 01:57 (200) Nie trzeba już ciągów formatu. Interpolacja łańcuchów znaków działa dobrze.
  • 2011-03-12 02:00 (198) Nieznacznie zoptymalizowane generowanie poszczególnych wierszy (zmiana kolejności indeksu potoku i tablicy).
  • 2011-03-12 02:09 (192) Nie ma -jointakiej potrzeby, ponieważ możemy właściwie wykorzystać dodatkową przestrzeń, aby uzyskać dobry efekt.
— Joey
źródło
5

Haskell, 243 znaków

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

Niezbyt sprytnie. Jestem pewien, że można go jakoś skrócić ...

  • Edycja: (246 -> 243) przyjęła sugestię @ FUZxxl dotyczącą użycia interakcji
— MtnViewMark
źródło
Co powiesz na używanieinteract
— FUZxxl
Pierwsza linia może być skrótem do z x|x=" (__) "|0<1=" || ".
— FUZxxl
Twój alternatywny pierwszy wiersz jest tylko krótszy, ponieważ upuściłeś dwa wymagane pola!
— MtnViewMark
Ups! Oczywiście masz rację.
— FUZxxl
4

Delphi, 348

Ta wersja tworzy ciąg, który można zapisać tylko raz; Cyfry są obsługiwane przez osobną funkcję, która działa za pomocą digit modulo m >= valuekonstrukcji (negowane, jeśli wartość <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

Pierwsze podejscie : 

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.

Wykorzystuje 3 tablice; jeden dla 7 łańcuchów, które można rozpoznać, jeden dla linii wyjściowych i jeden do mapowania 7 łańcuchów na 11 kolumn (10 cyfr i 1 kolumna początkowa).

— PatrickvL
źródło
3

GolfScript, 139 znaków

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*

Jeszcze mało golfa, ale pasuje do tweeta (tylko ASCII). Wypróbuj tutaj .

— Howard
źródło
2

J, 225

Przechodzi dwa podane testy, powinien działać do co najmniej kilkuset cyfr.

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

Po pierwsze: tak, tak, grabarze. Po drugie: to krępująco długie. No cóż. Nie zdecydowałem jeszcze, czy zagrać w golfa dalej, czy zwinąć się w pozycji embrionalnej i płakać. (Lub obydwa!)

Oto kilka wyjaśnień zamiast krótszego programu:

  • c to tablica 2x6 pustej komórki, komórka perełek do renderowania.
  • f renderuje wiersz „=” z czterema zewnętrznymi znakami jako lewy argument.
  • d renderuje wiersz liczydła, tłumacząc macierze 0/1 na komórki kulek wypełnione ||
  • g przyjmuje cyfry i kompiluje w pionie wiersze znaków za pomocą f do wierszy „formatujących” id do wierszy liczydła.
  • Ostatni wiersz pobiera dane wejściowe, dzieli na znaki i konwertuje je na liczby, podaje do g, a następnie drukuje.
— Jesse Millikan
źródło
2

C, 277 274 znaków

Wiesz, wydaje mi się, że po prostu nie mamy tutaj wystarczająco dużo rozwiązań, które naprawdę wykorzystują preprocesor C. Częściowo #definedzieje się tak, ponieważ faktycznie zajmują sporo miejsca. Ale wciąż jest tak duży potencjał. Czuję potrzebę zajęcia się tym problemem.

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

Tak lepiej

— chlebak
źródło
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]]

Przykład

w[6302715408]

liczydło

— DavidC
źródło
Gratulacje na 10 000! :-D
— Klamka
@Doorknob. Dzięki! Gratulacje dla ciebie 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")}

Pierwsza wersja, trochę golfa.

— schnaader
źródło
1

Scala (489 znaków)

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

Naprawdę kiepska próba.

— Gareth
źródło
1

Sclipting , 77 znaków

Nagroda dotyczy tweetów , a Twitter zlicza znaki (nie bajty). :)

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

Napisałem to wiele lat temu (kiedy opublikowano to wyzwanie), ale nigdy go nie opublikowałem, ponieważ wymyśliłem Sclipting po tym, jak to wyzwanie zostało opublikowane. Rozumiem, że jeśli uważasz, że to czyni go niekwalifikowalnym.

Wyjaśnienie

꿓뤽꿓뤽①長復 | 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
źródło
Dziękuję za interesującą odpowiedź. Zgadzam się, że najlepiej trzymać się zasady, że tylko języki opublikowane przed zadaniem pytania powinny kwalifikować się. Nie sądzę, abyś celowo zaprojektował swój język, aby wygrać to wyzwanie, ale jednocześnie nie sądzę, aby był sprawiedliwy w stosunku do innych odpowiedzi, i nie chcemy otwierać bram dla nowo wymyślonych języków na stare pytania, ponieważ wiemy, co się stanie ...
— gnibbler
@gnibbler: Jasne, nic mi nie jest. Myślę, że ta zasada jest ważna.
— Timwi
1

Pyton, 309 301 288 znaków

Wersja kompaktowa:

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]

Wyczyść wersję:

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

Zauważ, że w celu zagęszczenia zmieniono nazwy zmiennych na jedną literę, a zmieniono opisy list na generatory, które nie wymagają dodatkowych nawiasów.

— Nayuki
źródło
Korzystając z naszej strony potwierdzasz, że przeczytałeś(-aś) i rozumiesz nasze zasady używania plików cookie i zasady ochrony prywatności.
Licensed under cc by-sa 3.0 with attribution required.