Ou peut-être que ce n'est pas vraiment un labyrinthe, mais quand même.

Règles:

1. Entrée est une chaîne de deux lignes, constitué de *, 1, xet X. Cette chaîne est un labyrinthe à parcourir. Les lignes ont la même longueur .

   Vous pouvez prendre l'entrée comme une chaîne avec ,(virgule) ou tout séparateur pratique entre ces deux lignes. Ou vous pouvez prendre les deux lignes comme arguments séparés pour votre fonction.

2. La sortie est le nombre d'étapes que vous devez prendre pour quitter la chaîne (la dernière étape est l'étape qui vous fait sortir de la chaîne).

3. Vous commencez dans le coin supérieur gauche (la ligne supérieure), avant le premier symbole.

4. Pour chaque étape, vous avancez d'un symbole (de la nième à la (n + 1) ème position ). Ensuite, selon le personnage sur lequel vous marchez, le résultat est différent. Voici ce que fait chaque personnage:

   • *- rien. Vous marchez simplement dessus normalement.
   • x- une fois que vous avez marché dessus, changez de ligne, mais restez sur la même distance horizontale depuis le début. Par exemple, vous avez marché sur la troisième position de la ligne supérieure et rencontré un minuscule xici. Ensuite, vous passez immédiatement à la ligne inférieure, mais à nouveau à la troisième position.
   • X- changez de ligne et passez à la position suivante. L'exemple est le même là-bas, mais vous passez également de la troisième à la quatrième position (vous êtes donc sur la deuxième ligne à la quatrième position).
   • 1 - avancez simplement d'une autre position.

Une fois que chaque personnage fait son travail, il est remplacé par un espace et ne fonctionne plus.

Des exemples suivent.

1. Entrée :

   x
   *
   

   Comme dit précédemment, vous commencez avant le premier symbole de la première ligne. La première étape vous déplace sur la lettre xet cette lettre vous fait passer à la deuxième ligne. La lettre xne fonctionne plus comme x, mais remplacée par *. Cela sera plus pertinent dans les derniers exemples. Vous êtes maintenant sur un astérisque sur la ligne inférieure, et cela ne vous a rien fait.

   La deuxième étape vous fait avancer et vous quittez la chaîne, donc le labyrinthe est terminé et il a fallu 2 étapes.

   Sortie 2 .

2. Entrée :

   xX*
   x1*
   

   1ère étape : vous continuez x, ce qui vous déplace sur la xligne inférieure. Voici la règle qui dit que le caractère utilisé est remplacé par un astérisque. Ensuite, vous revenez sur la première ligne, mais elle n'est plus xlà, car elle a été utilisée et est devenue un astérisque. Vous vous déplacez donc en toute sécurité sur cet astérisque et l'étape est terminée (vous êtes maintenant en première position de la première ligne).

   2ème étape : vous avancez X, cela vous pousse vers la ligne inférieure puis vous pousse vers l'avant. Vous résidez maintenant sur la troisième position de la deuxième ligne (astérisque), n'ayant jamais visité la deuxième position (qui contient 1).

   3ème étape : vous avancez en sortant de la chaîne.

   Sortie : 3.

Cas de test:

1. Contribution:

   *1*
   xxx
   

   Sortie: 3. (car 1vous fait sauter sur la troisième position). Là, vous ne visitez jamais la deuxième ligne, mais c'est une partie obligatoire de l'entrée.

2. Contribution:

   *X*1*x
   x*1xx*
   

   Sortie: 4.

3. Contribution:

   1x1x
   ***X
   

   Production: 3.

4. Contribution:

   1*x1xxx1*x
   x*x1*11X1x
   

   Production: 6.

5. Contribution:

   xXXXxxx111*
   **xxx11*xxx
   

   Sortie: 6.

Escargots, 34 octets

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

Étendu:

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

Pour un chemin qui prend N étapes, le programme trouve une correspondance réussie pour chaque traversée de 0 étapes, 1 étapes, ..., N - 1 étapes.

Haskell, 68 66 65 octets

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

La fonction #prend les deux lignes comme paramètres séparés. Exemple d'utilisation: "1x1x" # "***X"-> 3.

Il suffit de compter les étoiles *sur lesquelles nous marchons plus 1 pour partir.

(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

Modifier: @feersum a enregistré un octet. Merci!

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}

Moins golfé

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
}

Tester

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 (sqlserver 2012+), 276 octets

Golfé:

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

Non golfé:

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

Violon

JavaScript, 211 octets

Je pense à créer une version qui montre chaque étape jouée l'une après l'autre, affichée sur une page Web.

(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}

Utilisé plus d'octets que je ne l'aurais espéré lors du remplacement xà *cause de JS immuable Strings. Les suggestions d'amélioration sont appréciées, en particulier avec la pièce de rechange.