前几天，我们的团队去了一个逃生室。难题之一是由六个机械开关组成的板，您必须找到打开和关闭的正确组合才能解锁盒子，如下所示：

-v-v-v-
-v-v-v-

作为开发人员，我们认为尝试2 ^ 6 = 64个组合中的每个组合要比实际解决难题更有效。因此，我们分配了一个可怜的家伙进行一些二进制计数：

-v-v-v-
-v-v-v-

-v-v-v-
-v-v-^-

-v-v-v-
-v-^-v-

-v-v-v-
-v-^-^-

等等。

挑战
编写一个程序，给定所有开关都按上述格式设置为关闭的字符串，从而以任意顺序生成打开和关闭的所有组合。

您可以编写完整的程序或函数。因此，您的程序可以通过stdin，文件或单个字符串参数接收输入，然后返回或打印输出。如果返回，则输出可能在列表/数组/等中。而不是单个字符串。如果输出为单个字符串，则板子之间应使用换行符分隔（允许使用尾随换行符）。

输入字符串将与正则表达式匹配，r'((-v)+-)(\n(-v)+-)*'并代表一块板，所有开关均关闭。这意味着无零情况，并且开关左对齐。每行可能没有相同数量的开关。

每个输出板应具有与输入完全相同的格式，除了v可以根据需要用^代替。输出板可以用任意数量的换行符分隔。

由于运行时间自然是开关数量的O（2 ^ n），因此您的代码将不会在任何排列的10个以上的开关上进行测试。

这是代码高尔夫球，因此以字节数为单位的最短代码获胜。

样本输入和输出

输入：

-v-

可能的输出：

-v-
-^-

输入：

-v-
-v-

可能的输出：

-^-
-^-
-^-
-v-

-v-
-^-


-v-
-v-

由于要为更大数量的开关检查答案非常繁琐，因此这里有一个Python脚本作为健全性检查工具。（不幸的是，我提供了一个当前注释掉的代码段，以在给定的输入文件中生成预期的输出，以备您需要更多的测试用例。）将输入字符串放在名为“ input”的文件中，并将换行符分隔的输出（对不起，没有列表格式）放在同一目录中的名为“ output”的文件中，然后运行python3 sanitycheck.py。

Haskell，25 24 23 17字节

mapM$min"^v".pure

在线尝试！

-1个字节感谢@ H.PWiz

-1字节感谢@nimi

返回字符串列表。TIO有2个额外的字节用于函数声明-我已经看到其他人在无点编写函数时将其关闭，因此除非另有说明，否则我会这样做。

上一个答案（25个字节）

g 'v'="v^"
g x=[x]
mapM g

这些解释都是针对先前的答案的，其工作方式几乎相同，不同之处在于我内联了的定义g。该方法g的工作原理是现在使用的词汇比较替代^v的v，并保持一切相同。

有趣的是，这适用于任意总机：

>>> mapM g "-----^-----"
  ["-----v-----", "-----^-----"]

说明（简短）

g 'v'="v^" -- for 'v', choose between 'v' or '^'
g x=[x]    -- for any other character, choose just that character
mapM g     -- find all ways to choose characters using g on the given input

说明（长）

mapM对于不熟悉Haskell的人来说，这是一个非常可怕的功能。但是在这种情况下不难理解。通过使其作用于Strings（在Haskell中为字符列表），我将其专用于其对列表的定义。因此，在这种情况下，其类型签名为

mapM :: (a -> [b]) -> [a] -> [[b]]
--      ^^^^^^^^^^                  arg 1: a function from any a to a list of b
--                    ^^^           arg 2: a list of a
--                           ^^^^^ return: a list of list of b

实际上，它在我的用法上甚至更加专业化，a而且b两者兼而有之Char，因此我们可以将类型签名视为

mapM :: (Char -> String) -> String -> [String]

g在解释其mapM工作原理之前，让我们快速看一下该做什么。

g :: Char -> String
g 'v' = "v^"
g  x  = [x]

g使用模式匹配将转换Char 'v'为字符串"v^"; 其他所有内容都将转换为单例字符串（请记住，字符串只是的列表Char，因此我们可以将其放入x单例列表中）。在REPL上进行测试，我们发现情况确实如此

>>> g 'a'
  "a"
>>> g 'b'
  "b"
>>> g 'v'
  "v^"

注意，g具有正确类型的参数可以作为mapM（当然！）。

我们将mapM通过给出它g和论点来探索工作原理

"-v-\n-v-"

作为输入。

mapM首先映射g在String，因为g皈依Chars到Strings，这给我们的列表Strings

["-", "v^", "-", "\n", "-", "v^", "-"]

虽然这是正确的输出类型，mapM但实际效果要稍微多一些。String如果必须从列表中的每个字符中选择一个字符String（按顺序），则可以将其视为可以从此列表创建的所有s 。

因此，对于第一个元素，您只能选择Char '-'。对于第二个元素，可以在'v'和之间进行选择'^'，依此类推。

它大致等效于以下python代码：

result = []
for x1 in "-":
  for x2 in "v^":
    for x3 in "-":
      ...
        result.append(''.join([x1, x2, x3, x4, x5, x6, x7]))

除了Haskell区分Chars和Strings之外，当将Chars放入列表中时，不需要join它们。

所以最终的输出是

["-v-\n-v-", "-v-\n-^", "-^-\n-v-", "-^-\n-^-"]

如预期的。

Perl 6，32个字节

{[X~] .comb».&{$_,('^'if /v/)}}

在线尝试！

• .comb 将字符串拆分为字符。
• ».&{...} 根据花括号之间的功能映射字符。
• $_, ('^' if /v/)产生每个字符的替代列表。仅v具有备用：^。
• [X~]使用string-concatenation叉积运算符减少该列表X~。

果冻，7个字节

«Ƭ€”^Œp

在线尝试！

输出是果冻字符串的列表。

说明：

«Ƭ€”^Œp  Arguments: 1
«Ƭ€”^    Dyad-nilad pair
  €       Map over left argument
 Ƭ         Apply repeatedly until a result that has previously been seen is seen
           again, return original and intermediate results
«           Dyad: Minimum of arguments
   ”^     Nilad: Literal: '^'
         Note: 'v' is the only character that is greater than '^' and can
         appear in the input, so, while for every character c other than 'v'
         this operation returns [c], for 'v' it returns ['v', '^']. In this way,
         duplicates are never going to appear in the output.
     Œp  Monad: Cartesian product of elements

Perl 5，29个字节

sub{glob"\Q@_"=~s/v/{v,^}/gr}

在线尝试！

我的第一次提交！

通常，Perl 5高尔夫球手提交程序，而不是提交功能，以节省sub{}最少参加的时间。但是，他们必须增加say，say␠，say for或者say for␠作为交换。

通过子方法，我可以缩短

say for glob"\Q$_"=~s/v/{v,^}/gr        # Perl 5, -0n, 32 bytes

至

sub{glob"\Q@_"=~s/v/{v,^}/gr}           # Perl 5, 29 bytes

解释很简单。Perl 5具有一个内置glob运算符，该运算符可以接受类似shell的glob模式，该模式可用于生成文件名foo*.txt列表（例如）或字符串列表（例如{a,b,c}）。问题是换行需要转义，这是我使用quotemeta（as \Q）完成的。

K（ngn / k），27 25字节

{?(,/,/:\:)/x,'"^"/"v"\x}

在线尝试！

"^"/"v"\替换"v"为"^"

x,' 用原始字符压缩

(,/,/:\:)/ 笛卡尔积

? 优衣库

APL（Dyalog Classic），21 17 15字节

⊃⊢∘.,.∪'v'⎕r'^'

在线尝试！

类似于我的k解决方案

返回字符串的n维数组（n =开关数）

以更容易解释的形式： ⊃(∘.,⌿ ⊢ ∪¨ 'v'⎕r'^')

'v'⎕r'^'用vs 替换^s

⊢ ∪¨...与每个原始字符结合。它是长度为1或2的字符串的向量

∘.,⌿ 笛卡尔积减少

⊃ 透露

要达到完全高尔夫版本，我们遵循模式f⌿ A g¨ B-> A f.g B：

∘.,⌿ ⊢ ∪¨ 'v'⎕r'^' -> ⊢ ∘.,.∪ 'v'⎕r'^'

作为副作用，不再需要括号

J，42个字节

]`('v'I.@e.~[)`[}"1'v^'{~2#:@i.@^1#.e.&'v'

在线尝试！

说明

]`('v' I.@e.~ [)`[}"1 ('v^' {~ 2 #:@i.@^ 1 #. e.&'v')

让我们拿

-v-
-v-

作为示例输入。

• ('v^' {~ 2 #:@i.@^ 1 #. e.&'v')创建所有可能的开关组合，而忽略输入格式。对于我们的示例，它产生：

  vv
  v^
  ^v
  ^^
  

  • 1 #. e.&'v'计算v输入中s 的数量。
  • 2 #:@i.@^将2提高至该幂，产生从0到该数字的整数i.，并将其转换为二进制#:
  • 'v^' {~更改为二进制数字来v和^
• ]`('v' I.@e.~ [)`[}"1修改原始输入，为上一步中描述的结果的每一行生成一个副本（即所有可能的v/ ^组合）。在每个副本v中，原始输入的替换为一个可能的v/ 序列^。

Java中，202个 197 189 191字节

是的，这是一种比较冗长的语言，但是我认为这是古典高尔夫：

import java.util.function.Function;

public class SwitchBored
{
    public static void main(String[] args)
    {
        Function<String, String> f = s->{byte i,j,k,m=1,u='^',d='v',a[]=(s+"\n\n").getBytes();for(i=0,s="";i<m;i++,s+=new String(a))for(j=0,k=0;k<a.length;k++){if(a[k]==d||a[k]==u){a[k]=(i&1<<j++)!=0?u:d;m<<=i>0?0:1;}}return s;};

        //System.out.println(f.apply("-v-"));
        System.out.println(f.apply("-v-v-v-\n-v-v-v-"));
        //System.out.println(f.apply("-v-v-v-\n-v-v-"));
        //System.out.println(f.apply("-v-v-v-v-v-\n-v-"));
        //System.out.println(f.apply("-v-v-v-v-v-\n-v-v-v-v-v-"));
    }
}

我认为处理适当的布局所必需的换行符的“简单”方法是实际重新使用原始输入字符数组，并仅在适当的位置用'v's和'^'s 填充它。

更新：

事实证明，不存储位置允许抛弃int和数组变量声明（以检查数组的每个位置是否包含一个v或^即时），节省了5个字节。

通过计算上限节省了另外8个字节 (1<<numberOfSwitches)更紧凑地。

根据注释中提到的规则，应该声明函数声明，因此现在是lambda ...

J，41 40 24字节

[:>@,@{<@(,'^'$~'v'=])"0

在线尝试！

Python 2，87个字节

def f(s):i=s.find('v');return(i>=0and f(s[:i].replace('^','v')+'^'+s[i+1:])+'\n'or'')+s

在线尝试！

非正则表达式方法。

C（gcc），75 74 70字节

-5字节感谢@ceilingcat

*b=0;f(char*s){b=b?b:s;*s?f(s+1),*s>46?*s=94,f(s+1),*s='v':0:puts(b);}

在线尝试！

要求存储s点可写

Python 3.8（预发布），129117116110106字节

-10个字节，感谢@Chas Brown

f=lambda s:{s.replace('v','{}').format(*['v^'[c<'1']for c in bin(x+i)[::-1]])for i in range(x:=1<<len(s))}

在线尝试！

C（gcc），102字节

i,j,l;f(char*s){for(l=j=0;l++<1<<j;puts(""))for(i=j=0;s[i];i++)putchar(s[i]>64?l&1<<j++?118:94:s[i]);}

在线尝试！

K4，44字节

解：

-1{@[x;&w;:;]@'"v^"@a\:'!*/a:(+/w:"v"=x)#2};

例子：

q)k)-1{@[x;&w;:;]@'"v^"@a\:'!*/a:(+/w:"v"=x)#2}"-v-";
-v-
-^-

q)k)-1{@[x;&w;:;]@'"v^"@a\:'!*/a:(+/w:"v"=x)#2}"-v-\n-v-";
-v-
-v-
-v-
-^-
-^-
-v-
-^-
-^-

q)k)-1{@[x;&w;:;]@/:"v^"@a\:'!*/a:(+/w:"v"=x)#2}"-v-v-\n-v-v-v-\n-v-";
-v-v-
-v-v-v-
-v-
-v-v-
-v-v-v-
-^-
-v-v-
-v-v-^-
-v-
-v-v-
-v-v-^-
-^-
-v-v-
-v-^-v-
-v-
-v-v-
-v-^-v-
-^-
-v-v-
-v-^-^-
-v-
-v-v-
-v-^-^-
-^-
-v-v-
-^-v-v-
-v-
-v-v-
-^-v-v-
-^-
-v-v-
-^-v-^-
-v-
-v-v-
-^-v-^-
-^-
-v-v-
-^-^-v-
-v-
-v-v-
-^-^-v-
-^-
-v-v-
-^-^-^-
-v-
-v-v-
-^-^-^-
-^-
-v-^-
-v-v-v-
-v-
-v-^-
-v-v-v-
-^-
-v-^-
-v-v-^-
-v-
-v-^-
-v-v-^-
-^-
-v-^-
-v-^-v-
-v-
-v-^-
-v-^-v-
-^-
-v-^-
-v-^-^-
-v-
-v-^-
-v-^-^-
-^-
-v-^-
-^-v-v-
-v-
-v-^-
-^-v-v-
-^-
-v-^-
-^-v-^-
-v-
-v-^-
-^-v-^-
-^-
-v-^-
-^-^-v-
-v-
-v-^-
-^-^-v-
-^-
-v-^-
-^-^-^-
-v-
-v-^-
-^-^-^-
-^-
-^-v-
-v-v-v-
-v-
-^-v-
-v-v-v-
-^-
-^-v-
-v-v-^-
-v-
-^-v-
-v-v-^-
-^-
-^-v-
-v-^-v-
-v-
-^-v-
-v-^-v-
-^-
-^-v-
-v-^-^-
-v-
-^-v-
-v-^-^-
-^-
-^-v-
-^-v-v-
-v-
-^-v-
-^-v-v-
-^-
-^-v-
-^-v-^-
-v-
-^-v-
-^-v-^-
-^-
-^-v-
-^-^-v-
-v-
-^-v-
-^-^-v-
-^-
-^-v-
-^-^-^-
-v-
-^-v-
-^-^-^-
-^-
-^-^-
-v-v-v-
-v-
-^-^-
-v-v-v-
-^-
-^-^-
-v-v-^-
-v-
-^-^-
-v-v-^-
-^-
-^-^-
-v-^-v-
-v-
-^-^-
-v-^-v-
-^-
-^-^-
-v-^-^-
-v-
-^-^-
-v-^-^-
-^-
-^-^-
-^-v-v-
-v-
-^-^-
-^-v-v-
-^-
-^-^-
-^-v-^-
-v-
-^-^-
-^-v-^-
-^-
-^-^-
-^-^-v-
-v-
-^-^-
-^-^-v-
-^-
-^-^-
-^-^-^-
-v-
-^-^-
-^-^-^-
-^-

说明：

就地替换"^"。确定开关的组合数量（例如2 ^ n），以二进制数计数，更换开关...

-1{@[x;&w;:;]@'"v^"@a\:'!*/a:(+/w:"v"=x)#2}; / the solution
-1                                         ; / print to STDOUT, swallow -1
  {                                       }  / lambda taking implicit x
                                        #2   / take 2
                             (         )     / do this together
                                  "v"=x      / does input = "v" ?
                                w:           / save as w
                              +/             / sum up
                           a:                / save as a
                         */                  / product
                        !                    / range 0..n
                    a\:'                     / convert each to base-2
               "v^"@                         / index into "v^"
             @'                              / apply each
   @[x;&w;:;]                                / apply assignment to x at indexes where w is true

R，116字节

function(x,u=utf8ToInt(x))apply(expand.grid(rep(list(c(118,94)),sum(u>45))),1,function(i)intToUtf8(`[<-`(u,u>45,i)))

在线尝试！

函数返回换行分隔板的向量

JavaScript，88个字节

s=>(g=n=>n--?g(n)+`
`+s.replace(/v/g,_=>'v^'[i=n&1,n>>=1,i]):'')(2**~-s.split`v`.length)

在线尝试！

视网膜0.8.2，29字节

T`¶v`;#
+%1`#
v$'¶$`^
%`;|$
¶

在线尝试！说明：

T`¶v`;#

将换行符更改为;s，将vs 更改为#标记。

+%1`#

#从左到右一次更换一个。

v$'¶$`^

将每行更改为两行，一行#替换为v，一行用a代替^。

%`;|$
¶

将;s换回换行符，并将结果隔开。

Perl -0 5，51个字节

$_=<>;s/\s/P/g;s/v/{v,^}/g;say s/P|$/\n/gr for glob

在线尝试！

JavaScript（Node.js），80 73 68字节

f=([x,...y],g=c=>f(y).map(z=>c+z))=>x?g(x).concat(x>'a'?g`^`:[]):[y]

在线尝试！

Python 3-结构，203字节

def f(a):
 b=[0]
 for l in a.split():b+=[b[-1]+l.count('v')]
 return'\n'.join(''.join(f"{k:b}".zfill(b[-1])[x:y]+'-\n'for x,y in zip(b,b[1:]))for k in range(2**b[-1])).replace('0','-v').replace('1','-^')

在线尝试！

首先尝试，不是很小，但可以。Python中没有优雅的字符串替换...

第一个循环建立线到位索引的映射，即对于每条线，存储位计数器中第一位的索引。这用于在下一个循环中索引位计数器。

第二个循环运行一个二进制计数器，提取每一行的位并进行迭代，然后将它们合并。将所有内容连接在一起后，使用字符串替换将其转换回切换映射格式。

我猜想，有一种更优雅的方法是重用输入字符串，而不是一遍又一遍地重建它。

编辑：受Python 3.8启发，这是一个更短的替换版本

Python 3-替换，123个字节

def f(a):r=range;n=a.count('v');return'\n'.join(a.replace('v','{}').format(*('v^'[k&2**i>0]for i in r(n)))for k in r(2**n))

在线尝试！

红宝石，64字节

返回一个数组。从获取数字$1$ 至 $2^v$ （哪里 $v$ 是输入中“ v”的数量），然后根据 $v$最低有效位。这使我们可以节省一个字节，而不是从$0$ 至 $2^v-1$，因为 $v$ 中的最低有效位 $2^v$ 全为零。

在Ruby中，i[j]返回从最低有效位开始的jth i位，也就是(i>>j)&1。

->s{(1..2**s.count(?v)).map{|i|j=-1;s.gsub(/v/){'v^'[i[j+=1]]}}}

在线尝试！

木炭，28字节

⪫ＥＸ²№θv⭆θ⎇⁼λv§v^÷ιＸ²№…θμv붶

在线尝试！链接是详细版本的代码。说明：

   ²                            Literal 2
  Ｘ                             Raised to power
    №                           Count of
      v                         Literal `v`
     θ                          In input string
 Ｅ                              Map over implicit range
        θ                       Input string
       ⭆                        Map over characters and join
           λ                    Current character
          ⁼                     Equal to
            v                   Literal `v`
         ⎇                      Then
              v^                Literal `v^`
             §                  Circularly indexed by
                 ι              Outer index
                ÷               Integer divided by
                   ²            Literal 2
                  Ｘ             Raised to power
                    №           Count of
                        v       Literal `v`
                      θ         In input string
                     …          Truncated to length
                       μ        Inner index
                         λ      Else current character
⪫                         ¶¶    Join with newlines
                                Implicitly print

PHP，93字节

for(;$j<1<<$x;$j+=print$s)for($x=0,$s=$argv[1];$i=strpos($s,v,$i+1);$s[$i]=$j&1<<$x++?'^':v);

在线尝试！

独立程序，通过命令行输入。

根据的数量循环输入字符串的可能排列数量v。而在二进制计数，替换每个二进制1与^和每个二进制0与v输入字符串。