Discussion :

[Invité]

Bonjour,

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
aaaaaaa
abbbbba
abcccba
abcdcba
abcccba
abbbbba
aaaaaaa

Avec ce programme :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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.

[Sve@r]

Bonjour

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)...

[Invité]

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

on a pour les 2 premières lignes :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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??

[Sve@r]

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.

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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.

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.

[wiztricks]

Salut,

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[Invité]

Domo arigato gozaimashita*

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :



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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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)