qbit/go
1
0
Fork 0
mirror of https://github.com/golang/go synced 2024-11-25 10:57:58 -07:00
Code Releases Activity

meteor-contest

Browse Source 
R=rsc
DELTA=1276  (1275 added, 0 deleted, 1 changed)
OCL=32851
CL=32854
This commit is contained in:
Rob Pike 2009-08-06 18:04:48 -07:00
parent 2b87d95f01
commit 7655588438
5 changed files with 1334 additions and 1 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

626
test/bench/meteor-contest.c Normal file
View File

@ -0,0 +1,626 @@
/*
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
* Neither the name of "The Computer Language Benchmarks Game" nor the
name of "The Computer Language Shootout Benchmarks" nor the names of
its contributors may be used to endorse or promote products derived
from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.
*/
/* The Computer Language Benchmarks Game
* http://shootout.alioth.debian.org/
*
* contributed by Christian Vosteen
*/
#include <stdlib.h>
#include <stdio.h>
#define TRUE 1
#define FALSE 0
/* The board is a 50 cell hexagonal pattern. For . . . . .
* maximum speed the board will be implemented as . . . . .
* 50 bits, which will fit into a 64 bit long long . . . . .
* int. . . . . .
* . . . . .
* I will represent 0's as empty cells and 1's . . . . .
* as full cells. . . . . .
* . . . . .
* . . . . .
* . . . . .
*/
unsigned long long board = 0xFFFC000000000000ULL;
/* The puzzle pieces must be specified by the path followed
* from one end to the other along 12 hexagonal directions.
*
* Piece 0 Piece 1 Piece 2 Piece 3 Piece 4
*
* 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
*
* Piece 5 Piece 6 Piece 7 Piece 8 Piece 9
*
* 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
*
* I had to make it 12 directions because I wanted all of the
* piece definitions to fit into the same size arrays. It is
* not possible to define piece 4 in terms of the 6 cardinal
* directions in 4 moves.
*/
#define E 0
#define ESE 1
#define SE 2
#define S 3
#define SW 4
#define WSW 5
#define W 6
#define WNW 7
#define NW 8
#define N 9
#define NE 10
#define ENE 11
#define PIVOT 12
char piece_def[10][4] = {
{ E, E, E, SE},
{ SE, E, NE, E},
{ E, E, SE, SW},
{ E, E, SW, SE},
{ SE, E, NE, S},
{ E, E, SW, E},
{ E, SE, SE, NE},
{ E, SE, SE, W},
{ E, SE, E, E},
{ E, E, E, SW}
};
/* To minimize the amount of work done in the recursive solve function below,
* I'm going to allocate enough space for all legal rotations of each piece
* at each position on the board. That's 10 pieces x 50 board positions x
* 12 rotations. However, not all 12 rotations will fit on every cell, so
* I'll have to keep count of the actual number that do.
* The pieces are going to be unsigned long long ints just like the board so
* they can be bitwise-anded with the board to determine if they fit.
* I'm also going to record the next possible open cell for each piece and
* location to reduce the burden on the solve function.
*/
unsigned long long pieces[10][50][12];
int piece_counts[10][50];
char next_cell[10][50][12];
/* Returns the direction rotated 60 degrees clockwise */
char rotate(char dir) {
return (dir + 2) % PIVOT;
}
/* Returns the direction flipped on the horizontal axis */
char flip(char dir) {
return (PIVOT - dir) % PIVOT;
}
/* Returns the new cell index from the specified cell in the
* specified direction. The index is only valid if the
* starting cell and direction have been checked by the
* out_of_bounds function first.
*/
char shift(char cell, char dir) {
switch(dir) {
case E:
return cell + 1;
case ESE:
if((cell / 5) % 2)
return cell + 7;
else
return cell + 6;
case SE:
if((cell / 5) % 2)
return cell + 6;
else
return cell + 5;
case S:
return cell + 10;
case SW:
if((cell / 5) % 2)
return cell + 5;
else
return cell + 4;
case WSW:
if((cell / 5) % 2)
return cell + 4;
else
return cell + 3;
case W:
return cell - 1;
case WNW:
if((cell / 5) % 2)
return cell - 6;
else
return cell - 7;
case NW:
if((cell / 5) % 2)
return cell - 5;
else
return cell - 6;
case N:
return cell - 10;
case NE:
if((cell / 5) % 2)
return cell - 4;
else
return cell - 5;
case ENE:
if((cell / 5) % 2)
return cell - 3;
else
return cell - 4;
default:
return cell;
}
}
/* Returns wether the specified cell and direction will land outside
* of the board. Used to determine if a piece is at a legal board
* location or not.
*/
char out_of_bounds(char cell, char dir) {
char i;
switch(dir) {
case E:
return cell % 5 == 4;
case ESE:
i = cell % 10;
return i == 4 || i == 8 || i == 9 || cell >= 45;
case SE:
return cell % 10 == 9 || cell >= 45;
case S:
return cell >= 40;
case SW:
return cell % 10 == 0 || cell >= 45;
case WSW:
i = cell % 10;
return i == 0 || i == 1 || i == 5 || cell >= 45;
case W:
return cell % 5 == 0;
case WNW:
i = cell % 10;
return i == 0 || i == 1 || i == 5 || cell < 5;
case NW:
return cell % 10 == 0 || cell < 5;
case N:
return cell < 10;
case NE:
return cell % 10 == 9 || cell < 5;
case ENE:
i = cell % 10;
return i == 4 || i == 8 || i == 9 || cell < 5;
default:
return FALSE;
}
}
/* Rotate a piece 60 degrees clockwise */
void rotate_piece(int piece) {
int i;
for(i = 0; i < 4; i++)
piece_def[piece][i] = rotate(piece_def[piece][i]);
}
/* Flip a piece along the horizontal axis */
void flip_piece(int piece) {
int i;
for(i = 0; i < 4; i++)
piece_def[piece][i] = flip(piece_def[piece][i]);
}
/* Convenience function to quickly calculate all of the indices for a piece */
void calc_cell_indices(char *cell, int piece, char index) {
cell[0] = index;
cell[1] = shift(cell[0], piece_def[piece][0]);
cell[2] = shift(cell[1], piece_def[piece][1]);
cell[3] = shift(cell[2], piece_def[piece][2]);
cell[4] = shift(cell[3], piece_def[piece][3]);
}
/* Convenience function to quickly calculate if a piece fits on the board */
int cells_fit_on_board(char *cell, int piece) {
return (!out_of_bounds(cell[0], piece_def[piece][0]) &&
!out_of_bounds(cell[1], piece_def[piece][1]) &&
!out_of_bounds(cell[2], piece_def[piece][2]) &&
!out_of_bounds(cell[3], piece_def[piece][3]));
}
/* Returns the lowest index of the cells of a piece.
* I use the lowest index that a piece occupies as the index for looking up
* the piece in the solve function.
*/
char minimum_of_cells(char *cell) {
char minimum = cell[0];
minimum = cell[1] < minimum ? cell[1] : minimum;
minimum = cell[2] < minimum ? cell[2] : minimum;
minimum = cell[3] < minimum ? cell[3] : minimum;
minimum = cell[4] < minimum ? cell[4] : minimum;
return minimum;
}
/* Calculate the lowest possible open cell if the piece is placed on the board.
* Used to later reduce the amount of time searching for open cells in the
* solve function.
*/
char first_empty_cell(char *cell, char minimum) {
char first_empty = minimum;
while(first_empty == cell[0] || first_empty == cell[1] ||
first_empty == cell[2] || first_empty == cell[3] ||
first_empty == cell[4])
first_empty++;
return first_empty;
}
/* Generate the unsigned long long int that will later be anded with the
* board to determine if it fits.
*/
unsigned long long bitmask_from_cells(char *cell) {
unsigned long long piece_mask = 0ULL;
int i;
for(i = 0; i < 5; i++)
piece_mask |= 1ULL << cell[i];
return piece_mask;
}
/* Record the piece and other important information in arrays that will
* later be used by the solve function.
*/
void record_piece(int piece, int minimum, char first_empty,
unsigned long long piece_mask) {
pieces[piece][minimum][piece_counts[piece][minimum]] = piece_mask;
next_cell[piece][minimum][piece_counts[piece][minimum]] = first_empty;
piece_counts[piece][minimum]++;
}
/* Fill the entire board going cell by cell. If any cells are "trapped"
* they will be left alone.
*/
void fill_contiguous_space(char *board, int index) {
if(board[index] == 1)
return;
board[index] = 1;
if(!out_of_bounds(index, E))
fill_contiguous_space(board, shift(index, E));
if(!out_of_bounds(index, SE))
fill_contiguous_space(board, shift(index, SE));
if(!out_of_bounds(index, SW))
fill_contiguous_space(board, shift(index, SW));
if(!out_of_bounds(index, W))
fill_contiguous_space(board, shift(index, W));
if(!out_of_bounds(index, NW))
fill_contiguous_space(board, shift(index, NW));
if(!out_of_bounds(index, NE))
fill_contiguous_space(board, shift(index, NE));
}
/* To thin the number of pieces, I calculate if any of them trap any empty
* cells at the edges. There are only a handful of exceptions where the
* the board can be solved with the trapped cells. For example: piece 8 can
* trap 5 cells in the corner, but piece 3 can fit in those cells, or piece 0
* can split the board in half where both halves are viable.
*/
int has_island(char *cell, int piece) {
char temp_board[50];
char c;
int i;
for(i = 0; i < 50; i++)
temp_board[i] = 0;
for(i = 0; i < 5; i++)
temp_board[((int)cell[i])] = 1;
i = 49;
while(temp_board[i] == 1)
i--;
fill_contiguous_space(temp_board, i);
c = 0;
for(i = 0; i < 50; i++)
if(temp_board[i] == 0)
c++;
if(c == 0 || (c == 5 && piece == 8) || (c == 40 && piece == 8) ||
(c % 5 == 0 && piece == 0))
return FALSE;
else
return TRUE;
}
/* Calculate all six rotations of the specified piece at the specified index.
* We calculate only half of piece 3's rotations. This is because any solution
* found has an identical solution rotated 180 degrees. Thus we can reduce the
* number of attempted pieces in the solve algorithm by not including the 180-
* degree-rotated pieces of ONE of the pieces. I chose piece 3 because it gave
* me the best time ;)
*/
void calc_six_rotations(char piece, char index) {
char rotation, cell[5];
char minimum, first_empty;
unsigned long long piece_mask;
for(rotation = 0; rotation < 6; rotation++) {
if(piece != 3 || rotation < 3) {
calc_cell_indices(cell, piece, index);
if(cells_fit_on_board(cell, piece) && !has_island(cell, piece)) {
minimum = minimum_of_cells(cell);
first_empty = first_empty_cell(cell, minimum);
piece_mask = bitmask_from_cells(cell);
record_piece(piece, minimum, first_empty, piece_mask);
}
}
rotate_piece(piece);
}
}
/* Calculate every legal rotation for each piece at each board location. */
void calc_pieces(void) {
char piece, index;
for(piece = 0; piece < 10; piece++) {
for(index = 0; index < 50; index++) {
calc_six_rotations(piece, index);
flip_piece(piece);
calc_six_rotations(piece, index);
}
}
}
/* Calculate all 32 possible states for a 5-bit row and all rows that will
* create islands that follow any of the 32 possible rows. These pre-
* calculated 5-bit rows will be used to find islands in a partially solved
* board in the solve function.
*/
#define ROW_MASK 0x1F
#define TRIPLE_MASK 0x7FFF
char all_rows[32] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31};
int bad_even_rows[32][32];
int bad_odd_rows[32][32];
int bad_even_triple[32768];
int bad_odd_triple[32768];
int rows_bad(char row1, char row2, int even) {
/* even is referring to row1 */
int i, in_zeroes, group_okay;
char block, row2_shift;
/* Test for blockages at same index and shifted index */
if(even)
row2_shift = ((row2 << 1) & ROW_MASK) | 0x01;
else
row2_shift = (row2 >> 1) | 0x10;
block = ((row1 ^ row2) & row2) & ((row1 ^ row2_shift) & row2_shift);
/* Test for groups of 0's */
in_zeroes = FALSE;
group_okay = FALSE;
for(i = 0; i < 5; i++) {
if(row1 & (1 << i)) {
if(in_zeroes) {
if(!group_okay)
return TRUE;
in_zeroes = FALSE;
group_okay = FALSE;
}
} else {
if(!in_zeroes)
in_zeroes = TRUE;
if(!(block & (1 << i)))
group_okay = TRUE;
}
}
if(in_zeroes)
return !group_okay;
else
return FALSE;
}
/* Check for cases where three rows checked sequentially cause a false
* positive. One scenario is when 5 cells may be surrounded where piece 5
* or 7 can fit. The other scenario is when piece 2 creates a hook shape.
*/
int triple_is_okay(char row1, char row2, char row3, int even) {
if(even) {
/* There are four cases:
* row1: 00011 00001 11001 10101
* row2: 01011 00101 10001 10001
* row3: 011?? 00110 ????? ?????
*/
return ((row1 == 0x03) && (row2 == 0x0B) && ((row3 & 0x1C) == 0x0C)) ||
((row1 == 0x01) && (row2 == 0x05) && (row3 == 0x06)) ||
((row1 == 0x19) && (row2 == 0x11)) ||
((row1 == 0x15) && (row2 == 0x11));
} else {
/* There are two cases:
* row1: 10011 10101
* row2: 10001 10001
* row3: ????? ?????
*/
return ((row1 == 0x13) && (row2 == 0x11)) ||
((row1 == 0x15) && (row2 == 0x11));
}
}
void calc_rows(void) {
int row1, row2, row3;
int result1, result2;
for(row1 = 0; row1 < 32; row1++) {
for(row2 = 0; row2 < 32; row2++) {
bad_even_rows[row1][row2] = rows_bad(row1, row2, TRUE);
bad_odd_rows[row1][row2] = rows_bad(row1, row2, FALSE);
}
}
for(row1 = 0; row1 < 32; row1++) {
for(row2 = 0; row2 < 32; row2++) {
for(row3 = 0; row3 < 32; row3++) {
result1 = bad_even_rows[row1][row2];
result2 = bad_odd_rows[row2][row3];
if(result1 == FALSE && result2 == TRUE
&& triple_is_okay(row1, row2, row3, TRUE))
bad_even_triple[row1+(row2*32)+(row3*1024)] = FALSE;
else
bad_even_triple[row1+(row2*32)+(row3*1024)] = result1 || result2;
result1 = bad_odd_rows[row1][row2];
result2 = bad_even_rows[row2][row3];
if(result1 == FALSE && result2 == TRUE
&& triple_is_okay(row1, row2, row3, FALSE))
bad_odd_triple[row1+(row2*32)+(row3*1024)] = FALSE;
else
bad_odd_triple[row1+(row2*32)+(row3*1024)] = result1 || result2;
}
}
}
}
/* Calculate islands while solving the board.
*/
int boardHasIslands(char cell) {
/* Too low on board, don't bother checking */
if(cell >= 40)
return FALSE;
int current_triple = (board >> ((cell / 5) * 5)) & TRIPLE_MASK;
if((cell / 5) % 2)
return bad_odd_triple[current_triple];
else
return bad_even_triple[current_triple];
}
/* The recursive solve algorithm. Try to place each permutation in the upper-
* leftmost empty cell. Mark off available pieces as it goes along.
* Because the board is a bit mask, the piece number and bit mask must be saved
* at each successful piece placement. This data is used to create a 50 char
* array if a solution is found.
*/
short avail = 0x03FF;
char sol_nums[10];
unsigned long long sol_masks[10];
signed char solutions[2100][50];
int solution_count = 0;
int max_solutions = 2100;
void record_solution(void) {
int sol_no, index;
unsigned long long sol_mask;
for(sol_no = 0; sol_no < 10; sol_no++) {
sol_mask = sol_masks[sol_no];
for(index = 0; index < 50; index++) {
if(sol_mask & 1ULL) {
solutions[solution_count][index] = sol_nums[sol_no];
/* Board rotated 180 degrees is a solution too! */
solutions[solution_count+1][49-index] = sol_nums[sol_no];
}
sol_mask = sol_mask >> 1;
}
}
solution_count += 2;
}
void solve(int depth, int cell) {
int piece, rotation, max_rots;
unsigned long long *piece_mask;
short piece_no_mask;
if(solution_count >= max_solutions)
return;
while(board & (1ULL << cell))
cell++;
for(piece = 0; piece < 10; piece++) {
piece_no_mask = 1 << piece;
if(!(avail & piece_no_mask))
continue;
avail ^= piece_no_mask;
max_rots = piece_counts[piece][cell];
piece_mask = pieces[piece][cell];
for(rotation = 0; rotation < max_rots; rotation++) {
if(!(board & *(piece_mask + rotation))) {
sol_nums[depth] = piece;
sol_masks[depth] = *(piece_mask + rotation);
if(depth == 9) {
/* Solution found!!!!!11!!ONE! */
record_solution();
avail ^= piece_no_mask;
return;
}
board |= *(piece_mask + rotation);
if(!boardHasIslands(next_cell[piece][cell][rotation]))
solve(depth + 1, next_cell[piece][cell][rotation]);
board ^= *(piece_mask + rotation);
}
}
avail ^= piece_no_mask;
}
}
/* qsort comparator - used to find first and last solutions */
int solution_sort(const void *elem1, const void *elem2) {
signed char *char1 = (signed char *) elem1;
signed char *char2 = (signed char *) elem2;
int i = 0;
while(i < 50 && char1[i] == char2[i])
i++;
return char1[i] - char2[i];
}
/* pretty print a board in the specified hexagonal format */
void pretty(signed char *b) {
int i;
for(i = 0; i < 50; i += 10) {
printf("%c %c %c %c %c \n %c %c %c %c %c \n", b[i]+'0', b[i+1]+'0',
b[i+2]+'0', b[i+3]+'0', b[i+4]+'0', b[i+5]+'0', b[i+6]+'0',
b[i+7]+'0', b[i+8]+'0', b[i+9]+'0');
}
printf("\n");
}
int main(int argc, char **argv) {
if(argc > 1)
max_solutions = atoi(argv[1]);
calc_pieces();
calc_rows();
solve(0, 0);
printf("%d solutions found\n\n", solution_count);
qsort(solutions, solution_count, 50 * sizeof(signed char), solution_sort);
pretty(solutions[0]);
pretty(solutions[solution_count-1]);
return 0;
}

669
test/bench/meteor-contest.go Normal file
View File

@ -0,0 +1,669 @@
/*
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
* Neither the name of "The Computer Language Benchmarks Game" nor the
name of "The Computer Language Shootout Benchmarks" nor the names of
its contributors may be used to endorse or promote products derived
from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.
*/
/* The Computer Language Benchmarks Game
* http://shootout.alioth.debian.org/
*
* contributed by The Go Authors.
* based on meteor-contest.c by Christian Vosteen
*/
package main
import (
"flag";
"fmt";
)
var max_solutions = flag.Int("n", 2100, "maximum number of solutions")
func boolInt(b bool) int8 {
if b {
return 1
}
return 0
}
/* The board is a 50 cell hexagonal pattern. For . . . . .
* maximum speed the board will be implemented as . . . . .
* 50 bits, which will fit into a 64 bit long long . . . . .
* int. . . . . .
* . . . . .
* I will represent 0's as empty cells and 1's . . . . .
* as full cells. . . . . .
* . . . . .
* . . . . .
* . . . . .
*/
var board uint64 = 0xFFFC000000000000
/* The puzzle pieces must be specified by the path followed
* from one end to the other along 12 hexagonal directions.
*
* Piece 0 Piece 1 Piece 2 Piece 3 Piece 4
*
* 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
*
* Piece 5 Piece 6 Piece 7 Piece 8 Piece 9
*
* 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
*
* I had to make it 12 directions because I wanted all of the
* piece definitions to fit into the same size arrays. It is
* not possible to define piece 4 in terms of the 6 cardinal
* directions in 4 moves.
*/
const (
E = iota;
ESE;
SE;
S;
SW;
WSW;
W;
WNW;
NW;
N;
NE;
ENE;
PIVOT;
)
var piece_def = [10][4]int8 {
[4]int8{ E, E, E, SE},
[4]int8{ SE, E, NE, E},
[4]int8{ E, E, SE, SW},
[4]int8{ E, E, SW, SE},
[4]int8{ SE, E, NE, S},
[4]int8{ E, E, SW, E},
[4]int8{ E, SE, SE, NE},
[4]int8{ E, SE, SE, W},
[4]int8{ E, SE, E, E},
[4]int8{ E, E, E, SW}
}
/* To minimize the amount of work done in the recursive solve function below,
* I'm going to allocate enough space for all legal rotations of each piece
* at each position on the board. That's 10 pieces x 50 board positions x
* 12 rotations. However, not all 12 rotations will fit on every cell, so
* I'll have to keep count of the actual number that do.
* The pieces are going to be unsigned long long ints just like the board so
* they can be bitwise-anded with the board to determine if they fit.
* I'm also going to record the next possible open cell for each piece and
* location to reduce the burden on the solve function.
*/
var (
pieces[10][50][12] uint64;
piece_counts[10][50] int;
next_cell[10][50][12] int8;
)
/* Returns the direction rotated 60 degrees clockwise */
func rotate(dir int8) int8 {
return (dir + 2) % PIVOT;
}
/* Returns the direction flipped on the horizontal axis */
func flip(dir int8) int8 {
return (PIVOT - dir) % PIVOT;
}
/* Returns the new cell index from the specified cell in the
* specified direction. The index is only valid if the
* starting cell and direction have been checked by the
* out_of_bounds function first.
*/
func shift(cell, dir int8) int8 {
switch dir {
case E:
return cell + 1;
case ESE:
if ((cell / 5) % 2) != 0 {
return cell + 7;
} else {
return cell + 6;
}
case SE:
if ((cell / 5) % 2) != 0 {
return cell + 6;
} else {
return cell + 5;
}
case S:
return cell + 10;
case SW:
if ((cell / 5) % 2) != 0 {
return cell + 5;
} else {
return cell + 4;
}
case WSW:
if ((cell / 5) % 2) != 0 {
return cell + 4;
} else {
return cell + 3;
}
case W:
return cell - 1;
case WNW:
if ((cell / 5) % 2) != 0{
return cell - 6;
} else {
return cell - 7;
}
case NW:
if ((cell / 5) % 2) != 0{
return cell - 5;
} else {
return cell - 6;
}
case N:
return cell - 10;
case NE:
if ((cell / 5) % 2) != 0{
return cell - 4;
} else {
return cell - 5;
}
case ENE:
if ((cell / 5) % 2) != 0{
return cell - 3;
} else {
return cell - 4;
}
}
return cell;
}
/* Returns wether the specified cell and direction will land outside
* of the board. Used to determine if a piece is at a legal board
* location or not.
*/
func out_of_bounds(cell, dir int8) bool {
switch(dir) {
case E:
return cell % 5 == 4;
case ESE:
i := cell % 10;
return i == 4 || i == 8 || i == 9 || cell >= 45;
case SE:
return cell % 10 == 9 || cell >= 45;
case S:
return cell >= 40;
case SW:
return cell % 10 == 0 || cell >= 45;
case WSW:
i := cell % 10;
return i == 0 || i == 1 || i == 5 || cell >= 45;
case W:
return cell % 5 == 0;
case WNW:
i := cell % 10;
return i == 0 || i == 1 || i == 5 || cell < 5;
case NW:
return cell % 10 == 0 || cell < 5;
case N:
return cell < 10;
case NE:
return cell % 10 == 9 || cell < 5;
case ENE:
i := cell % 10;
return i == 4 || i == 8 || i == 9 || cell < 5;
}
return false;
}
/* Rotate a piece 60 degrees clockwise */
func rotate_piece(piece int) {
for i := 0; i < 4; i++ {
piece_def[piece][i] = rotate(piece_def[piece][i]);
}
}
/* Flip a piece along the horizontal axis */
func flip_piece(piece int) {
for i := 0; i < 4; i++ {
piece_def[piece][i] = flip(piece_def[piece][i]);
}
}
/* Convenience function to quickly calculate all of the indices for a piece */
func calc_cell_indices(cell []int8, piece int, index int8) {
cell[0] = index;
for i := 1; i < 5; i++ {
cell[i] = shift(cell[i-1], piece_def[piece][i-1]);
}
}
/* Convenience function to quickly calculate if a piece fits on the board */
func cells_fit_on_board(cell []int8, piece int) bool {
return !out_of_bounds(cell[0], piece_def[piece][0]) &&
!out_of_bounds(cell[1], piece_def[piece][1]) &&
!out_of_bounds(cell[2], piece_def[piece][2]) &&
!out_of_bounds(cell[3], piece_def[piece][3]);
}
/* Returns the lowest index of the cells of a piece.
* I use the lowest index that a piece occupies as the index for looking up
* the piece in the solve function.
*/
func minimum_of_cells(cell []int8) int8 {
minimum := cell[0];
for i := 1; i < 5; i++ {
if cell[i] < minimum {
minimum = cell[i]
}
}
return minimum;
}
/* Calculate the lowest possible open cell if the piece is placed on the board.
* Used to later reduce the amount of time searching for open cells in the
* solve function.
*/
func first_empty_cell(cell []int8, minimum int8) int8 {
first_empty := minimum;
for first_empty == cell[0] || first_empty == cell[1] ||
first_empty == cell[2] || first_empty == cell[3] ||
first_empty == cell[4] {
first_empty++;
}
return first_empty;
}
/* Generate the unsigned long long int that will later be anded with the
* board to determine if it fits.
*/
func bitmask_from_cells(cell []int8) uint64 {
var piece_mask uint64;
for i := 0; i < 5; i++ {
piece_mask |= 1 << uint(cell[i]);
}
return piece_mask;
}
/* Record the piece and other important information in arrays that will
* later be used by the solve function.
*/
func record_piece(piece int, minimum int8, first_empty int8, piece_mask uint64) {
pieces[piece][minimum][piece_counts[piece][minimum]] = piece_mask;
next_cell[piece][minimum][piece_counts[piece][minimum]] = first_empty;
piece_counts[piece][minimum]++;
}
/* Fill the entire board going cell by cell. If any cells are "trapped"
* they will be left alone.
*/
func fill_contiguous_space(board []int8, index int8) {
if board[index] == 1 {
return;
}
board[index] = 1;
if !out_of_bounds(index, E) {
fill_contiguous_space(board, shift(index, E));
}
if !out_of_bounds(index, SE) {
fill_contiguous_space(board, shift(index, SE));
}
if !out_of_bounds(index, SW) {
fill_contiguous_space(board, shift(index, SW));
}
if !out_of_bounds(index, W) {
fill_contiguous_space(board, shift(index, W));
}
if !out_of_bounds(index, NW) {
fill_contiguous_space(board, shift(index, NW));
}
if !out_of_bounds(index, NE) {
fill_contiguous_space(board, shift(index, NE));
}
}
/* To thin the number of pieces, I calculate if any of them trap any empty
* cells at the edges. There are only a handful of exceptions where the
* the board can be solved with the trapped cells. For example: piece 8 can
* trap 5 cells in the corner, but piece 3 can fit in those cells, or piece 0
* can split the board in half where both halves are viable.
*/
func has_island(cell []int8, piece int) bool {
temp_board := make([]int8, 50);
var i int;
for i = 0; i < 5; i++ {
temp_board[cell[i]] = 1;
}
i = 49;
for temp_board[i] == 1 {
i--;
}
fill_contiguous_space(temp_board, int8(i));
c := 0;
for i = 0; i < 50; i++ {
if temp_board[i] == 0 {
c++;
}
}
if c == 0 || (c == 5 && piece == 8) || (c == 40 && piece == 8) ||
(c % 5 == 0 && piece == 0) {
return false;
}
return true;
}
/* Calculate all six rotations of the specified piece at the specified index.
* We calculate only half of piece 3's rotations. This is because any solution
* found has an identical solution rotated 180 degrees. Thus we can reduce the
* number of attempted pieces in the solve algorithm by not including the 180-
* degree-rotated pieces of ONE of the pieces. I chose piece 3 because it gave
* me the best time ;)
*/
func calc_six_rotations(piece, index int) {
cell := make([]int8, 5);
for rotation := 0; rotation < 6; rotation++ {
if piece != 3 || rotation < 3 {
calc_cell_indices(cell, piece, int8(index));
if cells_fit_on_board(cell, piece) && !has_island(cell, piece) {
minimum := minimum_of_cells(cell);
first_empty := first_empty_cell(cell, minimum);
piece_mask := bitmask_from_cells(cell);
record_piece(piece, minimum, first_empty, piece_mask);
}
}
rotate_piece(piece);
}
}
/* Calculate every legal rotation for each piece at each board location. */
func calc_pieces() {
for piece := 0; piece < 10; piece++ {
for index := 0; index < 50; index++ {
calc_six_rotations(piece, index);
flip_piece(piece);
calc_six_rotations(piece, index);
}
}
}
/* Calculate all 32 possible states for a 5-bit row and all rows that will
* create islands that follow any of the 32 possible rows. These pre-
* calculated 5-bit rows will be used to find islands in a partially solved
* board in the solve function.
*/
const (
ROW_MASK = 0x1F;
TRIPLE_MASK = 0x7FFF;
)
var (
all_rows = [32]int8{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31};
bad_even_rows [32][32]int8;
bad_odd_rows [32][32]int8;
bad_even_triple [32768]int8;
bad_odd_triple [32768]int8;
)
func rows_bad(row1, row2 int8, even bool) int8 {
/* even is referring to row1 */
var row2_shift int8;
/* Test for blockages at same index and shifted index */
if even {
row2_shift = ((row2 << 1) & ROW_MASK) | 0x01;
} else {
row2_shift = (row2 >> 1) | 0x10;
}
block := ((row1 ^ row2) & row2) & ((row1 ^ row2_shift) & row2_shift);
/* Test for groups of 0's */
in_zeroes := false;
group_okay := false;
for i := uint8(0); i < 5; i++ {
if row1 & (1 << i) != 0 {
if in_zeroes {
if !group_okay {
return 1;
}
in_zeroes = false;
group_okay = false;
}
} else {
if !in_zeroes {
in_zeroes = true;
}
if (block & (1 << i)) == 0 {
group_okay = true;
}
}
}
if in_zeroes {
return boolInt(!group_okay);
}
return 0;
}
/* Check for cases where three rows checked sequentially cause a false
* positive. One scenario is when 5 cells may be surrounded where piece 5
* or 7 can fit. The other scenario is when piece 2 creates a hook shape.
*/
func triple_is_okay(row1, row2, row3 int, even bool) bool {
if even {
/* There are four cases:
* row1: 00011 00001 11001 10101
* row2: 01011 00101 10001 10001
* row3: 011?? 00110 ????? ?????
*/
return ((row1 == 0x03) && (row2 == 0x0B) && ((row3 & 0x1C) == 0x0C)) ||
((row1 == 0x01) && (row2 == 0x05) && (row3 == 0x06)) ||
((row1 == 0x19) && (row2 == 0x11)) ||
((row1 == 0x15) && (row2 == 0x11));
}
/* There are two cases:
* row1: 10011 10101
* row2: 10001 10001
* row3: ????? ?????
*/
return ((row1 == 0x13) && (row2 == 0x11)) ||
((row1 == 0x15) && (row2 == 0x11));
}
func calc_rows() {
for row1 := int8(0); row1 < 32; row1++ {
for row2 := int8(0); row2 < 32; row2++ {
bad_even_rows[row1][row2] = rows_bad(row1, row2, true);
bad_odd_rows[row1][row2] = rows_bad(row1, row2, false);
}
}
for row1 := 0; row1 < 32; row1++ {
for row2 := 0; row2 < 32; row2++ {
for row3 := 0; row3 < 32; row3++ {
result1 := bad_even_rows[row1][row2];
result2 := bad_odd_rows[row2][row3];
if result1==0 && result2!=0 && triple_is_okay(row1, row2, row3, true) {
bad_even_triple[row1+(row2*32)+(row3*1024)] = 0;
} else {
bad_even_triple[row1+(row2*32)+(row3*1024)] = boolInt(result1!=0 || result2!=0);
}
result1 = bad_odd_rows[row1][row2];
result2 = bad_even_rows[row2][row3];
if result1==0 && result2!=0 && triple_is_okay(row1, row2, row3, false) {
bad_odd_triple[row1+(row2*32)+(row3*1024)] = 0;
} else {
bad_odd_triple[row1+(row2*32)+(row3*1024)] = boolInt(result1!=0 || result2!=0);
}
}
}
}
}
/* Calculate islands while solving the board.
*/
func boardHasIslands(cell int8) int8 {
/* Too low on board, don't bother checking */
if cell >= 40 {
return 0;
}
current_triple := (board >> uint((cell / 5) * 5)) & TRIPLE_MASK;
if (cell / 5) % 2 != 0 {
return bad_odd_triple[current_triple];
}
return bad_even_triple[current_triple];
}
/* The recursive solve algorithm. Try to place each permutation in the upper-
* leftmost empty cell. Mark off available pieces as it goes along.
* Because the board is a bit mask, the piece number and bit mask must be saved
* at each successful piece placement. This data is used to create a 50 char
* array if a solution is found.
*/
var (
avail uint16 = 0x03FF;
sol_nums [10]int8;
sol_masks [10]uint64;
solutions [2100][50]int8;
solution_count = 0;
)
func record_solution() {
for sol_no := 0; sol_no < 10; sol_no++ {
sol_mask := sol_masks[sol_no];
for index := 0; index < 50; index++ {
if sol_mask & 1 == 1 {
solutions[solution_count][index] = sol_nums[sol_no];
/* Board rotated 180 degrees is a solution too! */
solutions[solution_count+1][49-index] = sol_nums[sol_no];
}
sol_mask = sol_mask >> 1;
}
}
solution_count += 2;
}
func solve(depth, cell int8) {
if solution_count >= *max_solutions {
return;
}
for board & (1 << uint(cell)) != 0 {
cell++;
}
for piece := int8(0); piece < 10; piece++ {
var piece_no_mask uint16 = 1 << uint(piece);
if avail & piece_no_mask == 0 {
continue;
}
avail ^= piece_no_mask;
max_rots := piece_counts[piece][cell];
piece_mask := pieces[piece][cell];
for rotation := 0; rotation < max_rots; rotation++ {
if board & piece_mask[rotation] == 0 {
sol_nums[depth] = piece;
sol_masks[depth] = piece_mask[rotation];
if depth == 9 {
/* Solution found!!!!!11!!ONE! */
record_solution();
avail ^= piece_no_mask;
return;
}
board |= piece_mask[rotation];
if boardHasIslands(next_cell[piece][cell][rotation]) == 0 {
solve(depth + 1, next_cell[piece][cell][rotation]);
}
board ^= piece_mask[rotation];
}
}
avail ^= piece_no_mask;
}
}
/* pretty print a board in the specified hexagonal format */
func pretty(b *[50]int8) {
for i := 0; i < 50; i += 10 {
fmt.Printf("%c %c %c %c %c \n %c %c %c %c %c \n", b[i]+'0', b[i+1]+'0',
b[i+2]+'0', b[i+3]+'0', b[i+4]+'0', b[i+5]+'0', b[i+6]+'0',
b[i+7]+'0', b[i+8]+'0', b[i+9]+'0');
}
fmt.Printf("\n");
}
/* Find smallest and largest solutions */
func smallest_largest() (smallest, largest *[50]int8) {
smallest = &solutions[0];
largest = &solutions[0];
for i := 1; i < solution_count; i++ {
candidate := &solutions[i];
for j, s := range *smallest {
c := candidate[j];
if c == s {
continue
}
if c < s {
smallest = candidate;
}
break;
}
for j, s := range *largest {
c := candidate[j];
if c == s {
continue
}
if c > s {
largest = candidate;
}
break;
}
}
return;
}
func main() {
flag.Parse();
calc_pieces();
calc_rows();
solve(0, 0);
fmt.Printf("%d solutions found\n\n", solution_count);
smallest, largest := smallest_largest();
pretty(smallest);
pretty(largest);
}

24
test/bench/meteor-contest.txt Normal file
View File

@ -0,0 +1,24 @@
2098 solutions found
0 0 0 0 1
2 2 2 0 1
2 6 6 1 1
2 6 1 5 5
8 6 5 5 5
8 6 3 3 3
4 8 8 9 3
4 4 8 9 3
4 7 4 7 9
7 7 7 9 9
9 9 9 9 8
9 6 6 8 5
6 6 8 8 5
6 8 2 5 5
7 7 7 2 5
7 4 7 2 0
1 4 2 2 0
1 4 4 0 3
1 4 0 0 3
1 1 3 3 3

6
test/bench/timing.log
View File

@ -80,3 +80,9 @@ mandelbrot 5500
gccgo -O2 mandelbrot.go 57.49u 0.01s 57.51r gccgo -O2 mandelbrot.go 57.49u 0.01s 57.51r
gc mandelbrot 74.32u 0.00s 74.35r gc mandelbrot 74.32u 0.00s 74.35r
gc_B mandelbrot 74.28u 0.01s 74.31r gc_B mandelbrot 74.28u 0.01s 74.31r
meteor 16000
gcc -O2 meteor-contest.c 0.10u 0.00s 0.10r
gccgo -O2 meteor-contest.go 0.12u 0.00s 0.14r
gc meteor-contest 0.24u 0.00s 0.26r
gc_B meteor-contest 0.23u 0.00s 0.24r

10
test/bench/timing.sh
View File

@ -103,9 +103,17 @@ mandelbrot() {
run 'gc_B mandelbrot' $O.out -n 16000 run 'gc_B mandelbrot' $O.out -n 16000
} }
meteor() {
echo 'meteor 16000'
run 'gcc -O2 meteor-contest.c' a.out
run 'gccgo -O2 meteor-contest.go' a.out
run 'gc meteor-contest' $O.out
run 'gc_B meteor-contest' $O.out
}
case $# in case $# in
0) 0)
run="fasta revcom nbody binarytree fannkuch regexdna spectralnorm knucleotide mandelbrot" run="fasta revcom nbody binarytree fannkuch regexdna spectralnorm knucleotide mandelbrot meteor"
;; ;;
*) *)
run=$* run=$*