Dessinez un boulier Suanpan

32

Écrivez le programme le plus court qui prend un seul entier comme entrée et imprime un abaque Suanpan

Testcases

Contribution:

314159

Sortie:

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

Contribution:

6302715408

Sortie:

|\==============================================================/|
||  (__)  (__)  (__)  (__)  (__)  (__)  (__)  (__)  (__)  (__)  ||
||   ||   (__)  (__)  (__)   ||   (__)   ||   (__)  (__)   ||   ||
||   ||    ||    ||    ||    ||    ||    ||    ||    ||    ||   ||
||  (__)   ||    ||    ||   (__)   ||   (__)   ||    ||   (__)  ||
|<==============================================================>|
||  (__)  (__)   ||   (__)  (__)  (__)   ||   (__)   ||   (__)  ||
||   ||   (__)   ||   (__)  (__)   ||    ||   (__)   ||   (__)  ||
||   ||   (__)   ||    ||    ||    ||    ||   (__)   ||   (__)  ||
||   ||    ||    ||    ||    ||    ||    ||   (__)   ||    ||   ||
||   ||    ||    ||    ||    ||    ||    ||    ||    ||    ||   ||
||   ||    ||   (__)   ||    ||    ||   (__)   ||   (__)   ||   ||
||  (__)   ||   (__)   ||    ||   (__)  (__)   ||   (__)   ||   ||
||  (__)   ||   (__)  (__)  (__)  (__)  (__)   ||   (__)   ||   ||
||  (__)  (__)  (__)  (__)  (__)  (__)  (__)   ||   (__)  (__)  ||
||  (__)  (__)  (__)  (__)  (__)  (__)  (__)  (__)  (__)  (__)  ||
|/==============================================================\|
code-golf  ascii-art 
— gnibbler
source
Le numéro peut-il être donné sur la ligne de commande?
— Joey
Des restrictions sur la longueur d'entrée?
— Joey
Similaire à golf.shinh.org/p.rb?Soroban+Fixed si quelqu'un a besoin d'idées sur la façon de jouer au golf plus.
— Nabb
1
Ainsi, la rangée du haut et la rangée du bas sont toujours complètement remplies? Pourquoi ont-ils inventé un boulier aussi redondant? :)
— Timwi
@Timwi, le même boulier peut être utilisé pour l'hexidécimal. Lorsqu'elles sont utilisées pour la décimale, les lignes supplémentaires sont principalement utilisées lors des multiplications et des divisions
— gnibbler

Réponses:

14

J, 126 124 121 121 119 116 115 113 105 116 115 115 112 caractères

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

Prend l'entrée du clavier. Exemple:

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

L'astuce principale ici est l'abus de la boxe de J en redéfinissant les personnages qu'il utilise. Il utilise un paramètre global - 9!:7- pour ce faire. Il y a peut-être de la place pour jouer au golf, mais pour être honnête, j'étais simplement heureux de faire fonctionner quelque chose qui devrait compenser ma dernière tentative à cette question .

Convient à un tweet avec suffisamment de caractères pour dire 'Gaz a fait ça' :-).

Edit: 3 caractères d'économies sont dus à l'emprunt 2 6$' || (__)'de la réponse de Jesse Millikan .

Édition supplémentaire: perdu 11 personnages ajoutant des espaces supplémentaires de chaque côté que je n'avais pas remarqué n'étaient pas présents.

Explication:

Le code est divisé en trois sections principales:

1) Configuration

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

C'est lui-même en deux parties.
9!:7'\=/<=>/=\|='redéfinit les caractères que J utilisera pour afficher les cases. La boxe de J ressemble normalement à ceci:

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

mais après avoir redéfini cela ressemble à ceci:

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

(s=:[,.~,.)définit un verbe que je vais utiliser quelques fois plus tard. Cela s'avère être le meilleur endroit pour le déclarer. Il prend un caractère à gauche et un tableau de caractères à droite et prend en sandwich le tableau entre les caractères. Par exemple:

   3 5$'abcdefghijklmno'
abcde
fghij
klmno

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

La finale [sert juste à séparer la configuration de la partie suivante.

2) Entrée et représentation

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

".,.1!:1[1 prend l'entrée du clavier et la sépare en chiffres individuels:

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

((i.5)</5|]) crée une représentation des zéros et des uns de la partie inférieure de l'abaque:

   ((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) crée une représentation des zéros et des uns de la partie supérieure de l'abaque:

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

Ces deux parties sont regroupées en utilisant ;:

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

Ensuite, les boîtes sont placées les unes sur les autres pour former la base de l'abaque, donnant:

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

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

&.>signifie que ce qui suit fonctionnera successivement sur les deux boîtiers.
(,-.)c'est un crochet qui annulera l'entrée puis l'ajoutera à la fin de l'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

Cela fait vraiment partie de la représentation, mais pour le golf, il est préférable de l'avoir dans cette section. Appliqué à l'entrée précédente:

   (,-.)&.>,.(|:@(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[\' || (__)'){~ Les zéros et les uns sont maintenant utilisés pour sélectionner une chaîne pour représenter une perle ou son absence:

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

Mais maintenant, comme Howard me l'a fait remarquer, il y a un espace court de chaque côté des perles. Nous utilisons donc le sverbe prédéfini pour prendre en sandwich le contenu de chaque boîte entre deux colonnes d'espaces:

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

Cela fait, tout ce qui reste est de le convertir en une chaîne en utilisant ":afin que nous puissions le prendre en sandwich entre deux colonnes de |:

   '|'s":(' 's[:,.(_6[\'  ||   (__)'){~(,-.))&.>,.(|:@(1,.<&5);((i.5)</5|]))".,.1!:1[1
314159
|\======================================/|
||  (__)  (__)  (__)  (__)  (__)  (__)  ||
||  (__)  (__)  (__)  (__)   ||    ||   ||
||   ||    ||    ||    ||    ||    ||   ||
||   ||    ||    ||    ||   (__)  (__)  ||
|<======================================>|
||  (__)  (__)  (__)  (__)   ||   (__)  ||
||  (__)   ||   (__)   ||    ||   (__)  ||
||  (__)   ||   (__)   ||    ||   (__)  ||
||   ||    ||   (__)   ||    ||   (__)  ||
||   ||    ||    ||    ||    ||    ||   ||
||   ||    ||    ||    ||   (__)   ||   ||
||   ||   (__)   ||   (__)  (__)   ||   ||
||   ||   (__)   ||   (__)  (__)   ||   ||
||  (__)  (__)   ||   (__)  (__)   ||   ||
||  (__)  (__)  (__)  (__)  (__)  (__)  ||
|/======================================\|
— Gareth
source
J'ai senti qu'il y avait quelque chose de "mal" dans votre sortie, mais il m'a fallu un certain temps pour le reconnaître: vous omettez une colonne vide à l'extrême gauche et à droite de l'écran (troisième et avant-dernière colonne ascii).
— Howard
@Howard Woah, bon endroit. Je ne l'ai pas remarqué. Je vais essayer de le réparer.
— Gareth
@Howard Fixé au coût de 11 caractères. Dommage, j'ai pensé que je pourrais avoir une chance de descendre en dessous de 100. :-(
— Gareth
Bon travail. On dirait que @Howard a beaucoup de travail à faire pour rattraper son retard
— gnibbler
Bounty a 3 jours. J'ai marqué celui-ci comme accepté pour le moment.
— gnibbler
14

Ruby 1.9, 154 caractères

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

Suppose que l'entrée n'est pas terminée par une nouvelle ligne.

Fait amusant: en raison de la façon dont je transforme les chiffres d'entrée en nombres ( $&.hexest un octet plus court que $&.to_i), cet abaque fonctionne en fait avec des chiffres hexadécimaux jusqu'à e:

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

Car 0xf, une troisième perle apparaît comme par magie dans la moitié supérieure.

Lorsque vous autorisez des indicateurs supplémentaires lors de l'appel de script, cela peut être raccourci à 152 octets (code de 149 octets + 3 octets d'indicateurs d'invocation supplémentaires):

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

Courez avec ruby -n suanpan.rb.

— Ventero
source
12

Perl (151 caractères)

( 168 163 158 157 156 154 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\\|"

Explication

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

Édite

  • (154 → 151) Modification de trois \ns en caractères de nouvelle ligne réels. Je ne peux pas croire que je n'y ai pas pensé plus tôt!
— Timwi
source
1
C'est juste ... Génial!
— 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\|"

Histoire:

  • 2011-03-11 23:54 (340) Première tentative.
  • 2011-03-12 00:21 (323) Utilisation de l'interpolation de chaînes dans tout le code.
  • 12/03/2011 00:21 (321) Inline $l.
  • 2011-03-12 01:07 (299) A utilisé une fonction pour les parties les plus répétitives ainsi qu'une chaîne de format.
  • 2011-03-12 01:19 (284) Modifié légèrement les arguments de la fonction. Hourra pour le mode d'analyse des commandes.
  • 2011-03-12 01:22 (266) Plus de variables pour les expressions récurrentes.
  • 2011-03-12 01:28 (246) Maintenant, chaque ligne est générée par la fonction.
  • 2011-03-12 01:34 (236) Puisque j'utilise les caractères uniquement dans l'interpolation de chaînes, je peux ignorer en toute sécurité ce %qui fait des nombres à partir des chiffres.
  • 2011-03-12 01:34 (234) Légèrement optimisé la génération d'index de tableau dans la fonction.
  • 2011-03-12 01:42 (215) Je n'ai plus besoin de $ret $b. Et $aest également obsolète. Tel quel $l.
  • 2011-03-12 01:46 (207) Pas besoin de régler $OFSsi je n'en ai besoin qu'une seule fois.
  • 12/03/2011 01:49 (202) Inline $f.
  • 2011-03-12 01:57 (200) Plus besoin de la chaîne de formatage. L'interpolation de chaînes fonctionne très bien.
  • 2011-03-12 02:00 (198) Génération légèrement optimisée des lignes individuelles (réorganisation du pipeline et de l'index du tableau).
  • 2011-03-12 02:09 (192) Pas besoin -joincar nous pouvons réellement utiliser l'espace supplémentaire à bon escient.
— Joey
source
5

Haskell, 243 caractères

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

Pas particulièrement intelligent. Je suis sûr que cela peut être raccourci d'une manière ou d'une autre ...

  • Edit: (246 -> 243) a pris la suggestion de @ FUZxxl d'utiliser interact
— MtnViewMark
source
Que diriez-vous d'utiliserinteract
— FUZxxl
La première ligne peut être raccourcie z x|x=" (__) "|0<1=" || ".
— FUZxxl
Votre première ligne alternative est seulement plus courte car vous avez laissé tomber deux espaces nécessaires!
— MtnViewMark
Oops! Vous avez bien sûr raison.
— FUZxxl
4

Delphi, 348

Cette version construit une chaîne à écrire une seule fois; Les chiffres sont gérés par une fonction distincte qui fonctionne via une digit modulo m >= valueconstruction (annulée si valeur <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

Premier essai : 

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.

Cela utilise 3 tableaux; une pour les 7 chaînes qui pourraient être discernées, une pour les lignes de sortie et une pour mapper les 7 chaînes à 11 colonnes (10 chiffres et 1 colonne initiale).

— PatrickvL
source
3

GolfScript, 139 caractères

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*

Pas encore beaucoup joué au golf, mais il s'inscrit dans un tweet (avec seulement ASCII). Essayez-le ici .

— Howard
source
2

J, 225

Réussit deux tests donnés, devrait fonctionner jusqu'à au moins plusieurs centaines de chiffres.

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

Tout d'abord: oui, oui, le fossoyage. Deuxièmement: c'est juste d'une longueur embarrassante. Tant pis. Je n'ai pas encore décidé de jouer au golf plus loin ou de me recroqueviller en position fœtale et de pleurer. (Ou les deux!)

Voici un peu d'explication au lieu d'un programme plus court:

  • c est un tableau 2x6 de cellule vide, cellule de perle pour le rendu.
  • f affiche une ligne «=» avec les quatre caractères extérieurs comme argument de gauche.
  • d restitue une ligne d'abaque en traduisant les matrices 0/1 en cellules de perles remplies de ||
  • g prend les chiffres et compile verticalement les lignes de caractères en utilisant f pour les lignes de «formatage» et d pour les lignes de boulier.
  • La dernière ligne obtient une entrée, se divise en caractères et les convertit en nombres, alimente en g puis imprime.
— Jesse Millikan
source
2

C, 277 274 caractères

Vous savez, il me semble que nous n'avons tout simplement pas assez de solutions ici qui tirent vraiment parti du préprocesseur C. C'est en partie parce que ceux-ci #defineoccupent en fait un peu d'espace. Mais encore, il y a tellement de potentiel. Je ressens le besoin de combler cette lacune.

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

C'est mieux.

— boite à pain
source
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]]

Exemple

w[6302715408]

abaque

— DavidC
source
Félicitations pour 10k! :-D
— Poignée de porte
@Poignée de porte. Merci! Félicitations à vous aussi!
— 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")}

Première version, juste un peu de golf jusqu'à présent.

— schnaader
source
1

Scala (489 caractères)

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

Vraiment une tentative merdique vraiment.

— Gareth
source
1

Sclipting , 77 caractères

La prime fait référence aux tweets et Twitter compte les caractères (pas les octets). :)

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

J'ai écrit il y a quelques années (lorsque ce défi a été publié), mais je ne l'ai jamais publié parce que j'ai inventé Sclipting après la première publication de ce défi. Si vous pensez que cela le rend inéligible, je comprends.

Explication

꿓뤽꿓뤽①長復 | 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
source
Merci pour votre réponse intéressante. Je conviens qu'il est préférable de s'en tenir à la règle selon laquelle seules les langues publiées avant la question posée devraient être éligibles. Je ne crois pas que vous auriez délibérément conçu votre langue pour gagner ce défi, mais en même temps, je ne pense pas que ce soit juste pour les autres répondeurs, et nous ne voulons pas ouvrir les vannes pour les langues nouvellement inventées sur les anciens. questions puisque nous savons ce qui va se passer ...
— gnibbler
@gnibbler: Bien sûr, ça me va. Je pense que cette règle est importante.
— Timwi
1

Python, 309 301 288 caractères

Version compacte:

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]

Version claire:

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

Notez que pour la compactification, les variables ont été renommées en une seule lettre et les compréhensions de liste ont été remplacées par des générateurs qui ne nécessitent pas de crochets supplémentaires.

— Nayuki
source
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.