I am a fan of the professor Layton games. The games have a lot of puzzles, some of which are of the type that I believe that they can be solved by a program. The main candidate for this is the daily puzzles, puzzles that are designed to work even when there are many of the same type as opposed to being unique.
As such, I challenge you all to solve the puzzles.
"Bewitched"
You are given a 2d grid that represents a city block. Each cell in the grid can be either:
* An open street
* A street with a street lamp
* An obstacle (house/tree)
The goal is to find the configuration with the minimum number of lit lamps that:
* All streets (lamp or not) are lit
* No lit street lamp shines on another lit street lamp
Lamps light all streets in a plus shape, that is up, down, left and right, until blocked by either an obstacle or the edge of the map.
0=Open street
1=Obstacle
2=Lamp street
maps[0]=new Map(5,5, new <uint> [
0,1,0,2,0,
2,2,0,0,1,
0,0,1,0,2,
1,2,0,2,2,
0,0,2,1,0
]);
maps[1]=new Map(5,5, new <uint> [
0,2,0,2,2,
1,2,0,2,1,
0,2,1,2,2,
1,2,0,2,1,
2,2,2,2,2
]);
maps[2]=new Map(9,9,new <uint> [
1,2,0,2,0,2,0,2,1,
0,0,1,0,2,0,1,0,2,
2,1,2,0,2,1,2,2,0,
0,0,0,1,0,2,0,0,1,
0,2,1,0,0,0,1,0,0,
1,0,0,2,2,1,0,0,0,
0,0,2,1,0,2,2,1,2,
2,0,1,2,0,0,1,0,0,
1,2,0,0,2,0,0,2,1
]);
maps[3]=new Map(9,9,new <uint> [
2,0,1,2,2,1,2,0,2,
0,1,2,0,1,0,0,1,0,
0,1,0,1,0,2,0,1,0,
0,1,0,0,1,0,0,1,0,
0,0,2,2,0,2,2,0,0,
0,1,0,0,1,0,0,1,0,
0,1,2,2,0,1,0,1,0,
0,1,0,0,1,2,0,1,0,
2,0,2,1,2,0,1,2,2
]);
maps[4]=new Map(9,9,new <uint> [
1,2,1,1,2,1,1,2,2,
1,0,0,2,0,2,0,0,1,
0,2,1,0,1,0,1,0,1,
1,0,1,0,1,0,1,2,0,
1,0,2,0,0,0,0,2,1,
2,2,1,0,1,0,1,0,1,
1,0,1,2,1,0,1,0,2,
1,2,0,0,0,0,2,0,1,
2,0,1,1,2,1,1,2,1
]);
maps[5]=new Map(14,9,new <uint> [
2,0,1,2,0,0,2,1,0,2,1,0,2,1,
0,1,2,0,1,2,1,0,2,0,0,2,0,2,
2,0,2,1,0,2,2,2,1,0,1,0,1,0,
0,1,0,2,2,1,0,1,0,2,2,1,2,2,
1,0,2,1,0,0,2,2,2,0,1,2,0,1,
2,2,1,2,0,0,1,0,1,0,2,0,1,0,
0,1,2,1,0,1,0,2,2,0,1,2,0,2,
2,0,0,2,0,2,0,1,0,1,0,2,1,0,
1,2,0,1,2,0,1,0,2,0,2,1,2,2
]);
maps[6]=new Map(14,9,new <uint> [
0,0,2,0,2,0,0,1,0,0,2,0,0,2,
0,1,2,0,1,2,2,0,0,1,0,0,1,0,
2,0,1,1,2,0,2,1,2,0,1,0,2,2,
2,0,0,0,2,1,0,1,2,2,0,0,1,0,
1,0,2,1,1,0,0,0,0,1,1,2,0,1,
0,1,0,0,2,2,1,0,1,0,2,0,0,2,
2,0,2,1,0,0,1,0,2,0,1,1,0,2,
0,1,0,2,1,2,0,2,2,1,2,0,1,0,
2,0,0,0,2,0,1,2,0,0,0,2,0,0
]);
maps[7]=new Map(9,9,new <uint> [
0,0,2,0,0,0,0,0,0,
0,1,0,1,2,2,1,0,2,
2,0,0,2,0,1,1,1,0,
0,1,2,1,0,2,1,2,0,
2,0,0,2,0,2,0,0,0,
0,2,1,0,2,1,0,1,0,
0,1,1,1,2,0,0,0,2,
2,0,1,2,0,1,0,1,0,
0,2,0,0,0,0,2,0,0
]);
maps[8]=new Map(9,9,new <uint> [
2,0,1,0,2,2,0,0,2,
0,1,0,0,2,1,0,1,0,
2,0,2,1,0,0,0,2,2,
0,0,0,2,0,1,2,0,1,
2,1,2,0,1,0,2,1,0,
1,2,0,1,0,0,0,0,2,
0,0,2,0,2,1,0,2,2,
2,1,0,1,0,0,0,1,0,
2,0,2,0,2,2,1,2,2
]);
maps[9]=new Map(14,9,new <uint> [
2,0,1,2,1,0,2,0,2,0,1,2,0,2,
0,1,2,0,2,2,1,0,0,0,2,0,0,2,
2,0,2,1,0,1,0,0,2,1,0,0,1,0,
0,1,1,0,2,0,2,1,0,0,1,2,0,1,
0,2,0,2,0,1,0,2,1,2,2,0,0,2,
1,0,2,1,0,0,1,2,0,0,0,1,1,0,
0,1,2,2,1,2,0,0,1,0,1,0,2,2,
2,0,0,0,2,0,2,1,0,2,2,0,1,0,
0,0,2,1,0,2,0,2,0,1,0,1,2,0
]);
maps[10]=new Map(14,9,new <uint> [
0,2,0,0,0,2,1,2,0,0,2,0,0,2,
0,2,1,2,1,0,0,0,1,2,0,0,1,0,
0,1,2,0,0,1,2,0,0,1,2,1,2,0,
2,0,0,2,0,0,0,1,0,0,2,0,0,2,
1,2,0,1,0,0,2,0,2,0,1,0,2,1,
0,0,0,2,0,0,1,2,0,0,2,0,0,0,
2,0,1,0,1,0,2,0,1,2,0,0,1,0,
0,1,2,0,0,1,0,2,0,1,0,1,2,2,
0,0,2,0,2,0,0,1,0,0,2,0,0,2
]);
maps[11]=new Map(9,9,new <uint> [
1,2,0,1,2,0,0,2,1,
2,0,0,2,0,0,1,0,0,
0,1,0,0,2,1,0,1,2,
1,0,2,1,0,0,2,0,2,
2,0,1,0,1,2,1,2,0,
0,2,0,2,0,1,0,0,1,
0,1,2,1,2,0,2,1,0,
2,0,1,2,0,0,0,2,2,
1,2,0,0,2,1,2,0,1,
]);
maps[12]=new Map(9,9,new <uint> [
1,2,0,0,1,0,2,0,1,
0,0,0,2,0,0,2,0,0,
1,0,1,0,2,2,1,0,1,
0,2,2,1,0,1,2,2,0,
0,1,2,0,1,2,0,1,0,
2,2,2,1,0,1,0,2,2,
1,0,1,0,0,2,1,0,1,
0,2,0,2,2,0,2,0,0,
1,2,0,0,1,2,0,2,1
]);
maps[13]=new Map(14,9,new <uint> [
1,0,2,0,2,1,2,0,0,1,2,2,2,2,
2,0,0,1,0,2,2,1,0,0,2,0,1,0,
0,1,0,2,2,2,1,2,0,0,1,0,0,0,
0,0,0,0,1,2,2,2,1,2,2,2,0,0,
1,0,1,2,2,2,2,2,2,2,2,1,0,1,
2,2,2,2,2,1,2,2,2,1,2,2,2,0,
2,0,0,1,0,0,2,1,0,0,0,0,1,2,
0,1,0,0,2,0,1,0,0,2,1,0,2,0,
0,0,2,0,1,0,0,2,1,0,0,2,0,1
]);
maps[14]=new Map(14,9,new <uint> [
2,0,2,0,0,2,0,0,0,0,0,0,0,0,
0,0,0,0,2,0,1,0,0,0,0,2,0,2,
0,2,0,1,0,2,0,0,0,0,0,0,1,0,
1,0,0,0,1,0,0,0,0,1,0,0,0,2,
0,2,0,2,0,2,0,2,0,2,0,2,0,0,
2,0,2,0,1,0,0,0,0,0,0,0,2,1,
0,1,0,0,0,2,0,0,2,0,1,2,0,2,
2,0,2,0,2,0,2,1,0,2,0,0,2,0,
0,2,0,2,0,2,0,0,2,0,0,2,0,2
]);
maps[15]=new Map(14,9,new <uint> [
1,0,1,0,2,0,2,0,0,2,0,0,0,2,
0,2,2,0,1,2,1,0,1,0,1,2,1,0,
0,1,0,2,0,0,0,0,1,0,1,0,1,2,
2,2,0,2,1,0,1,2,1,0,2,0,2,0,
1,0,1,0,2,0,2,0,2,0,0,1,0,1,
0,2,0,2,0,1,0,1,0,1,0,2,0,2,
2,1,0,1,2,1,0,2,0,0,2,0,1,2,
0,1,0,1,0,1,0,1,2,1,0,0,0,0,
2,0,2,0,0,2,0,0,0,2,0,1,2,1
]);
maps[16]=new Map(9,9,new <uint> [
2,0,0,0,2,1,0,0,2,
0,1,0,2,0,1,0,2,0,
0,0,2,0,0,0,2,0,2,
0,2,1,0,0,2,0,0,1,
2,1,2,0,2,0,0,1,0,
1,2,0,0,0,2,1,0,2,
2,0,0,0,0,0,2,0,0,
0,0,0,1,0,2,0,1,0,
0,0,0,1,2,0,0,0,2
]);
maps[17]=new Map(14,9,new <uint> [
1,1,2,0,2,0,0,1,2,0,0,0,1,1,
0,1,0,1,0,0,2,2,0,1,0,2,2,1,
2,0,2,0,0,1,2,0,0,0,1,2,0,0,
0,0,1,0,0,2,1,0,0,2,2,0,0,2,
1,2,0,0,1,0,0,2,2,1,2,0,2,1,
2,0,0,2,0,0,2,1,0,0,0,1,0,2,
2,0,0,1,0,2,0,2,1,2,0,2,0,2,
1,2,2,0,1,0,0,0,2,0,1,0,1,0,
1,1,2,0,0,2,1,2,0,0,0,2,1,1
]);
"Alchemy":
You are given a 2d grid. On the grid are flasks. Each flask is labeled with a number.
Flasks can be connected on empty cells in the grid using straight, non crossing lines. Each connection can be done using one or two pipes. Connections can not cross each other.
The number on each flask is the number of pipes connecting it to the other flasks.
The goal is to connect all the flasks into one graph. That means that any flask should be reachable by any other flask.
40603
00010
40300
00001
20020
30200
01003
50400
00000
20303
300005003
003040020
000002003
200000000
004080040
000000000
203001003
000000000
304020102
30500203000403
01000000303000
00301002020100
30010200303003
02004003050020
00200300300103
20000000003030
00303010200000
30030503003003
"Fiefdoms"
You are given a 2d grid that represents a small country. On the grid are castles.
Each castle has a number on it. The number represents the area that it controls.
The goal is to create rectangular, non overlapping, regions with an area so that the single castle in each region has an area exactly matching the number on the castle.
Castles with numbers larger than 9 continue using hexadecimal digits.
90002
00000
00000
00000
60008
06600400
00000002
00004000
25000000
00000046
00050000
30000000
00400A30
500005000800
005080000020
000000090000
060000000004
300000000080
006000000000
030000060300
005000600004
"Ghouls"
You are given a 2d grid. Along the borders of the grid are guards and ghouls. Ghouls and Guards are color coded, there is only one each of each color. The inside of the grid is split into regions.
Each region contains one mirror. Mirrors are angled at a perfect 45 degrees angle. Each guard emits a beam towards the grid. The beam reflects at a 90 degrees angle when it hits a mirror. Both sides of a mirror may reflect a beam.
The goal is to reflect the beams so that they hit the matching ghoul in exactly the number of bounces marked on the ghoul.
0A00B0
01122B
D11220
03344A
B33440
00CD00
A=1
B=1
C=1
D=1
0ABBD0
011220
C13320
04335D
04455A
000C00
A=1
B=2
C=1
D=1
0ABCDEFG0H00
011233455660
07723345566I
I8722995aaaH
D888b99ccdaJ
0eebbfggcddB
CeebbfggchhK
0G0AE00JK0F0
A=2
B=1
C=3
D=1
E=4
F=2
G=2
H=1
I=2
J=3
K=5
"Ducklings"
You are given a 2d grid. On the grid are ducklings and their mothers.
The each grid cell contains one of:
* Empty
* Obstacle
* Mother duck
* Numbered duckling
The goal is to form chains consisting of a mother duck followed by four ducklings. You may place additional ducks to do so.
Mothers look in the direction opposite from the location of the first duckling of the chain. Mothers must not see any other chain.
Chains may not touch, diagonals don't count.
000002
0XX0M0
0M0X00
00X0M0
300XX0
00M000
X00MXM00X
010000X00
3X0X0X000
00X040X00
X00MX000X
00X000X00
000X0XMXM
00X0M0020
X030X000X
0X00M002000000
0010000XX00002
40000000000000
000X00X0010MX0
X020000000X000
4000040X000000
0000000X000000
4X0000300X000X
00000000X40004
Whose Tile Is It Anyway? ("Whose Tile" for short)
You are given a grid with open and closed cells and a set of blocks.
All blocks are straight lines. The blocks may be rotated on 90 degree angles.
Each block is composed of colored cells and align with the grid when placed in the grid.
The goal is to position all the blocks inside the open cells of the grid so that all overlapping parts of the blocks have the same color as the corresponding position of the other blocks.
Zero indicates open cells and ones indicate closed cells.
00000
01011
00000
01101
00001
BBBBB
RRRR
BBBRR
BBB
BRBRB
RRR
01000010
00011000
01000010
01011010
00000000
01110101
RBYGRBYG
RGBG
RBRBRB
YBYB
YYRGY
BYG
RGYRG
BYY
BBGGB
RB
YR
00000010
01010110
01000000
00010110
01100000
00001110
RRBBBR
BYGO
RRRGGG
GYBR
GGGYYY
GGO
BBYYGY
BR
BGGGO
BOOOG
000000
101010
000010
101000
001101
100000
RBYGYR
RBBY
BGRBYO
GYBR
OBGYR
GRYB
RBY
BGY
BY
01000001
00010110
10100000
00001010
10100010
00001000
GGPOY
YOBY
BYRPO
YROY
GGPGO
GOGO
GPGOG
GYGY
YBY
PBP
OBO
GBG
OY
GY
00000000
10101010
00001010
01010000
01010110
00000000
YYBRGYBR
GYGY
GYBRGYBB
GYRR
BRGYBR
YGGY
RRYB
GGYY
YBY
GBG
RBR
