Questa è un'ulteriore sfida alla sfida di generare puzzle Loopy . Potresti voler risolvere questa sfida prima di tentare la sfida più difficile nel link precedente.

L'obiettivo di questa sfida è convalidare la soluzione di un puzzle circolare. Si prega di prendere tutta la documentazione su cosa sia un puzzle loopy dal link precedente. Un puzzle loopy risolto è formattato in un modo molto simile all'output di un invio valido alla sfida "generate puzzle loopy" e può apparire così:

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

Il percorso che costituisce la soluzione è contrassegnato da |e -caratteri tra i +caratteri.

Specifica di input

Il tuo programma riceverà un puzzle circolare con una soluzione formattata come l'esempio sopra come input. Il tuo programma deve dedurre la dimensione del puzzle dall'input. È possibile formulare le seguenti ipotesi sull'input:

• Il puzzle ha non meno di 2 e non più di 99 celle in entrambe le direzioni
• Pertanto, ogni riga ha una lunghezza massima di 199 caratteri, esclusi i caratteri di nuova riga
• Pertanto, l'ingresso contiene un massimo di 99 righe
• ogni riga può terminare dopo l'ultimo carattere stampabile o può essere riempita con caratteri spazi bianchi in modo che abbia una lunghezza massima di 2 · y + 1 caratteri dove y è il numero di celle in direzione orizzontale
• ogni posizione sia x ed y coordinate contiene anche un +carattere
• le posizioni orizzontalmente o verticalmente adiacenti alle posizioni che contengono +caratteri contengono uno spazio bianco, sono dietro la fine della linea o contengono un -carattere se adiacente orizzontalmente o un |carattere se adiacente verticalmente
• tutte le altre posizioni sono o dietro l'estremità della linea o contenere uno dei caratteri , 0, 1, 2, o3
• tutte le righe sono terminate con i caratteri di nuova riga predefiniti della piattaforma
• c'è esattamente una nuova riga finale

L'input deve essere ricevuto in uno dei seguenti modi:

• Dall'input standard
• Come valore di un parametro denominato pin una richiesta POST HTTP
• Come il contenuto di un modulo HTML
• Come il contenuto di un file denominato pin una directory definita dall'implementazione
• In un modo definito di implementazione in fase di esecuzione se i primi quattro non sono disponibili
• Hard coded se la tua lingua non fornisce alcun mezzo per ricevere input

Specifica di uscita

Il programma terminerà per tutti gli input corrispondenti alla specifica di input e calcolerà se la soluzione al puzzle è corretta. Il programma deve generare il risultato del calcolo come valore booleano in uno dei seguenti modi:

• Come stato di uscita pari a zero (soluzione valida) o diverso da zero (soluzione non valida)
• Poiché il carattere y(la soluzione è valida) o n(la soluzione non è valida) seguito da zero o più caratteri arbitrari emessi in un modo definito dall'implementazione

Il comportamento del programma non è specificato quando si verificano input non formattati in base alle specifiche di input.

punteggio

Il punteggio del tuo programma è il numero di caratteri nella sua fonte, ad eccezione dei caratteri di spazi bianchi omettibili e dei commenti omettibili. Sei incoraggiato a indentare la tua proposta in modo che sia più facile da leggere per gli altri e commentare la tua soluzione in modo che sia più facile da seguire.

Gli invii che non seguono le specifiche di input o output o generano risultati errati non sono validi.

GolfScript, 133 caratteri

'|':^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/=

Si aspetta l'input da STDIN e stampa yper una soluzione valida e nper una non valida. Esegue l'attività utilizzando principalmente string-sostituzione sulla griglia o con versioni ruotate della griglia.

Codice annotato:

# 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 byte

Il programma completo, letto da STDIN, dovrebbe far fronte a qualsiasi schema di nuova riga comune purché abbia feed di riga. Grazie a HackerCow per aver sottolineato che non devo aggiungere una nuova riga in una domanda diversa, spingendomi a rimuoverla qui e salvare 4 byte

Codice golfizzato:

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");}}

Il codice esegue 3 controlli, controllando prima il numero di linee attorno a ciascun numero e che ogni giunzione ha 0 o 2 linee che conducono da esso, quindi che tutte le linee siano unite.

Codice formattato:

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')

Verifica se ogni numero ha il giusto numero di linee accanto ad esso, quindi cammina un percorso attorno alle linee e controlla se ne ha persa alcuna.