Escreva um programa ou função que inclua uma sequência de caracteres -=o.onde os -=o'e .' sempre se alternam, caractere para caractere. A string terá um comprimento ímpar maior que um e sempre começará e terminará em um de -=o.

Basicamente, a entrada parecerá uma linha de rostos de emoticons que compartilham olhos em vários estados de sonolência, por exemplo

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

Seu objetivo é imprimir ou devolver o rosto que é o mais sonolento ou o mais acordado (a escolha é sua). Se houver várias opções para quem está mais sonolento / acordado, qualquer uma delas pode ser exibida.

Existem nove rostos distintos e cinco níveis de sonolência:

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

No caso, não está claro, o percentual sonolência é calculado atribuindo 1a -de totalmente adormecido, 0.5para =por meio adormecida, e 0que opara acordado. Então a soma dos dois valores oculares divididos por dois é a porcentagem.

O código mais curto em bytes vence.

Casos de teste

Sonolento

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

Mais Desperta

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

Pitão, 12 10 bytes

hoSN%2.:z3

Isso imprime o emoticon mais sonolento. Verifique todos os casos de teste de uma vez no Pyth Compiler .

O crédito vai para o Sp3000 na idéia de usar a classificação .

Como funciona

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.

Python 2, 54 53 bytes

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

Esta é uma função que retorna o rosto que está mais acordado.

Muito obrigado ao xnor por fornecer muitos truques táticos para reduzir meu algoritmo original.

CJam, 12 bytes

q3ew2%{$}$0=

Isso imprime o emoticon mais sonolento. Experimente este violino ou este conjunto de testes no intérprete CJam.

O crédito vai para o Sp3000 na idéia de usar a classificação .

Como funciona

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.

Dyalog APL, 35 28 bytes

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

Esta é uma função monádica que pega a corda à direita e produz a face mais sonolenta.

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

Prolog, 205 189 bytes

Código

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

Explicação

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

Exemplo

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

Editar: salvou 16 bytes unificando cláusulas r com OR.

Clojure, 82 bytes

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

Bônus: a seguinte função menor imprime a mesma face, mas com mais estilo!

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

Teste aqui.

Ruby, 59 bytes

A função retorna o rosto mais sonolento, usando o truque de classificação.

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

Chamado assim:

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

Funciona na ordem dos olhos desajeitada devido ao tipo interno de olhos:

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

Minkolang 0.12 , 119 bytes

No começo, eu tentei fazer isso curto e muito golfe. Desisti e fui para algo um pouco mais "divertido", mas ainda relativamente golfista.

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

Experimente aqui!

Explicação

Mas na verdade, clique no link acima e clique Slow! De qualquer forma...

>2@fv

Isso pula sobre o fvque será importante mais tarde.

$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

O que tudo o que fez foi colocar ^ao lado dos rostos que combinavam. Então agora o codebox pode ficar assim:

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

Sem os comentários, é claro. Agora, o 40wburaco de minhoca enviou o ponteiro de instrução para v, o qual o redireciona imediatamente para F. Agora, Fé um comando "gosub". É como um goto, mas você pode voltar para onde o chamou. No momento em que Fé encontrada, a pilha é [3,1], então ela pula para o 1(talvez) na segunda linha. Enquanto o contador de programa estava descendo, ele continua empurrando 1s para a pilha ao longo do caminho. Isso é ... até que ele atinja a ^, quando for redirecionado de volta para onde ele será pressionado 1novamente. O ponteiro de instrução então pressionaf , o que restaura sua posição e direção (quando Ffoi encontrado anteriormente). Por conveniência, vou pegar o código a seguir e alterar seu layout. (O</\ servem para redirecionar o ponteiro de instruções, conforme necessário.)

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

Na verdade, estou meio orgulhoso de como usei vários recursos exclusivos do Minkolang que não costumava usar antes. Principalmente o ternário e o gosub. Enfim, aí está!

C, 70 bytes

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

A função retorna a face mais acordada. Ele modifica a string de entrada no lugar, para retornar uma string terminada em nulo.

Python 2/3, 54 56 bytes

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

Só queria adotar uma abordagem alternativa à resposta recursiva do xsot.

Isso pega a melhor (ou pior?) Tupla de pares de olhos adjacentes e os une.

Substitua max por min para retornar o mais sonolento (pois isso retorna o mais acordado)

Parece funcionar, usando o seguinte teste:

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)

O que fornece o seguinte resultado:

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

Braquilog , 10 bytes

s₃ᶠġ₂hᵐoᵒh

Experimente online!

Traduzido da resposta de Dennis 'Pyth.

Mathematica, 61 bytes

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

Vai para o mais sonolento.

F # 60

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

Retorna o rosto acordada a maior (mudança maxpor minpelo dormes)

Perl 5, 127 bytes

%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]

(Tenho certeza de que é possível fazê-lo mais brevemente.) Como funciona:

1. Pegue cada sequência de três caracteres da sequência, com sobreposição de uma (é isso que --posfaz).
2. Anexe essa cadeia de três caracteres a uma matriz se seu valor exceder o valor do último elemento da matriz; aqui, "valor" é apenas a soma dos valores de seus caracteres em sonolência.
3. Imprima o último elemento da matriz.

ES6, 81 72 bytes

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

Provavelmente requer o Chrome 45 ou o Firefox 41.

Agradecemos a @ETHproductions por salvar 9 bytes.

> <> , 55 bytes

tente aqui!

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

Saídas mais acordadas.

Como os valores ASCII para -, = e o aumentam respectivamente, eu poderia usar isso para minha vantagem. Basicamente, ele adiciona os valores da parte atual e anterior dos olhos, verifique se é um valor mais alto do que antes, se salva o novo valor e atualiza o rosto que representa, depois faz um loop até o final da entrada. Em seguida, gera a face que permanece. (Estou muito satisfeito com a adequação de todo o código)

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

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

Experimente online!

Pega cada conjunto de três caracteres, ignora o .meio, mapeia a adição dos outros dois a um número inteiro no intervalo de 0 a 4, concatena isso na frente do rosto do emoticon e depois classifica por isso. Agarra a última entrada (mais acordada), remove o número da frente e o gera.