| |
| Par thèmes : | |
|
•Algèbre •Analyse •Applications •Dénombrement et probabilités •Géométrie •Fondements •Histoire •Java •Théorie des nombres | |
| Alphabétique : | |
|
A à B --
C à D E à H -- I à M N à R -- S à Z |
| Code source en Python |
Explications liminaires
Ce qui suit est le code source traduit en Python de mon programme initial. Il est fonctionnel et en mode texte, je vais m'atteler à la phase graphique...
Si vous l'ignoriez, l'indentation est la clé de voute de tout programme écrit en Python : ici, elle est par multiples de 4 espaces à la fois : la respecter absolument.
Au détour d'une ligne, vous tomberez sur : /4.0. Ce n'est pas une erreur : par défaut Python aurait donné le quotient entier, écrire 4.0 force le calcul du quotient décimal.
Pour le tester, il est donc nécessaire que vous ayez Python (gratuit) installé sur votre machine. Vous pouvez soit tout retaper, soit demander que je vous envoie le fichier "impapairs.py" (9 ko) par mél en pièce jointe. Utliser, par exemple, la section du Forum nommée "Site : Bibmath.net" et ajouter une réponse à la "discussion" ouverte par Fred sous le vocable "Carrés magiques".
Python une fois installé, cliquer 2 fois sur impapairs.py (ou tout autre nom que vous lui aurez donné, si vous avez tout retapé).
En fin de listing, vous trouverez 3 copies d'écran... Tous réactions, commentaires sont les bienvenus.
# -*- coding: cp1252 -*-
def titre_general():
print " **********************************************"
print " * CARRES DE DIMENSIONS IMPAIREMENT PAIRE *"
print " * Modèle du Carré du Soleil *"
print " **********************************************"
def sortie():
print " Au revoir !"
return
# Remplissage des listes initiale et finale par des 0
def init(tb_mag,tb_init,n):
for j in range(n**2):
tb_mag.append(0)
tb_init.append(0)
return tb_mag
# Méthodes de calcul (dans l'ordre)
def normal(i,j,n,nn):
global tnb
tnb = n*(j -1) + i
return tnb
def normal_quadr(i,j,n,nn):
global tnb
c = i - nn*(i > nn)
nb = 1 + (i > nn) + 2 * (j > nn)
tnb = nn**2*(nb - 1) + nn*(l - 1) + c
return tnb
def ip_puis_pa(i,j,n,nn):
global tnb
tnb = (2*i-1+(j-1)*2*n)*(j<=nn)+(j>nn)*(2*i+(j-1-nn)*2*n)
return tnb
def ip_pa_1li(i,j,n,nn):
global tnb
if j %2 == 1:
tnb = 2*(i - 1)+ 1 + 2*n*(j/2)*(j>1)
else:
tnb = 2*i + 2*n*(j/2 -1)
return tnb
def normal_1s2(i,j,n,nn):
global tnb
tnb = nn*(j-1)+(i -(i % 2 == 0))/2 + 1 + 2*nn**2*(i % 2 == 0)
return tnb
def pairs_impairs_en_colonnes_sym(i,j,n,nn):
global tnb
if i == 1 or i == n:
normal(i,j,n,nn)
else:
dp = (((i - 2*(i>nn))/2)% 2 == 1)
if dp == 1:
tnb = n*(j-1) + n + 1 - i
else:
normal(i,j,n,nn)
return tnb
def normal_1s2_avec_symetrie_centrale_par_paires(i,j,n,nn):
global tnb
if j > nn:
tnb=(n**2)/2 +(i-(i % 2 == 0))/2 + 1 + (nn**2)*(i % 2 == 0) + nn*(j-nn-1)
else:
tnb = nn*(j-1) + (i -(i % 2 == 0))/2 + 1 + (nn**2)*(i % 2 == 0)
return tnb
# Procédure centrale de calcul, affichage et test de magie
def calcul(mode):
global i,j,n,nn,tem
while 1:
try:
n = int(raw_input("Veuillez choisir la dimension du carré (nombre impair x 2) : "))
if n % 2 == 0 and n % 4 != 0:
if (n/2) % 2 == 1:
break
print "Désolé ! Vous n'avez pas entré un nombre valide. Veuillez recommencer..."
except ValueError:
print "Désolé ! Ce n'est pas un nombre. Essayez encore..."
tb_mag = []
tb_init = []
init(tb_mag,tb_init,n)
nn = n/2
for nb in range(1,5):
for l in range(1,nn+1):
for c in range(1,nn+1):
j = l + nn*(nb>2)
i = c + nn*(1 - nb % 2)
if mode == 1:
normal(i,j,n,nn)
elif mode == 2:
normal_quadr(i,j,n,nn)
elif mode == 3:
ip_puis_pa(i,j,n,nn)
elif mode == 4:
ip_pa_1li(i,j,n,nn)
elif mode == 5:
normal_1s2(i,j,n,nn)
elif mode == 6:
pairs_impairs_en_colonnes_sym(i,j,n,nn)
else:
normal_1s2_avec_symetrie_centrale_par_paires(i,j,n,nn)
tb_init[n*(j -1 ) + i - 1] = tnb
if i == j or i+j == n+1: # Les diagonales restent en place
tb_mag[n*(j - 1)+ i - 1] = tnb
else: # initialisation du drapeau d'appartenance à une forme
tem = (i == nn or i == nn+1) and (j == 1 or j == n)
tem = tem + ((j == nn or j == nn+1) and (i == 1 or i == n))
tem = tem + (i == j - 1 or i + j == n or i+j == n + 2 or i == j +1)
if nb == 1:
quadr1(c,l,i,j,n,tnb,tb_mag)
elif nb == 2:
quadr2(c,l,i,j,n,tnb,tb_mag)
elif nb == 3:
quadr3(c,l,i,j,n,tnb,tb_mag)
else:
quadr4(c,l,i,j,n,tnb,tb_mag)
if n > 34:
print "Dimension trop grande : création d'un fichier"
ecriture_dans_fichier(tb_mag,n)
else:
affichage(tb_mag,tb_init,n)
teste_magie(tb_mag,n)
return
# Application des symétries dans chaque quadrant
def quadr1(c,l,i,j,n,tb_init,tb_mag):
if ((c - l) > n/4.0 and c > l) or ((l - c)< n/4.0 and c < l):
tb_mag[n*(j - 1) + n - i] = tnb
else:
tb_mag[n*(n - j) + i - 1] = tnb
return tb_mag
def quadr2(c,l,i,j,n,tnb,tb_mag):
if (c + l < 1 + nn and c + l > 1 + n/4)or c + l > 1 + 3*n/4.0:
tb_mag[n*(n - j) + i - 1] = tnb
elif tem == 0 and (c + l < 1 + n/4.0 or (c + l > 1 + nn and c + l< 1 + 3*n/4.0)):
tb_mag[n*(j-1)+ n - i] = tnb
else:
tb_mag[n*(n - j)+ n - i] = tnb
return tb_mag
def quadr3(c,l,i,j,n,tnb,tb_mag):
if (c + l> 1 + n/4.0 and c + l < 1 + nn) or c + l> 1 + 3*n/4.0:
tb_mag[n*(j - 1) + n - i] = tnb
elif tem == 0 and (c + l < 1 + n/4.0 or (c + l > 1 + nn and c + l < 1 + 3*n/4.0)):
tb_mag[n*(n - j) + i - 1] = tnb
else:
tb_mag[n*(n - j) + n - i] = tnb
return tb_mag
def quadr4(c,l,i,j,n,tnb,tb_mag):
if tem == 1:
tb_mag[n*(n - j) + n - i] = tnb
elif (c < l and l-c > n/4.0) or (c > l and c-l < n/4.0):
tb_mag[n*(j - 1) + n - i] = tnb
else:
tb_mag[n*(n - j) + i - 1] = tnb
return tb_mag
def affichage(tb_mag,tb_init,n):
for v in range(n**2):
if (v+1)%n == 1 and v+1 >n:
if n > 10:
# Pour voir le carré initial, remplacer tb_mag par tb_init
if n == 6:
print "%2i" % tb_mag[v],
elif n < 34:
print "%3i" % tb_mag[v],
def ecriture_dans_fichier(tb_mag,n):
nom = "dim" + str(n) + "mode" + str(mode)
f = open(nom, "w")
lgmax = 1 + len(str(n**2))
for j in range(n):
chaine = ""
for i in range(n):
ch = " "
nb = str(tb_mag[n*j+i])
lg = len(nb)
nbl = lgmax - lg -1
while nbl > 0:
ch = ch + " "
nbl = nbl - 1
nb = ch + nb
chaine = chaine + nb
f.write(chaine+"\n")
f.close()
print "Votre fichier se nomme ", nom
def teste_magie(tb_mag,n):
print "Test des lignes"
for j in range(n):
tot = 0
for i in range(n):
tot = tot + tb_mag[n*j+i]
print tot,
print "Test des colonnes"
for i in range(n):
tot=0
for j in range(n):
tot = tot + tb_mag[n*j+i]
print tot,
print "Test des diagonales"
tot1 = 0
tot2 = 0
for j in range(n):
i = j
tot1 = tot1 + tb_mag[n*j+i]
tot2 = tot2 + tb_mag[n*j+n-i-1]
print tot1,tot2
while 1:
aa = 1
while aa == 1:
try:
titre_general()
print " 1. Dans l'ordre normal par ligne du carré"
print " 2. Dans l'ordre normal par ligne de quadrant"
print " 3. Tous les nombres impairs, puis les pairs"
print " 4. Avec lignes de nombres impairs et pairs alternées"
print " 5. Ordre normal en sautant une case à chaque fois dans le carré"
print " 6. Par 2 colonnes à la fois avec symétrie dans chaque quadrant"
print " 7. Ordre normal en sautant une case et par paires symétriques de somme n^2"
print " 0. Sortie du programme"
mode = int(raw_input("Votre choix : "))
if mode > 7:
print "Désolé ! Vous n'avez pas entré un nombre valide. Veuillez recommencer..."
else:
break
except ValueError:
print "Désolé ! Ce n'est pas un nombre. Essayez encore..."
if mode == 0:
sortie()
break
calcul(mode)
raw_input(' ... Presser une touche ...')
... Faire son choix ...
Retour
• Les carrés impairement pairs
| |
|
•Corrigés concours •Exercices •Dossiers | |
| |
|
•Biographies •Formulaire •Traducteur | |
| |
|
•Carrés magiques •Cryptographie •Jeux mathématiques •Maths au quotidien | |
| |
|
•Actualités •Forum •Liens | |