Hôm nọ, nhóm chúng tôi đến một phòng thoát. Một trong những câu đố liên quan đến một bảng gồm sáu công tắc cơ, trong đó bạn phải tìm ra sự kết hợp chính xác giữa bật và tắt để mở khóa một hộp, giống như thế này:

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

Là nhà phát triển, chúng tôi quyết định sẽ hiệu quả hơn khi thử từng một trong 2 ^ 6 = 64 kết hợp so với thực sự giải câu đố. Vì vậy, chúng tôi đã chỉ định một số người nghèo làm một số đếm nhị phân:

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

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

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

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

vân vân

Thử thách
Viết chương trình, đưa ra tất cả các công tắc ở vị trí tắt dưới dạng một chuỗi được định dạng như trên, tạo ra tất cả các kết hợp bật và tắt theo bất kỳ thứ tự nào.

Bạn có thể viết một chương trình đầy đủ hoặc một chức năng. Do đó, chương trình của bạn có thể nhận đầu vào thông qua stdin, tệp hoặc dưới dạng đối số chuỗi đơn và trả về hoặc in đầu ra. Nếu được trả về, đầu ra có thể nằm trong danh sách / mảng / v.v. thay vì một chuỗi đơn. Nếu đầu ra là một chuỗi đơn, các bảng nên được phân tách bằng dòng mới (cho phép dòng mới được phép.)

Các chuỗi đầu vào sẽ khớp với biểu thức chính quy r'((-v)+-)(\n(-v)+-)*'và đại diện cho một bảng với tất cả các công tắc tắt. Điều này có nghĩa là không có trường hợp nào và các công tắc được căn trái. Mỗi hàng có thể không có cùng số lượng thiết bị chuyển mạch.

Mỗi bảng đầu ra phải có cùng định dạng với đầu vào, ngoại trừ việc v có thể được thay thế bằng ^ theo yêu cầu. Các bảng đầu ra có thể được phân tách bằng bất kỳ số lượng dòng mới.

Vì thời gian chạy tự nhiên là O (2 ^ n) trong số lượng công tắc, mã của bạn sẽ không được kiểm tra trên bất kỳ hơn 10 công tắc trong bất kỳ sắp xếp nào.

Đây là mã golf, vì vậy mã ngắn nhất về số byte thắng.

Đầu vào và đầu ra mẫu

Đầu vào:

-v-

Sản lượng có thể:

-v-
-^-

Đầu vào:

-v-
-v-

Sản lượng có thể:

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

-v-
-^-


-v-
-v-

Vì việc kiểm tra câu trả lời của bạn để biết số lượng thiết bị chuyển mạch lớn hơn, đây là tập lệnh Python như một công cụ kiểm tra độ tỉnh táo. (Tôi đã bao gồm một đoạn mã được nhận xét hiện tại để tạo đầu ra dự kiến ​​từ một tệp đầu vào nhất định trong trường hợp bạn muốn có nhiều trường hợp kiểm tra hơn. Thật không may, nó hơi linh hoạt về mặt đầu vào và đầu ra so với thông số kỹ thuật; đặt chuỗi đầu vào trong một tệp có tên 'đầu vào' và đầu ra được phân tách bằng dòng mới (xin lỗi, không có định dạng danh sách) trong một tệp có tên 'đầu ra' trong cùng thư mục và chạy python3 sanitycheck.py.

Haskell , 25 24 23 17 byte

mapM$min"^v".pure

Hãy thử trực tuyến!

-1 byte nhờ @ H.PWiz

-1 byte nhờ @nimi

Trả về một danh sách các chuỗi. TIO có thêm 2 byte cho khai báo hàm - Tôi đã thấy những người khác bỏ qua nó khi họ viết hàm miễn phí nên tôi cũng làm như vậy trừ khi được nói khác đi.

Câu trả lời trước (25 byte)

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

Tất cả các giải thích cho câu trả lời trước, hoạt động khá giống nhau, ngoại trừ tôi đã nêu ra định nghĩa của g. Cách glàm việc tại là bằng cách sử dụng từ vựng so sánh để thay thế ^vcho vvà giữ mọi thứ khác như vậy.

Thật thú vị, điều này hoạt động cho các tổng đài tùy ý:

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

Giải thích (Ngắn)

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

Giải thích (Dài)

mapMlà một chức năng khá đáng sợ cho những người không quen thuộc với Haskell. Nhưng nó không khó hiểu trong bối cảnh này. Bằng cách làm cho nó hoạt động trên Strings (mà trong Haskell là danh sách các ký tự), tôi đã chuyên môn hóa nó theo định nghĩa của nó cho các danh sách. Vì vậy, trong bối cảnh này, chữ ký loại của nó là

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

Nó thực sự thậm chí còn chuyên sâu hơn trong việc sử dụng nó của tôi - avà bcả hai Char- vì vậy chúng ta có thể thấy chữ ký loại là

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

Hãy nhanh chóng xem xét những gì glàm trước khi giải thích cách làm mapMviệc.

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

gsử dụng khớp mẫu để chuyển đổi Char 'v'thành chuỗi "v^"; mọi thứ khác được chuyển đổi thành một chuỗi singleton (hãy nhớ rằng, các chuỗi chỉ là danh sách của Chars, vì vậy chúng ta có thể đưa xvào danh sách singleton). Thử nghiệm trên REPL, chúng tôi thấy đây là trường hợp

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

Lưu ý rằng gcó loại đúng để trở thành một đối số mapM(không ngạc nhiên!).

Chúng ta sẽ khám phá cách mapMhoạt động bằng cách đưa ra gvà lập luận

"-v-\n-v-"

làm đầu vào.

mapMbản đồ đầu tiên gtrên Stringvà vì gchuyển đổi Charthành Strings, điều này cho chúng ta một danh sáchStrings

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

Trong khi đây là loại đầu ra chính xác, mapMlàm nhiều hơn một chút. Bạn có thể nghĩ về nó như hình thành tất cả các Strings mà bạn có thể tạo từ danh sách này nếu bạn phải chọn một ký tự từ mỗi ký tự Stringtrong đó (theo thứ tự).

Vì vậy, đối với phần tử đầu tiên, bạn không có lựa chọn nào khác ngoài việc chọn Char '-'. Đối với phần tử thứ hai, bạn có thể chọn giữa 'v'và '^', v.v.

Nó gần tương đương với mã python này:

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

Ngoại trừ việc Haskell tách biệt giữa Chars và Strings, khi nó đặt Chars vào danh sách, nó không cần đến joinchúng.

Vì vậy, đầu ra cuối cùng là

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

như mong muốn.

Perl 6 , 32 byte

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

Hãy thử trực tuyến!

• .comb chia chuỗi thành các ký tự.
• ».&{...} ánh xạ các ký tự theo chức năng giữa các dấu ngoặc nhọn.
• $_, ('^' if /v/)tạo ra một danh sách thay thế cho mỗi nhân vật. Chỉ vcó một thay thế : ^.
• [X~]giảm danh sách đó với toán tử sản phẩm chéo chuỗi X~.

Thạch , 7 byte

«Ƭ€”^Œp

Hãy thử trực tuyến!

Đầu ra là một danh sách các chuỗi Jelly.

Giải trình:

«Ƭ€”^Œ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 byte

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

Hãy thử trực tuyến!

Trình đầu tiên của tôi!

Thông thường, người chơi golf Perl 5 gửi chương trình thay vì các chức năng để tiết kiệm từ việc phải bao gồm sub{}ở mức tối thiểu. Nhưng họ phải bổ sung say, say␠, say forhoặc say for␠để đổi lấy.

Bằng cách tiếp cận phụ, tôi có thể rút ngắn

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

đến

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

Lời giải thích khá đơn giản. Perl 5 có một globtoán tử dựng sẵn chấp nhận một mẫu hình cầu giống như vỏ có thể được sử dụng để tạo danh sách các tên tệp (ví dụ foo*.txt) hoặc danh sách các chuỗi (ví dụ {a,b,c}). Điều hấp dẫn là dòng mới cần phải được thoát, mà tôi đã thực hiện bằng cách sử dụng quotemeta(như \Q).

K (ngn / k) , 27 25 byte

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

Hãy thử trực tuyến!

"^"/"v"\thay thế "v"bằng"^"

x,' zip với ký tự gốc

(,/,/:\:)/ sản phẩm cartesian hơn

? uniq

APL (Dyalog Classic) , 21 17 15 byte

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

Hãy thử trực tuyến!

tương tự như giải pháp k của tôi

trả về một chuỗi n chiều (n = số lượng thiết bị chuyển mạch)

ở dạng dễ giải thích hơn: ⊃(∘.,⌿ ⊢ ∪¨ 'v'⎕r'^')

'v'⎕r'^'thay vs bằng ^s

⊢ ∪¨... Liên hiệp với mỗi nhân vật gốc. đó là một vectơ của các chuỗi có độ dài 1 hoặc 2

∘.,⌿ giảm sản phẩm cartesian

⊃ tiết lộ

để đến phiên bản được đánh gôn hoàn toàn, chúng tôi theo mô hình f⌿ A g¨ B-> A f.g B:

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

như một tác dụng phụ, dấu ngoặc đơn không còn cần thiết

J , 42 byte

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

Hãy thử trực tuyến!

giải trình

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

Hãy lấy

-v-
-v-

như ví dụ đầu vào của chúng tôi.

• ('v^' {~ 2 #:@i.@^ 1 #. e.&'v')tạo ra tất cả các combo có thể chỉ của các công tắc, bỏ qua định dạng đầu vào. ví dụ của chúng tôi nó tạo ra:

  vv
  v^
  ^v
  ^^
  

  • 1 #. e.&'v'đếm số vs trong đầu vào.
  • 2 #:@i.@^tăng 2 lên sức mạnh đó, tạo ra các số nguyên từ 0 đến số đói. và chuyển đổi chúng thành nhị phân#:
  • 'v^' {~thay đổi chữ số nhị phân thành vvà^
• ]`('v' I.@e.~ [)`[}"1sửa đổi đầu vào ban đầu, tạo ra một bản sao của nó cho mỗi hàng của kết quả được mô tả trong bước trước đó (nghĩa là tất cả có thể v/ ^combo). Trong mỗi bản sao, vđầu vào ban đầu được thay thế bằng một chuỗi v/ ^.

Java, 202 197 189 191 byte

Vâng, đó là một ngôn ngữ tương đối dài dòng, nhưng đó là những gì tôi coi là chơi golf cổ điển:

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

Tôi nghĩ rằng một cách "đơn giản" để xử lý các ngắt dòng cần thiết để đạt được bố cục phù hợp là thực sự sử dụng lại mảng ký tự đầu vào ban đầu và chỉ điền nó với 'v's và '^'s tại các vị trí thích hợp.

Cập nhật:

Hóa ra việc không lưu trữ các vị trí cho phép bỏ các intkhai báo biến và mảng (với chi phí kiểm tra từng vị trí của mảng cho dù nó có chứa một vhoặc ^đang di chuyển), tiết kiệm 5 byte.

8 byte khác được lưu bằng cách tính giới hạn trên (1<<numberOfSwitches)gọn hơn.

Theo quy tắc được đề cập trong bình luận, nên tính khai báo hàm, vì vậy bây giờ nó là lambda ...

J, 41 40 24 bytes

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

Try it online!

Python 2, 87 bytes

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

Try it online!

A non-regex approach.

C (gcc), 75 74 70 bytes

-5 byte thanks to @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);}

Try it online!

requires the memory s points to to be writable

Python 3.8 (pre-release), 129 117 116 110 106 bytes

-10 bytes thanks to @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))}

Try it online!

C (gcc), 102 bytes

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

Try it online!

K4, 44 bytes

Solution:

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

Examples:

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-
-^-^-
-^-^-^-
-^-

Explanation:

In-place replacement of "^". Determine number of combinations of switches (e.g. 2^n), count up in binary, replace switches...

-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 bytes

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

Try it online!

Function returning a vector of newline separated boards

JavaScript, 88 bytes

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

Try it online!

Retina 0.8.2, 29 bytes

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

Try it online! Explanation:

T`¶v`;#

Change the newlines into ;s and the vs into # markers.

+%1`#

Replace the #s one at a time from left to right.

v$'¶$`^

Change each line into two lines, one with the # replaced with a v, one with it replaced with a ^.

%`;|$
¶

Change the ;s back into newlines and space the results apart.

Perl 5 -0, 51 bytes

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

Try it online!

JavaScript (Node.js), 80 73 68 bytes

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

Try it online!

Python 3 - construct, 203 bytes

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

Try it online!

First try, not very small but works. There is no elegant string replacement in Python...

The First loop builts a mapping of lines to bit indices, i.e. for each line, the index of the first bit in a bit counter is stored. This is used for indexing the bit counter in the next loop.

The Second loop runs a binary counter, extracts the bits for each line and iteration and joins them. After joining everything together, it is translated back to the switch map format, using string replacement.

I guess, there is a more elegant way by reusing the input string instead of rebuilding it over and over again.

Edit: inspired by the Python 3.8 answer, here is a much shorter replacing version

Python 3 - replace, 123 bytes

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

Try it online!

Ruby, 64 bytes

Returns an array. Gets numbers from $1$ to $2^v$ (where $v$ is the number of "v" in the input) and flips switches based on the $v$ least significant bits. This allows us to save a byte over iterating from $0$ to $2^v-1$, because the $v$ least significant bits in $2^v$ are all zero.

In Ruby, i[j] returns the jth bit of i starting from the least significant bit, aka it is equivalent to (i>>j)&1.

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

Try it online!

Charcoal, 28 bytes

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

Try it online! Link is to verbose version of code. Explanation:

   ²                            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 bytes

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

Try it online!

Standalone program, input via command line.

Loop the number of possible permutations of the input string based on the number of v's. While counting up in binary, replace each binary 1 with a ^ and each binary 0 with a v in the input string.