Geçen gün ekibimiz bir kaçış odasına gitti. Bulmacalardan biri, bir kutunun kilidini açmak için doğru açma / kapama kombinasyonunu bulmak zorunda olduğunuz altı mekanik anahtardan oluşan bir tahtadan oluşuyordu.

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

Geliştiriciler olarak, 2 ^ 6 = 64 kombinasyonlarının her birini denemenin aslında bulmacayı çözmekten daha etkili olacağına karar verdik. Bu yüzden bazı zavallı adama ikili sayma yapacak.

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

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

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

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

ve bunun gibi.

Meydan
yukarıdaki gibi biçimlendirilmiş bir dize olarak pozisyon kapama anahtarları tüm göz önüne alındığında, bu bir program yazın, herhangi bir sırada ve kapalı tüm kombinasyonlarını üretir.

Tam bir program veya bir fonksiyon yazabilirsiniz. Böylece, programınız stdin, dosya veya tek bir dize argümanı olarak girdi alabilir ve çıktıyı döndürür veya basar. Döndüğünde, çıktı / array / etc listesinde olabilir. tek bir dize yerine. Çıktı tek bir dize ise, panolar yeni satırlarla ayrılmalıdır (arkadaki satırlara izin verilir).

Giriş dizeleri regex r'((-v)+-)(\n(-v)+-)*'ile eşleşecek ve tüm kapanmaları ile bir kartı temsil edecektir . Bu, sıfır durum yok demektir ve anahtarlar sola hizalanır. Her satır aynı sayıda anahtara sahip olmayabilir.

Her çıkış kartı giriş ile tam olarak aynı formatta olmalıdır, ancak v'lerin gerektiği gibi ^ ile değiştirilmesi gerekir. Çıkış panoları herhangi bir sayıda yeni satırla ayrılabilir.

Çalışma zamanı doğal olarak anahtar sayısında O (2 ^ n) olduğundan, kodunuz herhangi bir düzende 10'dan fazla anahtarda test edilmeyecektir.

Bu kod-golf, bayt sayısındaki en kısa kod kazanır.

Örnek girişler ve çıkışlar

Giriş:

-v-

Mümkün çıktı:

-v-
-^-

Giriş:

-v-
-v-

Mümkün çıktı:

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

-v-
-^-


-v-
-v-

O anahtarların büyük sayılar için cevabınızı kontrol etmek son derece sıkıcı olduğundan, burada bir aklı kontrol aracı olarak bir Python komut dosyası. (Daha fazla test vakası istemeniz durumunda belirli bir girdi dosyasından beklenen çıktıyı elde etmek için şu anda yorumlanmış bir snippet'i ekledim.) Giriş ve çıkış açısından özellikten biraz daha az esnek; giriş dizisini 'input' adındaki bir dosyaya ve aynı satırdaki 'output' adındaki dosyaya newline ile ayrılmış çıktıya (üzgünüm, liste biçimlendirme yok) yerleştirin ve çalıştırın python3 sanitycheck.py.

Haskell , 25 24 23 17 bayt

mapM$min"^v".pure

Çevrimiçi deneyin!

@ H.PWiz sayesinde -1 bayt

@Nimi sayesinde -1 bayt

Dizelerin bir listesini döndürür. TIO'nun işlev bildirimi için 2 baytı var - Başkalarının işlevi noktaya yazmadan bıraktıklarını gördüm, aksi halde söylenmediği sürece aynısını yapıyorum.

Önceki Cevap (25 bayt)

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

Tüm açıklamaların hepsi, hemen hemen aynı şekilde çalışan önceki cevap için g. gŞimdi işe yarayan yol şununla değiştir ^v:v diğerlerinin ve her şeyi aynı tutmak .

İlginçtir, bu keyfi santraller için işe yarar:

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

Açıklama (Kısa)

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

Açıklama (Uzun)

mapMHaskell ile aşina olmayanlar için oldukça korkutucu bir işlevdir. Ancak bu bağlamda anlaşılması zor değil. Bunu String(Haskell'deki karakter listeleridir) üzerinde hareket ettirerek, listeler için tanımında uzmanlaştım. Yani bu bağlamda, tür imzası

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

Aslında onu kullanmamda daha da uzmanlaşmıştır - ave bher ikisi de Char- bu yüzden imzayı tip olarak görebiliriz.

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

gNasıl mapMçalıştığını açıklamadan önce ne yaptıklarına hızlıca bakalım .

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

gChar 'v'dize dönüştürmek için desen eşleştirme kullanır "v^"; her şey bir singleton dizgisine dönüştürülür (unutmayın, dizeler sadece Chars listeleridir , bu yüzden xbir singleton listesine koyabiliriz ). REPL üzerinde yapılan testler, durumun böyle olduğunu görüyoruz.

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

Bunun gargüman olması için doğru tipe sahip olduğuna dikkat edin mapM(şaşırtıcı olmayan bir şekilde!).

Nasıl mapMçalıştığını gve tartışarak nasıl çalıştığını keşfedeceğiz.

"-v-\n-v-"

giriş olarak.

mapMönce güzerinde harita String, ve çünkü s gdönüştürürCharStrings , bu bize bir liste verir.Strings

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

Bu doğru çıkış tipi olsa da, mapM , biraz daha fazlasını yapar. StringHer birinden String(sırayla) tek bir karakter seçmeniz gerektiğinde, bu listeden oluşturabileceğiniz her şeyi oluşturuyor olarak düşünebilirsiniz .

Yani ilk unsur için, seçmekten başka seçeneğin yok. Char '-' . İkinci öğe için, 'v've arasında '^'vb. Arasında seçim yapabilirsiniz .

Bu python koduna kabaca eşdeğerdir:

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

Bunun dışında Haskell Chars veString s , Chars'yi bir listeye koyduğunda , buna gerek kalmazjoin onlara .

Yani son çıktı

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

istediğiniz gibi.

Perl 6 , 32 bayt

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

Çevrimiçi deneyin!

• .comb dizeyi karakterlere böler.
• ».&{...} Karakterleri ayraçlar arasındaki işleve göre eşler.
• $_, ('^' if /v/)Her karakter için alternatiflerin bir listesini üretir. Sadece vbir alternatif var:^ .
• [X~]dize birleştirme çapraz ürün işleci ile bu listeyi azaltır X~.

Jöle , 7 bayt

«Ƭ€”^Œp

Çevrimiçi deneyin!

Çıkış Jelly dizelerinin bir listesidir.

Açıklama:

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

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

Çevrimiçi deneyin!

İlk gönderimim!

Normalde, Perl 5 golfçüler, sub{}en azından dahil etmek zorunda kalmaktan tasarruf etmek için işlevler yerine programlar sunar . Ama eklemek zorunda say, say␠,say for veya say for␠karşılığında.

Alt yaklaşıma giderek kısaltabilirim

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

için

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

Açıklama oldukça basittir. Perl 5, globdosya adlarının (örn. foo*.txt) Veya dizelerin listesini (örn. ) Listelerini üretmek için kullanılabilen, kabuk benzeri bir küre şeklini kabul eden bir yerleşik operatöre sahiptir {a,b,c}. Buradaki yakalamak, quotemeta(as \Q) kullanarak yaptığım newline'ın kaçması gerektiğidir .

K (ngn / k) , 27 25 bayt

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

Çevrimiçi deneyin!

"^"/"v"\ değiştirmek "v" sahip"^"

x,' orijinal karakterlerle zip

(,/,/:\:)/ kartezyen ürün bitti

? uniq

APL (Dyalog Classic) , 21 17 15 bayt

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

Çevrimiçi deneyin!

k çözümüme benzer

n boyutlu bir dizge dizisi döndürür (n = anahtar sayısı)

formu açıklamak daha kolay: ⊃(∘.,⌿ ⊢ ∪¨ 'v'⎕r'^')

'v'⎕r'^'yerine vs ile ^ler

⊢ ∪¨... orijinal karakterlerin her birinde sendikalar. uzunluğu 1 veya 2 olan bir dizi vektörü

∘.,⌿ kartezyen ürün azaltma

⊃ ifşa

Tamamen golf versiyonuna ulaşmak için deseni takip ediyoruz f⌿ A g¨ B-> A f.g B:

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

Yan etki olarak parantezlere ihtiyaç duyulmaz

J , 42 bayt

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

Çevrimiçi deneyin!

açıklama

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

Alalım

-v-
-v-

örnek girdi olarak.

• ('v^' {~ 2 #:@i.@^ 1 #. e.&'v')giriş biçimini yok sayarak sadece anahtarların tüm olası kombinasyonlarını yaratır. Örneğimiz için üretir:

  vv
  v^
  ^v
  ^^
  

  • 1 #. e.&'v'Girişteki vs sayısını sayar .
  • 2 #:@i.@^Bu güce 2 yükseltir, 0'dan bu sayıya tamsayılar üretiri. ve bunları ikiliye dönüştürür#:
  • 'v^' {~İkili hanelere yapılan değişiklikler vve^
• ]`('v' I.@e.~ [)`[}"1önceki girişi tarif edilen sonucun her bir sırası için bir kopyasını üreten orijinal girişi değiştirir (yani, tüm olası v/ ^kombinasyonlar). Her kopyanın vorjinal girişinin bir olası v/ dizisi ile değiştirilir ^.

Java, 202 197 189 191 bayt

Evet, nispeten ayrıntılı bir dildir, ancak klasik golf olarak kabul ettiğim şey budur:

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

Düzgün bir düzene ulaşmak için gerekli olan satır kesmeleriyle başa çıkmanın "basit" bir yolunun orijinal giriş karakter dizisini gerçekten yeniden kullanmak ve sadece 'v's ve'^' uygun pozisyonlarda s .

Güncellemeler:

Öyle değil çıktı pozisyonlara depolanması ditching sağlar int(bir içerip içermediğini dizinin her konumunu kontrol pahasına ve dizi değişken parametreleri vya da ^5 bayt tasarruf sinek).

Üst limiti (1<<numberOfSwitches)daha kompakt hesaplayarak bir 8 bayt daha kaydedildi .

Yorumda belirtilen kurala göre, işlev bildirimi sayılmalıdır, bu yüzden şimdi bir lambda ...

J , 41 40 24 bayt

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

Çevrimiçi deneyin!

Python 2 , 87 bayt

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

Çevrimiçi deneyin!

Regex olmayan bir yaklaşım.

C (gcc) , 75 74 70 bayt

@Ceilingcat sayesinde -5 bayt

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

Çevrimiçi deneyin!

hafıza gerektirir s noktalarının yazılabilir

Python 3.8 (yayın öncesi) , 129 117 116 110 106 bayt

@Chas Brown sayesinde -10 bayt

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

Çevrimiçi deneyin!

C (gcc) , 102 bayt

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

Çevrimiçi deneyin!

K4 , 44 bayt

Çözüm:

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

Örnekler:

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

Açıklama:

Yerinde değiştirilmesi "^". Anahtar kombinasyonlarının sayısını (örn. 2 ^ n) belirleyin, ikili sayın, anahtarları değiştirin ...

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

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

Çevrimiçi deneyin!

Newline vektör panoları dönen fonksiyonu

JavaScript, 88 bayt

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

Çevrimiçi deneyin!

Retina 0.8.2 , 29 bayt

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

Çevrimiçi deneyin! Açıklama:

T`¶v`;#

Yeni satırları ;s'ye, vs'yi #işaretçilere değiştirin.

+%1`#

S'yi #soldan sağa doğru bir seferde değiştirin .

v$'¶$`^

Her çizgiyi iki satır halinde değiştirin, biri a ile #değiştirilir v, biri a ile değiştirilir ^.

%`;|$
¶

Değişim ;sonuçları birbirinden satırbaşıyla ve uzaya göre geri.

Perl 5 -0 , 51 bayt

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

Çevrimiçi deneyin!

JavaScript (Node.js) , 80 73 68 bayt

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

Çevrimiçi deneyin!

Python 3 - yapı, 203 bayt

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

Çevrimiçi deneyin!

İlk önce deneyin, çok küçük değil ama çalışır. Python'da zarif bir dize değiştirme yoktur ...

İlk döngü, bit endekslerine göre çizgiler eşlemesi yapar, yani her satır için, bir bit sayacındaki ilk bitin indeksi depolanır. Bu, bir sonraki döngüde bit sayacını indekslemek için kullanılır.

İkinci döngü bir ikili sayıcı çalıştırır, her satır ve yinelemenin bitlerini çıkarır ve birleştirir. Her şeyi bir araya getirdikten sonra, dize değiştirme kullanılarak tekrar anahtar haritası formatına çevrilir.

Sanırım, giriş dizesini tekrar tekrar yapmak yerine tekrar kullanarak daha şık bir yol var.

Düzenleme: Python 3.8 cevap esinlenerek , burada çok daha kısa bir versiyonunu değiştirerek

Python 3 - değiştir, 123 bayt

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

Çevrimiçi deneyin!

Yakut , 64 bayt

Bir dizi döndürür. Sayıları alır$1$ için $2^v$ (nerede $v$ girişindeki "v" sayısıdır) ve tuşları temel alarak çevirir $v$en az anlamlı bit. Bu, yinelemenin üzerinden bir bayt kaydetmemize olanak sağlar.$0$ için $2^v-1$, Çünkü $v$ en az önemli bit $2^v$ hepsi sıfır.

Ruby'de, en az anlamlı olan bitin başındaki th bitini i[j]döndürür , aka eşdeğerdir .ji(i>>j)&1

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

Çevrimiçi deneyin!

Kömür , 28 bayt

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

Çevrimiçi deneyin! Bağlantı, kodun ayrıntılı bir versiyonudur. Açıklama:

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

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

Çevrimiçi deneyin!

Bağımsız program, komut satırı üzerinden giriş.

Giriş dizesinin olası permütasyon sayısını v's sayısına göre döngüleyin. İkili yukarı sayma ederken, her ikili yerini 1bir ile ^ve her ikili 0bir ile vgiriş dizesi.