Trouver les x,y,z tel que x*y*z = N

[Floklo]

Bien vu, pourtant quand je relie le code, je ne vois pas pourquoi ça ne prend pas cette solution en compte.
-----

[Floklo]

si trouvé en fait, la fonction range(1,N) exclut N dans la liste.
Il faut mette range(1,N+1)

[ansset]

ça marche, je ne comprenais pas trop non plus en première lecture.
cordialement.

[minushabens]

une autre approche consiste à faire des boucles descendantes:

pour i variant de N à 1
si i divise N
{
pour j variant de i à 1
si j divise N/i renvoyer le triple (i,j,n/(ij)) sinon rien
} sinon rien
}

[ansset]

insuffisant écrit comme ça

pour i variant de N à 1

car tu as déjà 1 et N comme solution.
donc il risque fort de t'en manquer à la fin.

[minushabens]

je ne comprends pas ce que tu veux dire. N est trouvé au premier pas et il est nécessairement associé à 1 et 1.

[minushabens]

ah oui je comprends le problème. J'ai écrit trop vite.

La première boucle va de N à 1 (en fait elle peut s'arrêter à floor(sqrt(N)) )

La deuxième boucle va de N/i à 1 (et pas de i à 1 comme j'ai écrit)
en fait il suffit de descendre de N/i à floor(sqrt(N/i))

mais de toutes manières, qu'on monte ou qu'on descende deux boucles sont suffisantes.

[ansset]

mais de toutes manières, qu'on monte ou qu'on descende deux boucles sont suffisantes.

ça, c'est juste,
le reste, c'était uniquement pour te titiller un peu...
m'en veux pas ?

[Floklo]

une autre approche consiste à faire des boucles descendantes:

pour i variant de N à 1
si i divise N
{
pour j variant de i à 1
si j divise N/i renvoyer le triple (i,j,n/(ij)) sinon rien
} sinon rien
}

Salut minushabens,

Je crois ne pas très bien avoir compris ta méthode.
J'ai fait ça, peux tu me dire où ça cloche ?

N = 36
liste_triplet = []
liste_sol =[]

for i in xrange(N,0,-1):
    
    if N%i == 0:
        
        for j in xrange(N/i,0,-1):
            
            if (N/i)%j == 0:
                
                liste_triplet.append(i)
                liste_triplet.append(j)
                liste_triplet.append(N/(i*j))
                liste_sol.append(liste_triplet)
                
print liste_sol

[minushabens]

effectivement j'ai négligé un problème. Dans la deuxième boucle il faut soit s'arrêter à la racine carrée de N/i (ce qui est le plus propre) soit vérifier que le troisième nombre (N/(ij) ) est inférieur ou égal à j.

[minushabens]

je l'ai programmé sous R, même si tu ne connais pas tu devrais comprendre.

#-----------------------------------
# d3f : décomposition en 3 facteurs
#-----------------------------------
function(n)
{
result<-NULL
n2<-ceiling(sqrt(n))
for(i in n:n2) 
   if (n%%i==0)
   {
     ni<-n/i
     ni2<-ceiling(sqrt(ni))
   for(j in ni:ni2) 
   if (ni%%j==0)
   result<-rbind(result,c(i,j,n/(i*j)))
   }

return(result)
}

> d3f(36)
     [,1] [,2] [,3]
[1,]   36    1    1
[2,]   18    2    1
[3,]   12    3    1
[4,]    9    4    1
[5,]    9    2    2
[6,]    6    6    1
[7,]    6    3    2

[Duongnh]

you can try this code :
x = int
y= int
z=int

liste_triplets = []

N = 36


for i in range(1,N):

x = i

for j in range(1,N):

y = j

for k in range(1,N):

z =k

if x*y*z == N:

if z >= y and y >= x: #modification

liste_nbr = [x,y,z]
liste_triplets.append(liste_nb r)


print liste_triplets

[Floklo]

Salut Duongnh,

je remarque que tu as juste copier/coller le code que j'ai posté message #6...

[danyvio]

Je ne connais pas Python mais j'ai quelques années de programmation au compteur...
Perso, j'aurais raisonné ainsi (pardon pour le manque de tabulations)

pour i de 1 à N

..........pour j de i+1 à N

.................pour k de j+1 à N

.................. Si i*j*k = N alors (enregistrer résultat)
.................. FinSi
.................FinPour
...........FinPour
FinPour

FIN

[danyvio]

Je ne connais pas Python mais j'ai quelques années de programmation au compteur...
Perso, j'aurais raisonné ainsi (pardon pour le manque de tabulations)

pour i de 1 à N

..........pour j de i+1 à N

.................pour k de j+1 à N

.................. Si i*j*k = N alors (enregistrer résultat)
.................. FinSi
.................FinPour
...........FinPour
FinPour

FIN

pour affiner et éviter des calculs inutiles "aux limites" , on peut améliorer ainsi :
pour i de 1 à N-2

..........pour j de i+1 à N-1

.................pour k de j+1 à N

.................. Si i*j*k = N alors (enregistrer résultat)
.................. FinSi
.................FinPour
...........FinPour
FinPour

FIN

[Chanur]

Bonjour,

(pardon pour le manque de tabulations)

Pour conserver les indentations, il suffit de mettre le code entre des balises [code] (icone # dans l'éditeur avancé).

[Tryss2]

Une façon plus optimisée de répondre à la question :

import math
FactorsCount = 3

def factor( data ):
  if (len(data) == FactorsCount ) :
    print(data)
    return
  
  if len(data) == 1 :
    N = data[-1]
    minV = 1
    maxV = int(math.sqrt(N))
  else :
    N = data[-1]
    minV = data[-2]
    maxV = int(math.sqrt(N))
    
  for i in range(minV,maxV+1) :
    if N%i == 0 :
      nextData = data[:-1]+[i,int(N/i)]
      factor(nextData)
      
      
  
  
factor( [67453554] )

A noter que l'on peut facilement modifier le nombre de facteurs

[ourdia]

Bonsoir.
Il faut faire une condition juste avant l'affichage du resultat pour éliminer les redondants, la condition à faire est: si le Resultat est différant de N il le prend en considération sino il va l'ignorer ou bien il peut l'afficher comme doublant.
Mais il faut initialisé le N au départ, par exemple: N =1
J'espère que ma repense comporte de nouveau pour vous.
Cordialement