If you have any questions, comments or issues with this project please post them here!

Hi. Davidās solution doesnāt assure non-repeated numbers in the bingo list.

Here is my solution to cover that:

```
import random
print('Bingo card generator')
print()
numbers = []
while len(numbers) < 8:
random_number = random.randint(0,90)
if random_number not in numbers:
numbers.append(random_number)
numbers.sort()
bingo = [ [numbers[0], numbers[1], numbers[2]],
[numbers[3], "BINGO", numbers[4]],
[numbers[5], numbers[6], numbers[7]] ]
for i in bingo:
for j in i:
print(j, end=' | ')
print()
```

It will be great to hear your comments about my code or any other solutions.

@segima,

nice one! tho i kinda didnāt get how it works id like to learn im still new if you donāt mind

for i in bingo:

for j in i :

then Iām printing j itāll avoid existing numbers ? how the jās cant be duplicated like thereās no command that explains this

if j is not in I print j

urs just printing the whole jās ?(Iām not really sure sorry)

my solution was this ,

```
import random, os, time
print("Welcome to \033[32mB\033[31mi\033[34mn\033[35mg\033[36mo\033[31m!\033[0m")
print()
print("3")
time.sleep(1)
print("2")
time.sleep(1)
print("1")
time.sleep(1)
os.system("clear")
bingo=[]
def num():
number=random.randint(0,90)
return number
def style_print():
for row in bingo:
print(row)
numbers= []
chosen_numbers=[ ]
for number in range(8):
if number not in bingo:
numbers.append(num())
numbers.sort()
bingo=[ [numbers[0],numbers[1],numbers[2]],
[numbers[3], "BINGO!", numbers[4]],
[numbers[5],numbers[6],numbers[7]] ]
print("\033[32mB\033[31mi\033[34mn\033[35mg\033[36mo\033[31m!\033[0m")
print()
style_print()
print("You WOn")
```

iv made another empty list to hold to already selected vars then used not in to append to the list then call those which are not appended to the already called list

Hi, @Rocko. Thanks for your comment.

The while loop is what assures non-repeated numbers. It iterates until the list length is eight, then it appends that number to the list only if it isnāt already in there.

The for loop with the two variables (i, j) is only to print out the bingo card.

PS: Itās way better inserting your code here as preformatted text.

@segima ,

oh haha ya I completely avoided that len part LOL I only checked the i, j var as I did my repeat check on the var zone xD. my mistake I see you put len in here but up until the project 43 len was probably not introduced to us ik len now as iv used it to sum other projects Iām on day 66 now and Lol ik the reformat thingy I just copy pasted my code so didnāt bother but anyways thnx for your suggestion duly noted.

nice solution, i completely forgot about checking for duplicates. i did it with a counter.

```
import random
BingoList=[['','',''],['','',''],['','','']]
NumberList=[]
def PrettyPrint():
print("-------------------------")
for k in range(3):
print(f"|",end="")
for l in range(3):
if k==1 and l==1:
print(f"{'BINGO':^7}|",end="")
else:
print(f"{BingoList[k][l]:^7}|",end="")
print("\n-------------------------")
counter=0
while counter <9:
Number=random.randint(0,91)
if Number not in NumberList:
NumberList.append(Number)
counter+=1
NumberList.sort()
counter=0
for k in range(0,3):
for l in range(0,3):
BingoList[k][l]=NumberList[counter]
counter+=1
print("BINGO Card Generator\n")
PrettyPrint()
```

my previous version that didnāt check for duplicates is different from davidās since i didnāt make an extra subroutine and just put the call in directly:

```
for i in range(9):
NumberList.append(random.randint(0,91))
```

another difference is that i wanted to avoid simply calling every single entry of the list (which happens what the solution does) because i want to use something that seems scalable (i know, a bit early to think about something like that ). i was surprised that the āprettyprintā in the solution doesnāt look pretty at all though

Hi guys,

I already know my code doesnāt meet acceptance criteria 4, but I donāt really understand why it does not execute .sort() properly for criteria 3. Could someone explain it to me please?

```
import random
bingoList = [[None, None, None],[None, None, None],[None, None, None]]
for i in range (3):
number = random.randint(0,90)
bingoList[0][i] = number
for i in range (2):
number = random.randint(0,90)
bingoList[1][i] = number
for i in range (3):
number = random.randint(0,90)
bingoList[2][i] = number
bingoList.sort()
print(f"""|{bingoList[0][0]:<8} | {bingoList[0][1]:^8} | {bingoList[0][2]:>8} |
---------------------------------
|{bingoList[1][0]:<8} | {'BINGO':^8} | {bingoList[1][1]:>8} |
---------------------------------
|{bingoList[2][0]:<8} | {bingoList[2][1]:^8} | {bingoList[2][2]:>8} |""")
```

ok, did some testing, and it seems .sort() does not work with 2d lists.

1d list needs to be done at first place, sorted, than it needs to be converted to a 2d listā¦

have fun guys!

Im beginning to get stuck at some point in the latest projects(totally normal I guess) , checking here for some ideas . Thanks everyone.

here is my code on day 43

```
import random
my2Dlist = [ [ None , None , None],
[ None , None , None],
[ None , None , None] ]
def prettyPrint():
print (f"""{my2Dlist[0][0]:<8}|{my2Dlist[0][1]:^8}|{my2Dlist[0][2]:>8}
---------------------------
{my2Dlist[1][0]:<8}|{my2Dlist[1][1]:^8}|{my2Dlist[1][2]:>8}
---------------------------
{my2Dlist[2][0]:<8}|{my2Dlist[2][1]:^8}|{my2Dlist[2][2]:>8}""")
while True:
for i in range(0,3):
for j in range (0,3):
my2Dlist[i][j]=random.randint(1,90)
my2Dlist[i].sort()
break
my2Dlist[1][1]="BINGO"
prettyPrint()
```

I confused a little bit and that because this is the first time i hear bingo is it a real game?

Hey @WaayeelkaCraxma!

BINGO is a real game played by many people. It is usually played in large groups and not online.

How do i allocate a place for each random number inside that 2D list we are supposed to create? Do I use the append() function?

The `append()`

function is used to add elements to an existing list, but itās typically used in a loop or by directly appending values one by one. If you know the specific indexes where you want to add elements to an existing 2D list, you can use `append()`

. But, you can use this code:

```
import random
# dimensions for the 2D list.
num_rows = 3
num_columns = 4
random_2d_list = [[random.randint(1, 100) for _ in range(num_columns)] for _ in range(num_rows)]
for row in random_2d_list:
print(row)
```

I received an error for the `prettyPrint()`

command but when I compare my code to the answer it seems to be the same. However, I did notice that the `prettyPrint()`

command seems to be nested within the parameters assigned as `bingo`

at the bottom.

The AI debugger is also suggesting a solution that I canāt seem to implement:

āThe error in your project is that the closing parenthesis for the `bingo`

list is missing in the `prettyPrint`

function call.ā

Is this a formatting issue or something else?

```
import random
bingo = []
def ran():
number = random.randint(1,90)
return number
def prettyPrint():
for row in bingo:
print(row)
numbers = []
for i in range(8):
numbers.append(ran())
numbers.sort()
bingo = [ [numbers[0], numbers[1], numbers[2]],
[numbers[3], "BINGO", numbers[4]],
[numbers[5], numbers[6], numbers[7]
]
prettyPrint()
```

The AI is almost right, youāre missing a `]`

after `numbers[7]`

.

That worked, thanks!

Itās best to format code like this well so that you can see it more clearly.

Correct code:

```
bingo = [
[numbers[0], numbers[1], numbers[2]],
[numbers[3], "BINGO", numbers[4]],
[numbers[5], numbers[6], numbers[7]],
]
```

Can anyone help me please? I feel really dumb tbh. This challenge is actually a lot more difficult than the previous Day 042 Mokebeast, which is literally a āProject Dayā: Iām really struggling in this challenge and feel its too advanced for me as a beginner.

```
print("David's Nan's Bingo Card Generator")
print()
import random, pprint
number1 = random.randint(0,90)
number2 = random.randint(0,90)
number3 = random.randint(0,90)
number4 = random.randint(0,90)
number5 = random.randint(0,90)
number6 = random.randint(0,90)
number7 = random.randint(0,90)
number8 = random.randint(0,90)
my2DList = [ [number1, number2, number3],
[number4, None, number5],
[number6, number7, number8] ]
my2DList[1][1]= "BINGO!"
my2DList.sort()
List = pprint.pp(my2DList)
```

Hello everyone,

I am trying to figure out how to do the .sort() for my code. Every time I try and place it somewhere it ends up not sorting or only sorting the first row of the card. Can I get help on how to fix my code?

```
import random
myBingoCard = [[0, 0, 0],
[0, "BINGO", 0],
[0, 0, 0]]
def generate_random_numbers(card):
numbers = random.sample(range(1, 91), 8)
numbers = sorted(numbers)
for i in range(3):
for j in range(3):
if card[i][j] == 0:
card[i][j] = numbers.pop(0)
def printBingoCard():
print("Welcome to Bingo!")
print()
print("Your Bingo Card:")
print()
for row in myBingoCard:
num = random.choices(range(91))
print(f"{myBingoCard[0][0]:^5} | {myBingoCard[0][1]:^5} | {myBingoCard[0][2]:^5}")
print(" -----------------")
print(f"{myBingoCard[1][0]:^5} | {myBingoCard[1][1]:^5} | {myBingoCard[1][2]:^5}")
print(" -----------------")
print(f"{myBingoCard[2][0]:^5} | {myBingoCard[2][1]:^5} | {myBingoCard[2][2]:^5}")
generate_random_numbers(myBingoCard)
printBingoCard()
```

NVM, my code works now I figured it out.