Écrivez un programme qui visualise une longue division avec l'art ASCII. L'entrée se compose de deux entiers, un numérateur et un dénominateur, en utilisant le format d'entrée de votre choix.

Exemples:

1234 ÷ 56:

     22
   ----
56|1234
   112
   ---
    114
    112
    ---
      2

1002012 ÷ 12:

     83501
   -------
12|1002012
    96
   ---
     42
     36
     --
      60
      60
      --
        12
        12
        --

0 ÷ 35

   0
   -
35|0

Règles:

• L'utilisation de l'opérateur de division du langage de programmation est autorisée.
• L'utilisation de la prise en charge des grands nombres entiers est également autorisée.
• Pour la cohérence:
  • Si le quotient est zéro, imprimez un seul zéro à la fin du plongeoir.
  • Si le reste est nul, ne l'imprimez pas.
  • N'imprimez pas de zéros non significatifs sur aucun nombre.
• Les sauts de ligne à la fin et les espaces de fin à droite sont autorisés.
• La solution avec le moins de personnages gagne.

Limites:

• 0 <= numérateur <= 10 ⁷² - 1
• 1 <= dénominateur <= 9999999

Cela implique que la sortie ne dépassera jamais 80 colonnes.

Suite de tests et exemple d'implémentation:

Vous pouvez utiliser long-division.c ( gist ) pour tester votre programme. Il s'agit en fait d'un script bash avec un programme C à l'intérieur. Ajustez-le pour appeler votre programme dans la suite de tests. Regardez le code C en bas pour voir l'implémentation de référence. Veuillez me faire savoir s'il y a des problèmes avec l'exemple de programme ou la suite de tests.

$ ./long-division.c 10 7
   1
  --
7|10
   7
  --
   3
$ ./long-division.c
PASS 1234 ÷ 56
PASS 1002012 ÷ 12
PASS 1 ÷ 1
--- snip ---

Score: 35 / 35
All tests passed!

Edit: Sur demande, je mets l' entrée de la suite de tests et la sortie attendue dans des fichiers texte ( gist ). Exemple d'utilisation (bash):

cat input | while read nd; do
    ./program $nd |
        sed 's/\s*$//' | sed -e :a -e '/^\n*$/{$d;N;};/\n$/ba'
done > output

diff -u expected output

Les commandes sed étranges filtrent les nouvelles lignes et les espaces en fin de sortie du programme.

Python 3, 284 257 caractères

div.py

n,t=input().split()
d=int(t)
l=lambda x:len(str(x))
s=l(n)
def p(x):print(' '*(l(d)+s-l(x)+1)+str(x))
p(int(n)//d)
p('-'*s)
p(t+'|'+n)
s=z=f=0
while t:
 try:
  while z<d:z=z*10+int(n[s]);s+=1
 except:t=0
 if z*f:p(z)
 if t:f=1;t=z//d*d;p(t);p('-'*l(z));z-=t

Utilisation: python3 div.py
entrée: à partir du clavier

test.py

import sys
sys.stdin=open('input'); sys.stdout=open('output','w')
for line in open('input'): exec(open('div.py').read())

correspond à la sortie attendue

Versions:
 1. 284
 2. 257 : s,z,f=0,0,0→ s=z=f=0; z and f→ z*f; meilleure boucle; supprimé quelques nouvelles lignes.

Haskell, 320 caractères

l=length
(®)=replicate
p!v=p&show v
p&s=(p-l s)®' '++s
0§_=[];_§l=l
d[m,n]=l c!(read m`div`e):l c&(l m®'-'):c:drop 1(g 0(map(toInteger.fromEnum)m)$1+l n)where
 e=read n;c=n++'|':m
 g r(d:z)p=i§[o!k,o!(i*e),o&(l(show k)®'-')]++g j z o where k=r*10+d-48;(i,j)=k`divMod`e;o=1+p
 g r[]p=r§[p!r]
main=interact$unlines.d.words

Réussit tous les tests. Bien que ce soit assez golfé - je pense qu'il reste encore beaucoup à faire ici ...

• Edit: (344 -> 339) retarde les readappels, ce qui réduit le besoin d'appeler show, suffisamment d'abréviation showcar cela sne vaut pas la peine.
• Modifier: (339 -> 320) réécrit les fonctions de formatage des champs de chaîne

JavaScript (400 394 418 )

function d(n,d){t=parseInt;p=function(v){return(s+v).substring(v.length)};a=function(v,c){return v.replace(/\d/g,c)};w='\n';q=b=o=c=e='';s=a(d,' ')+' ';f=true;i=-1;z='0';while(++i<n.length){s+=' ';if(t(c+=n[i])>=t(d)){q+=r=Math.floor(t(c)/t(d));o+=(!f?p(c)+w:e)+p(''+r*t(d))+w+p(a(c,'-'))+w;c=t(c)%t(d);f=false}else if(!f){q+=z;}c=(c==0)?e:e+c}return p(!q?z:q)+w+p(a(n,'-'))+w+d+'|'+n+w+o+(q?p(c):e)}

REMARQUE: Aussi tentant que cela puisse paraître de raser quelques caractères en les remplaçant c=(c==0)?par c=!c?, il n'est pas utilisable car il provoque des bogues liés aux virgules flottantes.

http://jsfiddle.net/nLzYW/9/

Exemple d'exécution:

document.writeln("<pre>");
document.writeln(d("1234","56"));
document.writeln();
document.writeln(d("1002012","12"));
document.writeln();
document.writeln(d("0","35"));
document.writeln();
document.writeln(d("123000123000123","123"));
document.writeln("</pre>");

Edit 1 : corrections de bugs mineurs, nombreuses optimisations de code.

Edit 2 : Correction d'un bug avec 1/7 générant une sortie supplémentaire.

Javascript: (372)

function g(a){for(var c="",e=0;e<a;e++)c=" "+c;return c}function i(a,c){for(var e=a+"/"+c+"\\",j=(""+c).split(""),k="",d=0,b=0;b<j.length;b++){d*=10;d+=parseInt(j[b],10);var f=d>9?b-1:b,h=0;h=Math.floor(d/a);d%=a;f=g(f+a.toString().split("").length);f+=h*a+"\n"+g(b+a.toString().split("").length)+"--\n"+g(b+a.toString().split("").length)+d+"\n";k+=f;e+=h}return e+"\n"+k}

Appelez en utilisant i (diviseur, nombre). CodeGolfed JS: http://jsfiddle.net/puckipedia/EP464/ Ungolfed (néerlandais) JS: http://jsfiddle.net/puckipedia/M82VM/

Renvoie la division longue (au format néerlandais tel que je l'ai appris):

5/25\05
 0
 --
 2
 25
  --
  0

Cas de test:

document.write("<pre>"+i(5,25)+"</pre>");
document.write("<pre>"+i(7,65669726752476)+"</pre>");