How to install a module using pip for specific Python version in Windows

In Windows, you can execute the pip module by mentioning the python version ( You need to ensure that the launcher is on your path )

py -3.5 -m pip install python_package

py -2.7 -m pip install python_package

Alternatively, you can call the desired python executable directly like this:

/path/to/python.exe -m pip install python_package

[Source]

How to use a linked list in C Programming

/* 
* Program to use linked lists
* From the book: C Programming Quickstart Visual Guide
*
* By adding pointers to the definations of a structure,
* we can create a linked list of unlimited length. (well,
* limited only by the amount of available memory).
*/

#include <stdio.h>
#include <string.h> // For string functions.
#include <stdlib.h> // For memory functions.

#define STR_LEN 20

int main (void) {

/*
* Define the structure.
*/

struct student_grade {
char first_name[STR_LEN];
char last_name[STR_LEN];
float grade;
struct student_grade *next;
};

/*
* Rename the structure syntax.
*/

typedef struct student_grade sg;

/*
* Create two structure pointers.
*/

sg *first = NULL;
sg *new = NULL;
sg *temp = NULL;

int num; // For counting the input.

/*
* Need a temporary float.
*/

float g; //grade

/*
* Need some strings to handle the input.
*/

char classname[12], fn[STR_LEN], ln[STR_LEN];

/*
* Prompt the user.
*/

printf("Enter the classname (without spaces): ");
scanf("%11s", classname);

/*
* Prompt the user again.
*/

printf("Enter the student's name and their grade. Enter 0 0 0 to quite.\n(First Last ##.#): ");

/*
* Read the input.
*/

num = scanf("%11s %11s %f", fn, ln, &g);

/*
* Check if the user is done
*/

while (fn[0] != '0') {

/*
* Handle input.
*/

if (num == 3) {

new = (sg *) malloc(sizeof(sg));

/*
* Check that new is not NULL.
*/

strncpy(new->first_name, fn, STR_LEN-1);

new ->first_name[STR_LEN-1] = '\0';

strncpy(new->last_name, ln, STR_LEN-1);

new->last_name[STR_LEN-1] = '0';

new->grade = g;
new->next = first;
first = new;

} else {

printf("The data was not in the proper format.\n");
}

/*
* Prompt the user.
*/

printf("Enter the studen's name and their grade. Enter 0 0 0 to quit.\n(First Last ##.#): ");

/*
* Read the input.
*/

num = scanf("%11s %11s %f", fn, ln, &g);

} // End of while loop

/*
* Print the data and free the memory.
*/

printf("Student and grades for the class '%s':\n", classname);

new = first; //Start at the beginning.

while (new != NULL) { //Stop when list is done.

printf("%s %s %01.f\n", new->first_name, new->last_name, new->grade);

temp = new->next;
free(new);
new = temp;

}

getchar(); //Pause
getchar();//Pause
return 0;

}

How to use an array of structures in C Programming

/*
* Program to use arrays of structures
* From the book: C Programming Visual Quickstart Guide
*
* Structures, just like integers, floats,
* and characters, can be used in arrays.
* This program creates a list of student
* names and gradesby taking input from 
* the user and storing it in an array
* of structures.
*/

#include <stdio.h>
/* 
* In order to use the strncpy() function,
* the string.h file must be included.
*/
#include <string.h>

/*
* Define two macro constants. The first 
* represents the maximum string length
* (for a person's first and last names.)
* The second will be the number of 
* elements in the array.
*/

#define STR_LEN 20

#define NUM_STUDENTS 10

int main (void) {

/*
* Define the structure. The structure
* has two character arrays and one float.
*/

struct student_grade {
char first_name[STR_LEN];
char last_name[STR_LEN];
float grade;
};

/*
* Use typedef to rename the structure 
* syntax, then create an array of 
* structures. The typedef simplififes
* the process of referring to a structure.
* Then an array of structures called class
* is created.
*/

typedef struct student_grade sg;

/*
* Create an array of structures.
*/

sg class[NUM_STUDENTS];

/* 
* Need some counters.
*/

int i, num;
int count =0;

/*
* Need some strings to handle the input.
*/

char classname[12], fn[STR_LEN], ln[STR_LEN];

/*
* Need a temporary float.
*/

/*
* grade
*/

float g;

/* 
* Prompt the user.
*/

printf("Enter the classname (without spaces): ");
scanf("%11s", classname);

/* 
* Loop to read in all the student data.
*/

for(i = 0; i < NUM_STUDENTS; ++i) {

/*
* Prompt the user.
*/

printf("Enter the student's name and their grade. Enter 0 0 0 to quit.\n(First Last ##.#): ");

/*
* Read in the input.
*/

num = scanf("%11s %11s %f", fn,ln, &g);

/*
* Check if the user is done.
*/

if(fn[0] == '0') {
break;
}

/*
* Handle the input.
*/

if(num == 3) {

strncpy(class[i].first_name, fn, STR_LEN-1);

class[i].first_name[STR_LEN-1] = '\0';

strncpy(class[i].last_name, ln, STR_LEN-1);

class[i].last_name[STR_LEN-1] = '\0';

class[i].grade = g;
++count;

/*
* Improper input format.
*/
} else {

printf("The data was not in the proper format.\n");
break;
}
}

/*
* Print the data.
*/

printf("Students and grades for the class '%s':\n", classname);

for(i = 0; i < count; ++i) {

printf("%s %s %0.1f\n", class[i].first_name, class[i].last_name, class[i].grade);
}

/*
* Pause.
*/

getchar();
getchar();
return 0;

}

How to use typedef in C Programming

/* 
* Program to use typedef
* From the book: C Programming Visual Quickstart Guide
*
* The typedef operator can help shorten how you
* refer to structures. This application uses 
* those structures to read data from a binary 
* file.
*/

#include <stdio.h>

/*
* Set the file path and name.
*/

#define THEFILE "weather.dat"

int main(void) {

/* 
* Define the structure.
*/

struct weather_record {
char date[11];
int high;
int low;
};

/* 
* Use typedef to create an alias.
* The first line  makes an alias so that 
wr (short for weather_record) stands for 
struct weather_record. Then wr is used to
* create a day variable of type struct
weather_record.
*/

typedef struct weather_record wr;

/*
* Create a structure variable.
*/

wr day;

/*
* Need a pointer of type FILE.
*/

FILE *fp;

/* 
* Attempt to open the file for binary reading.
*/

fp = fopen(THEFILE, "rb");

/*
* The file is open.
*/

if (fp != NULL) {

/*
* Loop through the entire file, assigning each structure to day.
*/

while(fread(&day, sizeof(wr), 1, fp)) {

/* 
* Print the information using the structure's field.
*/

printf("Date: %s\nHigh: %d\nLow: %d\n\n", day.date, day.high, day.low);

}

} else {

printf("The file could not be opened.\n");

/*
* Exit the function/application.
*/

return 1;
}

/*
* Close the file
*/

if (fclose(fp) !=0) {
printf("The file cound not be closed.\n");
}

/*
* Pause
*/

getchar();
return 0;

}

Python Game: Reversi

# Reversi
# https://inventwithpython.com/reversi.py

import random
import sys

def drawBoard(board):
    # This function prints out the board that it was passed. Returns None.
    HLINE = '  +---+---+---+---+---+---+---+---+'
    VLINE = '  |   |   |   |   |   |   |   |   |'

    print('    1   2   3   4   5   6   7   8')
    print(HLINE)
    for y in range(8):
        print(VLINE)
        print(y+1, end=' ')
        for x in range(8):
            print('| %s' % (board[x][y]), end=' ')
        print('|')
        print(VLINE)
        print(HLINE)


def resetBoard(board):
    # Blanks out the board it is passed, except for the original starting position.
    for x in range(8):
        for y in range(8):
            board[x][y] = ' '

    # Starting pieces:
    board[3][3] = 'X'
    board[3][4] = 'O'
    board[4][3] = 'O'
    board[4][4] = 'X'


def getNewBoard():
    # Creates a brand new, blank board data structure.
    board = []
    for i in range(8):
        board.append([' '] * 8)

    return board


def isValidMove(board, tile, xstart, ystart):
    # Returns False if the player's move on space xstart, ystart is invalid.
    # If it is a valid move, returns a list of spaces that would become the player's if they made a move here.
    if board[xstart][ystart] != ' ' or not isOnBoard(xstart, ystart):
        return False

    board[xstart][ystart] = tile # temporarily set the tile on the board.

    if tile == 'X':
        otherTile = 'O'
    else:
        otherTile = 'X'

    tilesToFlip = []
    for xdirection, ydirection in [[0, 1], [1, 1], [1, 0], [1, -1], [0, -1], [-1, -1], [-1, 0], [-1, 1]]:
        x, y = xstart, ystart
        x += xdirection # first step in the direction
        y += ydirection # first step in the direction
        if isOnBoard(x, y) and board[x][y] == otherTile:
            # There is a piece belonging to the other player next to our piece.
            x += xdirection
            y += ydirection
            if not isOnBoard(x, y):
                continue
            while board[x][y] == otherTile:
                x += xdirection
                y += ydirection
                if not isOnBoard(x, y): # break out of while loop, then continue in for loop
                    break
            if not isOnBoard(x, y):
                continue
            if board[x][y] == tile:
                # There are pieces to flip over. Go in the reverse direction until we reach the original space, noting all the tiles along the way.
                while True:
                    x -= xdirection
                    y -= ydirection
                    if x == xstart and y == ystart:
                        break
                    tilesToFlip.append([x, y])

    board[xstart][ystart] = ' ' # restore the empty space
    if len(tilesToFlip) == 0: # If no tiles were flipped, this is not a valid move.
        return False
    return tilesToFlip


def isOnBoard(x, y):
    # Returns True if the coordinates are located on the board.
    return x >= 0 and x <= 7 and y >= 0 and y <=7


def getBoardWithValidMoves(board, tile):
    # Returns a new board with . marking the valid moves the given player can make.
    dupeBoard = getBoardCopy(board)

    for x, y in getValidMoves(dupeBoard, tile):
        dupeBoard[x][y] = '.'
    return dupeBoard


def getValidMoves(board, tile):
    # Returns a list of [x,y] lists of valid moves for the given player on the given board.
    validMoves = []

    for x in range(8):
        for y in range(8):
            if isValidMove(board, tile, x, y) != False:
                validMoves.append([x, y])
    return validMoves


def getScoreOfBoard(board):
    # Determine the score by counting the tiles. Returns a dictionary with keys 'X' and 'O'.
    xscore = 0
    oscore = 0
    for x in range(8):
        for y in range(8):
            if board[x][y] == 'X':
                xscore += 1
            if board[x][y] == 'O':
                oscore += 1
    return {'X':xscore, 'O':oscore}


def enterPlayerTile():
    # Lets the player type which tile they want to be.
    # Returns a list with the player's tile as the first item, and the computer's tile as the second.
    tile = ''
    while not (tile == 'X' or tile == 'O'):
        print('Do you want to be X or O?')
        tile = input().upper()

    # the first element in the tuple is the player's tile, the second is the computer's tile.
    if tile == 'X':
        return ['X', 'O']
    else:
        return ['O', 'X']


def whoGoesFirst():
    # Randomly choose the player who goes first.
    if random.randint(0, 1) == 0:
        return 'computer'
    else:
        return 'player'


def playAgain():
    # This function returns True if the player wants to play again, otherwise it returns False.
    print('Do you want to play again? (yes or no)')
    return input().lower().startswith('y')


def makeMove(board, tile, xstart, ystart):
    # Place the tile on the board at xstart, ystart, and flip any of the opponent's pieces.
    # Returns False if this is an invalid move, True if it is valid.
    tilesToFlip = isValidMove(board, tile, xstart, ystart)

    if tilesToFlip == False:
        return False

    board[xstart][ystart] = tile
    for x, y in tilesToFlip:
        board[x][y] = tile
    return True


def getBoardCopy(board):
    # Make a duplicate of the board list and return the duplicate.
    dupeBoard = getNewBoard()

    for x in range(8):
        for y in range(8):
            dupeBoard[x][y] = board[x][y]

    return dupeBoard


def isOnCorner(x, y):
    # Returns True if the position is in one of the four corners.
    return (x == 0 and y == 0) or (x == 7 and y == 0) or (x == 0 and y == 7) or (x == 7 and y == 7)


def getPlayerMove(board, playerTile):
    # Let the player type in their move.
    # Returns the move as [x, y] (or returns the strings 'hints' or 'quit')
    DIGITS1TO8 = '1 2 3 4 5 6 7 8'.split()
    while True:
        print('Enter your move, or type quit to end the game, or hints to turn off/on hints.')
        move = input().lower()
        if move == 'quit':
            return 'quit'
        if move == 'hints':
            return 'hints'

        if len(move) == 2 and move[0] in DIGITS1TO8 and move[1] in DIGITS1TO8:
            x = int(move[0]) - 1
            y = int(move[1]) - 1
            if isValidMove(board, playerTile, x, y) == False:
                continue
            else:
                break
        else:
            print('That is not a valid move. Type the x digit (1-8), then the y digit (1-8).')
            print('For example, 81 will be the top-right corner.')

    return [x, y]


def getComputerMove(board, computerTile):
    # Given a board and the computer's tile, determine where to
    # move and return that move as a [x, y] list.
    possibleMoves = getValidMoves(board, computerTile)

    # randomize the order of the possible moves
    random.shuffle(possibleMoves)

    # always go for a corner if available.
    for x, y in possibleMoves:
        if isOnCorner(x, y):
            return [x, y]

    # Go through all the possible moves and remember the best scoring move
    bestScore = -1
    for x, y in possibleMoves:
        dupeBoard = getBoardCopy(board)
        makeMove(dupeBoard, computerTile, x, y)
        score = getScoreOfBoard(dupeBoard)[computerTile]
        if score > bestScore:
            bestMove = [x, y]
            bestScore = score
    return bestMove


def showPoints(playerTile, computerTile):
    # Prints out the current score.
    scores = getScoreOfBoard(mainBoard)
    print('You have %s points. The computer has %s points.' % (scores[playerTile], scores[computerTile]))



print('Welcome to Reversi!')

while True:
    # Reset the board and game.
    mainBoard = getNewBoard()
    resetBoard(mainBoard)
    playerTile, computerTile = enterPlayerTile()
    showHints = False
    turn = whoGoesFirst()
    print('The ' + turn + ' will go first.')

    while True:
        if turn == 'player':
            # Player's turn.
            if showHints:
                validMovesBoard = getBoardWithValidMoves(mainBoard, playerTile)
                drawBoard(validMovesBoard)
            else:
                drawBoard(mainBoard)
            showPoints(playerTile, computerTile)
            move = getPlayerMove(mainBoard, playerTile)
            if move == 'quit':
                print('Thanks for playing!')
                sys.exit() # terminate the program
            elif move == 'hints':
                showHints = not showHints
                continue
            else:
                makeMove(mainBoard, playerTile, move[0], move[1])

            if getValidMoves(mainBoard, computerTile) == []:
                break
            else:
                turn = 'computer'

        else:
            # Computer's turn.
            drawBoard(mainBoard)
            showPoints(playerTile, computerTile)
            input('Press Enter to see the computer\'s move.')
            x, y = getComputerMove(mainBoard, computerTile)
            makeMove(mainBoard, computerTile, x, y)

            if getValidMoves(mainBoard, playerTile) == []:
                break
            else:
                turn = 'player'

    # Display the final score.
    drawBoard(mainBoard)
    scores = getScoreOfBoard(mainBoard)
    print('X scored %s points. O scored %s points.' % (scores['X'], scores['O']))
    if scores[playerTile] > scores[computerTile]:
        print('You beat the computer by %s points! Congratulations!' % (scores[playerTile] - scores[computerTile]))
    elif scores[playerTile] < scores[computerTile]:
        print('You lost. The computer beat you by %s points.' % (scores[computerTile] - scores[playerTile]))
    else:
        print('The game was a tie!')

    if not playAgain():
        break

How do I use structures in C Programming

/*
* Program to use structures
* From the book: C Programming Visual Quickstart Guide
*
* One structure at a time is written to a binary file
*/

#include <stdio.h>

/*
* Set the file path and name as a C preprocessor macro.
*/

#define THEFILE "weather.dat"

int main (void) {

/*
* Define a structure and create a variable of that type.
* The structure will be called weather_record. It contains
* three members: a character array called date, an integer
* called high, and another integer called low. Each of 
* these correspond to the variables that were used in the
* previous versions of this application. 
* One variable of the weather_record type is created, 
* called today. Note that you have to use both the 
* keyword struct as well as the structure name in
* defining this variable.
*/

struct weather_record {
/*
* YYYY-MM-DD
*/
char date[11];

int high;
int low;

};

/* 
* One structure variable of type weather_record.
*/

struct weather_record today;

/* 
* Need a pointer of type FILE.
*/

FILE *fp;

/* 
* Attempt to open the file for appended binary writing.
*/

fp = fopen(THEFILE, "ab");

/*
* The file is open.
*/
if (fp != NULL) {

/*
* Prompt the user.
*/

printf("Enter a date, the high tempature, and the low tempature.\n(YYYY-MM-DD ## ##): ");

/* 
* Handle the input, assigning it to the structure fields.
*/

if(scanf ("%10s %d %d", today.date, &today.high, &today.low) ==3) {

/*
* Write the data.
*/

fwrite(&today, sizeof(struct weather_record), 1, fp);
printf("The data has been written.\n");

} else {

printf("The data was not in proper format.\n");
}

} else{

printf("The file could not be opened.\n");

/*
* Exit the function/application.
*/

return 1;

}

/* 
* Close the file.
*/

if (fclose(fp) != 0) {
printf("The file could not be closed.\n");
}

/*
* Pause
*/
getchar();
getchar();
return 0;

} 

How to navigate a binary file in C Programming

/*
* Program to navigate a binary file
* From the book: C Programming Visual Quickstart Guide
*
* A random point in the data file is used to
* return a "lucky number."
*/

#include <stdio.h>
/*
* For rand() and srand().
*/
#include <stdlib.h>
/*
* For time(), used with srand().
*/
#include <time.h>

/*
* Set the file path and name.
*/

#define THEFILE "numbers.dat"

/* 
* Numbers of items being written.
* Creat a constant macro representing
* the number of items in the array.
*/

#define ITEMS 50

int main(void) {

/* 
* Need a pointer of type FILE
*/

FILE *fp;

/*
* Two integers are required.
* The first integer will be used as the
* off-set: the location within the number
* file to move to. The second will store 
* the read-in number value.
*/

int offset, number;

/*
* Attempt to open the file for binary reading.
*/

fp = fopen(THEFILE, "rb");

/*
* Start a conditional based on the file pointer.
* The file is open.
*/

if (fp != NULL) {

/*
* Find a random offset in bytes.
* The first line seeds the rand() funcion.
* The second line picks an arbitrary offset,
* as a random number up to the number of items
* stored. After this second line of code, offset
* will be qual to a number between 0 and 49, 
* corresponding to the 50 items originally stored
* in the file (like an array though, we begin
* counting at 0.)
* The third line multiplies the value of offset
* by the size of an integer. This is neccessary
* because we need to specify the offset in bytes.
* For example, if the randomly generated value is 
10, then the offset needs to be 40 bytes: 10 times
* sizeof(int), normally 4 bytes.
*/

srand((unsigned)time(NULL));
offset = rand() % ITEMS;
offset *= sizeof(int);

/* 
* Move to the random location and read in a number.
* The first line moves the virtual marker offset
* bytes into the file, starting from the beginning
* of the file. The second line reads one bk of data
* of sizeof(number) bytes and stores this in the 
* number variable. Remember that the fread() 
* function takes an address of a variable as its 
* first argument, so &number is used (the memory
* addres of the number variable.)
*/

fseek(fp, offset, SEEK_SET);
fread(&number, sizeof(number), 1, fp);

/*
* Print the number.
*/

printf("Your lucky number is: %d.\n", number);

} else {

printf("The file could not be opened.\n");

/*
* Exit the function/application.
*/

return 1;
}

/*
* Close the file.
*/

if (fclose(fp) != 0){
printf("The file could not be closed.\n");

}

/* 
* Pause.
*/

getchar();

return 0;

}

Python Programming: Caesar Cipher

# Caesar Cipher
# URL: https://inventwithpython.com/cipher.py

MAX_KEY_SIZE = 26

def getMode():
    while True:
        print('Do you wish to encrypt or decrypt a message?')
        mode = input().lower()
        if mode in 'encrypt e decrypt d'.split():
            return mode
        else:
            print('Enter either "encrypt" or "e" or "decrypt" or "d".')

def getMessage():
    print('Enter your message:')
    return input()

def getKey():
    key = 0
    while True:
        print('Enter the key number (1-%s)' % (MAX_KEY_SIZE))
        key = int(input())
        if (key >= 1 and key <= MAX_KEY_SIZE):
            return key

def getTranslatedMessage(mode, message, key):
    if mode[0] == 'd':
        key = -key
    translated = ''

    for symbol in message:
        if symbol.isalpha():
            num = ord(symbol)
            num += key

            if symbol.isupper():
                if num > ord('Z'):
                    num -= 26
                elif num < ord('A'):
                    num += 26
            elif symbol.islower():
                if num > ord('z'):
                    num -= 26
                elif num < ord('a'):
                    num += 26

            translated += chr(num)
        else:
            translated += symbol
    return translated

mode = getMode()
message = getMessage()
key = getKey()

print('Your translated text is:')
print(getTranslatedMessage(mode, message, key))

Python Game: Sonar

# Sonar
# URL: https://inventwithpython.com/sonar.py

import random
import sys

def drawBoard(board):
    # Draw the board data structure.

    hline = '    ' # initial space for the numbers down the left side of the board
    for i in range(1, 6):
        hline += (' ' * 9) + str(i)

    # print the numbers across the top
    print(hline)
    print('   ' + ('0123456789' * 6))
    print()

    # print each of the 15 rows
    for i in range(15):
        # single-digit numbers need to be padded with an extra space
        if i < 10:
            extraSpace = ' '
        else:
            extraSpace = ''
        print('%s%s %s %s' % (extraSpace, i, getRow(board, i), i))

    # print the numbers across the bottom
    print()
    print('   ' + ('0123456789' * 6))
    print(hline)


def getRow(board, row):
    # Return a string from the board data structure at a certain row.
    boardRow = ''
    for i in range(60):
        boardRow += board[i][row]
    return boardRow

def getNewBoard():
    # Create a new 60x15 board data structure.
    board = []
    for x in range(60): # the main list is a list of 60 lists
        board.append([])
        for y in range(15): # each list in the main list has 15 single-character strings
            # use different characters for the ocean to make it more readable.
            if random.randint(0, 1) == 0:
                board[x].append('~')
            else:
                board[x].append('`')
    return board

def getRandomChests(numChests):
    # Create a list of chest data structures (two-item lists of x, y int coordinates)
    chests = []
    for i in range(numChests):
        chests.append([random.randint(0, 59), random.randint(0, 14)])
    return chests

def isValidMove(x, y):
    # Return True if the coordinates are on the board, otherwise False.
    return x >= 0 and x <= 59 and y >= 0 and y <= 14

def makeMove(board, chests, x, y):
    # Change the board data structure with a sonar device character. Remove treasure chests
    # from the chests list as they are found. Return False if this is an invalid move.
    # Otherwise, return the string of the result of this move.
    if not isValidMove(x, y):
        return False

    smallestDistance = 100 # any chest will be closer than 100.
    for cx, cy in chests:
        if abs(cx - x) > abs(cy - y):
            distance = abs(cx - x)
        else:
            distance = abs(cy - y)

        if distance < smallestDistance: # we want the closest treasure chest.
            smallestDistance = distance

    if smallestDistance == 0:
        # xy is directly on a treasure chest!
        chests.remove([x, y])
        return 'You have found a sunken treasure chest!'
    else:
        if smallestDistance < 10:
            board[x][y] = str(smallestDistance)
            return 'Treasure detected at a distance of %s from the sonar device.' % (smallestDistance)
        else:
            board[x][y] = 'O'
            return 'Sonar did not detect anything. All treasure chests out of range.'


def enterPlayerMove():
    # Let the player type in her move. Return a two-item list of int xy coordinates.
    print('Where do you want to drop the next sonar device? (0-59 0-14) (or type quit)')
    while True:
        move = input()
        if move.lower() == 'quit':
            print('Thanks for playing!')
            sys.exit()

        move = move.split()
        if len(move) == 2 and move[0].isdigit() and move[1].isdigit() and isValidMove(int(move[0]), int(move[1])):
            return [int(move[0]), int(move[1])]
        print('Enter a number from 0 to 59, a space, then a number from 0 to 14.')


def playAgain():
    # This function returns True if the player wants to play again, otherwise it returns False.
    print('Do you want to play again? (yes or no)')
    return input().lower().startswith('y')


def showInstructions():
    print('''Instructions:
You are the captain of the Simon, a treasure-hunting ship. Your current mission
is to find the three sunken treasure chests that are lurking in the part of the
ocean you are in and collect them.

To play, enter the coordinates of the point in the ocean you wish to drop a
sonar device. The sonar can find out how far away the closest chest is to it.
For example, the d below marks where the device was dropped, and the 2's
represent distances of 2 away from the device. The 4's represent
distances of 4 away from the device.

    444444444
    4       4
    4 22222 4
    4 2   2 4
    4 2 d 2 4
    4 2   2 4
    4 22222 4
    4       4
    444444444
Press enter to continue...''')
    input()

    print('''For example, here is a treasure chest (the c) located a distance of 2 away
from the sonar device (the d):

    22222
    c   2
    2 d 2
    2   2
    22222

The point where the device was dropped will be marked with a 2.

The treasure chests don't move around. Sonar devices can detect treasure
chests up to a distance of 9. If all chests are out of range, the point
will be marked with O

If a device is directly dropped on a treasure chest, you have discovered
the location of the chest, and it will be collected. The sonar device will
remain there.

When you collect a chest, all sonar devices will update to locate the next
closest sunken treasure chest.
Press enter to continue...''')
    input()
    print()


print('S O N A R !')
print()
print('Would you like to view the instructions? (yes/no)')
if input().lower().startswith('y'):
    showInstructions()

while True:
    # game setup
    sonarDevices = 16
    theBoard = getNewBoard()
    theChests = getRandomChests(3)
    drawBoard(theBoard)
    previousMoves = []

    while sonarDevices > 0:
        # Start of a turn:

        # sonar device/chest status
        if sonarDevices > 1: extraSsonar = 's'
        else: extraSsonar = ''
        if len(theChests) > 1: extraSchest = 's'
        else: extraSchest = ''
        print('You have %s sonar device%s left. %s treasure chest%s remaining.' % (sonarDevices, extraSsonar, len(theChests), extraSchest))

        x, y = enterPlayerMove()
        previousMoves.append([x, y]) # we must track all moves so that sonar devices can be updated.

        moveResult = makeMove(theBoard, theChests, x, y)
        if moveResult == False:
            continue
        else:
            if moveResult == 'You have found a sunken treasure chest!':
                # update all the sonar devices currently on the map.
                for x, y in previousMoves:
                    makeMove(theBoard, theChests, x, y)
            drawBoard(theBoard)
            print(moveResult)

        if len(theChests) == 0:
            print('You have found all the sunken treasure chests! Congratulations and good game!')
            break

        sonarDevices -= 1

    if sonarDevices == 0:
        print('We\'ve run out of sonar devices! Now we have to turn the ship around and head')
        print('for home with treasure chests still out there! Game over.')
        print('    The remaining chests were here:')
        for x, y in theChests:
            print('    %s, %s' % (x, y))

    if not playAgain():
        sys.exit()

Python Game: GUI Russian Roulette

# Russian Roulette
#
# Based on visual basic code found at:
# http://www.vintage-basic.net/bcg/russianroulette.bas

from tkinter import *
import random
import time
 
#root window
root = Tk()

#window title
root.title("Russian Roulette")

#window geometry
root.geometry("400x875")

#variables
rannum = IntVar() # Holds an integer; default value 0

#random_answers
random_answers = ["BANG!!!!! YOU'RE DEAD!\nCONDOLENCES WILL BE SENT TO YOUR RELATIVES.",
                 "YOU WIN!!!!!\nLET SOMEONE ELSE BLOW HIS BRAINS OUT."]



L1 = Label(root, text = "RUSSIAN ROULETTE")
L1.pack()
L2 = Label(root, text = "CREATIVE COMPUTING\nMORRISTOWN, NEW JERSEY")
L2.pack()
L3 = Label(root, text = "THIS IS A GAME OF RUSSIAN ROULETTE.")
L3.pack()
L4 = Label(root, text = "HERE IS A REVOLVER.")
L4.pack()
L5 = Label(root, text = "SPIN CHAMBER AND PULL TRIGGER")
L5.pack()
L6 = Label(root, text = "OR GIVE UP?")
L6.pack()

def goodbye(): 
    root.destroy()

def gu():
    L7 = Label(root, foreground='black', background='yellow', text = "CHICKEN!!!!!")
    L7.pack()
    # Disable button so user can't click again
    b1.config(state="disabled")
    b2.config(state="disabled")
    button = Button (root, text="QUIT", command=goodbye)
    button.pack()
   

def sp():
    L8 = Label(root, text = "- CLICK -")
    L8.pack()
    answer_1 = Label(root, text=random.choice(random_answers))
    answer_1.pack()
    L9 = Label(root, text = "...NEXT VICTIM...")
    L9.pack()
    

b1 = Button(root,
            text="SPIN",
            command=sp)
b1.pack()

b2 = Button(root,
            text="GIVE UP",
            command=gu)
b2.pack()

root.mainloop()