Citation : nicodec57

Bonjour,

J'ai un peu de difficulté à comprendre cet exercice.

Est-ce que quelqu'un pourrait me l'expliquer...

Imagine que tu as un tableau 1D d'entiers, au hasard ce tableau de 10 entiers :



J'appelle T ce tableau. On te dit : à partir de ce tableau, je construis un nouveau tableau TT de la façon suivante :

*) les extrémités de TT sont les mêmes que celles de T
*) Je remplis l'intérieur de TT en plaçant, dans l'ordre, la somme de DEUX éléments consécutifs de T, autrement dit en plaçant
10+15,
15+5
5+33
etc jusqu'à
33+20

donc au total TT est




Dans le problème posé
*) on part du tableau T : 1 1,
*) on applique la règle que je viens de donner et on obtient un nouveau tableau TT
*) on recommence avec le nouveau tableau TT
*) et ainsi de suite autant de fois qu'on veut.

On demande d'écrire le tableau qu'on obtient si on fait par exemple 20 fois ce qui précède.

Je pense avoir compris le problème posé, mais niveau code

Citation : candide

from math import factorial as f

def p(n): return f(n)//(f(n//2)*f(n-n//2))

print (p(1000))

EDIT : Je comprend de mieux en mieux, je fais une pause et je vois ça demain !

Citation : nicodec57

Je pense avoir compris le problème posé, mais niveau code

Citation : candide

from math import factorial as f

def p(n): return f(n)//(f(n//2)*f(n-n//2))

print (p(1000))

EDIT : Je comprend de mieux en mieux, je fais une pause et je vois ça demain !

Le code que tu montres n'est pas la "correction" de ce qui est attendu.
C'est une manière de résoudre ce problème de manière mathématique, qui demande bien plus que l'énoncé ne le présuppose, et n'implémente pas l'algo que Candide vient de t'expliquer.

Quel est alors la correction "type" ?

Malgré c'est réponse je pense quand même qu'avant de faire des exercices, il faut chercher une meilleur solution au lieu de foncer en codant un algo naif.
Par exemple, je me rappel d'un exercice sur Prologin ou la méthode naive était très longue alors qu'après avoir réfléchie, on se rendait compte qu'il suffisait d'implémenter une fonction affine .

Citation : EPonix

Par exemple, je me rappel d'un exercice sur Prologin ou la méthode naive était très longue alors qu'après avoir réfléchie, on se rendait compte qu'il suffisait d'implémenter une fonction affine .

L'exo sur les prisonniers, c'est ça ?

Bonjour,

J'apporte ma solution (qui, je pense, est plus débutant-friendly que les vôtres). Je construit et affiche le tableau de Pascal et ensuite, je donne la plus grande valeur.

# Construit un tableau de Pascal et affiche sa plus grande valeur

tab_pascal = [(1,)]    # la virgule pour montrer que c'est un tuple
tab_index = 0

niveau = int(input("Combien de niveau du tableau de Pascal ? : "))

while len(tab_pascal) < niveau:
    tup_temp = (1,)

    if tab_index >= 1:
        # on ne prend pas le dernier 1
        for i in range(len(tab_pascal[tab_index][:-1])):
            # on ajoute la somme de i+(i+1) au tuple temporaire
            tup_temp += (tab_pascal[tab_index][i]+tab_pascal[tab_index][i+1],)

    # on ajoute le dernier 1 à tup_temp
    tup_temp += (1,)
    # on ajoute le tuple temporaire à tab_pascal
    tab_pascal.append(tup_temp)

    tab_index += 1

for elements in tab_pascal:
    for ch in elements:
        print(ch, end=' ')
    print('')

print(("La plus grande valeur du niveau {} est {}.")\
          .format(niveau, max(tab_pascal[-1])))

Les commentaires sont les bienvenus (je VEUX progresser)

Bonjour, je venais demander des explications mais je viens de comprendre. C'est pointu quand même je n'aurais jamais trouvé tout seul.

n = 9
p = [1, 1]

for lig in range(2, n+1):
    q = [1]*(lig+1)
    
    for col in range(1, lig):
        q[col] = p[col] + p[col - 1]
    p = q

print(max(q))

Voilà ma solution pour l'exercice.

t'as oublié le print ligne 12

C'est fait.

from math import factorial as ft
def pascal(n):
     return int(ft(n))/(ft(n//2)*ft(n-n//2))

je préfère cela

Ma version:

def max_pascal(roof=10):
    """roof: la ligne désirée pour connaître le max"""

    #initialisation de la liste
    triangle = [1]

    #Juste une ligne en mémoire:
    #1. Ajout de l'élément 1 à l'indice 0
    #2. Boucle: i = i + (i+1)
    #3. Premier et dernier élément de la liste non inclus dans la boucle
    #4. Exemple: 1331 -> 11331 -> [0]=1, [1]=1+3, [2]=3+3, [3]=3+1, [4]=1

    for floor in range(1, roof+1):
        triangle.insert(0,1)  #1.
        for step in range(1, floor):  #3.
            triangle[step] += triangle[step+1]  #2.

    return max(triangle)


print(max_pascal())

-
Edité par Olygrim 14 mai 2014 à 16:06:18

Oups désolé message à supprimer

-
Edité par Zl4T 14 mai 2014 à 15:42:47

def convert(l):
    T=[]
    for i in range(len(l)):
        arg=str(l[i])
        T.append(arg)
    return " ".join(T)    
t=[1,1]
print(convert(t))
k=[1]
s=0
while(s!=10):
    l=[]
    for i in range(len(t)):
        if(i!=len(t)-1):
            arg=t[i]+(t[i+1])
            l.append(arg)
            arg=0
        else:
            break;
    t=k+l+k
    print(convert(t))
    
    s+=1            

1 1
1 2 1
1 3 3 1
1 4 6 4 1
1 5 10 10 5 1
1 6 15 20 15 6 1
1 7 21 35 35 21 7 1
1 8 28 56 70 56 28 8 1
1 9 36 84 126 126 84 36 9 1
1 10 45 120 210 252 210 120 45 10 1
1 11 55 165 330 462 462 330 165 55 11 1