Suatu hari, tim kami pergi ke ruang pelarian. Salah satu teka-teki melibatkan papan enam sakelar mekanis di mana Anda harus menemukan kombinasi yang benar dan mematikan untuk membuka kunci kotak, agak seperti ini:

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

Menjadi pengembang, kami memutuskan akan lebih efisien untuk mencoba setiap kombinasi 2 ^ 6 = 64 daripada benar-benar memecahkan teka-teki. Jadi kami menugaskan orang miskin untuk melakukan penghitungan biner:

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

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

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

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

dan seterusnya.

Tantangannya
Menulis sebuah program yang, mengingat semua sakelar dalam posisi tidak aktif sebagai string yang diformat seperti di atas, menghasilkan semua kombinasi on dan off dalam urutan apa pun.

Anda dapat menulis program lengkap atau fungsi. Dengan demikian, program Anda dapat menerima input melalui stdin, file, atau sebagai argumen string tunggal, dan mengembalikan atau mencetak hasilnya. Jika dikembalikan, hasilnya mungkin ada dalam daftar / array / etc. daripada string tunggal. Jika outputnya berupa string tunggal, papan harus dipisahkan oleh baris baru (trailing baris baru diizinkan.)

String input akan cocok dengan regex r'((-v)+-)(\n(-v)+-)*'dan mewakili satu papan dengan semua dimatikan. Ini berarti tidak ada wadah nol, dan sakelar dibariskan ke kiri. Setiap baris mungkin tidak memiliki jumlah sakelar yang sama.

Setiap papan keluaran harus memiliki format yang sama persis dengan input, kecuali bahwa v dapat diganti oleh ^ seperti yang diperlukan. Papan keluaran dapat dipisahkan oleh sejumlah baris baru.

Karena runtime secara alami O (2 ^ n) dalam jumlah switch, kode Anda tidak akan diuji pada lebih dari 10 switch dalam pengaturan apa pun.

Ini adalah kode-golf, jadi kode terpendek dalam jumlah byte menang.

Input dan output sampel

Memasukkan:

-v-

Output yang mungkin:

-v-
-^-

Memasukkan:

-v-
-v-

Output yang mungkin:

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

-v-
-^-


-v-
-v-

Karena sangat membosankan untuk memeriksa jawaban Anda untuk jumlah switch yang lebih besar, inilah skrip Python sebagai alat pemeriksaan kewarasan. (Saya telah memasukkan cuplikan yang saat ini dikomentari untuk menghasilkan output yang diharapkan dari file input yang diberikan jika Anda ingin lebih banyak kasus uji.) Sayangnya, ini agak kurang fleksibel dalam hal input dan output daripada spesifikasi, sayangnya; letakkan string input dalam file bernama 'input' dan output yang dipisahkan baris baru (maaf, tidak ada pemformatan daftar) dalam file bernama 'output' di direktori yang sama dan jalankan python3 sanitycheck.py.

Haskell , 25 24 23 17 byte

mapM$min"^v".pure

Cobalah online!

-1 byte terima kasih kepada @ H.PWiz

-1 byte terima kasih kepada @nimi

Mengembalikan daftar string. TIO memiliki 2 byte tambahan untuk deklarasi fungsi - Saya telah melihat orang lain meninggalkannya ketika mereka menulis fungsi pointfree jadi saya melakukan hal yang sama kecuali diperintahkan sebaliknya.

Jawaban Sebelumnya (25 byte)

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

Penjelasannya adalah semua untuk jawaban sebelumnya, yang bekerja dengan cara yang hampir sama, kecuali saya sebutkan definisi g. Cara gkerjanya saat ini adalah dengan menggunakan perbandingan leksikal untuk menggantikan ^vuntuk vdan menjaga segala sesuatu yang lain yang sama.

Menariknya, ini berfungsi untuk switchboards yang berubah-ubah:

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

Penjelasan (Pendek)

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

Penjelasan (Panjang)

mapMadalah fungsi yang cukup menakutkan bagi mereka yang tidak terbiasa dengan Haskell. Tetapi tidak sulit untuk memahami dalam konteks ini. Dengan membuatnya aktif pada Strings (yang dalam Haskell adalah daftar karakter), saya telah mengkhususkannya pada definisi untuk daftar. Jadi dalam konteks ini, tipenya adalah

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

Ini sebenarnya bahkan lebih khusus dalam penggunaan saya - adan bkeduanya Char- sehingga kita dapat melihat tipe tanda tangan sebagai

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

Mari kita cepat melihat apa yang gdilakukan sebelum menjelaskan cara mapMkerjanya.

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

gmenggunakan pencocokan pola untuk mengonversi Char 'v'menjadi string "v^"; semua yang lain dikonversi menjadi string tunggal (ingat, string hanya daftar Chars, sehingga kita dapat dimasukkan ke xdalam daftar tunggal). Menguji REPL, kami menemukan ini masalahnya

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

Catatan yang gmemiliki tipe yang tepat untuk menjadi argumenmapM (tidak mengejutkan!).

Kami akan mengeksplorasi cara mapMkerjanya dengan memberikannya gdan argumennya

"-v-\n-v-"

sebagai input.

mapMpeta pertama di gatas String, dan karena gmengkonversi Charke Strings, ini memberi kita daftarStrings

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

Meskipun ini adalah tipe output yang benar, mapMsedikit lebih banyak. Anda dapat menganggapnya sebagai membentuk semua Stringyang dapat Anda buat dari daftar ini jika Anda harus memilih satu karakter dari masing-masing Stringdi dalamnya (dalam urutan).

Jadi untuk elemen pertama, Anda tidak punya pilihan selain memilih Char '-'. Untuk elemen kedua, Anda dapat memilih antara 'v'dan '^', seterusnya, dan sebagainya.

Ini kira-kira setara dengan kode python ini:

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

Kecuali bahwa karena Haskell memisahkan antara Chars dan Strings, ketika itu menempatkan Chars ke dalam daftar, itu tidak perlujoin mereka.

Jadi hasil akhirnya adalah

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

seperti yang diinginkan.

Perl 6 , 32 byte

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

Cobalah online!

• .comb membagi string menjadi karakter.
• ».&{...} memetakan karakter sesuai dengan fungsi antara kawat gigi.
• $_, ('^' if /v/)menghasilkan daftar alternatif untuk setiap karakter. Hanya vmemiliki alternatif: ^.
• [X~]mengurangi daftar itu dengan operator lintas produk rangkaian-string X~.

Jelly , 7 byte

«Ƭ€”^Œp

Cobalah online!

Output adalah daftar string Jelly.

Penjelasan:

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

Cobalah online!

Kiriman pertama saya!

Biasanya, pegolf Perl 5 mengirimkan program alih-alih fungsi untuk menyelamatkan dari keharusan memasukkan sub{}minimal. Tapi mereka harus menambahkan say, say␠,say for atau say for␠dalam pertukaran.

Dengan melakukan pendekatan sub, saya bisa mempersingkat

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

untuk

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

Penjelasannya cukup sederhana. Perl 5 memiliki globoperator builtin yang menerima pola glob seperti shell yang dapat digunakan untuk menghasilkan daftar nama file (misalnya foo*.txt) atau daftar string (misalnya {a,b,c}). Tangkapannya adalah bahwa baris baru perlu diloloskan, yang telah saya lakukan menggunakan quotemeta(as \Q)

K (ngn / k) , 27 25 byte

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

Cobalah online!

"^"/"v"\ganti "v"dengan"^"

x,' zip dengan karakter asli

(,/,/:\:)/ produk cartesian berakhir

? uniq

APL (Dyalog Classic) , 21 17 15 byte

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

Cobalah online!

mirip dengan solusi k saya

mengembalikan array string n-dimensi (n = jumlah sakelar)

dalam bentuk yang lebih mudah dijelaskan: ⊃(∘.,⌿ ⊢ ∪¨ 'v'⎕r'^')

'v'⎕r'^'ganti vs dengan ^s

⊢ ∪¨... serikat pekerja dengan masing-masing karakter asli. itu adalah vektor string panjang 1 atau 2

∘.,⌿ pengurangan produk kartesius

⊃ membuka

untuk sampai ke versi yang sepenuhnya golf kita ikuti pola f⌿ A g¨ B-> A f.g B:

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

sebagai efek samping tanda kurung tidak lagi diperlukan

J , 42 byte

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

Cobalah online!

penjelasan

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

Biarkan

-v-
-v-

sebagai contoh input kami.

• ('v^' {~ 2 #:@i.@^ 1 #. e.&'v')membuat semua kombo yang mungkin dari sakelar, mengabaikan format input. untuk contoh kita menghasilkan:

  vv
  v^
  ^v
  ^^
  

  • 1 #. e.&'v'menghitung jumlah vs pada input.
  • 2 #:@i.@^menimbulkan 2 untuk kekuatan itu, menghasilkan bilangan bulat dari 0 sampai yang nomor i., dan mengkonversi mereka ke biner#:
  • 'v^' {~perubahan ke angka biner ke vdan^
• ]`('v' I.@e.~ [)`[}"1mengubah input asli, menghasilkan satu salinan untuk setiap baris hasil yang dijelaskan pada langkah sebelumnya (yaitu, semua kemungkinan v/ ^kombo). Dalam setiap salinan vinput asli diganti dengan satu kemungkinan urutan v/ ^.

Java, 202 197 189 191 byte

Ya, itu adalah bahasa yang relatif verbose, tapi itulah yang saya anggap sebagai golf klasik:

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

Saya berpikir bahwa cara "sederhana" untuk berurusan dengan jeda baris yang diperlukan untuk mencapai tata letak yang benar adalah dengan benar-benar menggunakan kembali array karakter input asli, dan hanya mengisinya dengan 'v' s dan '^'s pada posisi yang sesuai.

Pembaruan:

Ternyata tidak menyimpan posisi memungkinkan membuang intdan dan deklarasi variabel array (dengan biaya memeriksa setiap posisi array apakah itu berisiv atau ^dengan cepat), menghemat 5 byte.

8 byte lainnya disimpan dengan menghitung batas atas (1<<numberOfSwitches) lebih kompak.

Menurut aturan yang disebutkan dalam komentar, deklarasi fungsi harus dihitung, jadi sekarang ini lambda ...

J , 41 40 24 byte

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

Cobalah online!

Python 2 , 87 byte

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

Cobalah online!

Pendekatan non-regex.

C (gcc) , 75 74 70 byte

-5 byte terima kasih kepada @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);}

Cobalah online!

membutuhkan spoin memori agar dapat ditulis

Python 3.8 (pra-rilis) , 129 117 116 110 106 byte

-10 byte terima kasih kepada @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))}

Cobalah online!

C (gcc) , 102 byte

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

Cobalah online!

K4 , 44 byte

Larutan:

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

Contoh:

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

Penjelasan:

Penggantian di tempat "^". Tentukan jumlah kombinasi sakelar (mis. 2 ^ n), hitung dalam biner, ganti sakelar ...

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

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

Cobalah online!

Berfungsi mengembalikan vektor papan yang dipisahkan baris baru

JavaScript, 88 byte

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

Cobalah online!

Retina 0.8.2 , 29 byte

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

Cobalah online! Penjelasan:

T`¶v`;#

Ubah baris baru menjadi ;s dan vs menjadi #penanda.

+%1`#

Ganti #satu per satu dari kiri ke kanan.

v$'¶$`^

Ubah setiap baris menjadi dua baris, satu dengan yang #diganti dengan av , satu dengan yang diganti dengan a ^.

%`;|$
¶

Ubah ;kembali menjadi baris baru dan pisahkan hasilnya.

Perl 5 -0 , 51 byte

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

Cobalah online!

JavaScript (Node.js) , 80 73 68 byte

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

Cobalah online!

Python 3 - build, 203 byte

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

Cobalah online!

Coba pertama, tidak terlalu kecil tapi berhasil. Tidak ada penggantian string yang elegan di Python ...

Loop Pertama membangun pemetaan garis untuk indeks bit, yaitu untuk setiap baris, indeks bit pertama dalam penghitung bit disimpan. Ini digunakan untuk mengindeks penghitung bit di loop berikutnya.

Loop kedua menjalankan penghitung biner, mengekstrak bit untuk setiap baris dan iterasi dan bergabung dengan mereka. Setelah menggabungkan semuanya, itu diterjemahkan kembali ke format switch peta, menggunakan penggantian string.

Saya kira, ada cara yang lebih elegan dengan menggunakan kembali string input daripada membangunnya lagi dan lagi.

Sunting: terinspirasi oleh jawaban Python 3.8 , berikut adalah versi penggantian yang lebih singkat

Python 3 - ganti, 123 byte

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

Cobalah online!

Ruby , 64 byte

Mengembalikan array. Mendapat angka dari$1$ untuk $2^v$ (dimana $v$ adalah jumlah "v" pada input) dan membalik saklar berdasarkan pada $v$bit paling signifikan. Ini memungkinkan kita untuk menyimpan byte lebih dari iterasi$0$ untuk $2^v-1$, karena $v$ bit paling tidak signifikan dalam $2^v$ semuanya nol.

Di Ruby, i[j]mengembalikan jbit imulai dari bit paling signifikan, alias itu setara dengan (i>>j)&1.

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

Cobalah online!

Arang , 28 byte

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

Cobalah online! Tautan adalah untuk mengucapkan versi kode. Penjelasan:

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

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

Cobalah online!

Program mandiri, input melalui baris perintah.

Ulangi jumlah kemungkinan permutasi dari string input berdasarkan pada jumlah v's. Saat menghitung dalam biner, ganti setiap biner 1dengan a ^dan setiap biner 0dengan vdalam string input.