Forza bruta il centralino


32

L'altro giorno, il nostro team è andato in una stanza di fuga. Uno dei puzzle riguardava una scheda di sei interruttori meccanici in cui dovevi trovare la corretta combinazione di accensione e spegnimento per sbloccare una scatola, un po 'così:

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

Essendo sviluppatori, abbiamo deciso che sarebbe stato più efficiente provare ciascuna delle combinazioni 2 ^ 6 = 64 che risolvere effettivamente il puzzle. Quindi abbiamo incaricato un poveraccio di fare un conteggio binario:

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

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

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

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

e così via.

La sfida
Scrivere un programma che, dati tutti gli interruttori in posizione off come una stringa formattata come sopra, genera tutte le combinazioni di on e off in qualsiasi ordine.

È possibile scrivere un programma completo o una funzione. Pertanto, il programma può accettare input tramite stdin, un file o come singolo argomento stringa e restituire o stampare l'output. Se restituito, l'output potrebbe trovarsi in un elenco / array / ecc. piuttosto che una singola stringa. Se l'output è una singola stringa, le schede dovrebbero essere separate da newline (sono consentite le newline finali).

Le stringhe di input corrisponderanno al regex r'((-v)+-)(\n(-v)+-)*'e rappresenteranno una scheda con tutti gli interruttori spenti. Ciò significa che non è presente alcun caso zero e che gli interruttori sono allineati a sinistra. Ogni riga potrebbe non avere lo stesso numero di switch.

Ogni scheda di output deve avere lo stesso identico formato dell'input, tranne per il fatto che le v possono essere sostituite da ^ come richiesto. Le schede di output possono essere separate da un numero qualsiasi di newline.

Poiché il runtime è naturalmente O (2 ^ n) nel numero di switch, il tuo codice non verrà testato su più di 10 switch in nessuna disposizione.

Questo è code-golf, quindi vince il codice più breve nel numero di byte.

Ingressi e uscite di esempio

Ingresso:

-v-

Uscita possibile:

-v-
-^-

Ingresso:

-v-
-v-

Uscita possibile:

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

-v-
-^-


-v-
-v-

Dal momento che è estremamente noioso controllare la tua risposta per un numero maggiore di switch, ecco uno script Python come strumento di controllo di integrità. (Ho incluso uno snippet attualmente commentato per generare l'output previsto da un determinato file di input nel caso in cui desideri più casi di test.) Purtroppo è un po 'meno flessibile in termini di input e output rispetto alle specifiche; metti la stringa di input in un file chiamato 'input' e l'output separato da newline (scusa, nessuna formattazione dell'elenco) in un file chiamato 'output' nella stessa directory ed esegui python3 sanitycheck.py.


8
bella prima sfida!
Giuseppe,

12
Si spera che il "poveraccio" fosse a conoscenza del codice Gray per poter scambiare solo un bit tra una combinazione e l'altra.
Eric Duminil,

1
Il tempo è il nostro bene più prezioso, non sprecarlo invano.
Pedro Lobito,

6
Dato il tema, sono deluso che non hai richiesto un ordine che richieda il minor numero di toggle (ad es. 00-> 01-> 11-> 10 ha 3 toggle mentre 00-> 01-> 10-> 11 ha 4 ) - Compagno della forza bruta
ikegami il

2
@EricDuminil: se gli interruttori meccanici non fossero pulsanti (e forse anche se), molto probabilmente, la differenza del tempo necessario tra il passaggio di uno, due e tre interruttori consecutivi (che probabilmente potresti fare quasi contemporaneamente) non sarebbe abbastanza grande per compensare il lavoro mentale extra per seguire il codice Gray.
Tomasz,

Risposte:


23

Haskell , 25 24 23 17 byte

mapM$min"^v".pure

Provalo online!

-1 byte grazie a @ H.PWiz

-1 byte grazie a @nimi

Restituisce un elenco di stringhe. Il TIO ha 2 byte extra per la dichiarazione di funzione - ho visto altre persone lasciarlo fuori quando scrivono la funzione senza punti, quindi sto facendo lo stesso se non diversamente specificato.

Risposta precedente (25 byte)

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

Le spiegazioni sono tutte per la risposta precedente, che funziona più o meno allo stesso modo, tranne per il fatto che ho sottolineato la definizione di g. Il modo in cui gfunziona la società è quello di utilizzare il confronto lessicale di sostituire ^vper ve tenere tutto il resto lo stesso.

È interessante notare che questo funziona per centralini arbitrari:

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

Spiegazione (breve)

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

Spiegazione (lunga)

mapMè una funzione piuttosto spaventosa per coloro che non hanno familiarità con Haskell. Ma non è difficile da capire in questo contesto. Facendolo agire su Strings (che in Haskell sono elenchi di personaggi), l'ho specializzato nella sua definizione di elenchi. Quindi, in questo contesto, la sua firma di tipo è

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

In realtà è ancora più specializzato nel mio uso di esso - ae bsono entrambi Char- quindi possiamo vedere la firma del tipo come

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

Diamo un'occhiata a cosa gfa prima di spiegare come mapMfunziona.

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

gusa la corrispondenza del modello per convertire il Char 'v'nella stringa "v^"; tutto il resto viene convertito in una stringa singleton (ricordate, le stringhe sono solo liste di Chars, quindi possiamo mettere xuna lista singleton). Test su REPL, scopriamo che è così

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

Si noti che gha il tipo giusto per essere un argomento di mapM(non sorprende!).

Esploreremo come mapMfunziona dandogli ge l'argomento

"-v-\n-v-"

come input.

mapMprima mappe gsu String, e poiché gconverte Chars in Strings, questo ci dà un elenco diStrings

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

Mentre questo è il tipo di output corretto, mapMfa leggermente di più. Puoi pensare che formi tutti Stringi messaggi che potresti creare da questo elenco se dovessi scegliere un singolo personaggio da ciascuno Stringdi essi (in ordine).

Quindi, per il primo elemento, non hai altra scelta che scegliere il Char '-'. Per il secondo elemento, puoi scegliere tra 'v'e '^', così via e così via.

È approssimativamente equivalente a questo codice Python:

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

Solo che, dato che Haskell separa tra se Chare Strings, quando inserisce le Chars in un elenco, non ne ha bisogno join.

Quindi l'output finale è

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

come desiderato.


Ooh, stavo aspettando una risposta puramente funzionale, questo mi ha davvero lasciato senza fiato per quanto fosse conciso.
Rin Fourier trasforma il

2
@ Rin'sFouriertransform Sono stato contento di come ha mapMfunzionato bene per questa sfida, all'inizio l'avevo formulato come sequence . map gma che può essere espresso in modo compatto come mapM id . map ge poi ho visto che potevo solomapM g
Cole

1
Penso che tu possa scambiare =='v'per>'-'
H.Piz il

9

Perl 6 , 32 byte

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

Provalo online!

  • .comb divide la stringa in caratteri.
  • ».&{...} mappa i caratteri in base alla funzione tra parentesi graffe.
  • $_, ('^' if /v/)produce un elenco di supplenti per ogni personaggio. Solo vha un supplente: ^.
  • [X~]riduce tale elenco con l'operatore tra prodotti concatenazione di stringhe X~.

9

Gelatina , 7 byte

«Ƭ€”^Œp

Provalo online!

L'output è un elenco di stringhe Jelly.

Spiegazione:

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

In realtà ho cercato tra le pagine del codice Jelly per cercare di capire come la prima risposta ha superato di gran lunga ogni altra risposta, quasi sempre con un margine abbastanza buono ... ti dispiacerebbe spiegare come funziona?
Rin Fourier trasforma il

@ Rin'sFouriertransform Ho aggiunto una spiegazione.
Erik the Outgolfer,

6

Perl 5 , 29 byte

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

Provalo online!

La mia prima presentazione!


Normalmente, i golfisti di Perl 5 presentano programmi invece di funzioni per salvare dal dover includere sub{}almeno. Ma devono aggiungere say, say␠, say foro say for␠in cambio.

Seguendo l'approccio secondario, potrei accorciare

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

a

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

La spiegazione è abbastanza semplice Perl 5 ha un globoperatore incorporato che accetta un modello glob tipo shell che può essere usato per generare liste di nomi di file (es. foo*.txt) O liste di stringhe (es {a,b,c}.). Il trucco è che la newline deve essere sfuggita, che ho fatto usando quotemeta(as \Q).


4

K (ngn / k) , 27 25 byte

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

Provalo online!

"^"/"v"\sostituire "v"con"^"

x,' zip con i caratteri originali

(,/,/:\:)/ prodotto cartesiano sopra

? uniq


.. ed ecco io che penso di aver fatto bene in 44 byte!
streetster

4

APL (Dyalog Classic) , 21 17 15 byte

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

Provalo online!

simile alla mia soluzione k

restituisce una matrice n-dimensionale di stringhe (n = numero di switch)

in forma più semplice da spiegare: ⊃(∘.,⌿ ⊢ ∪¨ 'v'⎕r'^')

'v'⎕r'^'sostituire vs con ^s

⊢ ∪¨... sindacati con ciascuno dei personaggi originali. è un vettore di stringhe di lunghezza 1 o 2

∘.,⌿ riduzione cartesiana del prodotto

divulgare

per arrivare alla versione completamente golfizzata seguiamo il modello f⌿ A g¨ B-> A f.g B:

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

come effetto collaterale le parentesi non sono più necessarie


Qualsiasi cosa con un prodotto interno di un prodotto esterno merita +1.
Adám,

3

J , 42 byte

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

Provalo online!

spiegazione

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

Let take

-v-
-v-

come input di esempio.

  • ('v^' {~ 2 #:@i.@^ 1 #. e.&'v')crea tutte le possibili combinazioni dei soli switch, ignorando il formato di input. per il nostro esempio produce:

    vv
    v^
    ^v
    ^^
    
    • 1 #. e.&'v'conta i numeri di vs nell'input.
    • 2 #:@i.@^aumenta 2 a quella potenza, produce gli interi da 0 a quel numero i.e li converte in binari#:
    • 'v^' {~cambia in cifre binarie in ve^
  • ]`('v' I.@e.~ [)`[}"1modifica l'input originale, producendone una copia per ogni riga del risultato descritto nel passaggio precedente (ovvero, tutte le possibili v/ ^combo). In ogni copia i caratteri vdell'input originale vengono sostituiti con una possibile sequenza di v/ ^.

3

Java, 202 197 189 191 byte

Sì, è un linguaggio relativamente dettagliato, ma è quello che considero il golf classico:

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

Ho pensato che un modo "semplice" di trattare con le interruzioni di riga che sono necessari per realizzare alla disposizione corretta era effettivamente riutilizzare l'array di caratteri ingresso originale, e solo riempirlo con 'v's e '^'s nelle posizioni appropriate.

aggiornamenti:

Si è scoperto che non memorizzare le posizioni consente di abbandonare le intdichiarazioni delle variabili array e (al costo di controllare ogni posizione dell'array se contiene vo ^al volo), risparmiando 5 byte.

Altri 8 byte salvati calcolando il limite (1<<numberOfSwitches)superiore in modo più compatto.

Secondo la regola menzionata nel commento, è necessario contare la dichiarazione di funzione, quindi ora è un lambda ...


2
Sono abbastanza sicuro che devi includere la definizione della funzione ( String generate(String s) {...}) nel conteggio dei byte. Ecco una versione fissa / lambda per 191 byte . Ho fatto un po 'di golf secondario per radere 3 byte
Benjamin Urquhart il

@BenjaminUrquhart OK, questi sono i dettagli delle "regole" che non conosco (non sto giocando a golf qui regolarmente). Ho pensato che l'effettivo { function body }dovesse essere rilevante, perché non importa se lo si inserisce in una funzione che lo è statico meno, e ovviamente, se la dichiarazione conta per il punteggio, si può convertirlo in un'espressione lambda. Ma questo è ciò che viene fatto ora, grazie per averlo sottolineato.
Marco13

1
Alcuni suggerimenti: 1. utilizzare i codici ascii, non chars ( d=94). 2. Inizializza iquando lo dichiari. 3. Utilizzare i++<minvece di incremento separato (è necessario modificare il contenuto del ciclo in un unico posto, ma ciò non comporta alcun costo). 4. Puoi cavartela (i&1<<j++)>0? 5. Non penso che tu abbia bisogno del ciclo {}interno for. 6. Puoi sostituirlo a[k]==d||a[k]==ucon a[k]>45, credo. 7. Vai con j=k=0. Tutto ciò che dovrebbe rimuovere 19byte.
VisualMelon,

@VisualMelon Alcuni di questi sono gli approcci del "golf classico" e ne ho già applicati alcuni. Se sono applicabili o meno dipende - penso che alcuni {}siano necessari, ma posso dare un altro sguardo. L' a[k]>45può essere un trucco, però. Devo ammettere che ho solo scritto questo per perdere un po 'di tempo in attesa dell'inizio di una riunione (da qui il nome della classe - questo era intenzionale ;-)) ma forse avrò un'altra occhiata - grazie comunque!
Marco13

@ Marco13 in effetti, sono trucchi classici, ma tutti applicabili qui in particolare. Non rovinerò il divertimento dandoti la mia soluzione da 172 byte basata su di loro (A proposito, pensa che il tuo sia 192, non 191, ma non so come funziona il conteggio lambda: sono contrario ad esso ).
VisualMelon,

3

J , 41 40 24 byte

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

Provalo online!


molto impressionante. amo l'uso di {. anche se penso che [:>@,@{<@(,'^'$~'v'=])"0sarebbe leggermente più giusto dal momento che "Ogni scheda di output dovrebbe essere dello stesso identico formato dell'input" e l'input non è inscatolato.
Giona,

@Giona grazie. corretto.
ngn





2

K4 , 44 byte

Soluzione:

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

Esempi:

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

Spiegazione:

Sostituzione sul posto di "^". Determinare il numero di combinazioni di interruttori (ad es. 2 ^ n), contare in binario, sostituire gli interruttori ...

-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

2

R , 116 byte

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

Provalo online!

Funzione che restituisce un vettore di schede separate newline


ah, ero così concentrato sul prendere input in un modo molto più difficile che ho trascurato la facilità di questo. Bel uso di "[<-"!
Giuseppe

@Giuseppe: non sono molto soddisfatto di questa soluzione ... ma ho provato a generare le combinazioni in altri modi (ad es. Usando la conversione binaria) ma alla fine questa è stata la più breve.
digEmAll


1

Retina 0.8.2 , 29 byte

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

Provalo online! Spiegazione:

T`¶v`;#

Cambia le nuove righe in se ;le vs in #marker.

+%1`#

Sostituisci #uno alla volta da sinistra a destra.

v$'¶$`^

Cambia ogni riga in due righe, una #sostituita con una v, una sostituita con una ^.

%`;|$
¶

Cambia la ;s in nuove righe e distanzia i risultati.




1

Python 3 - costrutto, 203 byte

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

Provalo online!

Primo tentativo, non molto piccolo ma funziona. Non esiste un elegante ricambio di corde in Python ...

Il primo ciclo crea una mappatura delle linee in indici di bit, ovvero per ogni linea viene memorizzato l'indice del primo bit in un contatore di bit. Questo è usato per indicizzare il contatore di bit nel ciclo successivo.

Il secondo ciclo esegue un contatore binario, estrae i bit per ogni riga e iterazione e li unisce. Dopo aver unito tutto insieme, viene tradotto di nuovo nel formato della mappa di commutazione, usando la sostituzione della stringa.

Immagino che ci sia un modo più elegante riutilizzando la stringa di input invece di ricostruirla ancora e ancora.

Modifica: ispirato alla risposta Python 3.8 , ecco una versione sostitutiva molto più breve

Python 3 - sostituisci, 123 byte

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

Provalo online!


0

Rubino , 64 byte

12vvv02v1v2v

In Ruby, i[j]restituisce il jth bit di ipartenza dal bit meno significativo, ovvero è equivalente a (i>>j)&1.

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

Provalo online!


0

Carbone , 28 byte

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

Provalo online! Il collegamento è alla versione dettagliata del codice. Spiegazione:

   ²                            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

0

PHP , 93 byte

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

Provalo online!

Programma autonomo, input tramite riga di comando.

Effettua il ciclo del numero di possibili permutazioni della stringa di input in base al numero di v's. Durante il conto alla rovescia in binario, sostituire ogni binario 1con ^ae ogni binario 0con a vnella stringa di input.

Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.