Днями наша команда вирушила до кімнати втечі. Одна з головоломок включала дошку з шести механічних вимикачів, де вам довелося знайти правильну комбінацію ввімкнення та вимкнення, щоб розблокувати коробку, приблизно так:

-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 додаткові байти для оголошення функції - я бачив, як інші люди залишають його, коли вони записують функцію pointfree, тому я роблю те саме, якщо не сказано інше.

Попередній відповідь (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^"; все інше перетворюється на однотонну рядок (пам’ятайте, рядки - це лише списки Chars, тому ми можемо помістити їх 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 з нього (по порядку).

Отже, для першого елемента у вас немає іншого вибору, крім вибору 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, коли він ставитьChar s в список, їм це не потрібно join.

Отже, кінцевий вихід є

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

за бажанням.

Perl 6 , 32 байти

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

Спробуйте в Інтернеті!

• .comb розбиває рядок на символи.
• ».&{...} відображає символи відповідно до функції між дужками.
• $_, ('^' if /v/)створює список альтернативних для кожного символу. Тільки vє альтернативний: ^.
• [X~]зменшує цей список за допомогою оператора крос-продукту для конкатенації рядків 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}

Спробуйте в Інтернеті!

Моє перше подання!

Зазвичай Perfer 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оператор, який приймає глобальний зразок, подібний до оболонки, який може використовуватися для генерування списків імен файлів (наприклад foo*.txt) або списку рядків (наприклад {a,b,c}). Проблема полягає в тому, що потрібно вийти з нового рядка, що я зробив, використовуючи quotemeta(як \Q).

К (нг / к) , 27 25 байт

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

Спробуйте в Інтернеті!

"^"/"v"\замінити "v"на"^"

x,' zip з оригінальними символами

(,/,/:\:)/ декартовий продукт понад

? uniq

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

Ява, 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) більш компактно.

Згідно з правилом, зазначеним у коментарі, декларацію функції слід рахувати, тож тепер це лямбда ...

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 (попередній випуск) , 129 117 116 110 106 байт

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

Спробуйте в Інтернеті!

К4 , 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`#

Замініть #s по одному зліва направо.

v$'¶$`^

Змініть кожен рядок на два рядки, один із яких #замінено на a v, один із них замінено на a ^.

%`;|$
¶

Змініть ;повернення s на нові рядки та розставте результати.

Perl 5 -0 , 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);

Спробуйте в Інтернеті!

Автономна програма, введення через командний рядок.

Цикл кількості можливих перестановок вхідного рядка на основі кількості vs. Під час підрахунку у двійковій 1формі замініть кожне бінарне на а ^та кожне бінарне 0на а vу вхідному рядку.