soit un rectangle R1 à la position (x1,y1) et un rectangle mobile R2(x2,y2)
R2 se déplace en direction de R1, avec comme offsets possibles (n,0), (0,n) ou (n,n) pour simplifier.
ecrire une fonction qui teste si R1 et R2 entrent en collision et si oui, retourne la position que devrait avoir R2 pour toucher R1 sans le recouvrir.
cette fonction peut permettre à un personnage d'avoir un mouvement plus réaliste, càd, ne pas bloquer à plusieurs pixels d'un obstacle mais être contre l'obstacle.
j'ai suivi le cours pygame et paf une erreur : File is not a Windows BMP file pourtant mon image est bien une image bmp
voila mon code:
import pygame
from pygame.locals import *
pygame.init()
fenetre = pygame.display.set_mode((640,480))
liste_lutin = []
with open('laby') as laby:
line = 0
nb_char = 0
for char in laby.read():
if char == 'd':
liste_lutin.append((pygame.image.load("arrivee.bmp").convert(),(nb_char,line)))
if char == 'm':
liste_lutin.append((pygame.image.load("mur.bmp").convert(),(nb_char,line)))
if char == '\n':
line += 1
continue
nb_char += 1
for i in liste_lutin:
fenetre.blit(i[0],i[1])
pygame.display.flip()
continuer = 1
while continuer:
continuer = int(input())
désolé de déterrer ce sujet mais j'ai trouve un algorithme sur le trie qui utilise la récursivité:
import random
data = list(range(0,13))
random.shuffle(data)
def Min(List):
MinInt = Max(List) + 1
for i in List:
if i < MinInt:
MinInt = i
return MinInt
def Max(List):
MaxInt = 0
for i in List:
if i > MaxInt:
MaxInt = i
return MaxInt
def Merged(data,exp=False):
if len(data) < 2:
return data
milieu = len(data) // 2
left = data[:milieu]
right = data[milieu:]
merged_left = Merged(left,exp)
merged_right = Merged(right,exp)
union = Union(merged_left,merged_right)
if exp:
print('a gauche: ',left)
print('a droite: ',right)
print("union: ",union))
return union
def Union(left, right):
total_list = left + right
data =[]
data_copy = [i for i in total_list]
for i in total_list:
data.append(Min(data_copy))
del data_copy[data_copy.index(Min(data_copy))]
return data
n = Merged(data, True)
ça affiche:
a gauche: [0]
a droite: [7]
union: [0, 7]
a gauche: [11]
a droite: [0, 7]
union: [0, 7, 11]
a gauche: [2]
a droite: [4]
union: [2, 4]
a gauche: [3]
a droite: [2, 4]
union: [2, 3, 4]
a gauche: [11, 0, 7]
a droite: [3, 2, 4]
union: [0, 2, 3, 4, 7, 11]
a gauche: [1]
a droite: [10]
union: [1, 10]
a gauche: [5]
a droite: [1, 10]
union: [1, 5, 10]
a gauche: [8]
a droite: [9]
union: [8, 9]
a gauche: [12]
a droite: [6]
union: [6, 12]
a gauche: [8, 9]
a droite: [12, 6]
union: [6, 8, 9, 12]
a gauche: [5, 1, 10]
a droite: [8, 9, 12, 6]
union: [1, 5, 6, 8, 9, 10, 12]
a gauche: [11, 0, 7, 3, 2, 4]
a droite: [5, 1, 10, 8, 9, 12, 6]
union: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
exp = explication
- Edité par Le programmeur solitaire 21 novembre 2020 à 10:17:09
Bonjour, les Zéros , me revoilà, vous savez que python(qui est mon langage préféré aprés le C)à plusieurs défaut comme la lenteur mais surtout ce qui manque c'est les POINTEURS . voilà donc mon exercice: créer des pointeurs en python (ou plutôt esseyé de créer). Je sais c'est difficile mais faîtes le quand même .
example :
p = NewPointeur(val=5, types=int)
a = p.adresse
c = NewPointeur(adr=a)
print(p.adresse)
print(c.get)
print(GetValue(a))
SetValue(a, 10)
print(p.get)
print(c.get)
c.setVal(67)
print(p.get)
DelPointeur(a)
try:
print(c.get)
print(p.get)
except NameError:
print('ERROR')
Outre cela, l'exercice n'a pas grand intérêt, car l'objectif de Python est d'éviter la gestion mémoire, et je doute que dans ton exercice, tu as prévu l'allocation des pointeurs à l'aide de malloc, calloc, ... et si on prend mon exemple ci-dessus, en pure python, c'est équivalent à
i = [5]
def change(p):
p[0] = 12
change(i)
print(i[0])
et si on essaye de tenter une approche entre pointeurs et lenteur Python, faudra m'expliquer le rapport.
Celui qui trouve sans chercher est celui qui a longtemps cherché sans trouver.(Bachelard) La connaissance s'acquiert par l'expérience, tout le reste n'est que de l'information.(Einstein)
from itertools import product
from string import ascii_lowercase
def get_solutions(it, n):
return [''.join(x) for x in product(it, repeat=n)]
print(get_solutions(ascii_lowercase, 2))
Celui qui trouve sans chercher est celui qui a longtemps cherché sans trouver.(Bachelard) La connaissance s'acquiert par l'expérience, tout le reste n'est que de l'information.(Einstein)
from string import ascii_lowercase
def product(*args, repeat=1):
pools = [tuple(pool) for pool in args] * repeat
result = [[]]
for pool in pools:
result = [x+[y] for x in result for y in pool]
return [''.join(x) for x in result]
print(product(ascii_lowercase, repeat=2))
Celui qui trouve sans chercher est celui qui a longtemps cherché sans trouver.(Bachelard) La connaissance s'acquiert par l'expérience, tout le reste n'est que de l'information.(Einstein)
def product(*args, repeat=1):
pools = [tuple(pool) for pool in args] * repeat
result = [[]]
for pool in pools:
result = [x+[y] for x in result for y in pool]
return [''.join(x) for x in result]
print(product(''.join([chr(i) for i in range(ord('a'),ord('z')+1)]), repeat=2))
- Edité par Le programmeur solitaire 19 juin 2021 à 16:08:05
Celui qui trouve sans chercher est celui qui a longtemps cherché sans trouver.(Bachelard) La connaissance s'acquiert par l'expérience, tout le reste n'est que de l'information.(Einstein)
vous devez créer une fonction qui retourne une liste de toute les possibilités de mélange de lettre de longueur n(n sera en paramètre)
example:
print(posi(2))
qui affiche:
[aa, ab, ac, ad, af ,... , ga, gb, ..., ra, rb, rc, ... , ya, yb, ..., zy, zz]
Pour qu'on puisse traiter suffisamment d'instances, il faut paramétrer la taille N de l'alphabet (et non pas imposer N=26). S'il y a p répétitions, la liste sera de taille N^p, qui peut vite devenir très grand et limite l'intérêt de la question.
fred1599 a écrit:
from itertools import product
from string import ascii_lowercase
def get_solutions(it, n):
return [''.join(x) for x in product(it, repeat=n)]
print(get_solutions(ascii_lowercase, 2))
product de itertools semble la fonction adaptée en effet. Testons les performances :
from time import perf_counter
from itertools import product
from string import ascii_lowercase
def get_solutions(it, n):
return [''.join(x) for x in product(it, repeat=n)]
repeat=p=8
N=9
alpha=''.join([chr(i) for i in range(ord('a'),ord('z')+1)])[:N]
begin_perf = perf_counter()
begin_perf = perf_counter()
p3=get_solutions(alpha, p)
delta = perf_counter() - begin_perf
print(len(p3), N**p)
# 1.1 Go, 2.49s, (N=8,p=8)
# 2.9Go, 6.35s (N=9,p=8)
print(f"Temps d'exécution : {delta:.2f}s")
43046721 43046721
Temps d'exécution : 6.30s
Il y a 43 millions de mots à générer, ce n'est pas peu mais pas affolant non plus et pourtant ça met plus de 6s et surtout la conso mémoire est élevée : entre 2 Go et 3 Go (*). Je précise que 43 millions de mots de 8 lettres, ça fait 350 Mo.
(*) voir edit
Pour N=p=8, le temps est de 2.5s pour plus de 1Go de mémoire.
Maintenant, regardons le code sans itertools :
fred1599 a écrit:
from string import ascii_lowercase
def product(*args, repeat=1):
pools = [tuple(pool) for pool in args] * repeat
result = [[]]
for pool in pools:
result = [x+[y] for x in result for y in pool]
return [''.join(x) for x in result]
print(product(ascii_lowercase, repeat=2))
Là, les performances sont extrêmement dégradées. Si je lance le code pour N=9 et p=8, le programme bloque la machine (la mémoire dépasse vite les 8 Go). Et pour N=p=8, il faut 2.5 Go de mémoire et le temps est de 12,50s. Je suppose que c'est la multi-création de listes (les x+[y]) qui est à l'origine de ce coût.
En réalité, si on regarde bien, il n'y a que très peu de listes à créer, il y en a même repeat. Donc autant concaténer des chaînes caractères que des listes. D'où le code suivant :
from time import perf_counter
from string import ascii_lowercase
def product_str(alpha, p):
L=['']
for _ in range(p):
LL=[s+c for s in L for c in alpha]
L=LL
return LL
repeat=p=8
N=9
alpha=''.join([chr(i) for i in range(ord('a'),ord('z')+1)])[:N]
begin_perf = perf_counter()
p2=product_str(alpha, p)
delta = perf_counter() - begin_perf
print(len(p2), N**p)
# 531 Mo, 1.25s (N=8,p=8)
# 1.6 Go, 3.09s (N=9,p=8)
print(f"Temps d'exécution : {delta:.2f}s")
43046721 43046721
Temps d'exécution : 3.10s
Le temps et l'empreinte mémoire sont largement plus favorables qu'avec itertools, comme quoi, ce dernier n'est pas toujours la meilleure solution.
(*)EDIT
Comme me l'a fait comprendre H.D.1 dans ce message, la conso mémoire énorme n'est pas due à itertools mais au fait d'accumuler dans une liste. Si on écrit :
from time import perf_counter
from itertools import product
from string import ascii_lowercase
p=8
n=9
alpha=ascii_lowercase[:n]
begin_perf = perf_counter()
cpt=0
for x in product(alpha, repeat=p):
"".join(x)
cpt+=1
delta = perf_counter() - begin_perf
print(cpt, n**p)
print(f"Temps d'exécution : {delta:.2f}s")
43046721 43046721
Temps d'exécution : 9.20s
on peut vérifier que l'empreinte mémoire est insignifiante (le temps en revanche est plus lent que les 6s et 3s obtenues plus haut).
Voici ma variante (pas Covid) de la forme lambda: product_str = lambda alpha, p: [''] if p==0 else [s+c for s in product_str(alpha, p-1) for c in alpha]
Le Tout est souvent plus grand que la somme de ses parties.
Voici ma variante (pas Covid) de la forme lambda: product_str = lambda alpha, p: [''] if p==0 else [s+c for s in product_str(alpha, p-1) for c in alpha]
Le problème c'est que product_str(0) retourne [''] et non pas une liste vide. D'ailleurs j'ai édité mon code pour prendre en compte le paramètre inférieur à 1.
Le problème c'est que product_str(0) retourne [''] et non pas une liste vide. D'ailleurs j'ai édité mon code pour prendre en compte le paramètre inférieur à 1.
Ce n'est pas un problème c'est même la bonne réponse puisque ta fonction doit renvoyer une liste de mots de longueur 0 et il y a un mot et un seul de longueur 0, c'est le mot vide. D'ailleurs, c'est lié au fait que x**0=1, le seul cas douteux étant x=0.
J'ai un code semblable à celui de Pierrot sauf que je place le if à la fin pour tomber dans la bonne branche le plus souvent possible (en pratique ici ça ne changera rien) :
prod_rec=lambda alpha, p: [s+c for s in prod_rec(alpha, p-1) for c in alpha] if p else ['']
Si alpha est un alphabet vide alors la fonction retournera une liste vide (comme tu souhaites) donc j'ai choisi que 0**0 ferait 0 d'ailleurs Python donne 1 à 0**0.
Belle analyse, en effet je n'ai pas pensé à regarder la partie efficace du code, juste fonctionnelle...
À mon sens, c'est typiquement dans ce type d'exercice que PyPy et Cython peuvent sortir leur épingle du jeu.
Je pense pas qu'en pure python on puisse faire beaucoup mieux que le code que tu proposes.
Celui qui trouve sans chercher est celui qui a longtemps cherché sans trouver.(Bachelard) La connaissance s'acquiert par l'expérience, tout le reste n'est que de l'information.(Einstein)
× Après avoir cliqué sur "Répondre" vous serez invité à vous connecter pour que votre message soit publié.
× Attention, ce sujet est très ancien. Le déterrer n'est pas forcément approprié. Nous te conseillons de créer un nouveau sujet pour poser ta question.
le code FAIT le bonheur (pour moi en tous cas)
Python c'est bon, mangez-en.
le code FAIT le bonheur (pour moi en tous cas)
Python c'est bon, mangez-en.
le code FAIT le bonheur (pour moi en tous cas)
Python c'est bon, mangez-en.
le code FAIT le bonheur (pour moi en tous cas)
Python c'est bon, mangez-en.
le code FAIT le bonheur (pour moi en tous cas)
le code FAIT le bonheur (pour moi en tous cas)
Python c'est bon, mangez-en.
le code FAIT le bonheur (pour moi en tous cas)
Celui qui trouve sans chercher est celui qui a longtemps cherché sans trouver.(Bachelard)
La connaissance s'acquiert par l'expérience, tout le reste n'est que de l'information.(Einstein)
le code FAIT le bonheur (pour moi en tous cas)
Le Tout est souvent plus grand que la somme de ses parties.
le code FAIT le bonheur (pour moi en tous cas)
Celui qui trouve sans chercher est celui qui a longtemps cherché sans trouver.(Bachelard)
La connaissance s'acquiert par l'expérience, tout le reste n'est que de l'information.(Einstein)
Python c'est bon, mangez-en.
le code FAIT le bonheur (pour moi en tous cas)
Celui qui trouve sans chercher est celui qui a longtemps cherché sans trouver.(Bachelard)
La connaissance s'acquiert par l'expérience, tout le reste n'est que de l'information.(Einstein)
le code FAIT le bonheur (pour moi en tous cas)
Celui qui trouve sans chercher est celui qui a longtemps cherché sans trouver.(Bachelard)
La connaissance s'acquiert par l'expérience, tout le reste n'est que de l'information.(Einstein)
Découverte Python Doc Tkinter Les chaînes de caractères
Python c'est bon, mangez-en.
Le Tout est souvent plus grand que la somme de ses parties.
Python c'est bon, mangez-en.
Découverte Python Doc Tkinter Les chaînes de caractères
Python c'est bon, mangez-en.
Celui qui trouve sans chercher est celui qui a longtemps cherché sans trouver.(Bachelard)
La connaissance s'acquiert par l'expérience, tout le reste n'est que de l'information.(Einstein)