Brutalna siła rozdzielnicy

32

Któregoś dnia nasz zespół poszedł do pokoju ewakuacyjnego. Jedna z zagadek obejmowała tablicę sześciu mechanicznych przełączników, w której trzeba było znaleźć odpowiednią kombinację włączania i wyłączania, aby odblokować pudełko, mniej więcej tak:

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

Jako programiści postanowiliśmy, że bardziej efektywne będzie wypróbowanie każdej z 2 ^ 6 = 64 kombinacji niż rozwiązanie zagadki. Przydzieliliśmy więc jakiegoś biednego faceta do zliczenia binarnego:

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

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

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

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

i tak dalej.

Wyzwanie
Napisz program, który, biorąc pod uwagę wszystkie przełączniki w pozycji wyłączonej jako ciąg sformatowany jak powyżej, generuje wszystkie kombinacje włączania i wyłączania w dowolnej kolejności.

Możesz napisać pełny program lub funkcję. W ten sposób twój program może albo pobierać dane wejściowe przez stdin, plik, albo jako pojedynczy ciąg znaków i zwracać lub drukować dane wyjściowe. Jeśli zostanie zwrócone, dane wyjściowe mogą znajdować się w liście / tablicy / itp. zamiast jednego ciągu. Jeśli wynik jest pojedynczym ciągiem, tablice powinny być oddzielone znakami nowej linii (dozwolone są znaki nowej linii).

Ciągi wejściowe będą pasować do wyrażenia regularnego r'((-v)+-)(\n(-v)+-)*'i będą reprezentować jedną płytkę ze wszystkimi wyłącznikami. Oznacza to brak zerowej wielkości liter, a przełączniki są wyrównane do lewej. Każdy wiersz może nie mieć takiej samej liczby przełączników.

Każda płytka wyjściowa powinna mieć dokładnie taki sam format jak wejście, z tym wyjątkiem, że v można w razie potrzeby zastąpić ^. Tablice wyjściowe można oddzielić dowolną liczbą nowych linii.

Ponieważ środowisko wykonawcze ma naturalnie wartość O (2 ^ n) pod względem liczby przełączników, kod nie będzie testowany na więcej niż 10 przełącznikach w dowolnym układzie.

To jest golf golfowy, więc wygrywa najkrótszy kod w liczbie bajtów.

Przykładowe wejścia i wyjścia

Wkład:

-v-

Możliwe wyjście:

-v-
-^-

Wkład:

-v-
-v-

Możliwe wyjście:

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

-v-
-^-


-v-
-v-

Ponieważ sprawdzanie odpowiedzi w przypadku większej liczby przełączników jest niezwykle uciążliwe, oto skrypt w języku Python jako narzędzie do sprawdzania czystości. (Dołączyłem obecnie skomentowany fragment kodu, aby wygenerować oczekiwane dane wyjściowe z danego pliku wejściowego na wypadek, gdybyś chciał więcej przypadków testowych.) Niestety, jest nieco mniej elastyczny pod względem danych wejściowych i wyjściowych niż specyfikacja; umieść ciąg wejściowy w pliku o nazwie „wejście”, a wyjście oddzielone znakiem nowej linii (przepraszam, brak formatowania listy) w pliku o nazwie „wyjście” w tym samym katalogu i uruchom python3 sanitycheck.py.

Transformacja Fouriera Rina
źródło
8
miłe pierwsze wyzwanie!
Giuseppe
12
Mamy nadzieję, że „biedak” wiedział o kodzie Graya , aby przerzucić tylko jeden bit między każdą kombinacją.
Eric Duminil
1
Czas jest naszym najcenniejszym dobrem, nie marnuj go na próżno.
Pedro Lobito,
6
Biorąc pod uwagę temat, jestem rozczarowany, że nie wymagałeś zamówienia, które wymaga najmniejszej liczby przełączeń (np. 00-> 01-> 11-> 10 ma 3 przełączniki, a 00-> 01-> 10-> 11 ma 4 ) - Fellow brute force escaper
ikegami
2
@EricDuminil: gdyby mechaniczne przełączniki nie były przyciskami (a może nawet jeśli), najprawdopodobniej różnica czasu potrzebnego między przełączaniem jednego, dwóch i trzech kolejnych przełączników (co prawdopodobnie można zrobić prawie jednocześnie) nie byłaby wystarczająco duża aby zrównoważyć dodatkową pracę umysłową, aby postępować zgodnie z kodem Graya.
tomasz

Odpowiedzi:

23

Haskell , 25 24 23 17 bajtów

mapM$min"^v".pure

Wypróbuj online!

-1 bajt dzięki @ H.PWiz

-1 bajt dzięki @nimi

Zwraca listę ciągów. TIO ma 2 dodatkowe bajty dla deklaracji funkcji - widziałem, jak inni ludzie ją wyłączają, gdy piszą funkcję bez punktów, więc robię to samo, chyba że powiedziano inaczej.

Poprzednia odpowiedź (25 bajtów)

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

Wyjaśnienia dotyczą poprzedniej odpowiedzi, która działa prawie w ten sam sposób, z tą różnicą, że wstawiłem definicję g. Sposób, w jaki gdziała teraz jest za pomocą porównania leksykalnego zastąpił ^vza vi zachować wszystko inne tak samo.

Co ciekawe, działa to w przypadku dowolnych tablic rozdzielczych:

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

Wyjaśnienie (krótkie)

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

Objaśnienie (długie)

mapMjest dość przerażającą funkcją dla tych, którzy nie znają Haskella. Ale nie jest trudno zrozumieć w tym kontekście. Ustawiając go na Strings (które w Haskell są listami postaci), wyspecjalizowałem się w jego definicji list. Więc w tym kontekście jego podpis typu to

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

W rzeczywistości jest jeszcze bardziej wyspecjalizowany w moim użyciu - ai boba Char- i możemy zobaczyć podpis typu jako

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

Szybko spójrzmy na to, co grobi, zanim wyjaśnimy, jak to mapMdziała.

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

gużywa dopasowania wzorca do konwersji ciągu Char 'v'na ciąg "v^"; wszystko inne zostaje przekonwertowane na ciąg singletonu (pamiętaj, że ciągi to tylko listy Chars, więc możemy umieścić xlistę singletonów). Testując REPL, stwierdzamy, że tak jest

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

Zauważ, że gjest to odpowiedni typ argumentu mapM(nic dziwnego!).

Zbadamy, jak to mapMdziała, podając go gi argument

"-v-\n-v-"

jako dane wejściowe.

mapMpierwsze mapy gnad String, a ponieważ gkonwertuje Chars na Strings, daje nam to listęStrings

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

Chociaż jest to prawidłowy typ wyjściowy, mapMrobi nieco więcej. Możesz myśleć o tym jako o utworzeniu wszystkich Stringliter, które możesz stworzyć z tej listy, jeśli będziesz musiał wybrać po jednym znaku z każdej z nich String(w kolejności).

Tak więc dla pierwszego elementu nie masz innego wyboru niż wybranie Char '-'. Dla drugiego elementu, można wybrać pomiędzy 'v'i '^'tak dalej i tak dalej.

Jest to mniej więcej odpowiednik tego kodu python:

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

Tyle, że ponieważ Haskell rozdziela Chars i Strings, kiedy umieszcza Chars na liście, nie potrzebuje joinich.

Tak więc końcowy wynik to

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

zgodnie z życzeniem.

kapusta
źródło
Ooh, czekałem na czysto funkcjonalną odpowiedź, to naprawdę zdumiało mnie, jak zwięzłe było.
Przekształcenie Fouriera Rin w
2
@ Rin'sFouriertransform Byłem zadowolony z tego, jak dobrze mapMpracowałem dla tego wyzwania, na początku miałem to sformułowane jako, sequence . map gale można to wyrazić zwięźle, mapM id . map ga potem zobaczyłem, że mogęmapM g
cole
1
Myślę, że możesz zamienić =='v'na>'-'
H.PWiz
9

Perl 6 , 32 bajty

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

Wypróbuj online!

  • .comb dzieli ciąg na znaki.
  • ».&{...} odwzorowuje znaki zgodnie z funkcją między nawiasami klamrowymi.
  • $_, ('^' if /v/)tworzy listę alternatyw dla każdego znaku. Tylko vma zastępcę: ^.
  • [X~]zmniejsza tę listę za pomocą operatora krzyżowego łączenia produktów X~.
Sean
źródło
9

Galaretka , 7 bajtów

«Ƭ€”^Œp

Wypróbuj online!

Dane wyjściowe to lista ciągów galaretki.

Wyjaśnienie:

«Ƭ€”^Œ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
Erik the Outgolfer
źródło
Właśnie przeszukiwałem strony kodowe Jelly, aby dowiedzieć się, w jaki sposób pierwsza odpowiedź nieustannie obezwładnia każdą inną odpowiedź, prawie zawsze z całkiem dobrym marginesem ... czy zechciałby pan wyjaśnić, jak to działa?
Przekształcenie Fouriera Rin w
@ Rin'sFouriertransform Dodałem wyjaśnienie.
Erik the Outgolfer
6

Perl 5 , 29 bajtów

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

Wypróbuj online!

Moje pierwsze zgłoszenie!


Zwykle golfiści Perl 5 przesyłają programy zamiast funkcji, aby zaoszczędzić od konieczności dołączania sub{}co najmniej. Ale trzeba dodać say, say␠, say forlub say for␠w zamian.

Wybierając podejście podrzędne, mogłem skrócić

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

do

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

Wyjaśnienie jest dość proste. Perl 5 ma wbudowany globoperator, który akceptuje wzór globu podobny do powłoki, którego można użyć do wygenerowania list nazw plików (np. foo*.txt) Lub listy ciągów (np {a,b,c}.). Problem polega na tym, że nowa linia musi być zmieniona, co zrobiłem za pomocą quotemeta(as \Q).

ikegami
źródło
4

K (ngn / k) , 27 25 bajtów

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

Wypróbuj online!

"^"/"v"\wymienić "v"z"^"

x,' zip z oryginalnymi znakami

(,/,/:\:)/ produkt kartezjański zakończony

? uniq

ngn
źródło
.. i oto myślę, że dobrze zrobiłem w 44 bajtach!
streetster
4

APL (Dyalog Classic) , 21 17 15 bajtów

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

Wypróbuj online!

podobne do mojego rozwiązania k

zwraca n-wymiarową tablicę ciągów (n = liczba przełączników)

w łatwiejszej do wyjaśnienia formie: ⊃(∘.,⌿ ⊢ ∪¨ 'v'⎕r'^')

'v'⎕r'^'zamień vs na ^s

⊢ ∪¨... związki z każdą z oryginalnych postaci. jest to wektor ciągów o długości 1 lub 2

∘.,⌿ redukcja produktu kartezjańskiego

ujawniać

aby przejść do wersji w pełni golfowej, kierujemy się wzorem f⌿ A g¨ B-> A f.g B:

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

jako efekt uboczny nawiasy nie są już potrzebne

ngn
źródło
Wszystko z produktem wewnętrznym produktu zewnętrznego zasługuje na +1.
Adám
3

J , 42 bajty

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

Wypróbuj online!

wyjaśnienie

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

Niech weźmie

-v-
-v-

jako nasz przykładowy wkład.

  • ('v^' {~ 2 #:@i.@^ 1 #. e.&'v')tworzy wszystkie możliwe kombinacje samych przełączników, ignorując format wejściowy. w naszym przykładzie produkuje:

    vv
    v^
    ^v
    ^^
    
    • 1 #. e.&'v'zlicza liczby vs na wejściu.
    • 2 #:@i.@^podnosi 2 do tej potęgi, produkuje liczby całkowite od 0 do tej liczby i.i konwertuje je na binarne#:
    • 'v^' {~zmiany cyfr binarnych na vi^
  • ]`('v' I.@e.~ [)`[}"1zmienia oryginalny wejściowy, tworząc jedną kopię dla każdego rzędu w wyniku opisanego w poprzednim etapie (czyli wszystkie możliwe v/ ^combo). W każdej kopii voryginalne wejście jest zastępowane jedną możliwą sekwencją v/ ^.
Jonasz
źródło
3

Java, 202 197 189 191 bajtów

Tak, jest to dość szczegółowy język, ale to, co uważam za klasyczne golfa:

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

Myślałem, że „prosty” sposób radzenia sobie z podziałów wierszy, które są niezbędne do osiągnięcia celu prawidłowego układu było rzeczywiście ponownie użyć oryginalnego tablicę znaków wejściowych, a tylko wypełnić go z 'v'S i '^'S w odpowiednich pozycjach.

Aktualizacje:

Okazało się, że nie przechowywania stanowisk pozwala na wodowania inti deklaracji zmiennych array (kosztem sprawdzanie każdej pozycji tablicy, czy zawiera on vlub ^w locie), oszczędzając 5 bajtów.

Kolejne 8 bajtów zaoszczędzonych dzięki (1<<numberOfSwitches)bardziej zwartemu obliczeniu górnej granicy .

Zgodnie z regułą wymienioną w komentarzu należy policzyć deklarację funkcji, więc teraz jest to lambda ...

Marco13
źródło
2
Jestem prawie pewien, że musisz uwzględnić definicję funkcji ( String generate(String s) {...}) w swojej liczbie bajtów. Oto wersja fixed / lambda dla 191 bajtów . Zrobiłem trochę golfa, aby ogolić 3 bajty
Benjamin Urquhart
@BenjaminUrquhart OK, to są szczegóły „zasad”, których nie znam (nie gram tutaj tak regularnie). Pomyślałem, że rzeczywistość { function body }powinna być istotna, ponieważ nie ma znaczenia, czy umieścisz ją w funkcji, która jest, staticczy nie, i oczywiście, jeśli deklaracja liczy się do wyniku, można przekształcić ją w wyrażenie lambda. Ale tak się teraz dzieje, dziękuję za zwrócenie na to uwagi.
Marco13
1
Kilka sugestii: 1. używaj kodów ascii, a nie znaków ( d=94). 2. Zainicjuj, ikiedy to zadeklarujesz. 3. Użyj i++<mzamiast osobnego przyrostu (musisz zmodyfikować zawartość pętli w jednym miejscu, ale nie powoduje to żadnych kosztów). 4. Czy możesz uciec (i&1<<j++)>0? 5. Nie sądzę, żebyś potrzebował {}wewnętrznej forpętli. 6. Można wymienić a[k]==d||a[k]==uz a[k]>45, myślę. 7. Idź z j=k=0. Wszystko to powinno usunąć 19 bajtów.
VisualMelon,
@VisualMelon Niektóre z nich to podejście „klasycznego golfa”, a niektóre z nich już zastosowałem. To, czy mają one zastosowanie, zależy - uważam, że niektóre {}są konieczne, ale mogę mieć inny wygląd. a[k]>45Może być schludny trik, jednak. Wprawdzie napisałem to tylko po to, by marnować trochę czasu na rozpoczęcie spotkania (stąd nazwa klasy - to było zamierzone ;-)), ale może jeszcze popatrzę - dzięki w każdym razie!
Marco13
@ Marco13 rzeczywiście, są to klasyczne sztuczki, ale wszystkie mają tutaj zastosowanie. Nie zepsuję zabawy, dając ci moje 172-bajtowe rozwiązanie oparte na nich (BTW, wydaje się, że twoje ma 192, a nie 191, ale nie wiem, jak działa liczenie lambda: w każdym razie jestem przeciwny. ).
VisualMelon,
3

J , 41 40 24 bajtów

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

Wypróbuj online!

ngn
źródło
bardzo imponujące. uwielbiam używać {. chociaż myślę [:>@,@{<@(,'^'$~'v'=])"0, że byłoby to nieco bardziej sprawiedliwe, ponieważ „Każda płytka wyjściowa powinna mieć dokładnie taki sam format jak wejście”, a wejście nie jest zapakowane w ramkę.
Jonah
@Jonah dzięki. poprawione.
ngn
3

Python 2 , 87 bajtów

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

Wypróbuj online!

Podejście inne niż wyrażenia regularne.

Chas Brown
źródło
O wiele bardziej zwięzłe podejście niż moje, dobra robota!
movatica
3

C (gcc) , 75 74 70 bajtów

-5 bajtów dzięki @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);}

Wypróbuj online!

wymaga zapisywania spunktów pamięci

ngn
źródło
@cielingcat ma rację: tio.run
Brian Minton
@BrianMinton rzeczywiście. i nigdy bym nie pomyślał o spróbowaniu tego. miły!
ngn
3

Python 3.8 (wersja wstępna) , 129 117 116 110 106 bajtów

-10 bajtów dzięki @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))}

Wypróbuj online!

wilkben
źródło
1
Witamy w PPCG! 123 bajty przy użyciu podobnego pomysłu.
Chas Brown
1
119 bajtów (poprzednio zły link w tym komentarzu).
Chas Brown
2

K4 , 44 bajty

Rozwiązanie:

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

Przykłady:

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

Wyjaśnienie:

Wymiana w miejscu "^". Określić liczbę kombinacji przełączników (np. 2 ^ n), policzyć binarnie, wymienić przełączniki ...

-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
streetster
źródło
2

R , 116 bajtów

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

Wypróbuj online!

Funkcja zwracająca wektor tablic rozdzielonych znakiem nowej linii

digEmAll
źródło
ah, tak bardzo skupiłem się na przyjmowaniu informacji w znacznie trudniejszy sposób, że zaniedbałem łatwość tego. Niezłe wykorzystanie "[<-"!
Giuseppe
@Giuseppe: Nie jestem bardzo zadowolony z tego rozwiązania ... ale próbowałem wygenerować kombinacje na inne sposoby (np. Używając konwersji binarnej), ale okazało się, że jest najkrótszy.
digEmAll
1

JavaScript, 88 bajtów

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

Wypróbuj online!

darrylyeo
źródło
1
n>>=1->n/=2
ngn
1

Retina 0.8.2 , 29 bajtów

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

Wypróbuj online! Wyjaśnienie:

T`¶v`;#

Zmień znaki nowej linii na ;s, a vs na #markery.

+%1`#

Wymień je #pojedynczo od lewej do prawej.

v$'¶$`^

Zmień każdą linię na dwie linie, jedną z #zastąpioną przez a v, jedną z zastąpioną przez a ^.

%`;|$
¶

Zmień ;s z powrotem na nowe linie i rozdziel wyniki od siebie.

Neil
źródło
1

Perl 5 -0 , 51 bajtów

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

Wypróbuj online!

Xcali
źródło
39 38 32 29
ikegami
1
Och, podstawowa wskazówka: używanie -npozwoliłoby uniknąć potrzeby$_=<>;
ikegami
1

Python 3 - konstrukcja, 203 bajty

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

Wypróbuj online!

Pierwsza próba, niezbyt mała, ale działa. W Pythonie nie ma eleganckiej zamiany napisów ...

Pierwsza pętla buduje odwzorowanie linii na indeksy bitów, tj. Dla każdej linii przechowywany jest indeks pierwszego bitu w liczniku bitów. Służy do indeksowania licznika bitów w następnej pętli.

Druga pętla uruchamia licznik binarny, wyodrębnia bity dla każdej linii i iteracji i łączy je. Po połączeniu wszystkich elementów jest on ponownie tłumaczony do formatu mapy przełączników, z wykorzystaniem zamiany napisów.

Sądzę, że istnieje bardziej elegancki sposób, poprzez ponowne użycie ciągu wejściowego zamiast jego przebudowywania w kółko.

Edycja: zainspirowana odpowiedzią Python 3.8 , tutaj jest znacznie krótsza wersja zastępująca

Python 3 - zamień, 123 bajty

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

Wypróbuj online!

movatica
źródło
0

Rubinowy , 64 bajty

12vvv02v1v2v

W Ruby i[j]zwraca jth izaczynający się od najmniej znaczącego bitu, czyli równoważny (i>>j)&1.

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

Wypróbuj online!

Wartość tuszu
źródło
0

Węgiel drzewny , 28 bajtów

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

Wypróbuj online! Link jest do pełnej wersji kodu. Wyjaśnienie:

   ²                            Literal 2
  X                             Raised to power
    №                           Count of
      v                         Literal `v`
     θ                          In input string
 E                              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
                  X             Raised to power
                    №           Count of
                        v       Literal `v`
                      θ         In input string
                     …          Truncated to length
                       μ        Inner index
                         λ      Else current character
⪫                         ¶¶    Join with newlines
                                Implicitly print
Neil
źródło
0

PHP , 93 bajty

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

Wypróbuj online!

Samodzielny program, wprowadzany z wiersza poleceń.

Zapętlić liczbę możliwych permutacji ciągu wejściowego na podstawie liczby v. Podczas liczenia w formacie binarnym zamień każdy plik binarny na „ 1a”, ^a każdy plik binarny na „ 0a” vw ciągu wejściowym.

640 KB
źródło