Le challenge Python de l’été: écrire une multiplication posée

python afficher multiplication posée

Le challenge Python de l’été: écrire une multiplication posée

Pour cet été, je vous propose un mini-challenge qui consiste à écrire un programme Python permettant d’afficher une multiplication posée.

Voici un exemple…

from math import log

def produit(a,b):
    m = max(a,b)
    longueur = int( log(m)/log(10) ) + 1
    
    result = [ a , b ]
    line = 0
    
    for i in range( int( log(b)/log(10) ) + 1 ):
        result.append( (b%10) * a * (10**line) )
        line +=1
        b = b // 10
    
    somme = 0
    for i in range(2,len(result)):
        somme += result[i]
    result.append(somme)
    
    longueur_affichage = int( log( result[-1] )/log(10) ) + 3
    formattage = '{:>'+str(longueur_affichage)+'}'
    formattage2 = '{:>'+str(longueur_affichage-2)+'}'
    
    r = ''
    
    for i in range( len(result) ):
        if (i == 2) or (i == len(result)-1):
            r += '-'*longueur_affichage + '\n'
            
        if i == 1:
            r += '× ' + formattage2.format( result[i] )
        else:
            r += formattage.format( result[i] )
        r += '\n'
        
    return r
>>> produit(9877,971)
     9877
×     971
---------
     9877
   691390
  8889300
---------
  9590567

Si vous souhaitez soumettre votre code, insérez-le dans votre commentaire sous la forme:

<pre class="EnlighterJSRAW" data-enlighter-language="python" data-enlighter-theme="dracula" data-enlighter-highlight="" data-enlighter-linenumbers="" data-enlighter-lineoffset="" data-enlighter-title="" data-enlighter-group="">
Votre code Python
</pre>

ceci afin qu’il s’affiche correctement. Il apparaîtra après validation manuelle de ma part.

Stéphane Pasquet
Stéphane Pasquet

1 réflexion au sujet de « Le challenge Python de l’été: écrire une multiplication posée »

Nicolas PatroisPublié le  12:15 - Juil 24, 2021

Le script est très moche mais il fait le boulot. C’est la multiplication posée mais par jalousies.

def chiffres(n):
    return [int(i) for i in str(n)]

def jalousies(n,m):
    p=n*m
    n=chiffres(n)
    m=chiffres(m)
    
    tableau="   | "+" | ".join(map(str,n))+" |   \n"
    
    for cm in m:
        tableau+="---"+"+---"*(len(n)+1)+"\n"
        ligne=" %s |"
        for cn in n:
            ch=chiffres(cn*cm)
            if len(ch)==1:
                ch=[0]+ch
            c="%d/%d|"%(ch[0],ch[1])
            c=c.replace("0"," ")
            ligne+=c
        ligne+=" %d \n"%cm
        tableau+=ligne
    tableau+="---"+"+---"*(len(n)+1)+"\n"
    p=list(map(str,chiffres(p)))
    p=["0"]*(len(m)+len(n)-len(p))+p
    tableau+=" "*3+"| %s "*len(n)+"|   "
    tableau=tableau%tuple(p)
    
    affichage="".join(map(str,n))+" × "+"".join(map(str,m))+"\n"
    affichage+=tableau+"\n"
    affichage+="".join(p).replace(" ","")
    
    return affichage
    Stéphane Pasquet

    Stéphane PasquetPublié le  12:27 - Juil 24, 2021

    Ce n’est pas vraiment ce qui est demandé, mais bon… 🙂 Il aurait été dommage de ne pas l’afficher. Pour la curiosité, voici ce qu’il affiche :

    >>> print( jalousies(123,45) )
    123 × 45
       | 1 | 2 | 3 |   
    ---+---+---+---+---
     0 | /4| /8|1/2| 4 
    ---+---+---+---+---
     5 | /5|1/ |1/5| 5 
    ---+---+---+---+---
       | 5 | 3 | 5 |   
    05535

    La multiplication “par jalousies” est aussi connue sous le nom de multiplication per gelosia.

Nicolas PatroisPublié le  1:27 - Juil 24, 2021

Oui, ici, je ne sais pas comment afficher le résultat ainsi.
Si on regarde bien, c’est la même que nous mais sans les retenues.

Nicolas PatroisPublié le  6:33 - Juil 24, 2021

Sinon, voici mon script qui répond à la question, cette fois.

def multiposée(n,m):
  affichage=[" "+str(n)," "+str(m),"-"]
  for i,c in enumerate(str(m)[::-1]):
    affichage.append(" "+str(int(c)*n)+" "*i)
  affichage+=["-","  "+str(m*n)]
  l=len(affichage[-1])
  for i,e in enumerate(affichage):
    affichage[i]=e.rjust(l,e[0])
  affichage[1]="×"+affichage[1][1:]
  return "\n".join(affichage)
Stéphane Pasquet

Stéphane PasquetPublié le  11:27 - Juil 28, 2021

Là, je suis assez jaloux de ce script 🙂 Bien plus concis que le mien… En revanche, je suis moins fan des noms comportant des lettres accentuées pour les fonctions 🙂

Nicolas PatroisPublié le  12:54 - Juil 29, 2021

On peut obtenir la longueur d’un entier en le convertissant en une chaîne de caractères et de même, on peut obtenir ses chiffres.
Sinon, la ruse est dans le fait d’avoir utilisé la méthode rjust (qui pousse à droite, ljust pousse à gauche) avec un caractère de remplissage posé dès la création de chaque ligne au début de chacune d’elles.
Python accepte les noms accentués (utf8), je ne me prive pas de les utiliser.

Laissez votre message