Visualizza la divisione lunga con l'arte ASCII


16

Scrivi un programma che visualizza una lunga divisione con l'arte ASCII. L'input è composto da due numeri interi, un numeratore e un denominatore, utilizzando il formato di input desiderato.

Esempi:

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

Regole:

  • È consentito l'uso dell'operatore di divisione del linguaggio di programmazione .
  • È consentito anche il supporto di numeri interi grandi.
  • Per coerenza:
    • Se il quoziente è zero, stampare un singolo zero alla fine del trampolino.
    • Se il resto è zero, non stamparlo.
    • Non stampare zeri iniziali su nessun numero.
  • Sono consentite nuove righe in eccesso alla fine e spazi finali a destra.
  • Vince la soluzione con il minor numero di personaggi.

limiti:

  • 0 <= numeratore <= 10 72 - 1
  • 1 <= denominatore <= 9999999

Ciò implica che l'output non sarà mai più largo di 80 colonne.

Suite di test e implementazione del campione:

Puoi usare long-division.c ( gist ) per testare il tuo programma. In realtà è uno script bash con all'interno un programma C. Modificalo per invocare il tuo programma nella suite di test. Guarda il codice C in basso per vedere l'implementazione di riferimento. Per favore fatemi sapere se ci sono problemi con il programma di esempio o la suite di test.

$ ./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!

Modifica: su richiesta, inserisco l' input della suite di test e l' output previsto in file di testo (in sintesi ). Esempio di utilizzo (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

Gli strani comandi sed filtrano le nuove righe e gli spazi finali dall'output del programma.


Ho scoperto un piccolo difetto nell'implementazione di riferimento, vale a dire nel caso di 123000123000123 ÷ 123. Le linee di sottrazione si estendevano su uno spazio vuoto, ma avrebbero dovuto coprire solo la lunghezza delle cifre visibili del minuend. Ora è riparato.
Joey Adams,

2
Penso che l'output sia un po 'distorto nei confronti del pubblico golfista di lingua inglese: en.wikipedia.org/wiki/…
hallvabo

Puoi semplicemente creare un file che mostra l'output previsto di tutti i test e collegarlo ad esso?
mellamokb,

@mellamokb: Aggiunto, grazie!
Joey Adams,

Che dire di accettare? La domanda è abbastanza vecchia ...
Oleh Prypin,

Risposte:


3

Python 3, 284 257 caratteri

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

Utilizzo: python3 div.py
Input: da tastiera

test.py

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

partite in uscita previste

Versioni:
 1. 284
 2. 257 : s,z,f=0,0,0s=z=f=0; z and fz*f; migliore looping; rimosso alcune nuove righe.


2
potresti provare ideone per python3 e input - ideone.com/clone/ZZyzu
YOU

3

Haskell, 320 caratteri

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

Supera tutti i test. Mentre questo è un bel golf - penso che ci sia ancora molto da fare qui ...


  • Modifica: (344 -> 339) ritardare le readchiamate, il che riduce la necessità di chiamare show, abbastanza che abbreviando showcomes non ne vale la pena.
  • Modifica: (339 -> 320) riscrive le funzioni di formattazione del campo stringa

! Neat Ho fatto una soluzione Haskell con 344 caratteri, ma non l'ho pubblicata. Inoltre, non sapevo che potresti usare i simboli Unicode per gli operatori (senza -XUnicodeSyntax).
Joey Adams,

3

JavaScript ( 400394 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)}

NOTA: allettante quanto sembra radere qualche carattere sostituendolo c=(c==0)?conc=!c? , non è utilizzabile perché causa bug in virgola mobile.

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

Esempio di esecuzione:

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>");

Modifica 1 : correzioni di bug minori, numerose ottimizzazioni del codice.

Modifica 2 : correzione del bug con 1/7 che generava output extra.


Lo script di test ha rivelato un problema. d(1,7)(e test simili) ripetono il denominatore anziché stampare nulla. Questo è sbagliato perché questo numero dovrebbe essere la cifra del quoziente per il denominatore, che è zero.
Joey Adams,

Tutti i test ora passano.
Joey Adams

1

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}

Richiamare usando i (divisore, numero). Codegolfed JS: http://jsfiddle.net/puckipedia/EP464/ Ungolfed (olandese) JS: http://jsfiddle.net/puckipedia/M82VM/

Restituisce la divisione lunga (in formato olandese come l'ho imparato):

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

TestCase:

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

Ehi, questo non è lo stesso richiesto!
Oleh Prypin,

@BlaXpirit Lo so, l'ho imparato in quel modo.
puckipedia,

Interessante. Sebbene come dice @BlaXpirit, non segue le specifiche. La specifica vuole essere un equo standard di confronto per determinare l'efficienza del codice codificato, quindi non puoi arbitrariamente cambiare la specifica anche se non sei d'accordo con il formato di output :)
mellamokb
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.