Aller au contenu

MathieuClem

Membre
  • Compteur de contenus

    769
  • Inscription

  • Dernière visite

Messages posté(e)s par MathieuClem

  1. Clairement si tu recherches la fluidité, le MacBook Pro Classique n'est pas la bonne solution.

    La question des 8 Go est cruciale si tu veux que ta machine soit pérenne, les 8 Go sont donc à mon goût obligatoire.

    Vu ton utilisation, le MacBook Retina n'est clairement pas une bonne solution, vu le prix que tu veux mettre.

     

    Dans 3 ans voire plus, il ne ramera pas avec les utilisations basiques que tu demandes. Le processeur ne sera pas à la ramasse vu que ce ne sera que du traitement basique (texte/mail/photo amateur). De plus, étant donné que c'est un SSD, le MacBook ne ramera pas, ou très peu si tu le pousses au maximum.

     

    Un MacBook Air 128 Go de SSD et 8 Go de RAM, avec l'offre Apple On Campus (8-12%), semble la bonne solution. Tu tournes aux alentours de 1055€ si je me souviens bien.


  2. import random

    # ------------------------------------------------------------------------------------------------------------------------------------------------------

    labyrinthe = 0
    CellulesEnregistrees = 0
    globNbrColonnes = 0
    globNbrLignes = 0
    Entree = 0
    Sortie = 0
    MursH = 0
    MursV = 0

    def ChoisirEntreeEtSortie():
    """Définition de la cellule d'entrée et de sortie du labyrinthe"""

    global Entree
    global Sortie
    global MursV
    global MursH

    a = random.randint(0,1)
    if a == 0: # On enleve aléatoirement alors un mur, ici le mur est vertical, puis aléatoirement si c'est un mur de gauche ou de droite
    b = random.randint(0,1)
    d = globNbrLignes-1
    c = random.randint(0,d)

    if b == 0: # On enlève un mur à gauche et on choisit au hasard lequel
    MursV[c][0] = False
    MursV[(d-c)][globNbrColonnes] = False
    Entree = [c,0]
    Sortie = [d-c,globNbrColonnes-1]

    else: # Autrement c'est un mur de droite et on choisit au hasard lequel
    MursV[c][globNbrColonnes] = False
    MursV[d-c][0] = False
    Entree = [c,globNbrColonnes-1]
    Sortie = [d-c,0]

    else: # Autrement on enlève un mur horizontal
    b = random.randint(0,1)
    d = globNbrColonnes-1
    c = random.randint(0,d)

    if b == 0: # On enlève un mur en haut
    MursH[0][c] = False
    MursH[globNbrLignes][(d-c)] = False
    Entree = [0,c]
    Sortie = [globNbrLignes-1,(d-c)]

    else: # Sinon on enlève un mur du bas du labyrinthe
    MursH[globNbrLignes][c] = False
    MursH[0][(d-c)] = False
    Entree = [globNbrLignes-1,c]
    Sortie = [0,(d-c)]


    def OuverturedunMurEntre2Cellules(xA, yA, xB, yB):
    """Destruction d'un mur entre 2 cellules en fonction des cordonnées des cellules A(xA,yA) et B(xB,yB) """

    if xA == xB: # Les deux cellules étant sur la meme ligne, on enlève le mur vertical entre elles
    if yA < yB:
    MursV[xA][yB] = False
    else:
    MursV[xA][yA] = False

    if yA == yB: # Les deux cellules sont sur la meme colonne, on enlève le mur horizontal entre elles
    if xA < xB:
    MursH[xA+1][yA] = False
    else:
    MursH[xB+1][yA] = False


    def AlgoExplorationExhaustive():
    """Définition de l'algorithme permettant la création du labyrinthe"""

    global labyrinthe
    global CellulesEnregistrees
    CellulesEnregistrees = []
    labyrinthe = [[False]*(globNbrColonnes) for _ in range(globNbrLignes)]
    a = Entree[0]
    b = Entree[1]
    CaseSuivante = 0

    labyrinthe[a][b] = True
    CellulesEnregistrees.append([a,b])

    while True:
    ## On décrit les différentes possibilités d'ouverture entre les cellules,
    ## Différentes cas sont possibles en fonction de la position des cellules.
    listeVoisinsVisites = []
    if a == 0:
    if b != 0 and b != (globNbrColonnes-1): # Côté supérieur du labyrinthe excluant les coins
    if labyrinthe[a+1][b] == False:
    listeVoisinsVisites.append([a+1,b])
    if labyrinthe[a][b-1] == False:
    listeVoisinsVisites.append([a,b-1])
    if labyrinthe[a][b+1] == False:
    listeVoisinsVisites.append([a,b+1])

    else:
    if b == 0: # Coin supérieur gauche
    if labyrinthe[a+1][b] == False:
    listeVoisinsVisites.append([a+1,b])
    if labyrinthe[a][b+1] == False:
    listeVoisinsVisites.append([a,b+1])

    else: # Coin supérieur droit
    if labyrinthe[a+1][b] == False:
    listeVoisinsVisites.append([a+1,b])
    if labyrinthe[a][b-1] == False:
    listeVoisinsVisites.append([a,b-1])

    else:
    if b == 0:
    if a == (globNbrLignes - 1): # Coin inférieur gauche
    if labyrinthe[a][b+1] == False:
    listeVoisinsVisites.append([a,b+1])
    if labyrinthe[a-1][b] == False:
    listeVoisinsVisites.append([a-1,b])

    else: # Côté gauche du labyrinthe en excluant les coins
    if labyrinthe[a][b+1] == False:
    listeVoisinsVisites.append([a,b+1])
    if labyrinthe[a-1][b] == False:
    listeVoisinsVisites.append([a-1,b])
    if labyrinthe[a+1][b] == False:
    listeVoisinsVisites.append([a+1,b])

    else:
    if a == (globNbrLignes - 1):
    if b == (globNbrColonnes - 1): # Coin inférieur droit
    if labyrinthe[a-1][b] == False:
    listeVoisinsVisites.append([a-1,b])
    if labyrinthe[a][b-1] == False:
    listeVoisinsVisites.append([a,b-1])

    else: # Côté inférieur du labyrinthe en excluant les coins
    if labyrinthe[a][b-1] == False:
    listeVoisinsVisites.append([a,b-1])
    if labyrinthe[a][b+1] == False:
    listeVoisinsVisites.append([a,b+1])
    if labyrinthe[a-1][b] == False:
    listeVoisinsVisites.append([a-1,b])
    else:
    if b == (globNbrColonnes - 1): # Côté droit du labyrinthe en excluant les coins
    if labyrinthe[a+1][b] == False:
    listeVoisinsVisites.append([a+1,b])
    if labyrinthe[a][b-1] == False:
    listeVoisinsVisites.append([a,b-1])
    if labyrinthe[a-1][b] == False:
    listeVoisinsVisites.append([a-1,b])

    else: # N'est pas une case en bordure du labyrinthe
    if labyrinthe[a+1][b] == False:
    listeVoisinsVisites.append([a+1,b])
    if labyrinthe[a][b-1] == False:
    listeVoisinsVisites.append([a,b-1])
    if labyrinthe[a][b+1] == False:
    listeVoisinsVisites.append([a,b+1])
    if labyrinthe[a-1][b] == False:
    listeVoisinsVisites.append([a-1,b])

    # On vient de créer une liste des voisins que l'on peut visiter

    if (len(listeVoisinsVisites) > 0):
    nbrVoisinsNonVisites = 0
    if (len(listeVoisinsVisites) > 1):
    nbrVoisinsNonVisites = random.randint(0,(len(listeVoisinsVisites)-1))
    CaseSuivante = listeVoisinsVisites.pop(nbrVoisinsNonVisites) # On choisit un voisin au hasard
    CellulesEnregistrees.append([a,b]) # On sauvegarde la cellule courante
    OuverturedunMurEntre2Cellules(a,b,CaseSuivante[0],CaseSuivante[1]) # On ouvre le mur entre les deux cellules

    else:
    if (len(CellulesEnregistrees) > 0):
    CaseSuivante = CellulesEnregistrees.pop()
    else:
    break
    a = CaseSuivante [0]
    b = CaseSuivante [1]
    labyrinthe[a][b] = True


    def printMatrix(NbrLignes, NbrColonnes, MursH, MursV):
    """Définition du labyrinthe, avec des murs verticaux et horizontaux dans un quadrillage de taille NbrLignes*NbrColonnes"""

    # var

    ligne = 0
    colonne = 0

    # begin

    for ligne in range(NbrLignes*2+1):
    string =""
    if (ligne%2) == 0:
    for colonne in range(NbrColonnes*2+1):
    if (colonne%2) == 0:
    string += "+"
    else:
    if (MursH[ligne//2][(colonne-1)//2]) == True:
    string += "---"
    else:
    string += " "

    else:
    for colonne in range(NbrColonnes*2+1):
    if (colonne%2) == 1:
    string += " "
    else:
    if (MursV[(ligne-1)//2][colonne//2]) == True:
    string += "|"
    else:
    string += " "
    print (string)

    # end

    # ------------------------------------------------------------------------------------------------------------------------------------------------------
    def main():

    """Programme Main du module Labyrinthe"""
    # var
    global globNbrLignes
    global globNbrColonnes
    global MursV
    global MursH
    global labyrinthe



    # begin
    print("%s\n%s\n%s" % ('='*80, __doc__, '='*80))

    # begin
    while True :
    while True: # Demande de reseignements sur le nombre de colonnes
    try :
    NbrColonnes = int(input("Entrez un nombre entier de colonnes du labyrinthe : "))
    while NbrColonnes == 0 or NbrColonnes == 1 :
    NbrColonnes = int(input("Un labyrinthe doit avoir plus d'une colonne, veuillez taper un nombre entier supérieur à 1 : "))
    except ValueError :
    pass
    else:
    break

    while True: # Demande de reseignements sur le nombre de lignes
    try :
    NbrLignes = int(input("Entrez un nombre entier de lignes du labyrinthe : "))
    while NbrLignes == 0 or NbrLignes == 1 :
    NbrLignes = int(input("Un labyrinthe doit avoir plus d'une ligne, veuillez taper un nombre entier supérieur à 1 : "))
    except ValueError :
    pass
    else:
    break

    globNbrColonnes = NbrColonnes
    globNbrLignes = NbrLignes

    MursH = [[True]*(NbrColonnes) for _ in range(NbrLignes+1)]
    MursV = [[True]*(NbrColonnes+1) for _ in range(NbrLignes)]

    ChoisirEntreeEtSortie()

    AlgoExplorationExhaustive()

    printMatrix(NbrLignes, NbrColonnes, MursH, MursV)

    recommencer = input("Voulez-vous générer un nouveau labyrinthe ? Oui ou Non : ") # Demande sur le fait de rejouer ou non
    while recommencer != "Oui" and recommencer != "Non" :
    recommencer = input("Voulez-vous générer un nouveau labyrinthe ? Oui ou Non : ")
    if recommencer == "Oui" :
    pass
    elif recommencer == "Non" :
    break




    # end
    # end

    # ------------------------------------------------------------------------------------------------------------------------------------------------------

    if __name__ == '__main__':

    main()

    # ======================================================================================================================================================

     

  3. Salut les gens, comment va la populasse ?!

    Bon j'ai une petite question : Sur mon MacBook Retina 13", j'ai remarqué ça dans le Moniteur d'activité.

    Avec Mavericks, j'y comprends plus rien, je trouvais ça beaucoup plus clair avec le camembert. La mémoire virtuelle est de 8 Go ? J'utilise 7,20 Go avec du Safari et iTunes ?!!

     

    833574Capturedcran20131210231610.png

     

    Merci d'avance pour le petit coup de main 

  4. Le son de mon MacBook Pro Retina 13" m'a bluffé. Rien à voir avec n'importe quelle chaîne HiFi bien sûr, le son n'est pas extraordinaire, mais ce qui m'a bluffé, c'est la diffusion du son, il sort des 3 côtés, ce qui rend vraiment l'audio agréable à écouter. Au niveau de la qualité du son, rien de transcendant, mais suffisant pour une écoute en fond.

     

    J'ai une enceinte JBL Bluetooth quand il faut ambiancer un minimum le salon de l'appart'.

  5. Tu peux prendre le Pro classique si tu le souhaites, mais alors prend le d'occasion, pour 800€ ...

     

    Franchement le Air dont tu proposes vaut le coup. Tu achètes un disque dur externe pour 50€, et en plus de cela tu as ton écran externe. Le Air fera laaaargement le travail que tu demandes.

×
×
  • Créer...