Return to Unfiction unforum
 a.r.g.b.b 
FAQ FAQ   Search Search 
 
Welcome!
New users, PLEASE read these forum guidelines. New posters, SEARCH before posting and read these rules before posting your killer new campaign. New players may also wish to peruse the ARG Player Tutorial.

All users must abide by the Terms of Service.
Website Restoration Project
This archiving project is a collaboration between Unfiction and Sean Stacey (SpaceBass), Brian Enigma (BrianEnigma), and Laura E. Hall (lehall) with
the Center for Immersive Arts.
Announcements
This is a static snapshot of the
Unfiction forums, as of
July 23, 2017.
This site is intended as an archive to chronicle the history of Alternate Reality Games.
 
The time now is Tue Nov 12, 2024 8:20 pm
All times are UTC - 4 (DST in action)
View posts in this forum since last visit
View unanswered posts in this forum
Calendar
 Forum index » Diversions » Perplex City Puzzle Cards » PXC: Silver Puzzle Cards
Silver #231 Cast Adrift 2
Moderators: AnthraX101, bagsbee, BrianEnigma, cassandra, Giskard, lhall, Mikeyj, myf, poozle, RobMagus, xnbomb
View previous topicView next topic
Page 4 of 7 [100 Posts]   Goto page: Previous 1, 2, 3, 4, 5, 6, 7 Next
Author Message
Mathematician
Boot


Joined: 15 Mar 2006
Posts: 13
Location: Sturminster Newton

arnezami

I checked the first solution - the one leftmost in your post - I transcribed this as:

Spoiler (Rollover to View):


26 15 12 1 2 11 17 13 14



It gave an incorrect answer. I haven't checked the next two yet.

Given that I'm very tired - long day and all - I'm not sure the following will make sense or is even correct! However I'm thinking that - if the number of solutions found suggests that a 4x4 formation for the overall map is unlikely then the shape is likely to be as on the card.

xx
xxxx
xxxx
xxxx
xx

We just don't know which way is North. So all of the pieces would need to be turned through either 0, 90, 180 or 270 degrees but then assembled in a master map of the format above with North always up the page.
Not sure if this has any merit.

PostPosted: Sat Apr 15, 2006 6:49 pm
 View user's profile MSN Messenger
 Back to top 
Gibbet
Veteran


Joined: 07 Aug 2005
Posts: 121

ahdok wrote:
Gibbet, your solver appears to lie.


Hmm, so it would seem. (Worried face, have they rumbled my plan to hypnotise the world and rule........muhahahaha).

In my defence, the best solves i've come up with all seemed to work. But given my make-it-up-as-i-go-along coding knowledge and the fact that there appear to be many many solves from everyones better programs, i'd leave mine for inducing/curing headaches. (The 120fps version is even more impressive though!) Very Happy
_________________
"And I would have got away with it if it wasn't for those pesky cards!"

The OK13DTFC is but one of the things i'm ashamed of being associated with!


PostPosted: Sat Apr 15, 2006 9:37 pm
 View user's profile MSN Messenger
 Back to top 
arnezami
Veteran


Joined: 14 Apr 2006
Posts: 136

Mathematician wrote:
Given that I'm very tired - long day and all - I'm not sure the following will make sense or is even correct! However I'm thinking that - if the number of solutions found suggests that a 4x4 formation for the overall map is unlikely then the shape is likely to be as on the card.

xx
xxxx
xxxx
xxxx
xx

We just don't know which way is North. So all of the pieces would need to be turned through either 0, 90, 180 or 270 degrees but then assembled in a master map of the format above with North always up the page.
Not sure if this has any merit.

Very good point! In some way that makes more sense. Instead of changing North for the entire map as a whole (changing the directions of all the boats) its possible to change the orientation of the pieces individually while maintaining the map shape. This might have a significant impact on the number of solutions...

Will change the solver and try this.

arnezami

PS. Just for confirmation: your transcription of the first of three solutions seems ok. So it has to be a different solution.

PostPosted: Sun Apr 16, 2006 2:41 am
 View user's profile
 Back to top 
arnezami
Veteran


Joined: 14 Apr 2006
Posts: 136

Here are my results of all the things I tried. It now includes the solutions from rotating individual pieces (suggested by Mathematician).

The following table shows the number of solutions with a 4x4 map, the normal "odd map", the 3 rotations of the boat directions and the 3 rotations of the individual pieces. All solutions are found by covering more than 99% of the search space so these numbers are pretty accurate.

Code:

 No rotations:

 4x4 map   : 1032 solutions
 odd shape : 254 solutions

 Rotation of boat directions (odd shaped map):
 
  90 degrees : 6 solutions (reduced to 3)
 180 degrees : 117 solutions
 270 degrees : 63 solutions
 
 Rotation of individual pieces (odd shaped map):
 
  90 degrees : 59 solutions
 180 degrees : 93 solutions
 270 degrees : 24 solutions
 


While there are still some possible restrictions to try out its starting to look like this puzzle doesn't have a single (obvious) solution. I'm still thinking about horizontally and vertically flipping, rotating with 45 degrees, island visiting "rules" and even map shape changes. But somehow I get the feeling none of these will give us a definitive answer.

Maybe we should approach this problem differently: How do you create a puzzle like this that has (provably) only one answer?

An answer to that question may lead us to the obvious and correct answer to the puzzle (assuming no screw-up of course).

We could use some brilliant idea now Wink.

Or a hint...

Greetz,

arnezami

PS. I've attached all solutions mentioned in the above table.
solutions.zip
Description 
zip

 Download 
Filename  solutions.zip 
Filesize  502.18KB 
Downloaded  161 Time(s) 

PostPosted: Sun Apr 16, 2006 6:17 am
Last edited by arnezami on Sun Apr 16, 2006 12:07 pm; edited 5 times in total
 View user's profile
 Back to top 
SteveC
Unfettered


Joined: 05 May 2005
Posts: 381

I'm going with the MC screwup idea until we've had some sort of word back from them.. Anyone know what Kurt has to say in his hints?

PostPosted: Sun Apr 16, 2006 6:48 am
 View user's profile
 Back to top 
arnezami
Veteran


Joined: 14 Apr 2006
Posts: 136

Here is the source of my solver.

Please read the ReadMeFirst.txt first.

arnezami
CastAdrift2.zip
Description 
zip

 Download 
Filename  CastAdrift2.zip 
Filesize  37.18KB 
Downloaded  181 Time(s) 

PostPosted: Sun Apr 16, 2006 7:05 am
 View user's profile
 Back to top 
arnezami
Veteran


Joined: 14 Apr 2006
Posts: 136

Ok. Something just occured to me:

I was first thinking: maybe the island numbers (visited by a boat) should follow some kind of pattern. Maybe ascending or descending or some other pattern. This would certainly lower the amount of possible solutions.

But a very good way of ensuring that there would be only 1 solution is to make sure the pattern/series of numbers boat B went through would actually mean something. And then I saw something interesting: there are 27 islands: possibly 26 letters and one character for spacing? Is it possible we are actually searching for a word or sentence created by the numbers B goes through? And maybe the routes of the other boats also mean something?

Just a thought...

PostPosted: Sun Apr 16, 2006 12:04 pm
 View user's profile
 Back to top 
xorsyst
Guest


Here's my solver

Well, congratulations to arnezami on a definitely superior approach to the problem. For those interested I've put my C solver below. Warning: It's not very clear, it's hideously loop-unrolled for speed, and I'm not really a C programmer Smile

This is for the "maintaining the shape on the card" version.

A quick comment on the technique: Each individual square in the puzzle maintains a pointer to its cardinal neighbours. This allows us to follow the boat paths very quickly. We also maintain the grids so as we know which squares to move when we do a swap.

The algorithm used is the Johnson-Trotter permutation algorithm, which allows us to avoid recursion and to visit each permutation in an order by just performing one swap per iteration. The swapping has to do all the square pointer manipulation.

Hope you enjoy,
X

Code:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
   
typedef struct square {
   struct square *e, *n, *w, *s;
   int island;
} square;
   
typedef struct {
   square *squares[9];
   int looking; // 0 = left, 1 = right
   int num;
} grid;
   
grid *glist[18];
int init[] = {
    0, 0, 0, 0, 0, 0,-1,-1,-1,-1,-1,-1,
    0, 4, 0,16, 0, 0,-1,-1,-1,-1,-1,-1,
   13, 0, 0, 6, 0, 0,-1,-1,-1,-1,-1,-1,
    0, 0, 0, 0, 0, 0, 0, 0,21, 0, 0,22,
    5, 0, 0, 0, 0, 0, 0, 0, 0,18, 0, 0,
    0, 0, 0,12, 0, 0,25,19, 0, 0,11, 0,
    0, 0, 0, 0, 9, 0, 3, 0, 0, 0, 0, 0,
    0, 0,27, 0, 0, 0, 0, 0, 0, 0, 7, 0,
   17, 0, 0, 0,20, 0, 0, 0, 0, 0,23, 0,
    0, 0, 0, 0, 0, 0,24, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 8, 0, 0, 0, 0, 0,26,
    0, 0,15, 0,14, 0, 0, 0,10, 0, 2, 0,
    0, 0, 0, 0, 0, 0,-1,-1,-1,-1,-1,-1,
    0, 0, 0, 0, 1, 0,-1,-1,-1,-1,-1,-1,
    0, 0, 0, 0, 0, 0,-1,-1,-1,-1,-1,-1,
};

int starts[][32] = {
   {1, 0, 2, 0, 3, 0, 4, 0, 5, 0, 6, 0, 7, 0, 8, 0, 9, 0, 10, 0, 11, 0, 12, 0, 13, 0, 14, 0, 15, 0, 16, 0},
   {1, 0, 2, 0, 4, 0, 3, 0, 5, 0, 6, 0, 7, 0, 8, 0, 9, 0, 10, 0, 11, 0, 12, 0, 13, 0, 14, 0, 15, 0, 16, 0},
   {1, 0, 4, 0, 2, 0, 3, 0, 5, 1, 6, 1, 7, 1, 8, 1, 9, 1, 10, 1, 11, 1, 12, 1, 13, 1, 14, 1, 15, 1, 16, 1},
   {4, 0, 1, 0, 2, 0, 3, 0, 5, 0, 6, 0, 7, 0, 8, 0, 9, 0, 10, 0, 11, 0, 12, 0, 13, 0, 14, 0, 15, 0, 16, 0},
   {4, 1, 1, 0, 3, 0, 2, 0, 5, 1, 6, 1, 7, 1, 8, 1, 9, 1, 10, 1, 11, 1, 12, 1, 13, 1, 14, 1, 15, 1, 16, 1},
   {1, 0, 4, 1, 3, 0, 2, 0, 5, 0, 6, 0, 7, 0, 8, 0, 9, 0, 10, 0, 11, 0, 12, 0, 13, 0, 14, 0, 15, 0, 16, 0},
   {1, 0, 3, 0, 4, 1, 2, 0, 5, 1, 6, 1, 7, 1, 8, 1, 9, 1, 10, 1, 11, 1, 12, 1, 13, 1, 14, 1, 15, 1, 16, 1},
   {1, 0, 3, 0, 2, 0, 4, 1, 5, 0, 6, 0, 7, 0, 8, 0, 9, 0, 10, 0, 11, 0, 12, 0, 13, 0, 14, 0, 15, 0, 16, 0},
   {3, 0, 1, 0, 2, 0, 4, 0, 5, 1, 6, 1, 7, 1, 8, 1, 9, 1, 10, 1, 11, 1, 12, 1, 13, 1, 14, 1, 15, 1, 16, 1},
   {3, 0, 1, 0, 4, 0, 2, 0, 5, 0, 6, 0, 7, 0, 8, 0, 9, 0, 10, 0, 11, 0, 12, 0, 13, 0, 14, 0, 15, 0, 16, 0},
   {3, 0, 4, 0, 1, 0, 2, 0, 5, 1, 6, 1, 7, 1, 8, 1, 9, 1, 10, 1, 11, 1, 12, 1, 13, 1, 14, 1, 15, 1, 16, 1},
   {4, 0, 3, 0, 1, 0, 2, 0, 5, 0, 6, 0, 7, 0, 8, 0, 9, 0, 10, 0, 11, 0, 12, 0, 13, 0, 14, 0, 15, 0, 16, 0},
   {4, 1, 3, 1, 2, 0, 1, 0, 5, 1, 6, 1, 7, 1, 8, 1, 9, 1, 10, 1, 11, 1, 12, 1, 13, 1, 14, 1, 15, 1, 16, 1},
   {3, 1, 4, 1, 2, 0, 1, 0, 5, 0, 6, 0, 7, 0, 8, 0, 9, 0, 10, 0, 11, 0, 12, 0, 13, 0, 14, 0, 15, 0, 16, 0},
   {3, 1, 2, 0, 4, 1, 1, 0, 5, 1, 6, 1, 7, 1, 8, 1, 9, 1, 10, 1, 11, 1, 12, 1, 13, 1, 14, 1, 15, 1, 16, 1},
   {3, 1, 2, 0, 1, 0, 4, 1, 5, 0, 6, 0, 7, 0, 8, 0, 9, 0, 10, 0, 11, 0, 12, 0, 13, 0, 14, 0, 15, 0, 16, 0},
   {2, 0, 3, 1, 1, 0, 4, 0, 5, 1, 6, 1, 7, 1, 8, 1, 9, 1, 10, 1, 11, 1, 12, 1, 13, 1, 14, 1, 15, 1, 16, 1},
   {2, 0, 3, 1, 4, 0, 1, 0, 5, 0, 6, 0, 7, 0, 8, 0, 9, 0, 10, 0, 11, 0, 12, 0, 13, 0, 14, 0, 15, 0, 16, 0},
   {2, 0, 4, 0, 3, 1, 1, 0, 5, 1, 6, 1, 7, 1, 8, 1, 9, 1, 10, 1, 11, 1, 12, 1, 13, 1, 14, 1, 15, 1, 16, 1},
   {4, 0, 2, 0, 3, 1, 1, 0, 5, 0, 6, 0, 7, 0, 8, 0, 9, 0, 10, 0, 11, 0, 12, 0, 13, 0, 14, 0, 15, 0, 16, 0},
   {4, 1, 2, 0, 1, 0, 3, 1, 5, 1, 6, 1, 7, 1, 8, 1, 9, 1, 10, 1, 11, 1, 12, 1, 13, 1, 14, 1, 15, 1, 16, 1},
   {2, 0, 4, 1, 1, 0, 3, 1, 5, 0, 6, 0, 7, 0, 8, 0, 9, 0, 10, 0, 11, 0, 12, 0, 13, 0, 14, 0, 15, 0, 16, 0},
   {2, 0, 1, 0, 4, 1, 3, 1, 5, 1, 6, 1, 7, 1, 8, 1, 9, 1, 10, 1, 11, 1, 12, 1, 13, 1, 14, 1, 15, 1, 16, 1},
   {2, 0, 1, 0, 3, 1, 4, 1, 5, 0, 6, 0, 7, 0, 8, 0, 9, 0, 10, 0, 11, 0, 12, 0, 13, 0, 14, 0, 15, 0, 16, 0}
};

int map[20] = {1, 2, -1, -1, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, -1, -1};
int unmap[16] = {1, 2, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18};

square *slist[180], *slist2[180];
square *As, *Bs, *Cs, *Ds;
   
void initialize(int perm) {
   int i;
   int s = 0;
   
   for (s=0; s<180; s++) {
      if (init[s] >= 0) {
         slist[s] = (square *)malloc(sizeof(square));
         slist[s]->island = init[s];
      }
      else {
         slist[s] = NULL;
      }
      slist2[s] = NULL;
   }
   
   glist[0] = (grid *)malloc(sizeof(grid));
   glist[0]->num = 18;
   glist[17] = (grid *)malloc(sizeof(grid));
   glist[17]->num = 18;
   for (i=0; i<20; i++) {
      if (map[i] >= 0) {
         glist[map[i]] = (grid *)malloc(sizeof(grid));
         glist[map[i]]->num = starts[perm][(map[i]-1)*2];
         glist[map[i]]->looking = starts[perm][(map[i]-1)*2+1]; // eyes left
         int j, k;
         for (j=0; j<3; j++) {
            for (k=0; k<3; k++) {
               glist[map[i]]->squares[j*3+k] = slist[(((unmap[glist[map[i]]->num-1]-1)/4)*36)+(((unmap[glist[map[i]]->num-1]-1)%4)*3)+(j*12)+k];
               slist2[((i/4)*36)+((i%4)*3)+(j*12)+k] = glist[map[i]]->squares[j*3+k];
            }
         }
      }
      else {
      }
   }
   
   for (s=0; s<180; s++) {
      if (slist2[s] != NULL) {
         slist2[s]->w = s%12>0?slist2[s-1]:NULL;
         slist2[s]->e = s%12<11?slist2[s+1]:NULL;
         slist2[s]->n = s>11?slist2[s-12]:NULL;
         slist2[s]->s = s<168?slist2[s+12]:NULL;
      }
   }
   
   As = slist[139];
   Bs = slist[129];
   Cs = slist[121];
   Ds = slist[74];
};
   
void printworld(void) {
   square *s;
   s = slist[0];
   while (s->w != NULL) {s = s->w;}
   while (s->n != NULL) {s = s->n;}
   // s is now in the top left
   square *row, *col;
   printf("\n");
   char bp[4];
   int k = 0;
   int p = 0;
   for (row = s ; row != NULL ; row = row->s) {
      for (col = row ; col != NULL ; col = col->e) {
         if (col->island) {
            printf("| %3d ",col->island);
         }
         else {
            strcpy(bp," . ");
            if (col == As) { strcpy(bp,"-A-"); }
            if (col == Bs) { strcpy(bp,"-B-"); }
            if (col == Cs) { strcpy(bp,"-C-"); }
            if (col == Ds) { strcpy(bp,"-D-"); }
            printf("| %s ",bp);
         }
         p++;
         if (p%3 == 0) {
            printf("|");
         }
      }
      k++;
      printf("|\n");
      if (k%3==0) {
         printf("\n");
      }
   }
};
   
void permute(void) {
   // an implementation of the Johnson-Trotter algorithm
   int bigmob = 0;
   int big = 0, neighbour = 0;
   int i;
   for (i = 1; i <= 16; i++) { // iterate over each grid
      if (glist[i]->num > bigmob) { // might be faster done later
         if (glist[i]->looking) { // looking right
            if (glist[i]->num > glist[i+1]->num) {
               bigmob = glist[i]->num;
               big = i;
               neighbour = i+1;
            }
         }
         else { // looking left
            if (glist[i]->num > glist[i-1]->num) {
               bigmob = glist[i]->num;
               big = i;
               neighbour = i-1;
            }
         }
      }
   }
   if (big == 0 || neighbour == 0) {
      printf("ERROR - no biggest mobile found\n");
      exit(1);
   }
   
   // Change looking for all larger than biggest mobile number
   if (glist[1]->num > bigmob) {glist[1]->looking ^= 1;}
   if (glist[2]->num > bigmob) {glist[2]->looking ^= 1;}
   if (glist[3]->num > bigmob) {glist[3]->looking ^= 1;}
   if (glist[4]->num > bigmob) {glist[4]->looking ^= 1;}
   if (glist[5]->num > bigmob) {glist[5]->looking ^= 1;}
   if (glist[6]->num > bigmob) {glist[6]->looking ^= 1;}
   if (glist[7]->num > bigmob) {glist[7]->looking ^= 1;}
   if (glist[8]->num > bigmob) {glist[8]->looking ^= 1;}
   if (glist[9]->num > bigmob) {glist[9]->looking ^= 1;}
   if (glist[10]->num > bigmob) {glist[10]->looking ^= 1;}
   if (glist[11]->num > bigmob) {glist[11]->looking ^= 1;}
   if (glist[12]->num > bigmob) {glist[12]->looking ^= 1;}
   if (glist[13]->num > bigmob) {glist[13]->looking ^= 1;}
   if (glist[14]->num > bigmob) {glist[14]->looking ^= 1;}
   if (glist[15]->num > bigmob) {glist[15]->looking ^= 1;}
   if (glist[16]->num > bigmob) {glist[16]->looking ^= 1;}
   
   // ok, swap big with neighbour
   grid *bg = glist[big];
   grid *ng = glist[neighbour];
   glist[big] = ng;
   glist[neighbour] = bg;
   
   // now update square pointers for elements of grid
   square *temp2;
   temp2 = bg->squares[0]->n;
   bg->squares[0]->n = ng->squares[0]->n;
   ng->squares[0]->n = temp2;
   temp2 = bg->squares[1]->n;
   bg->squares[1]->n = ng->squares[1]->n;
   ng->squares[1]->n = temp2;
   temp2 = bg->squares[2]->n;
   bg->squares[2]->n = ng->squares[2]->n;
   ng->squares[2]->n = temp2;
      
   temp2 = bg->squares[6]->s;
   bg->squares[6]->s = ng->squares[6]->s;
   ng->squares[6]->s = temp2;
   temp2 = bg->squares[7]->s;
   bg->squares[7]->s = ng->squares[7]->s;
   ng->squares[7]->s = temp2;
   temp2 = bg->squares[8]->s;
   bg->squares[8]->s = ng->squares[8]->s;
   ng->squares[8]->s = temp2;
      
   temp2 = bg->squares[0]->w;
   bg->squares[0]->w = ng->squares[0]->w;
   ng->squares[0]->w = temp2;
   temp2 = bg->squares[3]->w;
   bg->squares[3]->w = ng->squares[3]->w;
   ng->squares[3]->w = temp2;
   temp2 = bg->squares[6]->w;
   bg->squares[6]->w = ng->squares[6]->w;
   ng->squares[6]->w = temp2;
      
   temp2 = bg->squares[2]->e;
   bg->squares[2]->e = ng->squares[2]->e;
   ng->squares[2]->e = temp2;
   temp2 = bg->squares[5]->e;
   bg->squares[5]->e = ng->squares[5]->e;
   ng->squares[5]->e = temp2;
   temp2 = bg->squares[8]->e;
   bg->squares[8]->e = ng->squares[8]->e;
   ng->squares[8]->e = temp2;
   
   // sort out pointing to self
   if (bg->squares[0]->n == bg->squares[6]) {
      bg->squares[0]->n = ng->squares[6];
      bg->squares[1]->n = ng->squares[7];
      bg->squares[2]->n = ng->squares[8];
      ng->squares[6]->s = bg->squares[0];
      ng->squares[7]->s = bg->squares[1];
      ng->squares[8]->s = bg->squares[2];
   }
   
   if (bg->squares[0]->w == bg->squares[2]) {
      bg->squares[0]->w = ng->squares[2];
      bg->squares[3]->w = ng->squares[5];
      bg->squares[6]->w = ng->squares[8];
      ng->squares[2]->e = bg->squares[0];
      ng->squares[5]->e = bg->squares[3];
      ng->squares[8]->e = bg->squares[6];
   }
   
   if (bg->squares[6]->s == bg->squares[0]) {
      bg->squares[6]->s = ng->squares[0];
      bg->squares[7]->s = ng->squares[1];
      bg->squares[8]->s = ng->squares[2];
      ng->squares[0]->n = bg->squares[6];
      ng->squares[1]->n = bg->squares[7];
      ng->squares[2]->n = bg->squares[8];
   }
   
   if (bg->squares[2]->e == bg->squares[0]) {
      bg->squares[2]->e = ng->squares[0];
      bg->squares[5]->e = ng->squares[3];
      bg->squares[8]->e = ng->squares[6];
      ng->squares[0]->w = bg->squares[2];
      ng->squares[3]->w = bg->squares[5];
      ng->squares[6]->w = bg->squares[8];
   }
      
   // reverse pointers
   if (bg->squares[0]->n != NULL) {
      bg->squares[0]->n->s = bg->squares[0];
      bg->squares[1]->n->s = bg->squares[1];
      bg->squares[2]->n->s = bg->squares[2];
   }
   
   if (ng->squares[0]->n != NULL) {
      ng->squares[0]->n->s = ng->squares[0];
      ng->squares[1]->n->s = ng->squares[1];
      ng->squares[2]->n->s = ng->squares[2];
   }
      
   if (bg->squares[6]->s != NULL) {
      bg->squares[6]->s->n = bg->squares[6];
      bg->squares[7]->s->n = bg->squares[7];
      bg->squares[8]->s->n = bg->squares[8];
   }
   
   if (ng->squares[6]->s != NULL) {
      ng->squares[6]->s->n = ng->squares[6];
      ng->squares[7]->s->n = ng->squares[7];
      ng->squares[8]->s->n = ng->squares[8];
   }
      
   if (bg->squares[0]->w != NULL) {
      bg->squares[0]->w->e = bg->squares[0];
      bg->squares[3]->w->e = bg->squares[3];
      bg->squares[6]->w->e = bg->squares[6];
   }
   
   if (ng->squares[0]->w != NULL) {
      ng->squares[0]->w->e = ng->squares[0];
      ng->squares[3]->w->e = ng->squares[3];
      ng->squares[6]->w->e = ng->squares[6];
   }
      
   if (bg->squares[2]->e != NULL) {
      bg->squares[2]->e->w = bg->squares[2];
      bg->squares[5]->e->w = bg->squares[5];
      bg->squares[8]->e->w = bg->squares[8];
   }
   
   if (ng->squares[2]->e != NULL) {
      ng->squares[2]->e->w = ng->squares[2];
      ng->squares[5]->e->w = ng->squares[5];
      ng->squares[8]->e->w = ng->squares[8];
   }
   
   return;
};
   
void checksolved(void) {
   square *A, *B, *C, *D;
   
   A = As;
   for (A = A->s; A != NULL && A->island == 0; A = A->s) {}
   if (A == NULL) {return;}
   D = Ds;
   for (D = D->n; D != NULL && D->island == 0; D = D->n) {}
   if (D == NULL) {return;}
   C = Cs;
   for (C = C->w; C != NULL && C->island == 0; C = C->w) {}
   if (C == NULL) {return;}
   B = Bs;
   for (B = B->n; B != NULL && B->island == 0; B = B->n) {}
   if (B == NULL) {return;}

   for ((A = A->n) && (A = A->e); A != NULL && A->island == 0; (A = A->n) && (A = A->e)) {}
   if (A == NULL) {return;}
   for (A = A->w; A != NULL && A->island == 0; A = A->w) {}
   if (A == NULL) {return;}
   for ((A = A->s) && (A = A->e); A != NULL && A->island == 0; (A = A->s) && (A = A->e)) {}
   if (A == NULL) {return;}
   for (A = A->w; A != NULL && A->island == 0; A = A->w) {}
   if (A == NULL) {return;}
   for (A = A->w; A != NULL && A->island == 0; A = A->w) {}
   if (A == NULL) {return;}
   for ((A = A->n) && (A = A->e); A != NULL && A->island == 0; (A = A->n) && (A = A->e)) {}
   if (A == NULL) {return;}
   for (A = A->s; A != NULL && A->island == 0; A = A->s) {}
   if (A == NULL) {return;}
   
   for ((D = D->s) && (D = D->w); D != NULL && D->island == 0; (D = D->s) && (D = D->w)) {}
   if (D == NULL) {return;}
   for ((D = D->s) && (D = D->e); D != NULL && D->island == 0; (D = D->s) && (D = D->e)) {}
   if (D == NULL) {return;}
   for (D = D->n; D != NULL && D->island == 0; D = D->n) {}
   if (D == NULL) {return;}
   for ((D = D->n) && (D = D->w); D != NULL && D->island == 0; (D = D->n) && (D = D->w)) {}
   if (D == NULL) {return;}
   for (D = D->e; D != NULL && D->island == 0; D = D->e) {}
   if (D == NULL) {return;}

   for (D = D->n; D != NULL && D->island == 0; D = D->n) {}
   if (D == NULL) {return;}
   for (D = D->e; D != NULL && D->island == 0; D = D->e) {}
   if (D == NULL) {return;}
   for (D = D->n; D != NULL && D->island == 0; D = D->n) {}
   if (D == NULL) {return;}
   for ((D = D->s) && (D = D->w); D != NULL && D->island == 0; (D = D->s) && (D = D->w)) {}
   if (D == NULL) {return;}
   for (D = D->n; D != NULL && D->island == 0; D = D->n) {}
   if (D == NULL) {return;}
   for (D = D->n; D != NULL && D->island == 0; D = D->n) {}
   if (D == NULL) {return;}
   
   
   for (C = C->s; C != NULL && C->island == 0; C = C->s) {}
   if (C == NULL) {return;}
   for ((C = C->s) && (C = C->e); C != NULL && C->island == 0; (C = C->s) && (C = C->e)) {}
   if (C == NULL) {return;}
   for (C = C->s; C != NULL && C->island == 0; C = C->s) {}
   if (C == NULL) {return;}
   for (C = C->w; C != NULL && C->island == 0; C = C->w) {}
   if (C == NULL) {return;}
   for (C = C->n; C != NULL && C->island == 0; C = C->n) {}
   if (C == NULL) {return;}
   for ((C = C->s) && (C = C->w); C != NULL && C->island == 0; (C = C->s) && (C = C->w)) {}
   if (C == NULL) {return;}
   for (C = C->e; C != NULL && C->island == 0; C = C->e) {}
   if (C == NULL) {return;}
   for ((C = C->s) && (C = C->w); C != NULL && C->island == 0; (C = C->s) && (C = C->w)) {}
   if (C == NULL) {return;}
   for (C = C->w; C != NULL && C->island == 0; C = C->w) {}
   if (C == NULL) {return;}
   for (C = C->n; C != NULL && C->island == 0; C = C->n) {}
   if (C == NULL) {return;}
   for (C = C->n; C != NULL && C->island == 0; C = C->n) {}
   if (C == NULL) {return;}
   for ((C = C->s) && (C = C->e); C != NULL && C->island == 0; (C = C->s) && (C = C->e)) {}
   if (C == NULL) {return;}
   for (B = B->e; B != NULL && B->island == 0; B = B->e) {}
   if (B == NULL) {return;}
   for (B = B->s; B != NULL && B->island == 0; B = B->s) {}
   if (B == NULL) {return;}
   for ((B = B->n) && (B = B->w); B != NULL && B->island == 0; (B = B->n) && (B = B->w)) {}
   if (B == NULL) {return;}
   for (B = B->w; B != NULL && B->island == 0; B = B->w) {}
   if (B == NULL) {return;}
   for (B = B->s; B != NULL && B->island == 0; B = B->s) {}
   if (B == NULL) {return;}
   for (B = B->s; B != NULL && B->island == 0; B = B->s) {}
   if (B == NULL) {return;}
   for (B = B->e; B != NULL && B->island == 0; B = B->e) {}
   if (B == NULL) {return;}
   for (B = B->n; B != NULL && B->island == 0; B = B->n) {}
   if (B == NULL) {return;}
   
   printworld();
   exit(0);
   
}

int count;
long int bigcount;

int main(int argc, char *argv[]) {
   if (argc != 2) {
      printf("Run with a parameter between 0 and 23 (inclusive)");
      exit(1);
   }
   int perm;
   sscanf(argv[1], "%d", &perm);
   if (perm > 23) {
      printf("Parameter too large\n");
      exit(2);
   }
   fprintf(stderr,"Adrift v2 running with permutation start %d\n", perm);
   initialize(perm);
   count = 0;
   bigcount = 0L;
   while (1) {
      count++;
      if ((count & 0xfffff) == 0) {
         count = 0;
         bigcount++;
         fprintf(stderr,"%03x,%04x of c,2000 (approx)\r", bigcount/0xffffL, bigcount%0xffffL);
      }
      permute();
      checksolved();
   }
   printworld();
}


PostPosted: Tue Apr 18, 2006 8:24 am
 Back to top 
ahdok
Boot


Joined: 07 Apr 2006
Posts: 41
Location: Cambridge

If your solver has recorded the solutions, can you check how many have all the boats end on the same island? I have a feeling the sailors should get to go to the pub together when they finish.

(it's a fairly obvious rule you can add in which cuts down the number of solutions by lots and lots Smile )

I tried looking at the cast adrift to get some clues, but that one was just "which island do all the boats visit" so it didn't help muchly.

PostPosted: Tue Apr 18, 2006 11:13 pm
 View user's profile
 Back to top 
ramsfan
Decorated

Joined: 07 Sep 2005
Posts: 232
Location: holmfirth, yorks

This card is driving me mad. Some thoughts for anyone who like me is doing this using pen and paper.
If you start by looking at C having to travel west, this excludes west from being to the left of a line linking 17 and 15. In turn this limits B's first island to 1,10,2,26. If you consider the second move to the east, this eliminates 2, and I think 26. So I think the first island has to be 1 or 10, which pretty much fixes the direction of north. Actually it throws up 2 issues about this card. You can't sail to 1 without going through 10, but a real ship would easily sail past 10 whilst sailing in the same direction. There's no rule to say it must stop at the first island in a particular direction. I guess that the direction can be within 22 degrees each side of a particular compass point. Considering 10 as the first island, do we go for the centre of the island, or either side, which gives quite a range for north. Also there's no rule to say you can't revisit the same island. I've tried a number of different combinations: all wrong. Hoping someone can put these thoughts to better use than me so far.
_________________
The best therapy is shrink rapped

PostPosted: Wed Apr 19, 2006 9:14 pm
 View user's profile
 Back to top 
Bakers_12
Decorated


Joined: 01 Feb 2006
Posts: 195
Location: Dartford

What if the compleated map is of the whole "globe" , so the east and west would meet up ? No wait that can't be right as there would then be more that one solve. Forget this post . Embarassed
_________________
"Skip To The End"

Playing : Dark Knight, Find 815


PostPosted: Thu Apr 20, 2006 4:29 am
 View user's profile
 Back to top 
lillyplop
Boot

Joined: 17 Oct 2005
Posts: 52

I am using the ultimate power of....Powerpoint. Systematically drawing on an arrowed line from each point.

In 24 hours I have managed to eliminate 105 combinations......phew this is tough.

Anyone know how many combinations I may have left?

PostPosted: Thu Apr 20, 2006 6:04 am
 View user's profile MSN Messenger
 Back to top 
arnezami
Veteran


Joined: 14 Apr 2006
Posts: 136

I've been improving the solver and been producing solutions in a form that can be analyzed by everyone. The solver now has a 100% coverage of the search space. Interestingly this resulted in quite an increase in solutions (i'm glad i did this improvement Wink). I've done all the searches again (with the different map shapes/rotations etc).

All the following solutions are found by covering 100% of the search space.

Code:

 No rotations:

 4x4 map   : 1307 solutions
 odd shape : 367 solutions

 Rotation of boat directions (odd shaped map):
 
  90 degrees : 10 solutions (reduced to 4)
 180 degrees : 126 solutions
 270 degrees : 80 solutions
 
 Rotation of individual pieces (odd shaped map):
 
  90 degrees : 180 solutions
 180 degrees : 127 solutions
 270 degrees : 35 solutions
 


I've also created an Excel file so everybody (with or without programming background) can analyze all the solutions found. It gives the ability to check for certain "patterns" (like all boats ending on the same island: no luck btw). It also gives the ability to "decode" the paths of boats by replacing island numbers by characters (according to a custom scheme). This latter ability probably needs more/many people to look at to see wether a certain "decoding" makes any sense or not. Since its an Excel-file I suspect more people can play with it and add new filters/pattern recognizers.

To use the excel-file with another map than the default one (which is the odd shaped map with no rotation) you have to copy-paste an "all_solutions_"-textfile into the green cell in the excel file. This way you can also analyze other maps/rotations.

Here is a screenshot btw:



Each solution-file now also contains all island numbers a boat passes (for each boat). So its a lot easier to try out a possible solution.

This is probably all I can do. Since we now have all solutions for several reasonable maps/rotations we "only" have to figure out which of the solutions is the "real one" by analyzing all the generated solutions. This why I created the excel-file. I hope somebody comes up with a good criteria so we can put this puzzle to rest...

Good luck. Smile

arnezami

PS. I've also attached the source of the improved solver.
PPS. Maybe somebody can contact the creators for a hint/clue and making them aware of our progress...
analysis_excel.zip
Description 
zip

 Download 
Filename  analysis_excel.zip 
Filesize  1.7MB 
Downloaded  182 Time(s) 
all_solutions.zip
Description 
zip

 Download 
Filename  all_solutions.zip 
Filesize  948.64KB 
Downloaded  175 Time(s) 
CastAdrift2_source.zip
Description 
zip

 Download 
Filename  CastAdrift2_source.zip 
Filesize  37.92KB 
Downloaded  157 Time(s) 

PostPosted: Thu Apr 20, 2006 10:35 am
 View user's profile
 Back to top 
TopGun2
Boot

Joined: 30 Nov 2005
Posts: 30
Location: Cambs, UK

SteveC wrote:
I'm going with the MC screwup idea until we've had some sort of word back from them.. Anyone know what Kurt has to say in his hints?


I agree, and with good reason....

Anyone seen the solve page for this card lately, it's got a corrections note now....

"Note:
This card has an error on it which we are working to correct. Please click the back button on your browser (this will not count as a failed solve attempt)"

Think I'll concentrate on a different card for a while! Evil or Very Mad

TG2
_________________
Audere Est Facere

PostPosted: Thu Apr 20, 2006 5:55 pm
 View user's profile Visit poster's website
 Back to top 
arnezami
Veteran


Joined: 14 Apr 2006
Posts: 136

TopGun2 wrote:
Anyone seen the solve page for this card lately, it's got a corrections note now....

"Note:
This card has an error on it which we are working to correct. Please click the back button on your browser (this will not count as a failed solve attempt)"

Think I'll concentrate on a different card for a while! Evil or Very Mad

TG2

Ah! That explains a lot. Thanks for the info.

PostPosted: Thu Apr 20, 2006 6:24 pm
 View user's profile
 Back to top 
Display posts from previous:   Sort by:   
Page 4 of 7 [100 Posts]   Goto page: Previous 1, 2, 3, 4, 5, 6, 7 Next
View previous topicView next topic
 Forum index » Diversions » Perplex City Puzzle Cards » PXC: Silver Puzzle Cards
Jump to:  

You cannot post new topics in this forum
You cannot reply to topics in this forum
You cannot edit your posts in this forum
You cannot delete your posts in this forum
You cannot vote in polls in this forum
You cannot attach files in this forum
You can download files in this forum
You cannot post calendar events in this forum



Powered by phpBB © 2001, 2005 phpBB Group