Utilisation de min() en indice d'itérable

Bonjour,

Pour un choix de 4 lettres par exemple, on affiche une suite de lettres agencées comme suit :

Code:

---

1 2 3 4 5 6 7

aaaaaaa abbbbba abcccba abcdcba abcccba abbbbba aaaaaaa

---

Avec ce programme :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13

alphabet =['a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z']   choice =int(input())   size =choice *2 -1 line =0 for _ in range(size): column =0 for _ in range(size): print(alphabet[min(min(line, size -1 -line), min(column, size -1 -column))], end ='') column +=1 line +=1 print()

---

Je trouve cette approche géniale mais je n'arrive pas à bien saisir l'utilisation de la fonction min(), le mécanisme m'échappe complètement dans ce programme.

Bonjour

Citation:

---

Envoyé par MissLoop

mais je n'arrive pas à bien saisir l'utilisation de la fonction min(), le mécanisme m'échappe complètement dans ce programme.

---

Moi aussi je pige pas (toutefois je me force pas non plus des masses). Je présume que cela met en oeuvre un raccourci mathématique entre le fait que

• pour une taille "n" demandée, il y aura alors 2n-1 lettres
• la première ligne aura 2n-1 "a"
• la seconde aura 2 "a" et 2n-1-2 "b"
• la troisième aura 2"a", 2 "b" et 2n-1-4 "c" => donc si on numérote les lignes à partir de 0, chaque ligne "l" aura "2n-1-2 * l" lettre de rang "l" dans l'alphabet (et toujours 2 lettres des rangs précédents)

et etc jusqu'au milieu du tableau puis on inverse le truc.

Accessoirement ton alphabet =['a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z'] aurait pu s'écrire plus simplement alphabet="abcdefghijklmnopqrstuvwxyz" ou encore mieux alphabet=string.ascii_lowercase (et dans ce cas, "alphabet" ne sert plus vraiment à grand chose)...

Je ne pige pas ton explication.
Si on considère n =4 alors l'algo va afficher :

Code:

---

1 2 3 4 5 6 7

a(n2 -1) a, b(n2 -1), a a, b, c(n2 -1), b, a a, b, c, d(n2 -1), c, b, a a, b, c(n2 -1), b, a a, b(n2 -1), a a(n2 -1)

---

Pour :

Code:

---

alphabet[min(min(line, size -1 -line), min(column, size -1 -column))]

---

on a pour les 2 premières lignes :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31

line =0 column =0 alphabet[min(min(0, 6), min(0, 6))], end ='') column =1 alphabet[min(min(0, 6), min(0, 5))], end ='') column =2 alphabet[min(min(0, 6), min(0, 4))], end ='') column =3 alphabet[min(min(0, 6), min(0, 3))], end ='') column =4 alphabet[min(min(0, 6), min(0, 2))], end ='') column =5 alphabet[min(min(0, 6), min(0, 1))], end ='') column =6 alphabet[min(min(0, 6), min(0, 0))], end ='')   line =1 column =0 alphabet[min(min(1, 5), min(0, 6))], end ='') column =1 alphabet[min(min(1, 5), min(0, 5))], end ='') column =2 alphabet[min(min(1, 5), min(0, 4))], end ='') column =3 alphabet[min(min(1, 5), min(0, 3))], end ='') column =4 alphabet[min(min(1, 5), min(0, 2))], end ='') column =5 alphabet[min(min(1, 5), min(0, 1))], end ='') column =6 alphabet[min(min(1, 5), min(0, 0))], end ='')

---

Je n'arrive pas à m'expliquer la logique de cet algo et puis surtout comment comprendre le min() de min() à 2 arguments + 2 × 2 pour afficher 1 index d'un itérable en décrémentation et en inversion dans l'ensemble du programme.
Franchement les kanjis me paraîtraient être moins du chinois que cet algo??

Citation:

---

Envoyé par MissLoop

Je ne pige pas ton explication.

---

Ben j'ai pas vraiment expliqué. J'ai juste donné une relation linéaire entre le numéro de la ligne et le nombre de lettres du rang de la ligne (ligne 1 nombre de "a", ligne 2 nombre de "b", etc). Mais en regardant mieux le code en fait cette relation bien que vérifiable n'a pas été utilisée.

Citation:

---

Envoyé par MissLoop

Si on considère n =4 alors l'algo va afficher :

Code:

---

1 2 3 4 5 6 7

a(n2 -1) a, b(n2 -1), a a, b, c(n2 -1), b, a a, b, c, d(n2 -1), c, b, a a, b, c(n2 -1), b, a a, b(n2 -1), a a(n2 -1)

---

---

Ce n'est pas ce que j'ai écrit. Pour la seconde ligne on n'a pas b(2n-1) mais b(2n-1-2) soit b(2n-3). Et dans les faits c'est bien ce qui se passe pour n=4 qui donne
aaaaaaa => 7a soit 2*4-1
abbbbba => a puis 5 (soit 2*4-3)b puis a
abcccba => a+b puis 3 (soit 2*4-5)c puis b+a
abcdcba => a+b+c+d puis 1 (soit 2*4-7)d puis c+b+a
abcccba
abbbbba
aaaaaaa => la même chose dans l'autre sens
Et attention, écrire n2 peut prêter à confusion avec n². Mieux vaut écrire 2n.

Citation:

---

Envoyé par MissLoop

Je n'arrive pas à m'expliquer la logique de cet algo et puis surtout comment comprendre le min() de min() à 2 arguments + 2 × 2 pour afficher 1 index d'un itérable en décrémentation et en inversion dans l'ensemble du programme.
Franchement les kanjis me paraîtraient être moins du chinois que cet algo??

---

T'as un outil extaordinaire: le print => print("line=%d, col=%d, min(%d, %d), min(%d, %d): %d" % (line, column, line, size-1-line, column, size-1-column, min(min(line, size -1 -line), min(column, size -1 -column)))).
Ce qui donne au résultat
line=0, col=0, min(0, 6), min(0, 6): 0
line=0, col=1, min(0, 6), min(1, 5): 0
line=0, col=2, min(0, 6), min(2, 4): 0
line=0, col=3, min(0, 6), min(3, 3): 0
line=0, col=4, min(0, 6), min(4, 2): 0
line=0, col=5, min(0, 6), min(5, 1): 0
line=0, col=6, min(0, 6), min(6, 0): 0

line=1, col=0, min(1, 5), min(0, 6): 0
line=1, col=1, min(1, 5), min(1, 5): 1
line=1, col=2, min(1, 5), min(2, 4): 1
line=1, col=3, min(1, 5), min(3, 3): 1
line=1, col=4, min(1, 5), min(4, 2): 1
line=1, col=5, min(1, 5), min(5, 1): 1
line=1, col=6, min(1, 5), min(6, 0): 0

line=2, col=0, min(2, 4), min(0, 6): 0
line=2, col=1, min(2, 4), min(1, 5): 1
line=2, col=2, min(2, 4), min(2, 4): 2
line=2, col=3, min(2, 4), min(3, 3): 2
line=2, col=4, min(2, 4), min(4, 2): 2
line=2, col=5, min(2, 4), min(5, 1): 1
line=2, col=6, min(2, 4), min(6, 0): 0

line=3, col=0, min(3, 3), min(0, 6): 0
line=3, col=1, min(3, 3), min(1, 5): 1
line=3, col=2, min(3, 3), min(2, 4): 2
line=3, col=3, min(3, 3), min(3, 3): 3
line=3, col=4, min(3, 3), min(4, 2): 2
line=3, col=5, min(3, 3), min(5, 1): 1
line=3, col=6, min(3, 3), min(6, 0): 0

line=4, col=0, min(4, 2), min(0, 6): 0
line=4, col=1, min(4, 2), min(1, 5): 1
line=4, col=2, min(4, 2), min(2, 4): 2
line=4, col=3, min(4, 2), min(3, 3): 2
line=4, col=4, min(4, 2), min(4, 2): 2
line=4, col=5, min(4, 2), min(5, 1): 1
line=4, col=6, min(4, 2), min(6, 0): 0

line=5, col=0, min(5, 1), min(0, 6): 0
line=5, col=1, min(5, 1), min(1, 5): 1
line=5, col=2, min(5, 1), min(2, 4): 1
line=5, col=3, min(5, 1), min(3, 3): 1
line=5, col=4, min(5, 1), min(4, 2): 1
line=5, col=5, min(5, 1), min(5, 1): 1
line=5, col=6, min(5, 1), min(6, 0): 0

line=6, col=0, min(6, 0), min(0, 6): 0
line=6, col=1, min(6, 0), min(1, 5): 0
line=6, col=2, min(6, 0), min(2, 4): 0
line=6, col=3, min(6, 0), min(3, 3): 0
line=6, col=4, min(6, 0), min(4, 2): 0
line=6, col=5, min(6, 0), min(5, 1): 0
line=6, col=6, min(6, 0), min(6, 0): 0

On voit mieux la relation de cause à effet entre la ligne en cours et son dessin. Le premier "min()" fait référence à la ligne en cours et le second "min()" fait référence à la colonne en cours. Pour la première ligne, la colonne n'a pas d'importance et on n'a que des "a". Pour la seconde ligne, à la première et dernière colonne là c'est la ligne qui n'a pas d'importance et on aura "a". Ensuite pour le reste de la ligne les colonnes n'auront plus d'importance et on aura que des "b". Pour la 3° ligne, ce sont les deux premières colonnes et dernières colonnes qui comptent ("a" et "b") puis le numéro de ligne ("c"). Et etc etc etc.

Et le couple (line, size-1-line) est un couple (x, y) avec y opposé de x. Quand x monte alors y descend.
On peut retrouver ça en prenant l'équation de droite passant par A(0, size - 1) et B(1, size - 2). Le vecteur AB a alors pour coordonnées (xB-xA, yB-yA) soit au résultat (1-0, (size-2)-(size-1)) soit au final (1, -1).
Si on prend un point M(x, y), alors AM a pour coordonnées (x, y - (size - 1)) soit en simplifiant les parenthèses (x, y - size + 1).
Et si M appartient à la droite, alors AM est colinéaire à AB donc 1 * (y-size+1) - (-1) * x = 0. Là aussi on simplifie les parenthèses et les (-1) ce qui donne au final y-size+1+x=0. On isole le "y" et on obtient l'équation de droite y=size-1-x.

Salut,

Quelque soit n, 2*n - 1 sera un nombre impair et la suite finie fabriquée par la boucle:

Code:

---

1 2 3

m = 2*n-1 for i in range(m): print(min(i, m-1-i)

---

sera "symétrique".

Pour n = 3, çà donne 0, 1, 2, 3, 2, 1, 0.
Et si on combine çà en double boucle, çà donne:

Code:

---

1 2 3 4 5 6 7 8 9 10

# => colonnes # | 0, 1, 2, 3, 2, 1, 0 # v # 0 l 0, 0, 0, 0, 0, 0, 0 # 1 i 0, 1, 1, 1, 1, 1, 0 # 2 g 0, 1, 2, 2, 2, 1, 0 # 3 n 0, 1, 2, 3, 2, 1, 0 # 2 e 0, 1, 2, 2, 2, 1, 0 # 1 s 0, 1, 1, 1, 1, 1, 0 # 0 0, 0, 0, 0, 0, 0, 0

---

Et "on voit" que le nombre associé à la ligne sert à filtrer celui qui sort de la colonne correspondante.

Donc on pourrait écrire:

Code:

---

1 2 3 4 5 6

T = lambda s: s[:] + s[:-1][::-1]   def g(n): s = T(list(range(n))) for i in s: print(''.join(alphabet[min(i, j)] for j in s))

---

On peut aussi remarquer les symétries autour de la ligne 3 et de la colonne 3 et écrire:

Code:

---

1 2 3 4 5

def h(n): A = alphabet print('\n'.join( T([ T(A[:i] + A[i] * (n - i)) for i in range(n) ])) )

---

et rendre le code encore plus mystérieux.

- W

:applo: Domo arigato gozaimashita* :applo:

Quand j'ai abordé le problème j'ai remarqué deux choses :
1. Selon la dimension choisie (le nombre de lettres) chaque lettre forme un cadre unique qui entoure chaque cadre jusqu'à la dernière lettre qui sera affichée au centre du bloc de lettre ainsi constitué.
Et j'ai commencé à élaborer en préambule un truc du genre :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27

def drawLine(design, lenght): print(design *lenght)   def drawBlankLine(design, lenght): if lenght > 1: print(design, end ="") for _ in range(lenght -2): print(" ", end ="") print(design)   def drawOblong(design, line, column): if column > 1: drawLine(design, column) for _ in range(line -2): drawBlankLine(design, column) drawLine(design, column)   alphabet =['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z']   designQuant =int(input()) line, column =designQuant *2 -1, designQuant *2 -1   for _ in range(designQuant): design =alphabet[_] drawOblong(design, line, column) line -=2 column -=2

---

Qui donne :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

4 aaaaaaa a a a a a a a a a a aaaaaaa bbbbb b b b b b b bbbbb ccc c c ccc d

---

Mais comment intégrer chaque cadre de lettre les uns dans les autres?? Impossible, je dois construire le bloc ligne par ligne.
2. Il existe une symétrie horizontale et verticale dans le bloc de lettres à afficher.

Et là prise de tête sur prise de choux j'ai essayé de construire un algo combinant la duplication circulaire de chaque lettre et le rapport de symétrie horizontale verticale du bloc de lettres.
Au final j'ai pondu un truc bien chiant qui n'a rien à voir et qui me fait honte aujourd'hui...

En fait c'est super simple et comme c'est super simple, c'est super géniale (enfin je trouve).

Code:

---

print(alphabet[min(min(line, size -1 -line), min(column, size -1 -column))], end ='')

---

Affiche dans la séquence, l'élément du tableau correspondant à son index égale au minimum des coordonnées (x1, x2) et (y1, y2) dont l'intersection constituent l'emplacement de l'élément à afficher :

Pièce jointe 559316

Merci Sve@r pour ton explication et tous les tips qu'elle renferme (construction de l'itérable "alphabet", n2 & n² versus 2n, le rappel de l'existence de la fonction print()).
Merci wiztricks pour toutes les idées que suggère ton explication, ceci étant il y a un souci avec :

Code:

---

1 2 3 4 5 6

T = lambda s: s[:] + s[:-1][::-1]   def g(n): s = T(list(range(n))) for i in s: print(''.join(alphabet[min(i, j)] for j in s))

---

Ça fonctionne bien jusqu'à n <=12, à partir de n <=13 il y a un décalage sur la ligne centrale qui va qui va crescendo jusqu'à n <=25 et :

Code:

---

1 2 3 4 5

def h(n): A = alphabet print('\n'.join( T([ T(A[:i] + A[i] * (n - i)) for i in range(n) ])) )

---

Donne l'erreur :

Code:

---

1 2	print('\n'.join(T([ T(A[:i] + A[i] * (n - i)) for i in range(n) ]))) TypeError: can only concatenate list (not "str") to list

---

Encore merci à tous les deux.
*Merci beaucoup (pour le travail accomplie ou le service rendu)

Citation:

---

Envoyé par MissLoop

Ça fonctionne bien jusqu'à n <=12, à partir de n <=13 il y a un décalage sur la ligne centrale qui va qui va crescendo jusqu'à n <=25

---

Voilà ce que çà sort chez moi pour n = 26:

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51

aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa abbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbba abcccccccccccccccccccccccccccccccccccccccccccccccba abcdddddddddddddddddddddddddddddddddddddddddddddcba abcdeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeedcba abcdefffffffffffffffffffffffffffffffffffffffffedcba abcdefgggggggggggggggggggggggggggggggggggggggfedcba abcdefghhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhgfedcba abcdefghiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiihgfedcba abcdefghijjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjihgfedcba abcdefghijkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkjihgfedcba abcdefghijklllllllllllllllllllllllllllllkjihgfedcba abcdefghijklmmmmmmmmmmmmmmmmmmmmmmmmmmmlkjihgfedcba abcdefghijklmnnnnnnnnnnnnnnnnnnnnnnnnnmlkjihgfedcba abcdefghijklmnooooooooooooooooooooooonmlkjihgfedcba abcdefghijklmnoppppppppppppppppppppponmlkjihgfedcba abcdefghijklmnopqqqqqqqqqqqqqqqqqqqponmlkjihgfedcba abcdefghijklmnopqrrrrrrrrrrrrrrrrrqponmlkjihgfedcba abcdefghijklmnopqrsssssssssssssssrqponmlkjihgfedcba abcdefghijklmnopqrstttttttttttttsrqponmlkjihgfedcba abcdefghijklmnopqrstuuuuuuuuuuutsrqponmlkjihgfedcba abcdefghijklmnopqrstuvvvvvvvvvutsrqponmlkjihgfedcba abcdefghijklmnopqrstuvwwwwwwwvutsrqponmlkjihgfedcba abcdefghijklmnopqrstuvwxxxxxwvutsrqponmlkjihgfedcba abcdefghijklmnopqrstuvwxyyyxwvutsrqponmlkjihgfedcba abcdefghijklmnopqrstuvwxyzyxwvutsrqponmlkjihgfedcba abcdefghijklmnopqrstuvwxyyyxwvutsrqponmlkjihgfedcba abcdefghijklmnopqrstuvwxxxxxwvutsrqponmlkjihgfedcba abcdefghijklmnopqrstuvwwwwwwwvutsrqponmlkjihgfedcba abcdefghijklmnopqrstuvvvvvvvvvutsrqponmlkjihgfedcba abcdefghijklmnopqrstuuuuuuuuuuutsrqponmlkjihgfedcba abcdefghijklmnopqrstttttttttttttsrqponmlkjihgfedcba abcdefghijklmnopqrsssssssssssssssrqponmlkjihgfedcba abcdefghijklmnopqrrrrrrrrrrrrrrrrrqponmlkjihgfedcba abcdefghijklmnopqqqqqqqqqqqqqqqqqqqponmlkjihgfedcba abcdefghijklmnoppppppppppppppppppppponmlkjihgfedcba abcdefghijklmnooooooooooooooooooooooonmlkjihgfedcba abcdefghijklmnnnnnnnnnnnnnnnnnnnnnnnnnmlkjihgfedcba abcdefghijklmmmmmmmmmmmmmmmmmmmmmmmmmmmlkjihgfedcba abcdefghijklllllllllllllllllllllllllllllkjihgfedcba abcdefghijkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkjihgfedcba abcdefghijjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjihgfedcba abcdefghiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiihgfedcba abcdefghhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhgfedcba abcdefgggggggggggggggggggggggggggggggggggggggfedcba abcdefffffffffffffffffffffffffffffffffffffffffedcba abcdeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeedcba abcdddddddddddddddddddddddddddddddddddddddddddddcba abcccccccccccccccccccccccccccccccccccccccccccccccba abbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbba aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa

---

Si vous voyez un décalage à partir de n = 12, peut être que vous affichez çà avec une police ou la taille des caractères n'est pas fixe (en tous cas, je ne vois pas de décalage).

Code:

---

1 2 3 4

Pour n = 27, çà plante avec: File "ae_40.py", line 37, in <listcomp> T([ T(A[:i] + A[i] * (n - i)) for i in range(n) ])) IndexError: string index out of range

---

Ce qui est normal compte tenu du nombre de lettres dans l'alphabet.

- W

Citation:

---

Voilà ce que çà sort chez moi pour n = 26:

---

Autant pour moi j'ai oublié une virgule dans mon tableau entre n et m, le code fonctionne parfaitement.

Par contre pour la seconde version j'ai un problème de concaténation, pas un dépassement d'index.
Voici le code tel que je l'exécute :

Code:

---

1 2 3 4 5 6 7 8 9 10

alphabet =['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z']   T = lambda s: s[:] + s[:-1][::-1] x =int(input())   def h(n): A = alphabet print('\n'.join(T([ T(A[:i] + A[i] * (n - i)) for i in range(n) ])))   h(x)

---

Citation:

---

Envoyé par MissLoop

Par contre pour la seconde version j'ai un problème de concaténation, pas un dépassement d'index.

---

Ca c'est parce que mon alphabet = "abcdefijklmnpqrstuvwxyz"

Sinon, effectivement on va avoir dans A[:i] + A[i] * (n - i) une tentative pour concaténer une liste (A[:i]) avec une chaine de caractères.

- W

Bien évidemment... encore merci.