Brute-Force-Schalttafel

32

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.

Rins Fourier-Transformation
quelle
8
schöne erste herausforderung!
Giuseppe
12
Hoffentlich wusste der "arme Kerl" von Gray-Code, um zwischen jeder Kombination nur ein Bit umzudrehen.
Eric Duminil
1
Zeit ist unser kostbarstes Gut, verschwenden Sie es nicht umsonst.
Pedro Lobito
6
Angesichts des Themas bin ich enttäuscht, dass Sie keine Bestellung mit der geringsten Anzahl von Umschaltern angefordert haben (z. B. 00-> 01-> 11-> 10 hat 3 Umschaltern, während 00-> 01-> 10-> 11 4 hat) ) - Brute Force Escaper
ikegami
2
@EricDuminil: Wenn die mechanischen Schalter keine Tasten wären (und vielleicht sogar wenn), dann wäre die Differenz zwischen dem Umschalten von einem, zwei und drei aufeinander folgenden Schaltern (die Sie wahrscheinlich fast gleichzeitig ausführen könnten) höchstwahrscheinlich nicht groß genug um die zusätzliche mentale Arbeit auszugleichen, folgen Sie dem Gray-Code.
Tomasz

Antworten:

23

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.

cole
quelle
Oh, ich habe auf eine rein funktionale Antwort gewartet, das hat mich wirklich umgehauen, wie kurz es war.
Rins Fourier-Transformation
2
@ Rin'sFouriertransform ich mit , wie schön zufrieden war mapMarbeitete für diese Herausforderung, hatte ich anfangs formulierte es so , sequence . map gaber das kann kompakt ausgedrückt werden als mapM id . map gich sah , und dann konnte ich nurmapM g
cole
1
Ich denke, Sie können =='v'für>'-'
H.PWiz
9

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~.
Sean
quelle
9

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
Erik der Outgolfer
quelle
Ich habe tatsächlich die Jelly-Codeseiten durchgesehen, um herauszufinden, wie die erste Antwort immer wieder jede andere Antwort übertroffen hat, fast immer mit ziemlich großem Abstand ... Möchten Sie erklären, wie das funktioniert?
Rins Fourier-Transformation
@ Rin'sFouriertransform Ich habe eine Erklärung hinzugefügt.
Erik der Outgolfer
6

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 .

Ikegami
quelle
4

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

ngn
quelle
.. und hier denke ich, dass ich in 44 Bytes in Ordnung war!
Streetster
4

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

ngn
quelle
Alles, was ein äußeres Produkt als inneres Produkt hat, verdient +1.
Adám
3

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 ^.
Jonah
quelle
3

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

Marco13
quelle
2
Ich bin mir ziemlich sicher, dass Sie die Funktionsdefinition ( String generate(String s) {...}) in Ihre Byteanzahl aufnehmen müssen. Hier ist eine feste / Lambda-Version für 191 Bytes . Ich habe ein bisschen Golf gespielt, um 3 Bytes zu sparen
Benjamin Urquhart,
@BenjaminUrquhart OK, das sind Details der "Regeln", mit denen ich nicht vertraut bin (ich spiele hier nicht sooo regelmäßig Golf). Ich dachte, dass das tatsächlich so ist{ function body } relevant sein sollte, weil es keine Rolle spielt, ob Sie es in eine Funktion setzen, die ist staticoder nicht, und natürlich kann man es in einen Lambda-Ausdruck umwandeln , wenn die Deklaration für die Punktzahl zählt. Aber das ist es, was jetzt gemacht wird, danke, dass du darauf hingewiesen hast.
Marco,
1
Einige Vorschläge: 1. Verwenden Sie ASCII-Codes, keine Zeichen ( d=94). 2. Initialisieren iSie, wenn Sie es deklarieren. 3. Verwenden Sie i++<manstelle eines separaten Inkrements (Sie müssen den Inhalt der Schleife an einer Stelle ändern, dies verursacht jedoch keine Kosten). 4. Kannst du damit durchkommen (i&1<<j++)>0? 5. Ich glaube nicht, dass du das {}für die innere forSchleife brauchst . 6. Sie können ersetzen a[k]==d||a[k]==umit a[k]>45, denke ich. 7. Gehen Sie mit j=k=0. All das sollte 19Byte entfernen.
VisualMelon
@VisualMelon Einige davon sind die "klassischen Golf" -Ansätze, von denen ich einige bereits angewendet habe. Ob sie anwendbar sind oder nicht, hängt davon ab - ich denke, dass einige {}notwendig sind, aber ich kann einen anderen Blick darauf werfen. Das a[k]>45mag jedoch ein ordentlicher Trick sein. Zugegeben, ich habe dies nur geschrieben, um einige Zeit damit zu verschwenden, auf den Beginn eines Meetings zu warten (daher der Klassenname - das war beabsichtigt ;-)), aber vielleicht werde ich es mir noch einmal ansehen - auf jeden Fall danke!
Marco,
@ Marco13 das sind zwar klassische tricks, aber alle hier spezifisch zutreffend. Ich werde den Spaß nicht verderben, indem ich Ihnen meine 172-Byte-Lösung auf der Grundlage dieser Werte gebe (übrigens, ich glaube, Ihre sind 192, nicht 191), aber ich weiß nicht, wie das Lambda-Zählen funktioniert: Ich bin auf jeden Fall dagegen ).
VisualMelon
3

J , 41 40 24 Bytes

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

Probieren Sie es online!

ngn
quelle
sehr beeindruckend. liebe die Verwendung von {. obwohl ich denke, [:>@,@{<@(,'^'$~'v'=])"0wäre etwas fairer, da "jede ausgangskarte genau das gleiche format wie der eingang haben sollte" und der eingang nicht umrahmt ist.
Jona
@Jonah danke. korrigiert.
20.
3

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.

Chas Brown
quelle
Ein viel prägnanterer Ansatz als meiner, gute Arbeit!
Movatica
3

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!

wilkben
quelle
1
Willkommen bei PPCG! 123 Bytes mit einer ähnlichen Idee.
Chas Brown
1
119 Bytes (bisher falscher Link in diesem Kommentar).
Chas Brown
2

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
Streetster
quelle
2

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

digEmAll
quelle
Ah, ich war so darauf konzentriert, Eingaben auf eine viel härtere Weise zu verarbeiten, dass ich die Leichtigkeit dieser vernachlässigte. Gute Verwendung von "[<-"!
Giuseppe
@ Giuseppe: Ich bin mit dieser Lösung nicht sehr zufrieden ... aber ich habe versucht, die Kombinationen auf andere Weise zu generieren (z. B. mit Hilfe der Binärkonvertierung), aber dies war am Ende die kürzeste.
digEmAll
1

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!

darrylyeo
quelle
1
n>>=1->n/=2
ngn
1

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.

Neil
quelle
1

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!

movatica
quelle
0

Ruby , 64 Bytes

Gibt ein Array zurück. Erhält Zahlen von1 zu 2v (woher v ist die Anzahl der "v" in der Eingabe) und Kippschalter basierend auf der vniedrigstwertige Bits. Dies ermöglicht es uns, ein Byte über Iteration von zu speichern0 zu 2v-1, weil der v niedrigstwertige Bits in 2v 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!

Wert Tinte
quelle
0

Kohle , 28 Bytes

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

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

   ²                            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
quelle
0

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.

640 KB
quelle