Einführung

Sie haben das Unglück, in einem außer Kontrolle geratenen Auto auf einem Hindernisparcours stecken zu bleiben. Alle Funktionen des Fahrzeugs sprechen nicht an, mit Ausnahme des beschädigten Lenksystems. Es kann geradeaus fahren oder nach rechts abbiegen. Kann das Auto in Sicherheit gebracht werden?

Mechanik

Ihr Auto beginnt in der oberen linken Ecke einer 8x8-Karte und versucht, sich in der unteren rechten Ecke in Sicherheit zu bringen. Das Auto hat eine Ausrichtung (anfangs rechts), die in 90-Grad-Schritten gemessen wird. Das Auto kann eine von zwei Aktionen ausführen:

1. Fahren Sie ein Quadrat vorwärts oder
2. Drehen Sie um 90 Grad im Uhrzeigersinn und fahren Sie dann ein Feld vorwärts

Beachten Sie, dass das Auto nicht scharf genug drehen kann, um eine 180-Grad-Drehung auf einem einzelnen Quadrat durchzuführen.

Einige der Plätze sind Hindernisse. Wenn das Auto auf ein Hindernisfeld fährt, stürzt es ab. Alles, was sich außerhalb des 8x8-Kurses befindet, wird als Hindernis angesehen, sodass das Abfahren des Kurses einem Absturz gleichkommt.

Das untere rechte Quadrat ist das sichere Quadrat, mit dem das Auto dem Hindernisparcours entkommen kann. Das Startquadrat und das sichere Quadrat gelten als keine Hindernisse.

Aufgabe

Sie müssen ein Programm oder eine Funktion schreiben, die als Eingabe ein 8x8-Array (Matrix, Listenliste usw.) verwendet, das den Hindernislauf darstellt. Das Programm gibt einen Booleschen Wert oder einen ähnlichen Wahrheitswert zurück oder gibt ihn aus. Wenn es für das Auto möglich ist, den sicheren Platz zu erreichen, ohne zusammenzustoßen (dh wenn die Karte lösbar ist), ist die Ausgabe True, ansonsten ist es False.

Wertung

Standard Code Golf Regeln - der Gewinner ist der Code mit den wenigsten Bytes.

Boni:

• Wenn Ihr Code für eine lösbare Karte eine gültige Reihe von Fahrereingaben ausgibt, die das Auto zum sicheren Feld führen, ziehen Sie 10 Prozentpunkte von Ihrer Punktzahl ab. Ein Beispiel für ein Ausgabeformat ist SRSSR(Straight, Right, Straight, Straight, Right). Diese Ausgabe würde die Standardausgabe ersetzen True.

• Wenn bei einer unlösbaren Karte die Ausgabe Ihres Codes zwischen Situationen unterscheidet, in denen ein Absturz unvermeidbar ist, und Situationen, in denen es möglich ist, den Hindernisparcours für immer zu befahren, ziehen Sie 10 Prozentpunkte von Ihrer Punktzahl ab. Eine Beispielausgabe kann sein, Crashwenn ein Crash unvermeidbar ist oder Stuckdas Auto für immer im Hindernisparcours steckt. Diese Ausgaben würden die Standardausgabe Falsefür eine unlösbare Karte ersetzen .

Beispiel

Wenn das Programm ein 8x8-Array wie dieses erhält:

[[0, 0, 0, 0, 0, 1, 0, 0],
 [0, 0, 0, 0, 0, 0, 1, 0], 
 [1, 1, 0, 0, 0, 0, 0, 0], 
 [0, 1, 0, 1, 0, 0, 0, 0], 
 [0, 0, 1, 1, 0, 0, 0, 0], 
 [0, 0, 0, 0, 1, 0, 1, 0], 
 [0, 0, 0, 0, 0, 0, 1, 0], 
 [0, 1, 1, 0, 0, 0, 1, 0]]

Es würde als eine Karte wie diese interpretiert, wobei schwarze Quadrate Hindernisse anzeigen:

Und eine mögliche Lösung könnte sein:

Da es eine Lösung gibt, sollte das Programm Truediese Karte zurückgeben / drucken . Die hier gezeigte Abfolge von Zügen ist SSSSRSRRRSRSSRRRSSRSSS.

JavaScript (ES6) - 122 124 148 162 172 178 187 190 193 208 Bytes

Vielen Dank an Optimizer und DocMax für hilfreiche Vorschläge zur Verbesserung dieses Codes:

F=a=>(D=(x,y,d)=>!D[i=[x,y,d]]&&(D[i]=1,x-=~d%2,y-=~-~d%2,x*y==49||!((x|y)&8||a[y][x])&&(D(x,y,d)||D(x,y,~-d%4))),D(-1,0))

Gibt true(wahr) für lösbar und false(falsch) für unlösbar zurück.

Funktioniert ab heute nur in Firefox, da JavaScript 1.7 unterstützt wird.

Test Board

Python 2 - 123 125 133 146 148 150 154 160

TrueAuf Erfolg, Falseauf Misserfolg.

def f(h=1,v=0,b=0,x=0,y=0,c=[]):s=x,y,h,v;a=b,x+h,y+v,c+[s];return(s in c)==(x|y)&8==b[y][x]<(x&y>6or f(h,v,*a)|f(-v,h,*a))

Sie müssen Eingabe wie angeben f(b=var_containing_board).

Lambda-Version - 154

Gibt 0(falsy) für Fehler zurück, Truefür Erfolg.

F=lambda b,x=0,y=0,h=1,v=0,c=[]:0if[x,y,h,v]in c or x|y>7or x|y<0 or b[y][x]else x&y==7or F(b,x+h,y+v,h,v,c+[[x,y,h,v]])or F(b,x+h,y+v,-v,h,c+[[x,y,h,v]])

Vielen Dank an Will und Brandon, dass sie die Funktion kürzer gemacht haben als das Lambda. Auch für mehr horizontales Scrollen: D

Dank an xnor für überlegenes Bit-Bashing und Logik!

Anmerkung bearbeiten: Ich bin mir ziemlich sicher, dass dies b[y][x]niemals ausgeführt wird, wenn der Bereich verlassen wird. Da wir uns außerhalb des Boards befinden, wird die Verlaufsprüfung s in cdurchgeführt False. Dann wird die Grenzüberprüfung (x|y)&8sein 8. Dann überprüft Python nicht einmal den letzten Wert von, ==da die ersten beiden bereits unterschiedlich sind.

C (GNU-C), 163 Bytes * 0,9 = 146,7

#C (GNU-C), 186 Bytes * 0,9 = 167,4

Meine neue Version verwendet eine vorzeichenbehaftete statt einer vorzeichenlosen Ganzzahl. Früher hatte ich Angst vor einer Rechtsverschiebung mit Vorzeichen, aber mir wurde klar, dass das Vorzeichen das Torquadrat ist und es keine Rolle spielt, was danach passiert.

Die Funktion verwendet ein Array von Bits (wobei die Bits blockierte Quadrate darstellen) in Form einer 64-Bit-Ganzzahl. Die Bits sind so angeordnet, wie Sie ein Buch lesen würden. Es gibt -1 für einen Absturz, 0 für ewiges Fahren oder 1 für die Flucht in die rechte untere Ecke zurück.

g(long long o) {
    typeof(o) a=0,i=255,r=1,u=0,l=0,d=0,M=~0LLU/i,D;
    for( ;i--;d = D<<8&~o)
        a |= D = d|r,
        r = (r|u)*2&~M&~o,
        u = (u|l)>>8&~o,
        l = ((l|d)&~M)/2&~o;
    return a<0?:-!(d|r|u|l);
}

Testprogramm

f(long long o){typeof(o)a=0,i=255,r=1,u=0,l=0,d=0,M=~0LLU/i,D;for(;i--;d=D<<8&~o)a|=D=d|r,r=(r|u)*2&~M&~o,u=(u|l)>>8&~o,l=((l|d)&~M)/2&~o;return a<0?:-!(d|r|u|l);}
{
    char* s[] = {"Crash", "Stuck", "Escape"};
    #define P(x) puts(s[f(x)+1])
    L ex = 0x4640500C0A034020;
    P(ex);
    L blocked = 0x4040404040404040;
    P(blocked);

    L dead = 0x10002;
    P(dead);

    return 0;
}

Ausgabe

Escape
Stuck
Crash

Python-Array-zu-Hex-Konverter:

a2b=lambda(A):"0x%X"%sum(A[i/8][i%8]<<i for i in range(64))

Python, 187-213

207 Zeichen, 10% Bonus für den Druckpfad

b=map(ord," "*9+" ".join("".join("o "[i]for i in j)for j in input())+" "*9)
def r(p,d,s):
 p+=(1,9,-1,-9)[d]
 if b[p]&1<<d:b[p]^=1<<d;return(s+"S")*(p==79)or r(p,d,s+"S")or r(p,(d+1)%4,s+"R")
print r(8,0,"")

Am Testeingang findet es einen etwas anderen Pfad: SSSSRSRSRRSSRSSRRSRSSRSSSSS

Der allgemeine Ansatz besteht darin, die Eingabe zunächst in ein Leerzeichen und ein os umzuwandeln. Leerzeichen haben ein Sechseck von 20, sodass alle vier unteren Bits nicht gesetzt sind. ohat ein Hex von 6F, so dass die niedrigen vier Bits alle gesetzt sind.

Ein Rand von os wird um das Board gelegt, damit wir uns keine Sorgen über schlechte Indizes machen müssen.

Während wir über das Brett gehen, benutzen wir die Bits in jedem Feld, um zu sehen, ob wir von dieser Seite kommen und passieren dürfen. Auf diese Weise vermeiden wir Endlosschleifen. Es ist nicht genug, einen einzigen Booleschen Wert pro Kachel zu haben, da Ihre Austrittsrichtung von Ihrer Eintrittsrichtung abhängt, sodass Kacheln zweimal besucht werden können.

Wir führen dann eine rekursive Suche nach einem sicheren Pfad durch.

Javascript - 270 - 20% = 216 262 - 20% = 210 Bytes

Da es mindestens eine Lösung geben sollte, die beide Boni einbringt (und nicht zu einer lächerlichen Stapeltiefe führt;) ...

Minimiert:

V=I=>{n=[N=[0,0,0]];v={};v[N]='';O='C';for(S='';n[0];){m=[];n.map(h=>{[x,y,d]=h;D=i=>[1,0,-1,0][d+i&3];p=v[h];for(j=2;j--;){O=v[c=[X=x+D(j),Y=y+D(3-3*j)),d+j&3]]?'K':O;J=X|Y;J<0||J>7||I[Y][X]||v[c]?O:(m.push(c),v[c]=p+'SR'[j])}S=(x&y)>6?p:S});n=m;}return S||O;};

Erweitert:

V = I => {
    n = [N=[0,0,0]];
    v = {};
    v[N] = '';
    O = 'C';

    for( S = ''; n[0]; ) {
        m = [];
        n.map( h => {
            [x,y,d] = h;
            D = i => [1,0,-1,0][d+i&3];
            p = v[h];
            for( j = 2; j--; ) {
                O = v[c = [X = x+D(j),Y = y+D(3-3*j),d+j&3]] ? 'K' : O;
                J = X|Y;
                J<0 || J>7 || I[Y][X] || v[c] ? O : (
                    m.push( c ),
                    v[c] = p + 'SR'[j]
                );
            }

            S = (x&y) > 6 ? p : S;
        } );
        n = m;
    }
    return S || O;
};

vist eine Hash-Tabelle mit Schlüsseln, bei denen es sich um Zustands-Tripel handelt (x,y,d), die der (x, y) -Koordinate und der Eingaberichtung entsprechen d. Jedem Schlüssel ist ein Wert zugeordnet, der aus der Folge von S(geraden) und R(rechten) Zügen besteht, die erforderlich sind, um den durch den Schlüssel dargestellten Zustand zu erreichen.

Der Code verwaltet auch einen Stapel von Tripeln (in Variablen n), die noch nicht verarbeitet wurden. Der Stapel enthält anfänglich nur das Dreifache (0,0,0), entsprechend dem Zustand, in dem das Auto direkt in der Zelle (0,0) steht. In der äußeren Schleife for( S = ... )prüft die Routine, ob noch unverarbeitete Tripel vorhanden sind. In diesem Fall durchläuft jedes unverarbeitete Triple die innere Schleife n.map( ....

Die innere Schleife macht fünf Dinge:

1. berechnet die zwei möglichen Bewegungen (geradeaus fahren, rechts abbiegen) aus dem aktuellen Zustand
2. Wenn einer dieser Schritte zu einem Zustand führt, der bereits in der Hash-Tabelle registriert ist, wird er für die weitere Verarbeitung ignoriert. Wir kennzeichnen die FALSE-Ausgabe jedoch als K(steckengeblieben), da wir mindestens eine Schleife gefunden haben, in der das Auto ohne Absturz für immer kreisen kann.
3. Wenn ein Staat legal und neu ist, wird er für den nächsten Durchgang der äußeren Schleife zur Hashtabelle ( v) und zum Stapel unverarbeiteter Tripel ( m) hinzugefügt
4. Wenn der neue Zustand registriert wird v, wird sein Wert auf den Wert des Ursprungszustandes (die Abfolge von Zügen) plus Roder Sbasierend auf dem aktuellen Zug gesetzt
5. wenn xund ysind 7, wird der Wert des Ursprungszustands (die Abfolge der Bewegungen, die ausgeführt werden, um den Ursprungszustand zu erreichen) kopiert S, da diese Bewegungsabfolge eine Lösung des Problems darstellt

Nachdem die innere Schleife beendet ist, wird n(der Stapel) durch m(den neuen Stapel) ersetzt.

Nachdem die äußere Schleife beendet wurde (es wurden keine neuen Zustände erreicht), gibt die Funktion ihre Ausgabe zurück. Wenn die (7,7) -Zelle erreicht wurde, Senthält sie eine Folge von Zügen, die zu dieser Zelle führen, und wird ausgegeben. Wenn die Zelle nicht erreicht wurde, Swird die leere Zeichenfolge angezeigt, und die Routine führt zur Ausgabe O, die Kgenau dann (stecken bleibt), wenn eine Schleife gefunden wurde, oder C(crash), wenn das Auto unweigerlich abstürzt.

Python 339 - 10% = 305 Bytes

Ich habe eine rekursive Tiefensuche verwendet, die frühzeitig mit Erfolg über beendet wird exit. Auch drucken Weg zum Erfolg in Form von 00001010101010101010101110100111001000, 0für gerade, 1für rechts. Die Antwort wird länger als optimal sein, da es die Tiefe zuerst ist. Ich bin mir sicher, dass einige Optimierungen des Algorithmus die Anzahl der Bytes erheblich verringern könnten.

b=input()
D=[(-1,0),(0,-1),(1,0),(0,1)]
def a(l):
 x,y=0,0
 v=2
 for d in l:
  if d=='1':v=(v+1) % 4
  x+=D[v][0]
  y+=D[v][1]
  if x<0 or x>7 or y<0 or y>7:return 0,x,y
  if b[y][x]:return -1,x,y
 return 1,x,y
def c(l):
 if len(l) < 39:
  t,x,y=a(l)
  if t==1:
   if (x,y)==(7,7):
    print l;exit(0)
   c(l+"0")
   c(l+"1")
c("")
print 0