15-en, BKE en het magisch vierkant

• Inleiding
• 15-en
• Boter-Kaas-en-Eieren
• Het Magisch Vierkant
• Alles bij elkaar

# 15-en

import random
from itertools import combinations

stock=[]
human=[]
computer=[]
move=0
player=’computer’
stop=False
defensive=True

def question(question, default):
    a=input(question+’ [‘+default+’]: ‘)
    if a==” or a[0].upper()==default.upper():
        return True
    else:
    return False

def resetup():
    global stock, human, computer, move, player

    for i in range(1, 10):
        stock.append(i)
    human=[]
    computer=[]
    move=0
    if player==’computer’:
        player=’human’
    else:
        player=’computer’

def setup():
    global player,defensive

    print(’15-en’)
    print()
    q=’Do you want the computer play defensive(d) or at random(r)?’
    if question(q, ‘D’):
        defensive=True
    else:
        defensive=False
    if question(‘Do you want to start?’, ‘Yes’):
        player=’computer’
    else:
        player=’human’
    print()
    resetup()

def scoreboard():
    global stock, human, computer

    human=sorted(human)
    computer=sorted(computer)
    stock=sorted(stock)
    print(‘—–Scoreboard————————-‘)
    print(‘Stock:’, end=’ ‘)
    print(*stock, end=’ ‘)
    print(‘You:’, end=’ ‘)
    print(*human, end=’ ‘)
    print(‘Computer:’, end=’ ‘)
    print(*computer)
    print(‘—————————————-‘)

def check15():
    s=0
    c=[]
    if player==’human’:
        comb=combinations(human,3)
uitleg code

def humanpick():
    global player, move, human

    wrong=True
    if move<9:
        scoreboard()
        while wrong:
            print(‘\nYour turn’)
            print(‘You can choose the following number(s): ‘, end=’ ‘)
            print(‘ ‘.join(str(x) for x in stock))
            try:
                g=int(input(‘Choose your number: ‘))
            except:
                print(‘You gave a false number: Try again…’)
                wrong=True
                continue
            if g==0:
                exit(0)
            if g in stock:
                stock.remove(g)
                human.append(g)
                wrong=False
            else:
                print(‘You choose a wrong number: Try again…’)
                wrong=True
        print()
        move+=1
        if move>4:
            w,c = check15()
            if w:
                print(‘You have won!!!’)
                print(‘Winning combination: ‘, end=’ ‘)
                print(*c)
                return 1
            else:
                player=’computer’
                return 0
        else:
            player=’computer’
            return 0

def computerpick():
    global player, move

    if move<9:
        scoreboard()
        print(‘\nMy turn:’)
        print(‘I can choose one of the following numbers: ‘, end=’ ‘)
        print(‘ ‘.join(str(x) for x in stock))

        wrong=True

        #defensive
        if defensive:
            if move>=3:
                temp=human.copy()
                s=0
                for i in range(1,10):
                    if not (i in temp) and (i in stock):
                        temp.append(i)
                        comb=combinations(temp,3)
                        for x in comb:
                            for y in range(3):
                                s+=x[y]
                        if s==15:
                            temp.remove(i)
                            wrong=False
                            g=i
                            break
                        else:
                            s=0
                            temp.remove(i)

        while wrong:
            g=random.randrange(1,10)
            wrong=not(g in stock)
        print(f’I choose {g}’)
        print()
        stock.remove(g)
        computer.append(g)
        move+=1
        if move>4:
            w,c = check15()
            if w:
                print(‘I have won!!!’)
                print(‘Winning combination: ‘, end=’ ‘)
                print(‘ ‘.join(str(x) for x in c))
                return 1
            else:
                player=’human’
                return 0
        else:
            player=’human’
            return 0

def play():
    global stop

    while not stop:
        if move>=9:
            print(‘It is a draw.’)
            stop=not(question(‘Play again? ‘, ‘Y’))
            if not stop:
                resetup()
            else:
                exit(0)
        elif player==’human’:
            if humanpick():
                stop=not(question(‘Play again? ‘, ‘Y’))
                if not stop:
                    resetup()
                else:
                    exit(0)
        elif player==’computer’:
            if computerpick():
                stop=not(question(‘Play again? ‘, ‘Y’))
                if not stop:
                    resetup()
                else:
                    exit(0)

setup()
play()

In de Python code wordt gebruik gemaakt van een functie die combinaties berekent.

Maar wat is ook al weer het verschil tussen combinaties en permutaties?

Voor beiden geldt dat je kijkt op hoeveel en op welke manier je k elementen uit een verzameling van n elementen haalt.

Voor de combinatie geldt dat de volgorde er niet toe doet.
Voor de permutatie doet de volgorde er wel toe.

De formule voor de combinatie luidt:

De formule voor de permutatie luidt:

Laten we eens kijken op hoeveel manieren je 3 elementen uit een verzameling van 4 elementen kunt halen:

Het aantal combinaties is:

Het aantal permutaties is:

Voorbeeld:

Stel we hebben de verzameling {1, 2, 3, 4}.
Welke combinaties (dat zijn er dus 4) van 3 elementen kan ik dan maken?
Welnu: {1, 2, 3}, {1, 2, 4}, {1, 3, 4} en {2, 3, 4}.

Als we vervolgens eens kijken naar de verzameling {1, 2, 3} en gaan hiervan de permutaties bekijken (dat zijn er 6) dan krijgen we:

{1, 2, 3}, {1, 3, 2}, {2, 1, 3}, {2, 3, 1}, {3, 1, 2} en {3, 2, 1}.

En ik had al 4 combinaties en er zijn dus per combinatie 6 permutaties. Dat betekent dat er 4×6 permutaties van onze startverzameling zijn:

# Tic-Tac-Toe: human vs computer
# Computer can play defensive

import random

board=[[‘.’,’.’,’.’],[‘.’,’.’,’.’],[‘.’,’.’,’.’]]
player=’X’
computer=’O’
turn=’human’
move=0
stop=False
#nt is used in printboard for normal-text(nt=True) or extended asccii-text(nt=False)
nt=False
defensive=True

def question(question, default):
    a=input(question+’ [‘+default+’]: ‘)
    if a==” or a[0].upper()==default.upper():
        return True
    else:
        return False

def printboard(normaltext=False):
    if normaltext:
        print(‘——-‘)
    else:
        print(‘╔═╦═╦═╗’)
    for x in range(3):
        if normaltext:
            print(f’|{board[x][0] if board[x][0] != “.” else 3*x+1}|’
f'{board[x][1] if board[x][1] != “.” else 3*x+2}|’
f'{board[x][2] if board[x][2] != “.” else 3*x+3}|\n——-‘)
        else:
            print(f’║{board[x][0] if board[x][0] != “.” else 3*x+1}║’
f'{board[x][1] if board[x][1] != “.” else 3*x+2}║’
f'{board[x][2] if board[x][2] != “.” else 3*x+3}║’)
            if x<2:
                print(‘╠═╬═╬═╣’)
    if normaltext:
        print()
    else:
        print(‘╚═╩═╩═╝’)

def setup():
    global player, computer, turn, nt, defensive

    q=’Do you want plain-text(p) or Ascii-text(a) for the grid?’
    if question(q, ‘A’):
        nt=False
    else:
        nt=True

    q=’Do you watn the computer play defensive(d) or at random(r)?’
    if question(q, ‘D’):
        defensive=True
    else:
        defensive=False

    q=’Do you want to play with “X”?’
    if question(q,’Yes’):
        player=’X’
        computer=’O’
        turn=’human’
    else:
        player=’O’
        computer=’X’
        turn=’computer’

def playerturn():
    global move, stop

    wrong=True
    while wrong:
        printboard(normaltext=nt)
        try:
            v=int(input(‘Wich field (number) do you want to use?’))
        except:
            print(‘false input: Give integer number’)
            wrong=True
            continue
        if v==0:
            stop=True
            exit(0)
        else:
            f=(v-1)//3
            g=(v)%3-1
            if g==-1:
                g=2
            wrong=(board[f][g] != ‘.’)
            if wrong:
                print(f’false input: Board({f+1}, {g+1}) (number {v}) is not free’)
    if not stop:
        board[f][g]=player
        move += 1

def givesum(cs):
    s=0
    #1st row horizontal
    if cs==1:
        for y in range(3):
            if board[0][y]==player:
                s+=2**y
    #2nd row horizontal
    if cs==2:
        for y in range(3):
            if board[1][y]==player:
                s+=2**(y+3)
    #3rd row horizontal
    if cs==3:
        for y in range(3):
            if board[2][y]==player:
                s+=2**(y+6)
    #1st column vertical
    if cs==4:
        for x in range(3):
            if board[x][0]==player:
                s+=2**(x*3)
    #2nd column vertical
    if cs==5:
        for x in range(3):
            if board[x][1]==player:
                s+=2**(x*3+1)
    #3rd column vertical
    if cs==6:
        for x in range(3):
            if board[x][2]==player:
                s+=2**(x*3+2)
    #Diagonal from upper left to lower right
    if cs==7:
        for x in range(3):
            if board[x][x]==player:
                s+=2**(4*x)
    #Diagonal from upper right to lower left
    if cs==8:
        for x in range(3):
            if board[2-x][x]==player:
                s+=4**(x+1)
    return s

def computerturn():
    global move

    #Defense
    f=-1
    if defensive:
uitleg code

    if f==-1:
        wrong=True
        while wrong:
            v=random.randint(1,9)
            f=(v-1)//3
            g=(v)%3-1
            if g==-1:
                g=2
            wrong=(board[f][g] != ‘.’)
    board[int(f)][int(g)]=computer
    move += 1

def score():
    global turn

    pw=False
    cw=False
    for x in range(3):
        if board[x][0] == player and board[x][1] == player and board[x][2] == player:
            pw=True
    if not pw:
        for y in range(3):
            if board[0][y] == player and board[1][y] == player and board[2][y] == player:
                pw=True
    if not pw:
        if (board[0][0] == player and board[1][1] == player and board[2][2] == player) or \
        (board[0][2] == player and board[1][1] == player and board[2][0] == player):
            pw=True
    if pw:
        printboard(normaltext=nt)
        print(‘You have won!!!’)
        return 1

    for x in range(3):
        if board[x][0] == computer and board[x][1] == computer and board[x][2] == computer:
            cw=True
    if not pw:
        for y in range(3):
            if board[0][y] == computer and board[1][y] == computer and board[2][y] == computer:
                cw=True
    if not pw:
        if (board[0][0] == computer and board[1][1] == computer and board[2][2] == computer) or \
        (board[0][2] == computer and board[1][1] == computer and board[2][0] == computer):
            cw=True
    if cw:
        printboard(normaltext=nt)
        print(‘I have won!!!’)
        return 1

    if move == 9:
        printboard(normaltext=nt)
        print(“It’s a draw!”)
        return 1

    if turn == ‘human’:
        turn=’computer’
    else:
        turn=’human’
    return 0

def play():
    global turn, stop, player, computer, board, move

    while not stop:
        if turn==’human’:
            playerturn()
            p=score()
        else:
            computerturn()
            p=score()
        if p == 1:
            stop=not question(‘Play Again?’, ‘Yes’)
            move=0
            if not stop:
                board=[[‘.’,’.’,’.’],[‘.’,’.’,’.’],[‘.’,’.’,’.’]]
                if question(‘Do you want to play with “X”?’, ‘Yes’):
                    player=’X’
                    computer=’O’
                    turn=’human’
                else:
                    player=’O’
                    computer=’X’
                    turn=’computer’

setup()
print(f'{“You” if turn==”human” else “Computer”} play{“s” if turn==”Computer” else “”} with X.’)
play()

#defensive play:
#used grid
#         84
# 1 2 4 7
# 8 16 32 56
# 64 128 256 488
#
# 73 146 292 273
#
# numbers in grid are decimal representitives of binairy numbers (000000001 to 100000000),
# wich ensures unique sums of all different combinations of cells
#