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.

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.

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

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

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

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

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

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

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

J , 41 40 24 byte

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

Provalo online!

Python 2 , 87 byte

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

Provalo online!

Un approccio non regex.

C (gcc) , 75 74 70 byte

-5 byte grazie a @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);}

Provalo online!

richiede che i spunti di memoria siano scrivibili

Python 3.8 (pre-release) , 129 117 116 110 106 byte

-10 byte grazie a @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))}

Provalo online!

C (gcc) , 102 byte

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

Provalo online!

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

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

JavaScript, 88 byte

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

Provalo online!

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.

Perl 5 -0 , 51 byte

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

Provalo online!

JavaScript (Node.js) , 80 73 68 byte

f=([x,...y],g=c=>f(y).map(z=>c+z))=>x?g(x).concat(x>'a'?g`^`:[]):[y]

Provalo online!

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!

Rubino , 64 byte

$1$$2^v$$v$$v$$0$$2^v-1$$v$$2^v$

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!

Carbone , 28 byte

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

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

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