Neulich ging unser Team in einen Fluchtraum. Eines der Rätsel bestand aus einer Platine mit sechs mechanischen Schaltern, bei denen Sie die richtige Kombination von Ein und Aus finden mussten, um eine Box zu entsperren.

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

Als Entwickler haben wir beschlossen, dass es effizienter ist, jede einzelne der 2 ^ 6 = 64-Kombinationen auszuprobieren, als das Rätsel tatsächlich zu lösen. Also haben wir einen armen Kerl beauftragt, eine Binärzählung durchzuführen:

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

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

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

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

und so weiter.

Die Herausforderung
Schreiben Sie ein Programm, das, wenn die Schalter wie oben formatiert sind, alle Kombinationen von Ein und Aus in beliebiger Reihenfolge generiert.

Sie können entweder ein vollständiges Programm oder eine Funktion schreiben. Daher kann Ihr Programm Eingaben entweder über stdin, eine Datei oder als einzelnes Zeichenfolgenargument aufnehmen und die Ausgabe entweder zurückgeben oder ausdrucken. Wenn zurückgegeben, kann die Ausgabe in einer Liste / Array / etc sein. eher als eine einzelne Zeichenfolge. Wenn es sich bei der Ausgabe um eine einzelne Zeichenfolge handelt, sollten die Boards durch Zeilenumbrüche getrennt werden (abschließende Zeilenumbrüche sind zulässig.)

Die Eingabezeichenfolgen entsprechen dem regulären Ausdruck r'((-v)+-)(\n(-v)+-)*'und stellen eine Karte dar, bei der alle Schalter ausgeschaltet sind. Dies bedeutet, dass kein Null-Fall vorliegt und die Schalter linksbündig ausgerichtet sind. Jede Zeile verfügt möglicherweise nicht über die gleiche Anzahl von Schaltern.

Jede Ausgangskarte sollte genau dasselbe Format wie die Eingabe haben, mit der Ausnahme, dass die vs nach Bedarf durch ^ ersetzt werden können. Die Ausgangskarten können durch beliebig viele Zeilenumbrüche getrennt werden.

Da die Laufzeit in Bezug auf die Anzahl der Schalter natürlich 0 (2 ^ n) beträgt, wird Ihr Code in keiner Anordnung an mehr als 10 Schaltern getestet.

Das ist Code-Golf, also gewinnt der kürzeste Code in der Anzahl der Bytes.

Beispiel für Ein- und Ausgänge

Eingang:

-v-

Mögliche Ausgabe:

-v-
-^-

Eingang:

-v-
-v-

Mögliche Ausgabe:

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

-v-
-^-


-v-
-v-

Da es äußerst mühsam ist, Ihre Antwort auf eine größere Anzahl von Schaltern zu überprüfen, finden Sie hier ein Python-Skript als Tool zur Überprüfung der Integrität. (Ich habe ein aktuell auskommentiertes Snippet eingefügt, um die erwartete Ausgabe aus einer bestimmten Eingabedatei zu generieren, falls Sie mehr Testfälle wünschen.) Leider ist es in Bezug auf Eingabe und Ausgabe einiges weniger flexibel als die Spezifikation. Legen Sie die Eingabezeichenfolge in eine Datei mit dem Namen 'input' und die durch Zeilenumbrüche getrennte Ausgabe (sorry, keine Listenformatierung) in eine Datei mit dem Namen 'output' im selben Verzeichnis und führen Sie sie aus python3 sanitycheck.py.

Haskell , 25 24 23 17 Bytes

mapM$min"^v".pure

Probieren Sie es online!

-1 Byte dank @ H.PWiz

-1 Byte danke an @nimi

Gibt eine Liste von Zeichenfolgen zurück. Das TIO hat 2 zusätzliche Bytes für die Funktionsdeklaration - ich habe gesehen, dass andere Leute es ausgeschaltet haben, als sie die Funktion ohne Punkte geschrieben haben, also mache ich dasselbe, sofern nicht anders angegeben.

Vorherige Antwort (25 Bytes)

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

Die Erklärungen beziehen sich alle auf die vorherige Antwort, die fast auf die gleiche Weise funktioniert, mit der Ausnahme, dass ich die Definition von eingefügt habe g. Die Art und Weise gfunktioniert , ist jetzt von lexikalischen Vergleich mit Ersatz ^vfür vund halten alles andere gleich.

Interessanterweise funktioniert dies für beliebige Telefonzentralen:

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

Erklärung (kurz)

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

Erklärung (lang)

mapMist eine ziemlich beängstigende Funktion für diejenigen, die Haskell nicht kennen. Aber es ist in diesem Zusammenhang nicht schwer zu verstehen. StringIch habe es auf seine Definition für Listen spezialisiert, indem ich es auf s wirken ließ (die in Haskell Listen von Zeichen sind). In diesem Zusammenhang lautet die Typensignatur also

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

Es ist sogar noch spezialisierter auf meine Verwendung - aund bbeides Char-, so dass wir die Typensignatur als sehen können

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

Schauen wir uns kurz an, was gpassiert, bevor wir erklären, wie es mapMfunktioniert.

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

gVerwendet Pattern Matching, um das Char 'v'in den String umzuwandeln "v^". alles andere wird in eine Singleton-Zeichenfolge konvertiert (denken Sie daran, dass Zeichenfolgen nur Listen von Chars sind, sodass wir xeine Singleton-Liste einfügen können). Beim Testen mit dem REPL stellen wir fest, dass dies der Fall ist

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

Beachten Sie, dass g es den richtigen Typ hat, um ein Argument von mapM(nicht überraschend!) Zu sein.

Wir werden untersuchen, wie es mapMfunktioniert, indem wir es gund das Argument geben

"-v-\n-v-"

als Eingabe.

mapMerste karten güber die Stringund da s nach gkonvertiert , gibt uns dies eine liste vonCharStringsStrings

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

Dies ist zwar der richtige Ausgabetyp, mapMleistet jedoch etwas mehr. Sie können sich das so vorstellen, als würden Sie alle Strings bilden, die Sie aus dieser Liste erstellen könnten, wenn Sie aus jedem einen einzelnen Charakter auswählen müsstenString ( müssten.

Für das erste Element haben Sie also keine andere Wahl, als das auszuwählen Char '-'. Für das zweite Element können Sie wählen zwischen'v' und '^'usw. .

Es entspricht ungefähr diesem Python-Code:

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

Abgesehen davon, dass Haskell zwischen Chars und Strings trennt , wenn er das setztChar s in eine Liste setzt, es nicht brauchtjoin .

Die endgültige Ausgabe ist also

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

wie gewünscht.

Perl 6 , 32 Bytes

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

Probieren Sie es online!

• .comb teilt die Zeichenfolge in Zeichen auf.
• ».&{...} Ordnet die Zeichen entsprechend der Funktion zwischen den geschweiften Klammern zu.
• $_, ('^' if /v/)erzeugt eine Liste von Alternativen für jedes Zeichen. Hat vnur eine Alternative:^ .
• [X~]Reduziert diese Liste mit dem produktübergreifenden Operator für die Verkettung von Zeichenfolgen X~.

Gelee , 7 Bytes

«Ƭ€”^Œp

Probieren Sie es online!

Die Ausgabe ist eine Liste von Jelly-Strings.

Erläuterung:

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

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

Probieren Sie es online!

Meine erste Einreichung!

Normalerweise übermitteln Perl 5-Golfer Programme anstelle von Funktionen, um zu vermeiden, dass diese sub{}mindestens enthalten sein müssen. Aber sie haben hinzuzufügen say, say␠, say foroder say for␠im Austausch.

Durch den Unteransatz könnte ich verkürzen

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

zu

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

Die Erklärung ist ganz einfach. Perl 5 verfügt über einen eingebauten globOperator, der ein Shell-ähnliches Glob-Muster akzeptiert, mit dem Listen mit Dateinamen (z. B. foo*.txt) oder Listen mit Zeichenfolgen (z {a,b,c}. B. ) erstellt werden können. Der Haken ist, dass die Newline geflüchtet werden muss, was ich mit quotemeta(as \Q) getan habe .

K (NGN / k) , 27 25 Bytes

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

Probieren Sie es online!

"^"/"v"\ ersetzen "v" mit"^"

x,' Reißverschluss mit den Originalbuchstaben

(,/,/:\:)/ kartesisches Produkt vorbei

? uniq

APL (Dyalog Classic) , 21 17 15 Bytes

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

Probieren Sie es online!

ähnlich wie bei meiner k-Lösung

gibt ein n-dimensionales Array von Strings zurück (n = Anzahl der Schalter)

in einfacher zu erklärender Form: ⊃(∘.,⌿ ⊢ ∪¨ 'v'⎕r'^')

'v'⎕r'^'Ersetze vs durch ^s

⊢ ∪¨... Gewerkschaften mit jedem der ursprünglichen Charaktere. Es ist ein Vektor von Zeichenfolgen der Länge 1 oder 2

∘.,⌿ kartesische Produktreduktion

⊃ offenbaren

um zur vollgolfversion zu gelangen folgen wir dem muster f⌿ A g¨ B->A f.g B :

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

Als Nebeneffekt werden die Klammern nicht mehr benötigt

J , 42 Bytes

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

Probieren Sie es online!

Erläuterung

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

Nehmen lassen

-v-
-v-

als unser beispieleingang.

• ('v^' {~ 2 #:@i.@^ 1 #. e.&'v')Erstellt alle möglichen Kombinationen nur der Schalter, wobei das Eingabeformat ignoriert wird. für unser Beispiel ergibt es:

  vv
  v^
  ^v
  ^^
  

  • 1 #. e.&'v'zählt die Anzahl von vs in der Eingabe.
  • 2 #:@i.@^erhöht 2 auf diese Potenz, erzeugt die ganzen Zahlen von 0 bis zu dieser Zahl i.und konvertiert sie in binäre Zahlen#:
  • 'v^' {~wechselt zu Binärziffern zu vund^
• ]`('v' I.@e.~ [)`[}"1ändert der ursprüngliche Eingang, beschrieben in dem vorhergehenden Schritt (dh alle möglichen für jede Zeile des Ergebnisses einer Kopie davon produziert v/ ^Kombinationen). In jeder Kopie wird die vder ursprünglichen Eingabe durch eine mögliche Folge von v/ ersetzt ^.

Java, 202 197 189 191 Bytes

Ja, es ist eine vergleichsweise wörtliche Sprache, aber das halte ich für klassisches Golfen:

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

Ich dachte, dass ein "einfacher" Weg, mit den Zeilenumbrüchen umzugehen, die notwendig sind, um ein korrektes Layout zu erreichen, darin besteht, das ursprüngliche Eingabezeichen-Array tatsächlich wiederzuverwenden und es nur an den entsprechenden Stellen mit 'v's und '^'s zu füllen .

Aktualisierung:

Es stellte sich heraus, dass das Nichtspeichern der Positionen das Löschen der intVariablendeklarationen und des Arrays ermöglicht (auf Kosten der Überprüfung jeder Position des Arrays, ob sie ein enthält)v oder^ ), wodurch 5 Bytes eingespart werden.

Weitere 8 Bytes werden durch die Berechnung der Obergrenze eingespart (1<<numberOfSwitches) kompakter .

Entsprechend der im Kommentar genannten Regel sollte die Funktionsdeklaration gezählt werden, also ist es jetzt ein Lambda ...

J , 41 40 24 Bytes

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

Probieren Sie es 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

Probieren Sie es online!

Ein nicht-regulärer Ansatz.

C (GCC) , 75 74 70 Bytes

-5 Byte dank @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);}

Probieren Sie es online!

setzt svoraus, dass die Speicherpunkte beschreibbar sind

Python 3.8 (Vorabversion) , 129 117 116 110 106 Bytes

-10 Bytes dank @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))}

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

Probieren Sie es online!

K4 , 44 Bytes

Lösung:

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

Beispiele:

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

Erläuterung:

Vor-Ort-Austausch von "^". Anzahl der Schalterkombinationen ermitteln (zB 2 ^ n), binär hochzählen, Schalter ersetzen ...

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

Probieren Sie es online!

Funktion, die einen Vektor von durch Zeilenumbrüche getrennten Karten zurückgibt

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)

Probieren Sie es online!

Retina 0.8.2 , 29 Bytes

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

Probieren Sie es online! Erläuterung:

T`¶v`;#

Ändern Sie die Zeilenumbrüche in ;s und die vs in #Marker.

+%1`#

Ersetzen Sie das #s nacheinander von links nach rechts.

v$'¶$`^

Ändern Sie jede Zeile in zwei Zeilen, eine mit dem #Ersetzten durch a v, eine mit dem Ersetzten durch a ^.

%`;|$
¶

Ändern Sie das ;s zurück in Zeilenumbrüche und platzieren Sie die Ergebnisse auseinander.

Perl 5 -0 , 51 Bytes

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

Probieren Sie es 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]

Probieren Sie es online!

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

Probieren Sie es online!

Erster Versuch, nicht sehr klein, aber funktioniert. In Python gibt es keinen Ersatz für elegante Saiten ...

Die erste Schleife erstellt eine Zuordnung von Zeilen zu Bitindizes, dh für jede Zeile wird der Index des ersten Bits in einem Bitzähler gespeichert. Dies wird zum Indizieren des Bitzählers in der nächsten Schleife verwendet.

Die zweite Schleife führt einen Binärzähler aus, extrahiert die Bits für jede Zeile und Iteration und fügt sie zusammen. Nachdem Sie alles zusammengefügt haben, wird es mithilfe der Zeichenfolgenersetzung wieder in das Switch-Map-Format übersetzt.

Ich denke, es gibt eine elegantere Möglichkeit, die Eingabezeichenfolge wiederzuverwenden, anstatt sie immer wieder neu zu erstellen.

Edit: Inspiriert von der Antwort in Python 3.8 ist hier eine viel kürzere Ersetzungsversion

Python 3 - ersetzen, 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))

Probieren Sie es online!

Ruby , 64 Bytes

Gibt ein Array zurück. Erhält Zahlen von$1$ zu $2^v$ (woher $v$ ist die Anzahl der "v" in der Eingabe) und Kippschalter basierend auf der $v$niedrigstwertige Bits. Dies ermöglicht es uns, ein Byte über Iteration von zu speichern$0$ zu $2^v-1$, weil der $v$ niedrigstwertige Bits in $2^v$ sind alle null.

Gibt in Ruby i[j]das jdritte Bit iab dem niedrigstwertigen Bit zurück, auch bekannt als (i>>j)&1.

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

Probieren Sie es online!

Kohle , 28 Bytes

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

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Erläuterung:

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

Probieren Sie es online!

Standalone-Programm, Eingabe über Kommandozeile.

Schleifen Sie die Anzahl der möglichen Permutationen der Eingabezeichenfolge basierend auf der Anzahl der v. Ersetzen Sie 1beim Hochzählen in der Binärdatei jede Binärdatei durch a ^und jede Binärdatei 0durch a vin der Eingabezeichenfolge.