Oder vielleicht ist es nicht wirklich ein Labyrinth, aber dennoch.

Regeln:

1. Eingang ist ein zweizeiliges string, bestehend aus *, 1, xund X. Diese Saite ist ein Labyrinth, durch das man laufen kann. Die Linien sind gleich lang .

   Sie können die Eingabe als Zeichenfolge mit ,(Komma) oder als beliebiges Trennzeichen zwischen diesen beiden Zeilen verwenden. Oder Sie können beide Zeilen als separate Argumente für Ihre Funktion verwenden.

2. Ausgabe ist die Anzahl der Schritte, die Sie ausführen müssen, um die Zeichenfolge zu verlassen (letzter Schritt ist der Schritt, der Sie aus der Zeichenfolge herausführt).

3. Sie beginnen in der oberen linken Ecke (der oberen Zeile) vor dem ersten Symbol.

4. Für jeden Schritt bewegen Sie sich um ein Symbol vorwärts (von der n-ten bis zur (n + 1) -ten Position ). Abhängig von dem Charakter, auf den Sie treten, ist das Ergebnis unterschiedlich. Das macht jeder Char:

   • *- nichts. Sie treten einfach normal darauf.
   • x- Wenn Sie darauf getreten sind, wechseln Sie die Linie, aber bleiben Sie von Anfang an auf dem gleichen horizontalen Abstand. Sie sind beispielsweise auf die dritte Position der oberen Zeile getreten und haben hier einen Kleinbuchstaben xgefunden. Dann bewegen Sie sich sofort in die untere Zeile, aber wieder an die dritte Position.
   • X- Schalten Sie die Leitung um und gehen Sie zur nächsten Position. Das Beispiel ist dort dasselbe, aber Sie bewegen sich auch von der dritten zur vierten Position (Sie befinden sich also in der zweiten Zeile an der vierten Position).
   • 1 - Gehen Sie einfach um eine weitere Position vorwärts.

Sobald jeder Charakter seine Arbeit erledigt hat, wird er durch ein Leerzeichen ersetzt und funktioniert nicht mehr.

Beispiele folgen.

1. Eingabe :

   x
   *
   

   Wie gesagt, Sie beginnen vor dem ersten Symbol der ersten Zeile. Der erste Schritt bringt Sie zum Buchstaben, xund dieser Buchstabe versetzt Sie in die zweite Zeile. Der Buchstabe xfunktioniert nicht mehr als x, sondern wird durch ersetzt *. Dies wird in den letzteren Beispielen relevanter sein. Du bist jetzt auf einem Sternchen in der unteren Zeile und es hat dir nichts getan.

   Der zweite Schritt bewegt dich vorwärts und du verlässt die Schnur, sodass das Labyrinth fertig ist und es 2 Schritte gedauert hat.

   Ausgabe 2 .

2. Eingabe :

   xX*
   x1*
   

   1. Schritt : Sie bewegen sich weiter x, was Sie in xdie untere Zeile bewegt . Hier kommt die Regel, die besagt, dass das verwendete Zeichen durch ein Sternchen ersetzt wird. Dann bewegen Sie sich zurück in die erste Zeile, diese ist jedoch nicht mehr xvorhanden, da sie verwendet wurde und zu einem Sternchen wurde. Sie bewegen sich also sicher auf diesem Stern und der Schritt ist abgeschlossen (Sie befinden sich nun an der ersten Position der ersten Zeile).

   2. Schritt : Sie bewegen sich weiter X, es schiebt Sie in die untere Zeile und schiebt Sie dann vorwärts. Sie befinden sich jetzt auf der dritten Position der zweiten Zeile (Sternchen) und haben die zweite Position (die enthält 1) noch nie besucht .

   3. Schritt : Sie bewegen sich vorwärts und verlassen die Zeichenkette.

   Ausgang : 3.

Testfälle:

1. Eingang:

   *1*
   xxx
   

   Ausgang: 3. (weil 1bringt Sie auf die dritte Position springen). Dort besucht man nie die zweite Zeile, sondern es wird ein Teil der Eingabe benötigt.

2. Eingang:

   *X*1*x
   x*1xx*
   

   Ausgang: 4.

3. Eingang:

   1x1x
   ***X
   

   Ausgang: 3.

4. Eingang:

   1*x1xxx1*x
   x*x1*11X1x
   

   Ausgang: 6.

5. Eingang:

   xXXXxxx111*
   **xxx11*xxx
   

   Ausgang: 6.

Schnecken, 34 Bytes

A^
\1r|\xud|\Xaa7},(\*|\xud=\x)r},

Erweitert:

{
    {
        \1 r |
        \x ud |
        \X aa7
    },
    (\* | \x ud =\x)
    r
},

Für einen Pfad, der N Schritte dauert, findet das Programm eine erfolgreiche Übereinstimmung für jede Durchquerung von 0 Schritten, 1 Schritten, ..., N - 1 Schritten.

Haskell, 68 66 65 Bytes

(a:b)#l@(c:d)|a<'+'=1+b#d|a>'w'=l#('*':b)|a>'W'=d#b|1<2=b#d
_#_=1

Die Funktion #nimmt beide Zeilen als separate Parameter. Anwendungsbeispiel: "1x1x" # "***X"-> 3.

Wir müssen nur die Sterne zählen, auf die *wir treten, plus 1 für das Verlassen.

(a:b)#l@(c:d)             -- bind: a -> first char of first line
                                   b -> rest of first line
                                   l -> whole second line
                                   c -> first char of second line (never used)
                                   d -> rest of second line
   |a < '+' = 1+b#d       -- stepped on a *, so add 1 and go on
   |a > 'w' = l#('*':b)   -- x switches lines and replaces the x with *
   |a > 'W' = d#b         -- X switch lines and go on
   |1<2     = b#d         -- the rest (-> 1) simply walks forward
_#_=1                     -- base case: the empty string counts 1 for leaving

Edit: @feersum hat ein Byte gespeichert. Vielen Dank!

JavaScript (ES6), 119

l=>{z=-~l.search`
`,l=[...l+' '];for(n=p=0;(c=l[p%=2*z])>' ';p+=c>'X'?z:c>'1'?z+1:c>'0'?1:(++n,1))l[p]='*';return-~n}

Weniger golfen

l=>{
  z=1+l.search`\n`;
  l=[...l+' '];
  for( n = p = 0; 
       (c=l[p%=2*z])>' '; 
       p += c>'X' ? z : c>'1' ? z+1 : c>'0'? 1 : (++n,1) )
    l[p] = '*';
  return 1+n
}

Prüfung

f=l=>{z=-~l.search`
`,l=[...l+' '];for(n=p=0;(c=l[p%=2*z])>' ';p+=c>'X'?z:c>'1'?z+1:c>'0'?1:(++n,1))l[p]='*';return-~n}

[['x\n*',2]
,['xX*\nx1*',3]
,['*1*\nxxx',3]
,['*X*1*x\nx*1xx*',4]
,['1x1x\n***X',3]
,['1*x1xxx1*x\nx*x1*11X1x',6]
,['xXXXxxx111*\n**xxx11*xxx',6]
].forEach(t=>{
  var i=t[0],k=t[1],r=f(i) 
  console.log('Test result '+r+(r==k?' OK ':' KO (expected '+k+')')+'\n'+i)
})  
 

TSQL (SQL Server 2012+), 276 Byte

Golf gespielt:

DECLARE @i VARCHAR(99)=
'xXXXxxx111*'+CHAR(13)+CHAR(10)+
'**xxx11*xxx'

,@t BIT=0,@c INT=1,@ INT=1WHILE @<LEN(@i)/2SELECT @t-=IIF(a like'[1*]'or'xx'=a+b,0,1),@c+=IIF(a='*'or'xx'=a+b,1,0),@+=IIF(a='x'and'x'>b,0,1)FROM(SELECT SUBSTRING(d,@t*c+@,1)a,SUBSTRING(d,(1-@t)*c+@,1)b FROM(SELECT LEN(@i)/2+1c,REPLACE(@i,'X','q'COLLATE thai_bin)d)x)x PRINT @c

Ungolfed:

DECLARE @i VARCHAR(99)=
'xXXXxxx111*'+CHAR(13)+CHAR(10)+
'**xxx11*xxx'

,@t BIT=0,@c INT=1,@ INT=1
WHILE @<LEN(@i)/2
  SELECT
    @t-=IIF(a like'[1*]'or'xx'=a+b,0,1),
    @c+=IIF(a='*'or'xx'=a+b,1,0),
    @ +=IIF(a='x'and'x'>b,0,1)
  FROM
    (
      SELECT
        SUBSTRING(d,@t*c+@,1)a,
        SUBSTRING(d,(1-@t)*c+@,1)b
      FROM 
        (SELECT LEN(@i)/2+1c,REPLACE(@i,'X','q'COLLATE thai_bin)d)x
    )x

PRINT @c

Geige

JavaScript, 211 Byte

Ich denke darüber nach, eine Version zu erstellen, die jeden Schritt nacheinander auf einer Webseite anzeigt.

(x,y)=>{t=0;l=0;n=1;while(t<x.length){c=(l?x:y);if(c[t]=='x'){l=!l;if(l){x=x.slice(0,t-2)+'*'+x.slice(t-1);}else{y=y.slice(0,t-2)+'*'+y.slice(t-1);}}if(c[t]=='X'){l=!l;t++;}if(c[t]=='1'){return n}

Verwendet mehr Bytes als ich gehofft hatte , als Ersatz xmit *wegen JS unveränderlich Strings. Verbesserungsvorschläge sind insbesondere beim Ersatzteil erwünscht.