Here is a game for 2 players played using an n-by-n grid drawn on paper.

Players take turns. On a turn a player writes any one integer, 1 to n, into any empty square of the grid.

After n^2 total turns, the game is over.

Player 1 gets the sum of the scores for each row. The score for a row is (the number of 1's in the row) * (the number of 2's in the row) * (the number of 3's in the row) *...(the number of m's in the row), where m is the largest integer such that all integers 1 through m occur in that row.

Player 2 gets the sum of the scores for each column. The score for a column is (the number of 1's in the column) * (the number of 2's in the column) * (the number of 3's in the column) *...(the number of m's in the column), where m is the largest integer such that all integers 1 through m occur in that column.

A player gets 1 point for a row/column if there are no 1's in that row/column.

The player with the largest score wins.

And example game:

1 1 2 1 2 5

1 3 2 1 3 5

5 1 1 1 3 1

1 2 1 2 1 2

2 1 1 2 1 1

2 3 5 3 4 1

Player 1 gets:

3*2 + 2*1*2 + 4 + 3*3 + 4*2 + 1*1*2*1*1

=

33 points.

Player 2 gets:

3*2 + 3*1*2 + 3*2 + 3*2*1 + 2*1*2*1 + 3*1

=

31 points.

Player 1 wins.

Thanks,

Leroy Quet

## Wednesday, August 17, 2011

### Binary Scramble Game

Here is a game for any plural number of players.

A list of 0's and 1's is written on a piece of paper by the players taking turns, each player appending a 0 or a 1 onto the right side of the list each turn. After a predetermined number of turns (which is a multiple of the number of players), the first part of this game is over.

In the second part of the game, the players take turns rewriting the entire list each turn with one digit the player chooses flipped from 0 to 1 or from 1 to 0.

The new list cannot match any list previously arrived at during the game.

If the lengths of the runs of 0's and 1's form a permutation of the lengths of the runs from any previous list, then the currently moving player gets a point.

(It doesn't matter if a particular run-length, an element in the permutation, was for a run of 0's or for a run of 1's.)

The game continues until either a player first achieves a predetermined score or until no more moves are possible.

The player with the greatest score wins.

Example game (to start):

001110101 (start: 2,3,1,1,1,1)

000110101 (3,2,1,1,1,1 point)

000111101 (3,4,1,1)

000011101 (4,3,1,1 point)

100011101 (1,3,3,1,1)

101011101 (1,1,1,1,3,1,1)

111011101 (3,1,3,1,1 point)

111010101 (3,1,1,1,1,1,1 point)

111010111 (3,1,1,1,3 point)

... etc.

Thanks,

Leroy Quet

A list of 0's and 1's is written on a piece of paper by the players taking turns, each player appending a 0 or a 1 onto the right side of the list each turn. After a predetermined number of turns (which is a multiple of the number of players), the first part of this game is over.

In the second part of the game, the players take turns rewriting the entire list each turn with one digit the player chooses flipped from 0 to 1 or from 1 to 0.

The new list cannot match any list previously arrived at during the game.

If the lengths of the runs of 0's and 1's form a permutation of the lengths of the runs from any previous list, then the currently moving player gets a point.

(It doesn't matter if a particular run-length, an element in the permutation, was for a run of 0's or for a run of 1's.)

The game continues until either a player first achieves a predetermined score or until no more moves are possible.

The player with the greatest score wins.

Example game (to start):

001110101 (start: 2,3,1,1,1,1)

000110101 (3,2,1,1,1,1 point)

000111101 (3,4,1,1)

000011101 (4,3,1,1 point)

100011101 (1,3,3,1,1)

101011101 (1,1,1,1,3,1,1)

111011101 (3,1,3,1,1 point)

111010101 (3,1,1,1,1,1,1 point)

111010111 (3,1,1,1,3 point)

... etc.

Thanks,

Leroy Quet

## Friday, July 22, 2011

### Combining And Dividing Integers Game

Here is a game for any plural number of players.

(And no grids!)

Players take turns, on each turn writing any positive integer to the end of a growing list of integers. The players do this until there is a predetermined number of integers in the list. (The number of integers is a multiple of the number of players.)

Players then take turns; on each turn a player rewrites the list with one of these changes:

Either:

The player changes one integer in the list to a product of any number of PROPER divisors, each divisor greater than 1, that all multiply to that integer. (The divisors must be placed between the same integers in the list as the integer they replaced, but they can be in any order amongst themselves between those integers.)

Or:

The player replaces two adjacent integers in the list with their sum. (The sum goes in the same location within the list as the two integers it replaces.)

The first player to get a list completely of primes is the winner.

If a large predetermined number of moves have taken place, and no one has yet won, then the game is a tie.

Example:

2 players:

List to start:

2, 4, 10, 4, 1, 10

P1:

2, 4, 2, 5, 4, 1, 10

P2:

2, 4, 2, 5, 5, 10

P1:

2, 6, 5, 5, 10

P2:

2, 6, 5, 15

P1:

2, 6, 20

P2:

8, 20

P1:

8, 4, 5

P2:

12, 5

P1:

2, 3, 2, 5

Player 1 wins.

Thanks,

Leroy Quet

(And no grids!)

Players take turns, on each turn writing any positive integer to the end of a growing list of integers. The players do this until there is a predetermined number of integers in the list. (The number of integers is a multiple of the number of players.)

Players then take turns; on each turn a player rewrites the list with one of these changes:

Either:

The player changes one integer in the list to a product of any number of PROPER divisors, each divisor greater than 1, that all multiply to that integer. (The divisors must be placed between the same integers in the list as the integer they replaced, but they can be in any order amongst themselves between those integers.)

Or:

The player replaces two adjacent integers in the list with their sum. (The sum goes in the same location within the list as the two integers it replaces.)

The first player to get a list completely of primes is the winner.

If a large predetermined number of moves have taken place, and no one has yet won, then the game is a tie.

Example:

2 players:

List to start:

2, 4, 10, 4, 1, 10

P1:

2, 4, 2, 5, 4, 1, 10

P2:

2, 4, 2, 5, 5, 10

P1:

2, 6, 5, 5, 10

P2:

2, 6, 5, 15

P1:

2, 6, 20

P2:

8, 20

P1:

8, 4, 5

P2:

12, 5

P1:

2, 3, 2, 5

Player 1 wins.

Thanks,

Leroy Quet

## Sunday, June 12, 2011

### Divisor Over Sums Game

Here is another game that uses an n-by-n grid drawn on paper.

This game is for 2 players.

Players take turns placing 1,2,3,... n^2 into empty squares of the grid, one number each turn.

(So, player 1 places the odd numbers into the grid, and player 2 places the evens.)

Let H represent the collection of variables h, where each h is the sum of a HORIZONTALLY-adjacent pair of integers in the grid.

Let V represent the collection of variables v, where each v is the sum of a VERTICALLY-adjacent pair of integers in the grid.

(So, H and V each consist of n*(n-1) variables.)

Player 1 then chooses a variable d which divides at least one of the h's.

Player 1 gets as a score:

d*(number of h's that are divisible by d)

Player 2 then chooses a variable d' which divides at least one of the v's.

Player 2 gets as a score:

d'*(number of v's that are divisible by d')

The player with the largest score wins.

For example, let us say two poorly-playing players have this n=4 grid:

08 09 01 10

03 11 16 07

02 14 15 05

04 12 06 13

H =

(17,10,11, 14,27,23,

16,29,20, 16,18,19)

Let us say that player 1 picks 4, then he gets 4*3 = 12 points.

(Because h's = 16, 20, and 16 are divisible by 4.)

Had he picked 29, he could have gotten 29, however.

V =

(11,5,6, 20,25,26,

17,31,21, 17,12,18)

Player 2 picks 3 and gets 3*4 = 12 points.

She should have picked 31.

Yes, you can always score at least n*(n-1) by picking d or d' = 1.

As implied in the example, a player is responsible for finding his/her own score.

Thanks,

Leroy Quet

This game is for 2 players.

Players take turns placing 1,2,3,... n^2 into empty squares of the grid, one number each turn.

(So, player 1 places the odd numbers into the grid, and player 2 places the evens.)

Let H represent the collection of variables h, where each h is the sum of a HORIZONTALLY-adjacent pair of integers in the grid.

Let V represent the collection of variables v, where each v is the sum of a VERTICALLY-adjacent pair of integers in the grid.

(So, H and V each consist of n*(n-1) variables.)

Player 1 then chooses a variable d which divides at least one of the h's.

Player 1 gets as a score:

d*(number of h's that are divisible by d)

Player 2 then chooses a variable d' which divides at least one of the v's.

Player 2 gets as a score:

d'*(number of v's that are divisible by d')

The player with the largest score wins.

For example, let us say two poorly-playing players have this n=4 grid:

08 09 01 10

03 11 16 07

02 14 15 05

04 12 06 13

H =

(17,10,11, 14,27,23,

16,29,20, 16,18,19)

Let us say that player 1 picks 4, then he gets 4*3 = 12 points.

(Because h's = 16, 20, and 16 are divisible by 4.)

Had he picked 29, he could have gotten 29, however.

V =

(11,5,6, 20,25,26,

17,31,21, 17,12,18)

Player 2 picks 3 and gets 3*4 = 12 points.

She should have picked 31.

Yes, you can always score at least n*(n-1) by picking d or d' = 1.

As implied in the example, a player is responsible for finding his/her own score.

Thanks,

Leroy Quet

## Saturday, June 4, 2011

### Palindromic Rows/Columns

This game is for 2 players.

Start by drawing an n-by-n grid on paper.

(Who would have guessed??)

The players take turns filling in empty squares of the grid, one square per move. Each player fills in floor(n^2/4) squares, so that there are a total of 2*floor(n^2/4) squares (about 1/2 of grid) filled in at game's end.

Player 1 gets as a score the number of grid-squares whose states need to be changed (from filled to unfilled, or vice versa) in order to make each ROW a palindrome.

Player 2 gets as a score the number of grid-squares whose states need to be changed in order to make each COLUMN a palindrome.

The player with the SMALLEST score wins.

{I know that the rules could have had Player 1 score with the number of squares needed to make the *columns* into palindromes, and Player 2 could have had the rows, then the *highest* score wins; but if each player attempts to determine their own score, then with my way each player has an incentive to be as efficient as possible in determining how many squares need to be changed to achieve the palindromes.}

Thanks,

Leroy Quet

Start by drawing an n-by-n grid on paper.

(Who would have guessed??)

The players take turns filling in empty squares of the grid, one square per move. Each player fills in floor(n^2/4) squares, so that there are a total of 2*floor(n^2/4) squares (about 1/2 of grid) filled in at game's end.

Player 1 gets as a score the number of grid-squares whose states need to be changed (from filled to unfilled, or vice versa) in order to make each ROW a palindrome.

Player 2 gets as a score the number of grid-squares whose states need to be changed in order to make each COLUMN a palindrome.

The player with the SMALLEST score wins.

{I know that the rules could have had Player 1 score with the number of squares needed to make the *columns* into palindromes, and Player 2 could have had the rows, then the *highest* score wins; but if each player attempts to determine their own score, then with my way each player has an incentive to be as efficient as possible in determining how many squares need to be changed to achieve the palindromes.}

Thanks,

Leroy Quet

## Thursday, May 12, 2011

### (Not)Divisors Or (Not)Multiples

This game is for any plural number of players.

Start with an n-by-n grid drawn on paper. (I suggest an n of at least 4 or 5 if there are two players who are beginners. I suggest a larger n if there are more players.)

The game starts with Player 1 placing any integer >=2 in any square of the grid.

Thereafter, the players take turns. On a turn a player places any integer >= 2 in any empty square that is adjacent to and above, below, left of, or right of any square with an integer in it already.

Each number must not have been used in the game yet.

And each number written down must be a divisor or a multiple of each preexisting number that is orthogonally (above, below, left of, right of) adjacent to it.

And each number written down must NOT be a divisor or a multiple of (may be coprime or not coprime to) each preexisting number that is diagonally adjacent to it.

The last player able to move wins.

Example finished game:

(n = 4. ** denotes an empty square. Leading 0's here are for formatting.)

** ** ** 15

** ** 10 05

08 04 02 **

** ** 06 03

Thanks,

Leroy Quet

Start with an n-by-n grid drawn on paper. (I suggest an n of at least 4 or 5 if there are two players who are beginners. I suggest a larger n if there are more players.)

The game starts with Player 1 placing any integer >=2 in any square of the grid.

Thereafter, the players take turns. On a turn a player places any integer >= 2 in any empty square that is adjacent to and above, below, left of, or right of any square with an integer in it already.

Each number must not have been used in the game yet.

And each number written down must be a divisor or a multiple of each preexisting number that is orthogonally (above, below, left of, right of) adjacent to it.

And each number written down must NOT be a divisor or a multiple of (may be coprime or not coprime to) each preexisting number that is diagonally adjacent to it.

The last player able to move wins.

Example finished game:

(n = 4. ** denotes an empty square. Leading 0's here are for formatting.)

** ** ** 15

** ** 10 05

08 04 02 **

** ** 06 03

Thanks,

Leroy Quet

## Saturday, May 7, 2011

### Plexus Via Midpoints And Endpoints

This is a game for two players.

Start with a lattice of n-by-n dots (which are the vertices of an (n-1)-by-(n-1)-squares grid). n is odd.

One of the players draw a straight line-segment from the middle dot of the lattice to any adjacent dot above, below, left of, or right of the central dot.

(It doesn't matter which direction this line-segment is drawn.)

The game consists of "full-moves", each of which consists of two "half-moves". In a full-move, one player moves then the other. The order of the players in the full-moves alternates.

So, we have the players moving like this:

(1,2),(2,1),(1,2),(2,1),(1,2),(2,1),...

In a full-move, the players each draw a straight line-segment from a dot already connected with another dot via a line-segment, to an adjacent dot (in the direction of either above, below, left of, or right of). The adjacent dot must have no line-segments yet connected with it.

The first player to move within a full-move decides if his/her line segment will be drawn from a dot already connected to 2 or 3 line-segments (a midpoint), or from a dot already connected to by exactly one line-segment (an endpoint).

The second player to move in the full-move must also draw his/her line-segment from a midpoint or from an endpoint just as the first player in the full-move did.

In other words, if the first player in the full-move draws from a midpoint, the second player must also draw from a midpoint. And if the first player drew from an endpoint, the second player must also draw from an endpoint.

(A player is free to decide which midpoint or endpoint to draw from, however, provided that the dot he/she draws to doesn't have any line segments connecting to it yet.)

If it is impossible for the second player in the full-move to do as the first player did (draw from midpoint or draw from endpoint), he/she loses his turn in this particular full-move, and the first player to move in that full-move then gets a point. (The second player still moves first in the next full-move, though.)

The game continues until all dots have each been connected with at least one line-segment.

The player with the largest score wins.

Thanks,

Leroy Quet

Start with a lattice of n-by-n dots (which are the vertices of an (n-1)-by-(n-1)-squares grid). n is odd.

One of the players draw a straight line-segment from the middle dot of the lattice to any adjacent dot above, below, left of, or right of the central dot.

(It doesn't matter which direction this line-segment is drawn.)

The game consists of "full-moves", each of which consists of two "half-moves". In a full-move, one player moves then the other. The order of the players in the full-moves alternates.

So, we have the players moving like this:

(1,2),(2,1),(1,2),(2,1),(1,2),(2,1),...

In a full-move, the players each draw a straight line-segment from a dot already connected with another dot via a line-segment, to an adjacent dot (in the direction of either above, below, left of, or right of). The adjacent dot must have no line-segments yet connected with it.

The first player to move within a full-move decides if his/her line segment will be drawn from a dot already connected to 2 or 3 line-segments (a midpoint), or from a dot already connected to by exactly one line-segment (an endpoint).

The second player to move in the full-move must also draw his/her line-segment from a midpoint or from an endpoint just as the first player in the full-move did.

In other words, if the first player in the full-move draws from a midpoint, the second player must also draw from a midpoint. And if the first player drew from an endpoint, the second player must also draw from an endpoint.

(A player is free to decide which midpoint or endpoint to draw from, however, provided that the dot he/she draws to doesn't have any line segments connecting to it yet.)

If it is impossible for the second player in the full-move to do as the first player did (draw from midpoint or draw from endpoint), he/she loses his turn in this particular full-move, and the first player to move in that full-move then gets a point. (The second player still moves first in the next full-move, though.)

The game continues until all dots have each been connected with at least one line-segment.

The player with the largest score wins.

Thanks,

Leroy Quet

## Tuesday, April 26, 2011

### Palindromes/Antipalindromes In Sequence

Game for 2 players.

Make a row of m squares drawn on paper, where m is decided by both players.

(I suggest that m be >= 16 for beginners.)

Players take turns. On a turn, a player places either a 0 or a 1 into any empty square.

After a total of m moves, and when each square has one digit in it, play is over.

Player 1 gets the sum of the lengths of all (not necessarily distinct but possibly overlapping*) palindromes

(a(1),a(2),a(3)...a(3),a(2),a(1))

of EVEN length (in the row of 0's and 1's) as her/his score.

Player 1's score =

sum{k=1 to [m/2]} 2k*(# of palindromes of length 2k).

Player 2 gets the sum of the lengths of all (not necessarily distinct but possibly overlapping*) antipalindromes

(a(1),a(2),a(3)...1-a(3),1-a(2),1-a(1))

(of even length) (in the row of 0's and 1's) as her/his score.

Player 2's score =

sum{k=1 to [m/2]} 2k*(# of antipalindromes of length 2k).

*(By "not necessarily distinct", I mean the patterns of 0's and 1's in different palindomes/antipalindromes may match. I of course don't mean the SAME palindrome/antipalindrome {in the same position and of the same length} can count more than once.)

The player with the largest score is the winner.

For example, let us say we have the following row (m=16):

1001001101000100

We have the following palindromes of even length:

00, 00, 11, 00, 00, 00

1001, 1001, 0110

So player 1 gets (2*6 + 4*3 =) 24 points.

We have the following antipalindromes:

10, 01, 10, 01, 10, 01, 10, 01, 10

0011, 1010

100110, 110100

01001101

So player 2 gets (2*9 + 4*2 + 6*2 + 1*8=) 46 points.

Player 2 wins.

(Did I make a mistake counting up the palindromes and antipalindromes in my example?)

I suggest, if this game isn't played on a computer, that players count their own (anti)palindromes, and confirm them with their opponent. (If a player misses any that would contribute to his/her own score, it would be his/her own fault.)

Thanks,

Leroy Quet

Make a row of m squares drawn on paper, where m is decided by both players.

(I suggest that m be >= 16 for beginners.)

Players take turns. On a turn, a player places either a 0 or a 1 into any empty square.

After a total of m moves, and when each square has one digit in it, play is over.

Player 1 gets the sum of the lengths of all (not necessarily distinct but possibly overlapping*) palindromes

(a(1),a(2),a(3)...a(3),a(2),a(1))

of EVEN length (in the row of 0's and 1's) as her/his score.

Player 1's score =

sum{k=1 to [m/2]} 2k*(# of palindromes of length 2k).

Player 2 gets the sum of the lengths of all (not necessarily distinct but possibly overlapping*) antipalindromes

(a(1),a(2),a(3)...1-a(3),1-a(2),1-a(1))

(of even length) (in the row of 0's and 1's) as her/his score.

Player 2's score =

sum{k=1 to [m/2]} 2k*(# of antipalindromes of length 2k).

*(By "not necessarily distinct", I mean the patterns of 0's and 1's in different palindomes/antipalindromes may match. I of course don't mean the SAME palindrome/antipalindrome {in the same position and of the same length} can count more than once.)

The player with the largest score is the winner.

For example, let us say we have the following row (m=16):

1001001101000100

We have the following palindromes of even length:

00, 00, 11, 00, 00, 00

1001, 1001, 0110

So player 1 gets (2*6 + 4*3 =) 24 points.

We have the following antipalindromes:

10, 01, 10, 01, 10, 01, 10, 01, 10

0011, 1010

100110, 110100

01001101

So player 2 gets (2*9 + 4*2 + 6*2 + 1*8=) 46 points.

Player 2 wins.

(Did I make a mistake counting up the palindromes and antipalindromes in my example?)

I suggest, if this game isn't played on a computer, that players count their own (anti)palindromes, and confirm them with their opponent. (If a player misses any that would contribute to his/her own score, it would be his/her own fault.)

Thanks,

Leroy Quet

## Friday, April 22, 2011

### Divisors/Multiples Sequence Game

Here is a game for any plural number of players.

r is a positive integer agreed upon by all players before the start of the game.

I suggest that r be congruent to 1 mod {the number of players}.

The game starts with a(1) = 1 and b(1) = 1. m and n both equal 1.

Players alternate moves.

(*)n=n+1.

(**)m=m+1.

A player on his move picks an integer a(m) that is either a divisor or a multiple of a(m-1).

a(m) must be <= r.

The player gets max(a(m),a(m-1))/min(a(m),a(m-1)) added to his score if a(m) is not among (b(1),b(2),...b(n-1)).

But the player gets

2*max(a(m),a(m-1))/min(a(m),a(m-1))

added to his score if a(m) is among (b(1),b(2),...b(n-1)).

The player continues his turn as far as he wants, but until a(m) is not amongst (b(1),b(2),...b(n-1)).

If the player is to continue his move, he goes to (**).

If a(m) is not among (b(1),b(2),...b(n-1)) and the player wants to end his move, then b(n) = a(m), and switch whose turn it is, go to (*) if n is < r.

Play until n = r, and (b(1),b(2),...b(n)) is a permutation of the integers 1 through r.

The winner is then the player with the LOWEST score.

Thanks,

Leroy Quet

r is a positive integer agreed upon by all players before the start of the game.

I suggest that r be congruent to 1 mod {the number of players}.

The game starts with a(1) = 1 and b(1) = 1. m and n both equal 1.

Players alternate moves.

(*)n=n+1.

(**)m=m+1.

A player on his move picks an integer a(m) that is either a divisor or a multiple of a(m-1).

a(m) must be <= r.

The player gets max(a(m),a(m-1))/min(a(m),a(m-1)) added to his score if a(m) is not among (b(1),b(2),...b(n-1)).

But the player gets

2*max(a(m),a(m-1))/min(a(m),a(m-1))

added to his score if a(m) is among (b(1),b(2),...b(n-1)).

The player continues his turn as far as he wants, but until a(m) is not amongst (b(1),b(2),...b(n-1)).

If the player is to continue his move, he goes to (**).

If a(m) is not among (b(1),b(2),...b(n-1)) and the player wants to end his move, then b(n) = a(m), and switch whose turn it is, go to (*) if n is < r.

Play until n = r, and (b(1),b(2),...b(n)) is a permutation of the integers 1 through r.

The winner is then the player with the LOWEST score.

Thanks,

Leroy Quet

## Saturday, April 9, 2011

### Sums Equal 1,2,3,...m In Small Grid

This can be considered both a puzzle and a solitaire game.

Make an n-by-n grid on paper. (I suggest that n = 3 for beginners.)

Fill the grid with UNIQUE positive integers, one integer per square of the grid. The numbers need not be consecutively valued necessarily.

Your score is the largest integer m such that integers 1 through m all occur as sums within the grid (without missing any positive integers <=m).

A "sum" is of any number of addends (possibly just 1) that are all *consecutively placed* within a row of the grid or a column of the grid. (No diagonals in this variation.)

So, for example, if we have the following 3-by-3 grid:

2 9 8

3 1 10

7 6 15

...the sums 1 through 19 all occur in this grid. So, I get a score of 19.

(Notice that some values of sums occur more than once.)

I bet it is easy to do better than I did with a 3-by-3 grid, since my grid is inefficient, and I didn't try too hard to find it.

(Note: There are 27 possible sums in a 3-by-3 grid of 1, 2, or 3 consecutively placed addends. I don't know what the largest possible score is for a 3-by-3 grid, though.)

You can "play" someone else by both of you trying to score as well as you can on same-sized grids. Just try to outscore your opponent.

Update: The largest score I personally received on the 3-by-3 grid is 20. But someone using a computer, I think, found a 3-by-3 grid with a score of 25.

Update2: Someone else found a 3-by-3 grid with a score of 26.

Thanks,

Leroy Quet

Make an n-by-n grid on paper. (I suggest that n = 3 for beginners.)

Fill the grid with UNIQUE positive integers, one integer per square of the grid. The numbers need not be consecutively valued necessarily.

Your score is the largest integer m such that integers 1 through m all occur as sums within the grid (without missing any positive integers <=m).

A "sum" is of any number of addends (possibly just 1) that are all *consecutively placed* within a row of the grid or a column of the grid. (No diagonals in this variation.)

So, for example, if we have the following 3-by-3 grid:

2 9 8

3 1 10

7 6 15

...the sums 1 through 19 all occur in this grid. So, I get a score of 19.

(Notice that some values of sums occur more than once.)

I bet it is easy to do better than I did with a 3-by-3 grid, since my grid is inefficient, and I didn't try too hard to find it.

(Note: There are 27 possible sums in a 3-by-3 grid of 1, 2, or 3 consecutively placed addends. I don't know what the largest possible score is for a 3-by-3 grid, though.)

You can "play" someone else by both of you trying to score as well as you can on same-sized grids. Just try to outscore your opponent.

Update: The largest score I personally received on the 3-by-3 grid is 20. But someone using a computer, I think, found a 3-by-3 grid with a score of 25.

Update2: Someone else found a 3-by-3 grid with a score of 26.

Thanks,

Leroy Quet

## Friday, April 1, 2011

### Multiples/Divisors Blob Game

This game is for 2 players.

Start with an n-by-n grid drawn on paper. (n should be at least 8, I suggest.)

The first player fills in any one of the grid's squares to start.

Thereafter, players continue to take turns each filling in one empty square each turn.

After the first move, each square that is filled in must be immediately next to (in the direction of above, below, left of, or right of) at least one square that is already filled in.

After both players have each filled in floor(n^2/4) squares (for 2*floor(n^2/4) squares filled in total), the game is over.

Player 1 gets as a score the number of ROWS of the grid meeting this condition: Every run-length (of runs each of either all filled in squares or all empty squares) in that particular row is either a multiple or divisor of every other run length in that row.

Player 2 gets as a score the number of COLUMNS of the grid meeting this condition: Every run-length (of runs each of either all filled in squares or all empty squares) in that particular column is either a multiple or divisor of every other run length in that column.

The player with the largest score wins.

Example: (n=12)

o o * o o o o o o o o o

o o * * o o * * o o o o

o o o * * o * * o * * *

o o o o * * * * * * o *

o o o * * * * o o * * *

o o o * o o * o * * * o

o * * * * * * * o o * o

o * o o * * o * * o * *

* * o o * * * * o o * *

* o o o * o o * * o * o

* * o * * * o o o * * *

o o o o o * * o * * * o

Run-lengths of rows:

(2,1,9)

(2,2,2,2,4) Point!

(3,2,1,2,1,3)

(4,6,1,1)

(3,4,2,3)

(3,1,2,1,1,3,1)

(1,7,2,1,1)

(1,1,2,2,1,2,1,2) Point!

(2,2,4,2,2) Point!

(1,3,1,2,2,1,1,1)

(2,1,3,3,3)

(5,2,1,3,1)

Run-lengths of columns:

(8,3,1)

(6,3,1,1,1) Point!

(2,4,1,5)

(1,2,1,3,3,1,1)

(2,3,1,5,1)

(3,2,1,3,1,2)

(1,6,1,1,2,1) Point!

(1,3,2,4,2)

(3,1,1,1,1,1,1,1,1,1) Point!

(2,4,4,2) Point!

(2,1,1,8) Point!

(2,3,2,2,1,1,1)

Player 2 wins, 5 to 3.

Thanks,

Leroy Quet

Start with an n-by-n grid drawn on paper. (n should be at least 8, I suggest.)

The first player fills in any one of the grid's squares to start.

Thereafter, players continue to take turns each filling in one empty square each turn.

After the first move, each square that is filled in must be immediately next to (in the direction of above, below, left of, or right of) at least one square that is already filled in.

After both players have each filled in floor(n^2/4) squares (for 2*floor(n^2/4) squares filled in total), the game is over.

Player 1 gets as a score the number of ROWS of the grid meeting this condition: Every run-length (of runs each of either all filled in squares or all empty squares) in that particular row is either a multiple or divisor of every other run length in that row.

Player 2 gets as a score the number of COLUMNS of the grid meeting this condition: Every run-length (of runs each of either all filled in squares or all empty squares) in that particular column is either a multiple or divisor of every other run length in that column.

The player with the largest score wins.

Example: (n=12)

o o * o o o o o o o o o

o o * * o o * * o o o o

o o o * * o * * o * * *

o o o o * * * * * * o *

o o o * * * * o o * * *

o o o * o o * o * * * o

o * * * * * * * o o * o

o * o o * * o * * o * *

* * o o * * * * o o * *

* o o o * o o * * o * o

* * o * * * o o o * * *

o o o o o * * o * * * o

Run-lengths of rows:

(2,1,9)

(2,2,2,2,4) Point!

(3,2,1,2,1,3)

(4,6,1,1)

(3,4,2,3)

(3,1,2,1,1,3,1)

(1,7,2,1,1)

(1,1,2,2,1,2,1,2) Point!

(2,2,4,2,2) Point!

(1,3,1,2,2,1,1,1)

(2,1,3,3,3)

(5,2,1,3,1)

Run-lengths of columns:

(8,3,1)

(6,3,1,1,1) Point!

(2,4,1,5)

(1,2,1,3,3,1,1)

(2,3,1,5,1)

(3,2,1,3,1,2)

(1,6,1,1,2,1) Point!

(1,3,2,4,2)

(3,1,1,1,1,1,1,1,1,1) Point!

(2,4,4,2) Point!

(2,1,1,8) Point!

(2,3,2,2,1,1,1)

Player 2 wins, 5 to 3.

Thanks,

Leroy Quet

## Monday, March 21, 2011

### Sum Kind Of Game

This is a game for two players.

Start with an n-by-n grid drawn on paper, where n is even.

Players take turns placing numbers into the empty grid squares, one number per move.

Player 1 places into the grid a 1 then a 2 then 3 then... then the value of n^2/2-1 then finally the value of n^2/2.

Player 2, on the other hand, goes the opposite way, placing into the grid the value of n^2/2 then the value of n^2/2-1 then... then 3 then a 2 and finally a 1.

Player 1 gets as a score the number of squares with integers S where each is the sum of the values in two different squares of the same ROW (same row as their sum S).

Player 2 gets as a score the number of squares with integers S where each is the sum of the values in two different squares of the same COLUMN (same column as their sum S).

(The addends can be the same value, but must be in different squares.)

It doesn't matter who wrote down each number as far as scoring is concerned.

Largest score wins.

Sample game: (n=6)

01 02 03 04 05 18

12 17 05 15 11 10

10 14 13 17 03 06

09 14 06 04 09 02

08 16 07 15 08 12

16 18 07 13 11 01

Player 1 gets for each row (top to bottom):

3, 2, 2, 1, 2, 1

11 points.

Player 2 gets for each column (left to right):

2, 2, 1, 1, 3, 2

11 points.

(I may have made a mistake or two figuring these out.)

A tie, if I didn't err.

----

Is there a bias in favor of one player in the game because strategies are different due to the two orders the numbers are placed into the grid?

Thanks,

Leroy Quet

Start with an n-by-n grid drawn on paper, where n is even.

Players take turns placing numbers into the empty grid squares, one number per move.

Player 1 places into the grid a 1 then a 2 then 3 then... then the value of n^2/2-1 then finally the value of n^2/2.

Player 2, on the other hand, goes the opposite way, placing into the grid the value of n^2/2 then the value of n^2/2-1 then... then 3 then a 2 and finally a 1.

Player 1 gets as a score the number of squares with integers S where each is the sum of the values in two different squares of the same ROW (same row as their sum S).

Player 2 gets as a score the number of squares with integers S where each is the sum of the values in two different squares of the same COLUMN (same column as their sum S).

(The addends can be the same value, but must be in different squares.)

It doesn't matter who wrote down each number as far as scoring is concerned.

Largest score wins.

Sample game: (n=6)

01 02 03 04 05 18

12 17 05 15 11 10

10 14 13 17 03 06

09 14 06 04 09 02

08 16 07 15 08 12

16 18 07 13 11 01

Player 1 gets for each row (top to bottom):

3, 2, 2, 1, 2, 1

11 points.

Player 2 gets for each column (left to right):

2, 2, 1, 1, 3, 2

11 points.

(I may have made a mistake or two figuring these out.)

A tie, if I didn't err.

----

Is there a bias in favor of one player in the game because strategies are different due to the two orders the numbers are placed into the grid?

Thanks,

Leroy Quet

## Saturday, March 12, 2011

### Flipping Bits/Squares

This game is for any plural number of players.

You need a blank piece of paper and a pen/pencil.

A predetermined number of rounds are played.

Start each round by making a row of n squares, where n is at least 7 or more if there are 2 players; n is larger if there are more players.

Fill in every other square.

Take turns.

On a turn a player can change any ONE square from filled in to not filled in, or vice versa.

Make a new row of squares to reflect the move.

A move may not lead to a pattern of how the squares are filled that has already existed in the round.

If all patterns achievable by changing one square (flipping one bit) lead to patterns that have already existed in the round, then a player flips two bits. If all patterns achievable by flipping two bits also lead to patterns that already occurred in the round, then flip three bits; etc.

A player MUST move with the fewest number of bits flipped as possible that will lead to a new pattern for the round.

As soon as a player achieves with their move a pattern with exactly one bit/square a different color (either filled or not filled) than the rest of the row, then that player gets {the number of squares from the left side of the row that is this unique square's position} added to his/her score.

The round is then over.

(So, one player scores each round.)

Play a predetermined number of rounds, adding up each player's scores.

The player with the largest grand total wins.

Example round: (n = 7)

(*)( )(*)( )(*)( )(*): start

(*)( )( )( )(*)( )(*): player 1

(*)( )( )( )(*)( )( ): player 2

(*)( )( )(*)(*)( )( ): player 1

(*)(*)( )(*)(*)( )( ): player 2

(*)(*)( )(*)(*)( )(*): player 1

(*)(*)(*)(*)(*)( )(*): player 2

Player 2 gets 6 points, since the blank square is the 6th square from the left.

(I wonder what the funnest n is for any given number of players, especially for 2 players.)

Thanks,

Leroy Quet

You need a blank piece of paper and a pen/pencil.

A predetermined number of rounds are played.

Start each round by making a row of n squares, where n is at least 7 or more if there are 2 players; n is larger if there are more players.

Fill in every other square.

Take turns.

On a turn a player can change any ONE square from filled in to not filled in, or vice versa.

Make a new row of squares to reflect the move.

A move may not lead to a pattern of how the squares are filled that has already existed in the round.

If all patterns achievable by changing one square (flipping one bit) lead to patterns that have already existed in the round, then a player flips two bits. If all patterns achievable by flipping two bits also lead to patterns that already occurred in the round, then flip three bits; etc.

A player MUST move with the fewest number of bits flipped as possible that will lead to a new pattern for the round.

As soon as a player achieves with their move a pattern with exactly one bit/square a different color (either filled or not filled) than the rest of the row, then that player gets {the number of squares from the left side of the row that is this unique square's position} added to his/her score.

The round is then over.

(So, one player scores each round.)

Play a predetermined number of rounds, adding up each player's scores.

The player with the largest grand total wins.

Example round: (n = 7)

(*)( )(*)( )(*)( )(*): start

(*)( )( )( )(*)( )(*): player 1

(*)( )( )( )(*)( )( ): player 2

(*)( )( )(*)(*)( )( ): player 1

(*)(*)( )(*)(*)( )( ): player 2

(*)(*)( )(*)(*)( )(*): player 1

(*)(*)(*)(*)(*)( )(*): player 2

Player 2 gets 6 points, since the blank square is the 6th square from the left.

(I wonder what the funnest n is for any given number of players, especially for 2 players.)

Thanks,

Leroy Quet

## Tuesday, February 22, 2011

### Another Binary Primes Game

This is a game for 2 players.

Draw a single column of n squares.

Players take turns. On a turn a player writes an x into any blank square. Each player makes a total of floor(n/4) x's, so about half the squares are filled at game's end.

A player's score equals the number of DISTINCT primes they can find whose binary representation is a substring in the columns, if each x is interpreted as a 1 and each blank square is interpreted as a 0. Player 1 finds binary primes written from top to bottom in the column, and player 2 finds primes written from bottom to top in the column.

Largest score wins.

Thanks,

Leroy Quet

Draw a single column of n squares.

Players take turns. On a turn a player writes an x into any blank square. Each player makes a total of floor(n/4) x's, so about half the squares are filled at game's end.

A player's score equals the number of DISTINCT primes they can find whose binary representation is a substring in the columns, if each x is interpreted as a 1 and each blank square is interpreted as a 0. Player 1 finds binary primes written from top to bottom in the column, and player 2 finds primes written from bottom to top in the column.

Largest score wins.

Thanks,

Leroy Quet

## Saturday, January 15, 2011

### Binary Primes Game

This is a game for two players.

Start by drawing an n-by-n grid on paper. (I don't suggest that n be too big, unless you are playing this game on a computer.)

n is odd. (Thanks to Ilmari Karonen for pointing out that a win can always be forced by player 2 if n is even {except for a likely small number of even exceptions}.)

The players take turn filling in squares, each player filling in one empty square per move.

Each player fills in floor(n^2/4) squares total.

(So, 2*floor(n^2/4) squares are filled in all together at the game's completion.)

Now, interpret the filled-in (black) squares and the blank (white) squares in each row and column as the digits of a binary number. In any particular row or column, either all the black squares represent a 0 or all of the black squares represent 1. And the white squares each equal the opposite binary digit than the black squares represent in that row/column. And the binary number can be read either top to bottom, or bottom to top (for each column), or left to right, or right to left (for each row).

So, to be clear, the binary digit (0 or 1) represented by a color has to remain the same within any particular row or column, but can differ between different rows and columns.

And the direction the binary number is read can differ between different rows and columns.

So, after the game is complete, the players go through and write down in two lists, one for the columns and one for the rows, the decimal representation of the largest possible PRIME possible, if any is possible, for each row and each column.

Player 1 gets as a score the product of all of the primes in the columns.

Player 2 gets as a score the product of all of the primes in the rows.

The player with the largest score wins.

Example (randomly "played" with no strategy):

n=6:

. * * . . *

* * . . . *

. * * * . .

. * * . . .

* . * * * .

. * . . * *

Largest primes, or 1 if all possibilities are composite or 1:

For columns:

1, 61, 29, 53, 3, 1.

Score =

61*29*53*3 = 281271.

For rows:

1, 1, 1, 1, 29, 19.

29*19 = 551.

Player 1 (columns) wins, obviously.

Thanks,

Leroy Quet

Start by drawing an n-by-n grid on paper. (I don't suggest that n be too big, unless you are playing this game on a computer.)

n is odd. (Thanks to Ilmari Karonen for pointing out that a win can always be forced by player 2 if n is even {except for a likely small number of even exceptions}.)

The players take turn filling in squares, each player filling in one empty square per move.

Each player fills in floor(n^2/4) squares total.

(So, 2*floor(n^2/4) squares are filled in all together at the game's completion.)

Now, interpret the filled-in (black) squares and the blank (white) squares in each row and column as the digits of a binary number. In any particular row or column, either all the black squares represent a 0 or all of the black squares represent 1. And the white squares each equal the opposite binary digit than the black squares represent in that row/column. And the binary number can be read either top to bottom, or bottom to top (for each column), or left to right, or right to left (for each row).

So, to be clear, the binary digit (0 or 1) represented by a color has to remain the same within any particular row or column, but can differ between different rows and columns.

And the direction the binary number is read can differ between different rows and columns.

So, after the game is complete, the players go through and write down in two lists, one for the columns and one for the rows, the decimal representation of the largest possible PRIME possible, if any is possible, for each row and each column.

Player 1 gets as a score the product of all of the primes in the columns.

Player 2 gets as a score the product of all of the primes in the rows.

The player with the largest score wins.

Example (randomly "played" with no strategy):

n=6:

. * * . . *

* * . . . *

. * * * . .

. * * . . .

* . * * * .

. * . . * *

Largest primes, or 1 if all possibilities are composite or 1:

For columns:

1, 61, 29, 53, 3, 1.

Score =

61*29*53*3 = 281271.

For rows:

1, 1, 1, 1, 29, 19.

29*19 = 551.

Player 1 (columns) wins, obviously.

Thanks,

Leroy Quet

Subscribe to:
Posts (Atom)