Escribir un programa o función que toma en una cadena de caracteres -=o., donde los -=o's y .' S siempre se alternan, un personaje a otro. La cadena tendrá una longitud impar mayor que uno y siempre comenzará y terminará en uno de -=o.

Básicamente, la entrada se verá como una línea de caras de emoticones que comparten ojos en varios estados de somnolencia, p. Ej.

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

Su objetivo es imprimir o devolver la cara que sea la más soñolienta o la más despierta (depende de usted cuál elija). Si hay varias opciones para saber quién está más somnoliento / más despierto, cualquiera de ellas puede salir.

Hay nueve caras distintas y cinco niveles de somnolencia:

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

En caso de que no esté claro, el porcentaje de somnolencia se calcula asignando 1a -completamente dormido, 0.5a =medio dormido y 0a odespierto. Entonces, la suma de los dos valores oculares divididos por dos es el porcentaje.

El código más corto en bytes gana.

Casos de prueba

Más somnoliento

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

Más despierto

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

Pyth, 12 10 bytes

hoSN%2.:z3

Esto imprime el emoticon más somnoliento. Verifique todos los casos de prueba a la vez en el Compilador Pyth .

El crédito va a @ Sp3000 por la idea de utilizar la clasificación .

Cómo 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 es una función que devuelve la cara que está más despierta.

Muchas gracias a xnor por proporcionar muchos trucos tácticos para acortar mi algoritmo original.

CJam, 12 bytes

q3ew2%{$}$0=

Esto imprime el emoticon más somnoliento. Pruebe este violín o este conjunto de pruebas en el intérprete de CJam.

El crédito va a @ Sp3000 por la idea de utilizar la clasificación .

Cómo 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 es una función monádica que toma la cadena a la derecha y genera la cara más somnolienta.

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

Prólogo, 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).

Explicación

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

Ejemplo

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

Editar: se guardaron 16 bytes al unificar las cláusulas r con OR.

Clojure, 82 bytes

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

Bonificación: la siguiente función más pequeña imprime la misma cara, ¡pero con más estilo!

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

Prueba aquí.

Ruby, 59 bytes

La función devuelve la cara más somnolienta, usando el truco de clasificación.

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

Llamado así:

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

Funciona en un orden de ojos incómodo debido a la clase interna de ojos:

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

Minkolang 0.12 , 119 bytes

Al principio, intenté hacer esto corto y realmente golfista. Me di por vencido y fui por algo un poco más "divertido", pero aún relativamente golfístico.

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

Pruébalo aquí!

Explicación

Pero realmente, ¡haz clic en el enlace de arriba y haz clic Slow! De todas formas...

>2@fv

Esto omite el fv, que será importante más adelante.

$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

Lo único que hizo fue poner un ^lado de las caras que coincidían. Entonces, el cuadro de código podría verse así:

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

Sin los comentarios, por supuesto. Ahora, el 40wagujero de gusano envió el puntero de instrucciones a v, que inmediatamente lo redirige F. Ahora, Fes un comando "gosub". Es como un goto, pero puedes volver a donde lo llamaste. En el momento en que Fse encuentra, la pila es [3,1], por lo que salta al 1(tal vez) en la segunda fila. Mientras el contador del programa se dirigía hacia abajo, continúa, empujando 1s en la pila a lo largo del camino. Es decir ... hasta que golpea a ^, en cuyo punto se redirige hacia arriba, donde empuja a cada uno 1nuevamente. Luego f, el puntero de instrucción golpea , lo que restaura su posición y dirección (cuando Fse encontró anteriormente). Por conveniencia, tomaré el siguiente código y cambiaré su diseño. (Los</\ servir para redirigir el puntero de instrucciones según sea necesario.)

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

De hecho, estoy un poco orgulloso de cómo utilicé varias funciones exclusivas de Minkolang que nunca antes había usado. Principalmente el ternario y el gosub. De todos modos, ahí lo tienes!

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

La función devuelve la cara más despierta. Modifica la cadena de entrada en su lugar, para devolver una cadena terminada en nulo.

Python 2/3, 54 56 bytes

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

Solo quería tomar una táctica alternativa a la respuesta recursiva de xsot.

Esto toma la mejor (¿o la peor?) Tupla de pares de ojos adyacentes y los une.

Reemplace max con min para devolver el sueño más (ya que esto devuelve el más despierto)

Parece funcionar, usando la siguiente prueba:

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)

Lo que da el siguiente 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

Brachylog , 10 bytes

s₃ᶠġ₂hᵐoᵒh

Pruébalo en línea!

Traducido de la respuesta Pyth de Dennis.

Mathematica, 61 bytes

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

Va por el más somnoliento.

F # 60

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

Devuelve la cara más despierta (cambia maxpor minla más dormida)

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]

(Estoy seguro de que se puede hacer más brevemente). Cómo funciona:

1. Tome cada cadena de tres caracteres de la cadena, con una superposición de uno (eso es lo que --poshace).
2. Agregue esa cadena de tres caracteres a una matriz si su valor excede el del último elemento de la matriz; aquí, "valor" es solo la suma de los valores de sus personajes en la somnolencia.
3. Imprime el último elemento de la matriz.

ES6, 81 72 bytes

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

Probablemente requiere Chrome 45 o Firefox 41.

Gracias a @ETHproductions por guardar 9 bytes.

> <> , 55 bytes

Pruébalo aquí!

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

Salidas cara más despierto.

Dado que los valores ASCII para -, = yo aumentan respectivamente, podría usar eso para mi ventaja. Básicamente, agrega los valores de la parte del ojo actual y anterior, verifique si es un valor más alto que antes, si lo es, guarda el nuevo valor y actualiza la cara que representa, luego realiza un bucle hasta el final de la entrada. Luego sale la cara que queda. (Estoy muy contento de lo bien que todo el código encaja en su lugar)

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

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

Pruébalo en línea!

Toma cada conjunto de tres caracteres, ignora el .del medio, asigna la suma de los otros dos a un número entero en el rango 0-4, concatena eso al frente de la cara del emoticón y luego lo ordena por eso. Agarra la última entrada (la más despierta), elimina el número del frente y lo emite.