也许它不是真正的迷宫，但仍然如此。

规则：

1. 输入是一个两行字符串，包括*，1，x和X。那根绳子是迷宫。线的长度相等。

   您可以将输入作为带有,（逗号）的字符串或这两行之间的任何方便的分隔符。或者，您也可以将这两行作为函数的单独参数。

2. 输出是退出字符串必须执行的步骤数（最后一步是将您移出字符串的步骤）。

3. 您从左上角（较高的线）开始，在第一个符号之前。

4. 对于每一步，您将向前移动一个符号（从第n个位置到第（n + 1）个位置）。然后，根据您所踩的角色，结果是不同的。这是每个字符的作用：

   • *- 没有。您通常只是踩到它。
   • x-踩到它后，切换线路，但与起点保持相同的水平距离。例如，您踩到较高行的第三个位置，并在x此处遇到了一个小写字母。然后，您立即移至下一行，但再次移至第三位置。
   • X-切换线路并转到下一个位置。此处的示例相同，但您也从第三位置移至第四位置（因此，第二行位于第四位置）。
   • 1 -向前移动另一个位置。

每个角色完成工作后，将替换为空格，不再“有效”。

示例如下。

1. 输入：

   x
   *
   

   如前所述，您从第一行的第一个符号开始。第一步将您移至字母上x，此字母将您切换至第二行。该字母x不再用作x，而是由代替*。在后面的示例中，这将更有意义。您现在位于底行的星号上，对您没有任何作用。

   第二步是将您向前移动，然后退出弦线，因此迷宫完成了，并且花费了2个步骤。

   输出 2。

2. 输入：

   xX*
   x1*
   

   第一步：继续前进x，这会将您移至x下一行的。这是一条规则，该规则说使用的字符替换为星号。然后，您移回第一行，但x由于它已被使用并成为星号，因此不再存在。因此，您可以安全地在该星号上移动，并且该步骤已完成（您现在位于第一行的第一个位置）。

   第二步：继续前进X，它会将您推到较低的线，然后再将您向前推。您现在位于第二行的第三个位置（星号），而从未访问过第二个位置（包含1）。

   第三步：向前移动，退出字符串。

   输出：3。

测试用例：

1. 输入：

   *1*
   xxx
   

   输出：3。（因为1使您跳到第三位置）。在那里您永远不会访问第二行，但这是输入的必需部分。

2. 输入：

   *X*1*x
   x*1xx*
   

   输出：4。

3. 输入：

   1x1x
   ***X
   

   输出：3。

4. 输入：

   1*x1xxx1*x
   x*x1*11X1x
   

   输出：6。

5. 输入：

   xXXXxxx111*
   **xxx11*xxx
   

   输出：6。

蜗牛，34个字节

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

展开：

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

对于需要N步的路径，程序将为每遍历0步，1步，...，N-1步找到一个成功的匹配项。

Haskell，68 66 65字节

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

函数#将这两行作为单独的参数。用法示例："1x1x" # "***X"-> 3。

我们只需要算出*我们踩下的星星加1即可离开。

(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

编辑：@feersum保存了一个字节。谢谢！

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}

少打高尔夫球

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
}

测试

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字节

打高尔夫球：

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

取消高尔夫：

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

小提琴

JavaScript，211字节

我正在考虑制作一个版本，该版本可以显示在网页上显示的每个步骤。

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

由于JS不可变x，*因此使用的字节数超出了我希望替换时使用的字节数Strings。提出改进建议，尤其是更换零件。