Dies ist eine zusätzliche Herausforderung für die Herausforderung " Loopy-Rätsel generieren" . Möglicherweise möchten Sie diese Herausforderung lösen, bevor Sie die schwierigere Herausforderung im vorherigen Link versuchen.

Das Ziel dieser Herausforderung ist es, die Lösung für ein Loop-Puzzle zu validieren. Bitte nehmen Sie die gesamte Dokumentation darüber, was ein Loop-Puzzle ist, aus dem vorherigen Link. Ein gelöstes Loopy-Puzzle wird ähnlich wie die Ausgabe einer gültigen Übermittlung an die Herausforderung "Loopy-Puzzles generieren" formatiert und sieht möglicherweise folgendermaßen aus:

+-+-+ +-+ +-+ +
|   | | |2|3|  
+-+ + + + + +-+
 2| | | |2|  3|
+ + +-+ + + +-+
 2|  2 1|3| |  
+-+ +-+ +-+ +-+
|2  | |    1 2|
+ +-+ +-+ +-+ +
| |2 1 2|3|3| |
+ + +-+ +-+ +-+
| | |3|2   1   
+ +-+ +-+-+-+-+
|        2 2  |
+-+-+-+-+-+-+-+

Der Pfad, aus dem die Lösung besteht, ist mit markiert | und -Zeichen zwischen den +Zeichen .

Eingabespezifikation

Ihr Programm erhält ein Loop-Puzzle mit einer Lösung, die wie im obigen Beispiel formatiert ist, als Eingabe. Ihr Programm soll die Größe des Puzzles aus der Eingabe ableiten. Sie können die folgenden Annahmen über die Eingabe treffen:

• Das Puzzle hat nicht weniger als 2 und nicht mehr als 99 Zellen in beide Richtungen
• Somit hat jede Zeile eine maximale Länge von 199 Zeichen ohne die Zeilenumbruchzeichen.
• Somit enthält der Eingang maximal 99 Zeilen
• Jede Zeile kann nach dem letzten druckbaren Zeichen enden oder mit Leerzeichen aufgefüllt werden, sodass sie eine Länge von bis zu 2 · y + 1 Zeichen hat, wobei y die Anzahl der Zellen in horizontaler Richtung ist
• Jede Position mit x- und y- Koordinaten enthält sogar a+ Zeichen
• Positionen horizontal oder vertikal neben Positionen, die +Zeichen enthalten , enthalten entweder ein Leerzeichen, befinden sich hinter dem Zeilenende oder enthalten ein -Zeichen, wenn sie horizontal benachbart sind, oder a| Zeichen, wenn sie vertikal benachbart sind
• Alle anderen Positionen entweder hinter dem Ende der Zeile oder eines der Zeichen enthalten , 0, 1,2 , oder3
• Alle Zeilen werden mit den Standard-Zeilenumbruchzeichen Ihrer Plattform abgeschlossen.
• Es gibt genau eine nachfolgende Newline

Die Eingabe muss auf eine der folgenden Arten empfangen werden:

• Von der Standardeingabe
• Als Wert eines Parameters namens p in einer HTTP-POST-Anforderung benannt ist
• Als Inhalt eines HTML-Formulars
• Als Inhalt einer Datei mit dem Namen p in einem implementierungsdefinierten Verzeichnis benannt ist
• In einer Implementierung zur Laufzeit definiert, wenn die vorherigen vier nicht verfügbar sind
• Fest codiert, wenn Ihre Sprache keine Möglichkeit bietet, Eingaben zu empfangen

Ausgabespezifikation

Ihr Programm endet für alle Eingaben, die der Eingabespezifikation entsprechen, und berechnet, ob die Lösung für das Rätsel korrekt ist. Ihr Programm gibt das Ergebnis der Berechnung auf eine der folgenden Arten als booleschen Wert aus:

• Als Exit-Status entweder Null (Lösung ist gültig) oder ungleich Null (Lösung ist ungültig)
• Als Zeichen y(Lösung ist gültig) oder n(Lösung ist ungültig) gefolgt von null oder mehr beliebigen Zeichen, die in einer implementierungsdefinierten Weise ausgegeben werden

Das Verhalten Ihres Programms ist nicht angegeben, wenn Eingaben auftreten, die nicht gemäß der Eingabespezifikation formatiert sind.

Wertung

Die Punktzahl Ihres Programms ist die Anzahl der Zeichen in seiner Quelle, mit Ausnahme von auslassbaren Leerzeichen und auslassbaren Kommentaren. Sie werden aufgefordert, Ihre Einreichung einzurücken, damit sie für die anderen leichter zu lesen ist, und Ihre Lösung zu kommentieren, damit sie leichter zu befolgen ist.

Einsendungen, die der Eingabe- oder Ausgabespezifikation nicht entsprechen oder falsche Ergebnisse generieren, sind ungültig.

GolfScript, 133 Zeichen

'|':^4,{48+.(}%+^*1>.^/'-'*+2/:F;4{{~@@/*}2F//n%zip-1%n*}:X*.'+-'?.3+@/(-2<' 9'+\+'9-+  99|+  9'3/:F;.,4*{X}*.9`?@=\' +09
'-!&'ny'1/=

Erwartet die Eingabe von STDIN und druckt yfür eine gültige und nfür eine ungültige Lösung . Führt die Aufgabe aus, indem hauptsächlich Zeichenfolgen im Raster oder mit gedrehten Versionen des Rasters ersetzt werden.

Kommentierter Code:

# construct the string "|0|/|1|0|2|1|3|2-0-/-1-0-2-1-3-2"
# split into pieces of two and save to variable F
'|':^4,{48+.(}%+^*1>.^/'-'*+
2/:F;

# run the code block X 4 times
# with X: string-replace 1st item in F with 2nd, 3rd with 4th, ...
# i.e. '|0' with '|/', '|1' with '|0'
# and then rotate grid by 90 degrees
4{{~@@/*}2F//n%zip-1%n*}:X*

# for a valid grid all digits are now reduced to exactly '0'
# (i.e. no '1' or '2' or '3' or '/')

# now follow the loop along and remove it
# start: find the first occurence of '+-+' and replace with '+ 9'
# note: '9' is the marker for the current position
.'+-'?
.3+@/(-2<' 9'+\+

# string-replace '9-+' or '9|+' by '  9' (i.e. go one step along the loop)
# using block X enough times
'9-+  99|+  9'3/:F;
.,4*{X}*

# look for the marker '9' in the result and check if it is at the original
# position again
.9`?
@=

# the remaining grid must not contain any digits besides 0 and 9
# esp. no '|' or '-' may remain
\' +09
'-!

# check if both conditions are fulfilled and output corresponding character
&'ny'1/=

C # 803 579 Bytes

Ein vollständiges Programm, das aus STDIN gelesen wird, sollte mit jedem gängigen neuen Zeilenschema fertig werden, solange es Zeilenvorschübe enthält. Vielen Dank an HackerCow für den Hinweis, dass ich keine neue Zeile an eine andere Frage anhängen muss, und ich wurde aufgefordert, sie hier zu entfernen und 4 Byte zu sparen

Golfcode:

using C=System.Console;class P{static void Main(){var D=C.In.ReadToEnd().Replace("\r","").Split('\n');int w=D[0].Length+2,h=D.Length+1,i=0,j,c,T=0,O=1,o,z,R=0;var B=new int[w,h];var S=new int[w*h*9];for(;i++<w-2;)for(j=0;j<h-2;B[i,j]=c)if((c=(D[j++][i-1]-8)%10)>5){c=5;T++;S[0]=i+j*w;}for(i=0;++i<w-1;)for(j=0;++j<h-1;)R=(i%2+j%2>1&(o=B[i,j-1]%2+B[i-1,j]%2+B[i+1,j]%2+B[i,j+1]%2)>0&o!=2)|((c=B[i,j])<4&c!=o)?7:R;for(o=h=0;o<O;B[i,j]=0)if(B[i=(c=S[o++])%w,j=c/w]>4){h++;S[O++]=(S[O++]=c-w-1)+2;S[O++]=(S[O++]=c+w-1)+2;z=j%2<1?w*2:2;S[O++]=c-z;S[O++]=c+z;}C.Write(h-R<T?"n":"y");}}

Der Code führt 3 Überprüfungen durch, wobei zuerst die Anzahl der Zeilen um jede Nummer überprüft wird und dass von jeder Kreuzung 0 oder 2 Zeilen ausgehen, und dann, dass alle Zeilen miteinander verbunden sind.

Formatierter Code:

using C=System.Console;

class P
{
    static void Main()
    {
        var D=C.In.ReadToEnd().Replace("\r","").Split('\n');
        int w=D[0].Length+2,h=D.Length+1,i=0,j,c,T=0,O=1,o,z,R=0;
        var B=new int[w,h]; // this is the grid
        var S=new int[w*h*9]; // this is a list of joined up lines (stored as x+y*w)

        for(;i++<w-2;)
            for(j=0;j<h-2;B[i,j]=c)
                if((c=(D[j++][i-1]-8)%10)>5)
                { // we are a line
                    c=5;
                    T++; // increment line counter
                    S[0]=i+j*w; // set start of loop
                }

        for(i=0;++i<w-1;) // this loop checks the numbers and that every + has 0 or 2 lines leading from it
            for(j=0;++j<h-1;)
                R=(i%2+j%2>1&(o=B[i,j-1]%2+B[i-1,j]%2+B[i+1,j]%2+B[i,j+1]%2)>0&o!=2)|((c=B[i,j])<4&c!=o)?7:R; // set R to 7 (no significance) if check fails

        for(o=h=0;o<O;B[i,j]=0) // this loops through the list of joined lines adding more until the whole loop has been seen
            if(B[i=(c=S[o++])%w,j=c/w]>4)
            {
                h++; // increment "seen" counter
                S[O++]=(S[O++]=c-w-1)+2;
                S[O++]=(S[O++]=c+w-1)+2;
                z=j%2<1?w*2:2; // special for | and -
                S[O++]=c-z;
                S[O++]=c+z;
            }

        C.Write(h-R<T?"n":"y"); // check if R is greater than 0 or h is less than T and output appropriately
    }
}

Cobra - 514

class P
    def main
        t,m,g=[[1]][:0],nil,File.readAllLines('p')
        u,i=g[0].length,1
        for l in g.length,for c in u,if g[l][c]in'0123'
            n=0
            for j in-1:2:2,for r in[g[l+j][c],g[l][c+j]],if r in'-|',n+=1
            if'[n]'<>g[l][c],m?='n'
        else if g[l][c]in'-|',x,y,t,d=c,l,t+[[c,l]],g[l][c]
        while i
            i=z=6
            for f,b in[[-1,1],[1,1],[0,2],[-1,-1],[+1,-1],[0,-2]]
                if'-'==d,f,b=b,f
                for w in t.count,if z and t[w]==[x+f,y+b],t,x,y,d,z=t[:w]+t[w+1:],x+=f,y+=b,g[y][x],0
                i-=z//6
        print if(t.count,'n',m?'y')

Überprüft, ob jede Zahl die richtige Anzahl von Zeilen neben sich hat, geht dann einen Pfad um die Zeilen herum und prüft, ob sie eine verpasst hat.