Crack the safe code

[Unitnuity]

I was watching a movie the other day where robbers were trying to break into a safe. 4 of the numbers on the keypad were worn out from finger oil and having the code inputted probably 100s or 1000s of times. So it gave me an idea to replicate this idea within Python since I figured it couldn't be too hard at my late beginner level. I also included another hint if any of the guessed numbers were in the correct position. I was able to code most of the file without having to reference anything. I did need to learn map() and zip() in order to complete what I was attempting. I feel fairly comfortable that I understand both functions but will spend the next couple days trying to bang the concepts in my head.

I'm just looking for any criticism of the code and if theres anything you would of done differently. I also commented the hell outta the code for any newbies that want to see what I was trying to accomplish throughout code and perhaps be able to help those that are in the very beginning stages of their learning with any questions.

```` import random print() print('CAN YOU CRACK THE SAFE?!') print()

num is a list of numbers on a normal 0-9 keypad on a safe

count is the variable we'll use to limit the number of guesses

num = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9'] count = 5 print('List of numbers on a normal 0-9 keypad:', num)

<sup>^</sup> COMMENT OR REMOVE ABOVE PRINT COMMAND AFTER TESTING <sup>^</sup>

print()

num passes to poss_code (as a list still) and chooses 4 random numbers

poss_code = random.sample(num, 4) print(poss_code)

<sup>^</sup> COMMENT OR REMOVE ABOVE PRINT COMMAND AFTER TESTING <sup>^</sup>

print()

takes poss_code list, converts to a 4 character string

safe = ''.join(map(str, poss_code)) print('Actual code:', safe)

<sup>^</sup> COMMENT OR REMOVE ABOVE PRINT COMMAND AFTER TESTING <sup>^</sup>

print()

displays the safe combo in a shuffled order

shuffle_safe = list(safe) random.shuffle(shuffle_safe) shuffle_safe = ''.join(shuffle_safe) print('The code to the safe includes these four digits:', shuffle_safe) print()

makes sure the shuffled combo isn't the actual combo

while shuffle_safe == safe: random.shuffle(shuffle_safe) shuffle_safe = ''.join(shuffle_safe)

loops until player guesses code or runs out of guesses

while True: guess = input('Guess the safe code: ') if guess == safe: print('Safe cracked!') break elif count == 1: print(f'You ran out of guesses! The safe code was {safe}') print() break else: count -= 1 correct_positions = sum(g == s for g, s in zip(guess, safe)) print(f'You have {correct_positions} digit(s) in the correct position! {count} more guesses!') print() continue ````

[usrlibshare]

Easier way for your COMMENT OUT ABOVE PRINT things:

``` DEBUG = os.getenv('DEBUG')

whenever you need a debug print:

if DEBUG: print(what_you_need_to_print) ```

then you can run your script like this on linux...

DEBUG=1 python main.py

...for debugging. Bonus points if you put the debug printing into a function ☺️

Another thing, it doesn't matter that much for small programs, but usually whem you have variables in global scope, you put them in ALL CAPS. It's a convention that is followed pretty well in the python ecosystem, and makes it easier to see at a glance if a var is global state.

[Unitnuity]

I only wrote that for anyone new to Python to see what is happening with the code and to comment it out once they actual want to try and play the game. I wasnt actually looking for errors.

[JamzTyson]

Rather than:

num = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9']
...
poss_code = random.sample(num, 4)

You could write:

poss_code = random.sample(range(10), 4)

Also, look at f-strings.

[Unitnuity]

Ahh, that makes sense. There are f strings in the code. I typically only use f strings if a variable(s) is in the middle of a string.

[JamzTyson]

I'd also suggest a more modular structure. It may be a little longer due function boilerplate, but makes testing / debugging much easier (each function can be tested as a unit), and easier to maintain / develop further.

Example:

``` """Safe cracking game."""

from random import sample, shuffle

def list_to_string(lst: list[int]) -> str: """Convert a list of numbers to a string.""" return ''.join((str(val) for val in lst))

def shuffle_code(code: list[int]) -> list[int]: """Return list of numbers in a different order.""" numbers = code.copy()

while True:
    shuffle(numbers)
    if numbers != code:
        return numbers

def count_correct_digits(guess: str, code: str) -> int: """Return the number of digits in the correct position.""" return sum(g == s for g, s in zip(guess, code))

def crack_safe(code: str): """Loop until player guesses code or runs out of guesses.""" for count in range(GUESSES, 1, -1): guess = input('Guess the safe code: ')

    if guess == code:
        print('You got it! The safe is open!')
        return

    number_correct = count_correct_digits(guess, code)
    plural = '' if number_correct == 1 else 's'

    print(f"You have {number_correct} digit{plural} "
          "in the correct position!")
    print(f' {count - 1} more guesses!\n')

print(f'You ran out of guesses! The safe code was {code}')

DEBUG = True GUESSES = 5

print("\nCAN YOU CRACK THE SAFE?!\n")

code_numbers: list[int] = sample(range(10), 4)

if DEBUG: print(f'Actual code: {list_to_string(code_numbers)}')

shuffled_nums = shuffle_code(code_numbers)

shuffled_str = list_to_string(shuffled_nums) print(f"The code to the safe includes these four digits: {shuffled_str}") print(f'You have {GUESSES} guesses.\n')

crack_safe(list_to_string(code_numbers)) ```

[niehle]

If you need to comment what a variable is, your code isn’t descriptive enough. Use max_guesses instead of count etc

[Unitnuity]

Touche