Chi è il più assonnato di tutti?

31

Scrivere un programma o una funzione che prende in una stringa di caratteri -=o.in cui i -=o's e .' s sempre alternativo, un personaggio all'altro. La stringa avrà una lunghezza dispari maggiore di una e inizierà e finirà sempre in una delle -=o.

Fondamentalmente, l'input sembrerà una linea di facce di emoticon che condividono gli occhi in vari stati di sonnolenza, ad es

o.=.=.-.-.o.o

Il tuo obiettivo è stampare o restituire il viso che è il più assonnato o il più sveglio (dipende da te che scegli). Se sono disponibili più opzioni per chi è più assonnato / più sveglio, è possibile che venga emesso uno di essi.

Esistono nove volti distinti e cinque livelli di sonnolenza:

-.- is 100% sleepy
-.= is 75% sleepy
-.o is 50% sleepy
=.- is 75% sleepy
=.= is 50% sleepy
=.o is 25% sleepy
o.- is 50% sleepy
o.= is 25% sleepy
o.o is 0% sleepy

Nel caso in cui non sia chiaro, la percentuale di sonnolenza viene calcolata assegnando 1a -per completamente addormentato, 0.5a =per mezzo addormentato e 0a oper sveglio. Quindi la somma dei due valori degli occhi divisi per due è la percentuale.

Vince il codice più breve in byte.

Casi test

assopite

-.- GIVES -.-
=.- GIVES =.-
o.o GIVES o.o
o.-.= GIVES -.=
=.-.= GIVES =.- OR -.=
o.-.= GIVES -.=
-.-.= GIVES -.-
o.o.- GIVES o.-
=.=.=.o GIVES =.=
-.=.=.= GIVES -.=
=.o.-.= GIVES -.=
o.-.o.=.= GIVES o.- OR -.o OR =.=
-.o.-.=.= GIVES -.=
o.o.o.o.o GIVES o.o
-.-.-.-.- GIVES -.-
o.=.=.-.-.o.o GIVES -.-
-.=.-.o.o.=.o.-.o.=.-.o.=.o.- GIVES -.= OR =.-

Molto sveglio

-.- GIVES -.-
=.- GIVES =.-
o.o GIVES o.o
o.-.= GIVES o.-
=.-.= GIVES =.- OR -.=
o.-.= GIVES o.-
-.-.= GIVES -.=
o.o.- GIVES o.o
=.=.=.o GIVES =.o
-.=.=.= GIVES =.=
=.o.-.= GIVES =.o
o.-.o.=.= GIVES o.=
-.o.-.=.= GIVES -.o OR o.- OR =.=
o.o.o.o.o GIVES o.o
-.-.-.-.- GIVES -.-
o.=.=.-.-.o.o GIVES o.o
-.=.-.o.o.=.o.-.o.=.-.o.=.o.- GIVES o.o
code-golf  string 
— Hobby di Calvin
fonte
31
Mi sento-.-
— Kritixi Lithos il

Risposte:

28

Pyth, 12 10 byte

hoSN%2.:z3

Questo stampa l'emoticon più assonnato. Verifica tutti i casi di test contemporaneamente nel compilatore Pyth .

Il merito va a @ Sp3000 per l'idea di utilizzare l'ordinamento .

Come funziona

hoSN%2.:z3
              (implicit) Save the in z.
      .:z3    Compute all substrings of length 3.
    %2        Keep every seconds substring. This discards non-emoticons.
 o            Sort the emoticons by the following key:
  SN            Sort the characters of the emoticon.
                This works since '-' < '=' < 'o'.
h             Retrieve the first, minimal element.
— Dennis
fonte
18
Cos'è questa stregoneria ?!
— AvZ,
@Dennis Sono nuovo di Pyth, quindi potrebbe essere sbagliato: perché no hS%2.:z3?
— Helix Quar,
5
@helix Perché vogliamo =.-essere più assonnati di -.o, ma sono ordinati diversamente. Avevo fatto lo stesso errore.
— xnor
9

Python 2, 54 53 byte

f=lambda s:s and max((s+' ')[:3],f(s[2:]),key=sorted)

Questa è una funzione che restituisce il viso più sveglio.

Mille grazie a xnor per aver fornito molti trucchi tattici per abbreviare il mio algoritmo originale.

— xsot
fonte
Bene, mi sento sciocco non rendermi conto che i simboli sono ordinati in base al risveglio. Penso che tu possa ricorrere al maxpiuttosto che f=lambda s:s[3:]and max(s[:3],f(s[2:]))or s
— iterarlo
In realtà, penso che questo non funzioni =.-.o, poiché =.-vs -.oè l'eccezione alla regola di ordinamento.
— xnor
In realtà, ho appena realizzato di aver letto male l'op. Ho pensato che le facce siano ordinate come appaiono nella tabella. A causa di questo presupposto, la mia presentazione non riesce per "= .o.-". Penso di avere una soluzione però.
— xsot,
@xsot Credo che ,key=sortedsarebbe una soluzione, ma si tratta di 11 caratteri quindi il tuo è probabilmente più breve.
— xnor
Sì, questa è la soluzione che avevo in mente
— xsot
6

CJam, 12 byte

q3ew2%{$}$0=

Questo stampa l'emoticon più assonnato. Prova questo violino o questa suite di test nell'interprete CJam.

Il merito va a @ Sp3000 per l'idea di utilizzare l'ordinamento .

Come funziona

q            e# Read all input from STDIN.
 3ew         e# Push all overlapping slices of length 3.
    2%       e# Keep every seconds slice. This discards non-emoticons.
      {$}$   e# Sort the slices by their sorted characters.
             e# This works since '-' < '=' < 'o'.
          0= e# Retrieve the first, minimal slice.
— Dennis
fonte
4

Dyalog APL, 35 28 byte

{⊃{⍵[⍒{+/'.??o='⍳⍵}¨⍵]}3,/⍵}

Questa è una funzione monadica che prende la stringa a destra e produce il volto più assonnato.

    {⊃{⍵[⍒{+/'.??o='⍳⍵}¨⍵]}3,/⍵}'o.=.=.-.-.o.o'
-.-
— lirtosiast
fonte
{(⊃⍒3+/'.??o='⍳⍵)⊃3,/⍵}
— user46915
E dati i vincoli di input, ??anche questo non è necessario.
— user46915
4

Prolog, 205 189 byte

Codice

r([X|T],[N|B],M):-N=M,write(X);r(T,B,M).
p(X):-findall(S,sub_atom(X,_,3,_,S),L),findall(E,(nth1(I,L,E),I mod 2=\=0),R),maplist(atom_codes,R,Q),maplist(sum_list,Q,S),min_list(S,M),r(R,S,M).

Spiegazione

r([X|T],[N|B],M):-N=M,write(X);r(T,B,M).
p(X):-findall(S,sub_atom(X,_,3,_,S),L),              % L = all sublists of length 3
      findall(E,(nth1(I,L,E),I mod 2=\=0),R),        % R = every other element of L
      maplist(atom_codes,R,Q),                       % Q = list of decimal ascii codes 
                                                           created from R

      maplist(sum_list,Q,S),                         % S = list of sums of R's lists
      min_list(S,M),                                 % M = minimum sum
      r(R,S,M).                                      % Prints first element in R with sum M

Esempio

>p('-.=.-.o.o.=.o.-.o.=.-.o.=.o.-').
-.=

Modifica: salvato 16 byte unificando le clausole r con OR.

— Emigna
fonte
1

Clojure, 82 byte

(fn[x](println(apply str(apply min-key #(reduce +(map int %))(partition 3 2 x)))))

Bonus: la seguente funzione più piccola stampa lo stesso volto, ma con più stile!

(fn[x](println(apply min-key #(reduce +(map int %))(partition 3 2 x))))

Prova qui

— galdre
fonte
1

Rubino, 59 byte

La funzione restituisce il viso più assonnato, usando il trucco di ordinamento.

f=->(s){s.split(?.).each_cons(2).min_by{|e|e.sort}.join(?.)}

Chiamato così:

f.call("o.=.=.-.-.o.o")
# => "-.-"

Funziona su un ordine oculare scomodo a causa del tipo di occhi interni:

f.call("=.-.o")
# => "=.-"
— Neil Slater
fonte
1

Minkolang 0,12 , 119 byte

All'inizio, ho provato a fare questo breve e davvero da golf. Ho rinunciato e ho optato per qualcosa di un po 'più "divertente", ma ancora relativamente golfoso.

>2@fv$oI2:[9[i$z3[iciz1+q=]++3=tt"^"3zpt]$x$x]IX3140w
o.o1F
o.=1$
=.o1+
=.=12
o.-1:
-.o11
=.-1+
-.=13
-.-1[
/c0i<
\qO].

Provalo qui!

Spiegazione

Ma davvero, fai clic sul link sopra e fai clic Slow! Comunque...

>2@fv

Questo salta il fv, che sarà importante in seguito.

$o                                                  Read in whole input as characters 
  I2:                                               Half the stack length
     [                                              Open for loop (for each face)
      9[                                            Open another for loop - 9 repeats
        i$z                                         Stores loop counter in register
           3[                                       Open another for loop - 3 repeats
             ic                                     Copy char 1/2/3
               iz1+q                                Retrieve char from lookup table
                    =                               1 if equal, 0 otherwise
                     ]                              Close for loop
                      ++                            Add twice
                        3=                          1 if equal to 3, 0 otherwise
                          tt      t                 Ternary - executes first part when 0,
                                                    second part otherwise
                            "^"3zp                  Put a ^ next to the face that matched
                                   ]                Close lookup for loop
                                    $x$x            Dump first two characters
                                        ]           Close for loop
                                         IX         Dump the whole stack
                                           31       Push a 3, then a 1
                                             40w    Wormhole to (4,0) in the code

Tutto ciò che ha fatto è stato quello di mettere ^accanto alle facce che corrispondevano. Quindi ora la codebox potrebbe apparire così:

>2@fv$oI2:[9[i$z3[iciz1+q=]++3=tt"^"3zpt]$x$x]IX3140w
o.o1F
o.=1$
=.o1+
=.=^2   <-- caret
o.-^:   <-- caret
-.o11
=.-1+
-.=^3   <-- caret
-.-1[
/c0i<
\qO].

Senza i commenti, ovviamente. Ora, il 40wwormhole ha inviato il puntatore dell'istruzione a v, che lo reindirizza immediatamente su F. Ora, Fè un comando "gosub". È come un goto, ma puoi tornare dove l'hai chiamato. Al momento F, lo stack lo è [3,1], quindi passa alla 1(forse) sulla seconda riga. Mentre il contatore del programma stava andando verso il basso, continua, spingendo 1s sulla pila lungo la strada. Cioè ... fino a quando non colpisce a ^, a quel punto viene reindirizzato indietro, dove si spinge di 1nuovo ciascuno . Il puntatore dell'istruzione quindi colpisce f, il che ripristina la sua posizione e direzione (quando è Fstato rilevato in precedenza). Per comodità, prenderò il seguente codice e cambierò il suo layout. (Il</\ serve per reindirizzare il puntatore dell'istruzione secondo necessità.)

$+                 Sum up the whole stack
  2:               Divide by 2 (because each 1 was pushed twice)
    1+             Add 1 (shift down one row)
      3[           Open for loop - 3 repeats
        i          Push loop counter
         0c        Copy top of stack
           q       Retrieve face character
            O      Output as character
             ].    Close for loop and stop when it's done.

In realtà sono un po 'orgoglioso di come ho usato più funzionalità uniche di Minkolang che non avevo mai usato prima. Principalmente il ternario e il gosub. Comunque, eccolo qui!

— El'endia Starman
fonte
1

C, 70 byte

char*f(char*s){char*p=s[3]?f(s+2):s;return*s+s[2]>*p+p[2]?s[3]=0,s:p;}

La funzione restituisce la faccia più sveglia. Modifica la stringa di input in atto, in modo da restituire una stringa con terminazione null.

— han
fonte
1

Python 2/3, 54 56 byte

lambda x:".".join(max(zip(x[::2],x[2::2]),key=sorted))

Volevo solo prendere una virata alternativa alla risposta ricorsiva di xsot.

Questo prende la migliore (o la peggiore?) Tupla di paia di occhi adiacenti e li unisce.

Sostituisci max con min per restituire il più assonnato (poiché questo restituisce il più attivo)

Sembra funzionare, usando il seguente test:

for line in """-.- GIVES -.-
    =.- GIVES =.-
    o.o GIVES o.o
    o.-.= GIVES o.-
    =.-.= GIVES =.- OR -.=
    o.-.= GIVES o.-
    -.-.= GIVES -.=
    o.o.- GIVES o.o
    =.=.=.o GIVES =.o
    -.=.=.= GIVES =.=
    =.o.-.= GIVES =.o
    o.-.o.=.= GIVES o.=
    -.o.-.=.= GIVES -.o OR o.- OR =.=
    o.o.o.o.o GIVES o.o
    -.-.-.-.- GIVES -.-
    o.=.=.-.-.o.o GIVES o.o
    -.=.-.o.o.=.o.-.o.=.-.o.=.o.- GIVES o.o""".splitlines():
    inp, _, opts = line.partition(" GIVES ")
    optst = opts.split(" OR ")
    act = f(inp)
    print(inp, "expected", opts, "got", act, "equal?", act in optst)

Che dà il seguente risultato:

-.- expected -.- got -.- equal? True
=.- expected =.- got =.- equal? True
o.o expected o.o got o.o equal? True
o.-.= expected o.- got o.- equal? True
=.-.= expected =.- OR -.= got =.- equal? True
o.-.= expected o.- got o.- equal? True
-.-.= expected -.= got -.= equal? True
o.o.- expected o.o got o.o equal? True
=.=.=.o expected =.o got =.o equal? True
-.=.=.= expected =.= got =.= equal? True
=.o.-.= expected =.o got =.o equal? True
o.-.o.=.= expected o.= got o.= equal? True
-.o.-.=.= expected -.o OR o.- OR =.= got =.= equal? True
o.o.o.o.o expected o.o got o.o equal? True
-.-.-.-.- expected -.- got -.- equal? True
o.=.=.-.-.o.o expected o.o got o.o equal? True
-.=.-.o.o.=.o.-.o.=.-.o.=.o.- expected o.o got o.o equal? True
— TLW
fonte
Due domande veloci: 1) l'etichettatura come Python 2/3 quando qualcosa funziona con entrambi è consigliata? 2) La f=parte richiesta è parte della dimensione del codice per questa sfida? Se non lo faccio, creerà la lambda e poi la getta via di nuovo immediatamente ...
— TLW
1
1) "Python 2/3" o solo "Python" va bene, penso 2) Se non ti serve, il f=consenso corrente sembra essere che le funzioni anonime siano ok per impostazione predefinita, quindi puoi rilasciare f=in questo caso ( xsot ne ha bisogno poiché è ricorsivo)
— Sp3000,
0

Mathematica, 61 byte

"."
Sort[Partition[#~StringSplit~%,2,1]][[1]]~StringRiffle~%&

Va per il più assonnato.

— LegionMammal978
fonte
Questa funzione è attiva una sola volta, a meno che non si ripeta l'intero codice ogni volta che si desidera chiamarlo. Il punto di invio delle funzioni è che siano riutilizzabili . La chiamata alla funzione interrompe il valore del globale su %cui si basa.
— Martin Ender,
0

F # 60

fun s->Seq.max[for n in 0..2..String.length s-2->s.[n..n+2]]

Restituisce il viso più sveglio (cambia maxper minper il più assonnato)

— Sehnsucht
fonte
0

Perl 5, 127 byte

%h=qw[- 2 = 1];sub r{$b=0;$b+=$h{$_}for split'',pop;$b}($_)=<>;@a='o.o';while(/.../g){push@a,$& if(r$&)>r$a[-1];--pos}say$a[-1]

(Sono sicuro che è fattibile più brevemente.) Come funziona:

  1. Prendi ogni stringa di tre caratteri dalla stringa, con una sovrapposizione di una (ecco cosa --posfa).
  2. Aggiungi quella stringa di tre caratteri a un array se il suo valore supera quello dell'ultimo elemento dell'array; qui, "valore" è solo la somma dei valori dei suoi personaggi nella sonnolenza.
  3. Stampa l'ultimo elemento dell'array.
— msh210
fonte
0

ES6, 81 72 byte

a=>"-.-,-.=,=.-,-.o,=.=,o.-,=.o,o.=,o.o".split`,`.find(b=>a.includes(b))

Probabilmente richiede Chrome 45 o Firefox 41.

Grazie a @ETHproductions per il salvataggio di 9 byte.

— Neil
fonte
1
Bello, ma "=.-"dovrebbe essere cambiato "-.o"; lo stesso con "=.o"e "o.-". Inoltre, potresti essere in grado di salvare alcuni byte mettendo tutto in una stringa, separato da virgole e usando .split`,` .
— ETHproductions
L'uso di split potrebbe salvare 9 caratteri
— edc65,
@ETHproductions Mi dispiace non aver notato che l'elenco originale dei volti non era esso stesso in ordine di sonnolenza.
— Neil,
0

> <> , 55 byte

provalo qui!

<v~i:i&0"."0
 >i:@+:&:@)?v&~i0(?v
 ^?)0i:r~r&~<;ooo$r<

Emette la faccia più sveglia.

Dato che i valori ASCII per -, = e o aumentano rispettivamente, potrei usarlo a mio vantaggio. Fondamentalmente aggiunge i valori della parte dell'occhio corrente e precedente, controlla se è un valore più alto di prima, se lo è salva il nuovo valore e aggiorna la faccia che rappresenta, quindi scorre fino alla fine dell'input. Quindi emette la faccia che rimane. (Sono molto contento di come tutto il codice si adatta perfettamente)

— torcado
fonte
0

Perl 5 -MList::Util=max -p , 68 byte

s|..(?=(.))|$t=max$t,ord($&)%15%4+ord($1)%15%4 .$&.$1|eg;$_=$t;s/.//

Provalo online!

Afferra ogni set di tre caratteri, ignora il .centro, mappa l'aggiunta degli altri due a un numero intero compreso tra 0 e 4, lo concatena alla parte anteriore della faccia dell'emoticon, quindi ordina per quello. Afferra l'ultima voce (la più attiva), rimuove il numero dalla parte anteriore e lo emette.

— Xcali
fonte
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.