devine ton numéro

Oct 17 2020

Un script simple qui vous demande de penser à un nombre entre 1 et 63 propose ensuite une liste de nombres et vous demande si votre numéro est dans cette liste. Cela peut-il être remanié davantage? Existe-t-il de meilleures façons de créer des listes? Des améliorations?

x= [xx for xx in range(1,64)]
num_i = [i for i in range(1,64,2)]
num_ii = x[1::16]+ x[2::16]+ x[5::16]+ x[6::16]+ \
         x[9::16]+ x[10::16]+ x[13::16]+ x[14::16]
num_ii.sort()
num_iii= x[3::16]+ x[4::16]+ x[5::16]+ x[6::16]+ \
         x[11::16]+ x[12::16]+ x[13::16]+ x[14::16]
num_iii.sort()
num_iv=  x[7::16]+ x[8::16]+ x[9::16]+ x[10::16]+ \
        x[11::16]+ x[12::16]+ x[13::16]+ x[14::16]
num_iv.sort()
num_v= x[15::32]+ x[16::32]+ x[17::32]+ x[18::32]+ \
       x[19::32]+ x[20::32]+ x[21::32]+ x[22::32]+ \
       x[23::32]+ x[24::32]+ x[25::32]+ x[26::32]+ \
       x[27::32]+ x[28::32]+ x[29::32]+ x[30::32]
num_v.sort()
num_vi= [x for x in range(32,64)]
num_lists=[num_i,num_ii,num_iii,num_iv,num_v,num_vi]
addition_num= [1,2,4,8,16,32]
start_end= ["Think of a number between 1 and 63","I think the number you thought of was ..."]
intro= ["Is your number in the group of numbers below?",
        "Is your number in this group of numbers ?","Is your number in this third group of numbers ?",
        "Half way there. Is your number in this group of numbers ?",
        "One more after this one. Is your number in this group of numbers ?",
        "Last one. Is your number in this group of numbers ?"]
def format_list(xx):    
    for a,b,c,d,e,f,g,h in zip(xx[::8],xx[1::8],xx[2::8],xx[3::8],xx[4::8],xx[5::8],xx[6::8],xx[7::8]):
        print('{:<8}{:<8}{:<8}{:<8}{:<8}{:<8}{:<8}{:<}'.format(a,b,c,d,e,f,g,h))
    print('-'*62)
def main():    
    count=0
    your_guess= 0
    print(start_end[0])
    ready= input('are you ready?(enter to quit or any key)')
    if ready:
        while count < 6:
            print(intro[count])    
            format_list(num_lists[count])
            reply = input("y/n ?")
            if reply == "y" :
                your_guess += addition_num[count]
            count +=1
    print(start_end[1] + str(your_guess))
    replay= input('Play again? (enter to quit or any key)')
    if replay:        
        main()
if __name__ == '__main__':
    main()

Réponses

10 hjpotter92 Oct 17 2020 at 23:17

Numéros magiques

Comme déjà mentionné dans les commentaires, les chiffres \$ 1, 2, \cdots \$semblent être complètement aléatoires pour quiconque n'est pas sûr de la façon dont la sommation va (ou est censée) fonctionner. La génération des listes est également très lourde. La même astuce pourrait être étendue à une sélection jusqu'à \$ 127, 255, 511, \cdots, 2^{n} - 1 \$.

Récursif `main`

Vous avez un appel récursif au maincas où le joueur voudrait rejouer le jeu. Les appels récursifs lorsque vous ne revenez jamais peuvent entraîner des débordements de pile. Dans ce scénario, la récursivité n'est pas vraiment nécessaire de toute façon.

Utilisation excessive des listes

Vous avez presque tout mis dans des listes. Cela inclut tous les nombres de \$ 1-63 \$, tous les graphiques générés à partir de ces nombres, agrégation de toutes les listes ci-dessus, liste des puissances de \$ 2 \$, etc.

Pour certains d'entre eux, un tuple (immuable) est bon, d'autres n'ont pas besoin d'être placés dans une liste de toute façon.

Dénomination des variables

x, xx, xxx, xxxx, .. ne sont pas vraiment significatifs. Utilisez de meilleurs noms de variables.

Pour la génération des listes numériques:

for start in (2 ** i for i in range(6)):
    l = [_ for _ in range(start, 64) if _ % (start * 2) >= start]

Récrire:

INTROS = (
    "Is your number in the group of numbers below?",
    "Is your number in this group of numbers?",
    "Is your number in this third group of numbers?",
    "Half way there. Is your number in this group of numbers?",
    "One more after this one. Is your number in this group of numbers?",
    "Last one. Is your number in this group of numbers?",
    # "Or maybe the following?",
    # "Add more intro strings here",
    # "to get larger guessing range",
)
COUNT = len(INTROS)
UPPER_LIMIT = 2 ** COUNT


def display_chart(index: int, columns: int = 8):
    print(INTROS[index])
    start = 1 << index
    chart = [str(x) for x in range(start, UPPER_LIMIT) if x % (start * 2) >= start]
    for i in range(len(chart) // columns):
        print("\t".join(chart[i * columns : (i + 1) * columns]))


def game():
    guess = 0
    print(f"Think of a number between 1 and {UPPER_LIMIT - 1}")
    for current in range(COUNT):
        display_chart(current)
        reply = input("y/n? ")
        if reply == "y":
            guess += 1 << current
    print(f"I think the number you thought of was ... {guess}")


def main():
    while True:
        game()
        character = input("Play again? (enter to quit or any key)")
        if not character:
            break


if __name__ == "__main__":
    main()

La réécriture est maintenant de nature complètement dynamique. Si vous souhaitez augmenter la plage, ajoutez simplement une autre section au INTROStuple.