In Twitch Plays Pokémon ist eines der nervigsten Hindernisse, denen man begegnen kann, ein Eispuzzle, bei dem man von einem Ort zum anderen wandern muss, indem man den ganzen Weg in eine Richtung gleitet, bis man auf eine Mauer oder einen Felsbrocken stößt.

Ihre Aufgabe ist es, ein Programm zu erstellen, das ein zufälliges, schwieriges Eispuzzle generiert.

Ihr Programm wird drei Zahlen akzeptieren, M, N, und P, als Eingang (mit 10 <= M <= 30, 15 <= N <= 40und 0 <= P < 65536):

12 18

und wird ausgeben:

• Ein MBy- NGrid bestehend aus .und O, das Eis bzw. einen Boulder darstellt.
• Eine Positionsmarkierung, die angibt, von wo aus das Puzzle eingegeben wird. Diese Positionsmarke besteht aus einem Buchstaben L, R, T, oder B, links Darstellen, rechts, oben und unten, gefolgt von einer Zahl , die Position darstellt (von links oder von oben) auf der Seite eingegeben wird aus.
• Eine ähnliche Positionsmarkierung, die angibt, wo das Rätsel beendet wird.
• Die kürzeste Lösung des Rätsels, bestehend aus einer Folge von L, R, U, und Dsind.

Beispielausgabe:

..O...O...........
............O.....
..O...............
.......O..........
..................
...........O......
O..O...........O..
..........O.......
..O..........O....
........O.........
O....O.........O..
............O.....
R 4
B 5
LDLDRULD
(Note that this output is actually invalid because it is not actually long enough.)

Für eine Eingabe Mund Nmuss die Lösung des Puzzles mindestens min(M, N)Schritte haben und mindestens die 2 (M + N)gesamten Leerzeichen bewegen . (Als Referenz, bewegt sich der oben Puzzle insgesamt 12 Schritte, Bewegen 69 Plätze.) Ihre Puzzle - Generator eine andere erzeugen muss Mdurch NPuzzle mit einem anderen Lösungsweg für jeden Samen (dh eine andere Abfolge von Schritten für jede Lösung) P.

• Beachten Sie, dass die Anforderung eines anderen Lösungspfads darin besteht, Lösungen zu vermeiden, die versuchen, systematisch Felspfade zu generieren, wie hier Claudius Lösung . Wenn es zwei oder drei Paare identischer Lösungen aufgrund von Macken in der Zufälligkeit gibt, ist dies in Ordnung, solange das Programm nicht absichtlich versucht, systematisch Rätsel mit der gleichen Abfolge von Zügen zu generieren.

Der kürzeste Code für die oben genannten Aufgaben gewinnt.

Python, 672 548 Zeichen, interessantere Rätsel

Obwohl ich mich strikt an die Regeln halte, schlägt mein anderes Python-Programm dieses. Ich habe beschlossen, ein Programm zu schreiben, das ohnehin interessantere Rätsel generiert. Hier ist es:

R=range;import random as J;X=J.randint
x=(0,1,-1,0);y=x[2:]+x
g=lambda r,c:(0<=r<H)+(0<=c<W)>1and f[r][c]or x[(r,c)in(A,E)]
l=lambda r,c:g(r+y[d],c+x[d])<1and(r,c)or l(r+y[d],c+x[d])
H,W,P=input();J.seed(P)
while 1:
 A=(-1,X(0,W));E=(H,X(0,W));f=[[X(0,7)for _ in R(W)]for _ in R(H)]
 q=[(A,'')];n=z={}
 while q and n!=E:
    n,O=q.pop()
    for d in R(4):
     N=l(*n)
     if g(n[0]+y[d],n[1]+x[d])and N not in z:q[:0]=[(N,O+"URLD"[d])];z[N]=1
 if(n==E)*len(O)>min(H,W):print"\n".join(''.join('O.'[c>0]for c in T)for T in f),"\nT",A[1],"\nB",E[1],"\n",O;break

Einrückungsstufen sind Leerzeichen, Tabulator, Tabulator + Leerzeichen.

Proben :

$ echo [10,15,0] | python ice2.py
.....OO........
...............
...O....O.OO..O
...........O...
..O....O.......
.......O....O..
....O..........
.............O.
..............O
...............
T 1
B 10
DLURDRURULDRD

Es wird Pals Startwert verwendet, sodass jedes Pdas gleiche Rätsel generiert und jedes andere Phöchstwahrscheinlich anders ist:

$ echo [10,15,1] | python ice2.py
.OOO.O.........
...O......O.O.O
.......O.......
..O..........OO
.....O.........
.............O.
.O.............
.O............O
O....O.........
......O........
T 14
B 8
DLDRDLURULD

Es funktioniert einigermaßen schnell bis zu einer Größe von, M=25,N=40aber danach wird es sehr langsam. Es sollte theoretisch funktionieren, M=30, N=40wenn Sie es lange genug laufen lassen. Ich habe hier in der Spur manuell geschrieben, da es schwer zu folgen ist - das Programm gibt nur das Puzzle aus.

$ echo [25,40,0] | python ice2.py
                   *
...................dO....urrrO..O..O....
....O.....O........dO....u..dO..........
..........O.....O..d....Ou.Odrrrrrrrrrrr
...........O.......d.O..Ou..O.....OOllld
.O....O.OO.........drrrrrrO....Olllud..O
O......O...O.O.....O............dO.ud...
O........OO..........O.........Od..ud..O
.........O......................d..ud...
....O.....O.O....O.....O........d..ud.O.
.....O..O...................O...d..udO..
.........O.........O..O.........d..ud...
.......O.O...O..O.OO....O...OOlldOOld...
........Olllllllllu....OO.OO..dOO...O...
.O.O....Od........u......O....d..O...O..
..O....O.d........u..O........d..O..O...
....O....d..O.....uO.....O....d.........
.........d........u...........d.........
.........d....O...u.O..O.....Od.O.......
........Od...O....u...........d.........
.O.....OuxrrrrO...u...OOOO..O.d.........
........udO..dO.O.u...........d.........
O..O.O..ud...d..urrO..........d.O...O...
........ud...d..u.O.O........Od..O...O..
..OO....ud..Od..u......OllllludO.....O..
..O....OldO..dOOlllllllld...Old...O..O..
             *
T 19
B 13
DRURDRDLDLULDLDLULDLURULDLURD

Erklärung :

Das Programm durchläuft eine Schleife und generiert eine zufällige Startposition oben, eine zufällige Endposition unten und ein zufälliges Raster mit der 12.5%Chance, dass sich an einer bestimmten Stelle ein Felsbrocken befindet. Dann löst es das Rätsel mit einer Breitensuche. Wenn die Lösung existiert und größer als ist min(H,W), wird sie gedruckt und beendet.

Java - 2632

Während ich die technische Reinheit von Claudius Antwort bewundere , habe ich mich entschlossen, etwas schwierigere Rätsel zu machen;)

Grundlegende Schritte (ziemlich einfach):

Randomize entry location
Step forward
For min(m,n)-1 steps:
    Rotate left or right
    Slide until I hit something or go a random distance
    Place a rock in front of stopping location
If I can slide straight to any wall:
    Slide to exit
Else
    Create another step and try again

If at any step I get trapped, start over
If BFS finds shorter path, start over

Ich markiere auch jeden Punkt als "Nogo", während ich rutsche. Wenn ich auf einem Nogo-Platz lande (oder direkt vor einem, was bedeuten würde, dass ein Stein dorthin geht), ist das ein ungültiger Schritt.

Die Idee ist also, zufällig viele Karten zu generieren und die erste gültige zu behalten. Ich habe vor, dieses Verfahren intelligenter zu gestalten (Backtracking usw.), aber es funktioniert derzeit einwandfrei. Wir werden sehen, dass dadurch möglicherweise auch redundanter Code eingespart wird.

So wie es ist, werden kleine Karten (15x10) fast sofort, mittlere Karten (30x20) in wenigen Sekunden und große Karten (40x30) in zufälliger Zeit zwischen 20 Sekunden und 20 Minuten erzeugt, abhängig vom Startwert. Es werden je nach Größe zwischen 300.000 und 500.000 Karten pro Sekunde auf meinem Computer getestet.

Randnotiz: Manchmal sind die Karten nicht zu schwer, einfach weil es nur so viele Steine ​​wie Stufen gibt und es meistens nur eine Option gibt, wenn Sie einen tatsächlichen Stein treffen möchten, es sei denn, die Stufe führt Sie zu einer Mauer. Ich werde das später beheben, indem ich "zufällige" Steine ​​an sicheren Stellen platziere, nachdem alle Schritte gezeichnet wurden. Da Nogo-Spots bereits markiert sind, sollte das ziemlich einfach sein. Genießen Sie vorerst nur diese Beispiele:

Ausgabe mit verschiedenen Größen / Samen:

$ java I 30 20 6851              $ java I 15 10 1     $ java I 15 10 65513  

............................O.      .......O.......     ....O..........     
..............................      ...............     ...............     
..............................      .........O.....     .........O.....     
..........O......O............      .............O.     ..............O     
...............O...........O..      ...............     ...............     
..............................      .......O.......     .....O.O.......     
..............................      O..............     ...............     
........................O.....      ...............     ..........O....     
..............................      ...............     O..............     
...O.......................O..      ......O........     ...............     
O...............O.OO..........          
..............O..........O....          
...........O..................      T 14                R 6         
....O.........................      T 7                 T 14            
..............................      DLDLULURU           LULDLDRURU
..............................
..............................
.................O............
.O............................
..............................


B 28
R 9
ULURDLDLDRURDLDRURUR

Maximale Größe 40x30:

$ java I 40 30 2

........................................
........................................
........................................
........................................
................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....................

B 19
B 11
URURDLULULDRDRDLULDLDLULURDLD

Golf gespielt:

import java.util.*;import java.awt.*;class I{int m,n,p,g,a[][],b[][];Random r;Point s,e,c;ArrayList<Integer>z;void Q(String q,int l){if(l>0)System.out.println(q);else System.out.print(q);}void G(String[]y){m=Integer.valueOf(y[0]);n=Integer.valueOf(y[1]);p=Integer.valueOf(y[2]);r=new Random(p);Q("",1);int o=0,i,j,u=0;char t,f[]={85,76,68,82};while(o<3){if(++u%20000==0)Q("\r#"+u,0);a=new int[m+2][n+2];b=new int[m+2][n+2];for(i=0;i<m+2;i++)for(j=0;j<n+2;j++)if(i==0||i==m+1||j==0||j==n+1)a[i][j]=2;s=new Point();int e=r.nextInt(m*2+n*2);if(e<m*2){s.x=e%m+1;s.y=e<m?0:n+1;}else{s.y=(e-m*2)%n+1;s.x=(e-m*2)<n?0:m+1;}if(s.x<1)g=3;else if(s.x>m)g=1;else if(s.y<1)g=2;else if(s.y>n)g=0;a[s.x][s.y]=0;c=new Point(s);z=new ArrayList<Integer>();z.add(g);for(i=0;i++<Math.min(m,n)-1;)if(N()<1&&N()<1)break;o=((z.size()>=Math.min(m,n)-1)?1:0)+F()+((V()==z.size())?1:0);}Q("\r",0);for(j=1;j<n+1;j++){for(i=1;i<m+1;i++)Q(String.valueOf(a[i][j]>0?'O':'.'),0);Q("",1);}Q("\n\n",0);if(s.x<1||s.x>m){t=s.x<1?'L':'R';u=s.y;}else{t=s.y<1?'T':'B';u=s.x;}Q(t+" "+u,1);if(e.x<1||e.x>m){t=e.x<1?'L':'R';u=e.y;}else{t=e.y<1?'T':'B';u=e.x;}Q(t+" "+u,1);for(i=0;i<z.size();)Q(String.valueOf(f[z.get(i++)]),0);Q("",1);}public static void main(String[]a){new I().G(a);}int F(){int c=0;while(C()<1&&c++<10)if(N()<1)return 0;return e==null?0:1;}int C(){int d=g<2?-1:1;if(g%2<1){int y=c.y;while(y>0&&y<n+1){y+=d;if(a[c.x][y]==1)return 0;}e=new Point(c.x,y);}else{int x=c.x;while(x>0&&x<m+1){x+=d;if(a[x][c.y]==1)return 0;}e=new Point(x,c.y);}a[e.x][e.y]=0;return 1;}int V(){if((s.x-e.x)+(s.y-e.y)<2)return 0;Queue<Point>q=new ArrayDeque<Point>();Queue<Integer>d=new ArrayDeque<Integer>();a[s.x][s.y]=-2;q.add(s);d.add(0);while(q.size()>0){Point t=q.poll();int h=d.poll(),i=0;if(t.equals(e))return h;for(;i<4;i++){Point n=S(a,t,i<2?0:1,i%2<1?-1:1,99,1);if(a[n.x][n.y]==-2)continue;a[n.x][n.y]=-2;q.add(n);d.add(h+1);}}return 0;}int N(){Point q;int d=g<2?-1:1,x,y;System.arraycopy(a,0,b,0,a.length);q=S(b,c,g,d,r.nextInt((g%2<1?n:m)/2)+2,0);if(q.x<1||q.y<1||q.x>m||q.y>n||q.equals(c)||b[q.x][q.y]!=0)return 0;x=q.x;y=q.y;if(g%2<1)y+=d;else x+=d;if(b[x][y]<0)return 0;b[q.x][q.y]=-1;b[x][y]=1;int f=r.nextInt(2)<1?-1:1;g=g%2<1?(f<0?1:3):(g=f<0?0:2);c=q;System.arraycopy(b,0,a,0,a.length);z.add(g);return 1;}Point S(int[][]u,Point f,int w,int d,int q,int s){int i=1,x=f.x,y=f.y;for(;i<=q;i++){if(w%2<1)y=f.y+i*d;else x=f.x+i*d;if(e!=null&&e.x==x&&e.y==y)return e;if(y<0||y>n+1||x<0||x>m+1)return f;if(s<1&&u[x][y]<1)u[x][y]=-1;if(u[x][y]>0){if(w%2<1)y-=d;else x-=d;return new Point(x,y);}}if(w%2<1)return new Point(f.x,f.y+i*d);else return new Point(f.x+i*d,f.y);}}

Mit Zeilenumbrüchen:

import java.util.*;
import java.awt.*;

class I{
    int m,n,p,g,a[][],b[][];
    Random r;
    Point s,e,c;
    ArrayList<Integer>z;

    void Q(String q,int l){if(l>0)System.out.println(q);else System.out.print(q);}

    void G(String[]y){
        m=Integer.valueOf(y[0]);
        n=Integer.valueOf(y[1]);
        p=Integer.valueOf(y[2]);
        r=new Random(p);
        Q("",1);

        int o=0,i,j,u=0;
        char t,f[]={85,76,68,82};
        while(o<3){
            if(++u%20000==0)
                Q("\r#"+u,0);

            a=new int[m+2][n+2];
            b=new int[m+2][n+2];
            for(i=0;i<m+2;i++)
                for(j=0;j<n+2;j++)
                    if(i==0||i==m+1||j==0||j==n+1)
                        a[i][j]=2;

            s=new Point(); 
            int e=r.nextInt(m*2+n*2);
            if(e<m*2){
                s.x=e%m+1;
                s.y=e<m?0:n+1;
            }else{
                s.y=(e-m*2)%n+1;
                s.x=(e-m*2)<n?0:m+1;
            }
            if(s.x<1)g=3;
            else if(s.x>m)g=1;
            else if(s.y<1)g=2;
            else if(s.y>n)g=0;

            a[s.x][s.y]=0;
            c=new Point(s);
            z=new ArrayList<Integer>();
            z.add(g);

            for(i=0;i++<Math.min(m,n)-1;)
                if(N()<1&&N()<1)
                        break;
            o=((z.size()>=Math.min(m,n)-1)?1:0)+F()+((V()==z.size())?1:0);
        }

        Q("\r",0);
        for(j=1;j<n+1;j++){
            for(i=1;i<m+1;i++)
                Q(String.valueOf(a[i][j]>0?'O':'.'),0);
            Q("",1);
        }
        Q("\n\n",0);
        if(s.x<1||s.x>m){
            t=s.x<1?'L':'R';
            u=s.y;
        }else{
            t=s.y<1?'T':'B';
            u=s.x;
        }
        Q(t+" "+u,1);
        if(e.x<1||e.x>m){
            t=e.x<1?'L':'R';
            u=e.y;
        } else {
            t=e.y<1?'T':'B';
            u=e.x;
        }
        Q(t+" "+u,1);
        for(i=0;i<z.size();)
            Q(String.valueOf(f[z.get(i++)]),0);
        Q("",1);
    }

    public static void main(String[]a){
        new I().G(a);
    }

    int F(){
        int c=0;
        while(C()<1&&c++<10)
            if(N()<1)
                return 0;
        return e==null?0:1;
    }

    int C(){
        int d=g<2?-1:1;
        if(g%2<1){
            int y=c.y;
            while(y>0&&y<n+1){
                y+=d;
                if(a[c.x][y]==1)
                    return 0;
            }
            e=new Point(c.x,y);
        }else{
            int x=c.x;
            while(x>0&&x<m+1){
                x+=d;
                if(a[x][c.y]==1)
                    return 0;
            }
            e=new Point(x,c.y);
        }
        a[e.x][e.y]=0;
        return 1;
    }


    int V(){
        if((s.x-e.x)+(s.y-e.y)<2)
            return 0;
        Queue<Point>q=new ArrayDeque<Point>();
        Queue<Integer>d=new ArrayDeque<Integer>();
        a[s.x][s.y]=-2;

        q.add(s);
        d.add(0);
        while(q.size()>0){
            Point t=q.poll();
            int h=d.poll(),i=0;
            if(t.equals(e))
                return h;
            for(;i<4;i++){
                Point n=S(a,t,i<2?0:1,i%2<1?-1:1,99,1);
                if(a[n.x][n.y]==-2)
                    continue;
                a[n.x][n.y]=-2;
                q.add(n);d.add(h+1);
            }
        }
        return 0;
    }


    int N(){
        Point q;
        int d=g<2?-1:1,x,y;
        System.arraycopy(a,0,b,0,a.length);
        q=S(b,c,g,d,r.nextInt((g%2<1?n:m)/2)+2,0);      
        if(q.x<1||q.y<1||q.x>m||q.y>n||q.equals(c)||b[q.x][q.y]!=0)
            return 0;
        x=q.x;
        y=q.y;
        if(g%2<1)
            y+=d;
        else
            x+=d;
        if(b[x][y]<0)
            return 0;
        b[q.x][q.y]=-1;
        b[x][y]=1;
        int f=r.nextInt(2)<1?-1:1;          
        g=g%2<1?(f<0?1:3):(g=f<0?0:2);
        c=q;
        System.arraycopy(b,0,a,0,a.length);
        z.add(g);
        return 1;
    }

    Point S(int[][]u,Point f,int w,int d,int q,int s){
        int i=1,x=f.x,y=f.y;
        for(;i<=q;i++){
            if(w%2<1)
                y=f.y+i*d;
            else
                x=f.x+i*d;
            if(e!=null&&e.x==x&&e.y==y)
                return e;
            if(y<0||y>n+1||x<0||x>m+1)
                return f;
            if(s<1&&u[x][y]<1)
                u[x][y]=-1;
            if(u[x][y]>0){
                if(w%2<1)
                    y-=d;
                else
                    x-=d;
                return new Point(x,y);
            }
        }
        if(w%2<1)
            return new Point(f.x,f.y+i*d);
        else
            return new Point(f.x+i*d,f.y);              
    }
}

Python, 235 206 185 176 Zeichen

H,W,P=input()
t=''
for x in range(16):t+=".O"[(P>>x)%2]
for n in[t[1:],t[0],"O","...O"]+["."]*(H-5)+[".O.."]:print(n*W)[:W]
print"B 1\nR",(H,3)[-W%4/2],"\n",("URDR"*W)[:W+W%2]

Verwendung :

Die Eingabe erfolgt über die Standardeingabe des Formulars [M, N, P].

$ echo [14, 17, 2] | python ice.py
O..............O.
.................
OOOOOOOOOOOOOOOOO
...O...O...O...O.
.................
.................
.................
.................
.................
.................
.................
.................
.................
.O...O...O...O...
B 1
R 3
URDRURDRURDRURDRUR

Sie sagten, die Karten müssten für jeden Samen unterschiedlich sein P... und das sind:

$ echo [14, 17, 233] | python ice.py
..O.OOO..........
OOOOOOOOOOOOOOOOO
OOOOOOOOOOOOOOOOO
...O...O...O...O.
.................
.................
.................
.................
.................
.................
.................
.................
.................
.O...O...O...O...
B 1
R 3
URDRURDRURDRURDRUR
$ echo [14, 17, 65133] | python ice.py
.OO.OO..OOOOOOO.O
OOOOOOOOOOOOOOOOO
OOOOOOOOOOOOOOOOO
...O...O...O...O.
.................
.................
.................
.................
.................
.................
.................
.................
.................
.O...O...O...O...
B 1
R 3
URDRURDRURDRURDRUR

Und ein Beispiel mit einer anderen Größe:

$ echo [10, 15, 65133] | python ice.py
.OO.OO..OOOOOOO
OOOOOOOOOOOOOOO
OOOOOOOOOOOOOOO
...O...O...O...
...............
...............
...............
...............
...............
.O...O...O...O.
B 1
R 10
URDRURDRURDRURDR

Erfüllt alle angegebenen objektiven Kriterien:

• Jedes Pführt zu einem anderen Rätsel
• Es gibt nur eine Lösung, also die kürzeste
• Die Lösung unternimmt N + N%2zumindest SchritteN
• Die Lösung braucht immer mehr als 2 (M + N) gesamte Fläche

Erklärung :

Jede Zeile wird erstellt, indem ein bestimmtes Zeichenfolgenelement wiederholt Wund die Länge auf W(Ich verwende Hund Wanstelle von) begrenzt wirdM und N) erstellt.

Die ersten beiden Reihen hängen davon ab P, um jedes Puzzle einzigartig zu machen. Beachten Sie grundsätzlich, dass dies Pin eine 16-Bit-Ganzzahl ohne Vorzeichen passt. Ich konvertiere Pnach binär und verwende .für 0 und Ofür 1:

t=''
for x in range(16):t+=".O"[(P>>x)%2]

Das erste Zeilenelement sind die letzten 15 Bits, t[1:]während das zweite Zeilenelement das erste Bit ist t[0]. Ich konnte nicht alles in eine Zeile schreiben, da die minimale Breite 15 ist, was nicht für alle 16 Bits passen würde, wennP schreiben, > 32767 Die ersten beiden Zeilen repräsentieren also eindeutig jeden der möglichen Werte von P.

Die dritte Reihe ist eine volle Wand, so dass der Wert von P keinen Einfluss auf die Lösung hat.

Folgen Sie dann den tatsächlichen Labyrinthelementen. Diese Linie druckt sie alle und wiederholt sie bis zur Kappe. Das Ergebnis ist wie oben dargestellt:

for n in[t[1:],t[0],"O","O..."]+["."]*(H-5)+["..O."]:print(n*W)[:W]

Der Rest wollte nur herausfinden, wie man das dynamisch erzeugte Labyrinth löst. Dies hängt nur von der Breite des Labyrinths ab. Ich stellte fest, dass die Lösungen für eine gegebene Breite waren:

  W  | solution 
-----+---------
  1  | UR
  2  | UR
  3  | UR DR
  4  | UR DR 
  5  | UR DR UR
  6  | UR DR UR
  7  | UR DR UR DR
  8  | UR DR UR DR

usw. Daher wird es nur URDRwiederholt und an der richtigen Stelle abgeschnitten W+W%2.

print"B 1\nR",(H,3,3,H)[W%4],"\n",("URDR"*W)[:W+W%2]