Écrivez un programme ou une fonction qui accepte une chaîne de caractères -=o.où les -=o«et .» alternent toujours, caractère à caractère. La chaîne aura une longueur impaire supérieure à un et débutera et se terminera toujours par l'un des -=o.

Fondamentalement, l'entrée ressemblera à une ligne de visages d'émoticônes qui partagent les yeux dans divers états de somnolence, par exemple

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

Votre objectif est d'imprimer ou de rendre le visage le plus endormi ou le plus éveillé (à vous de choisir). S'il y a plusieurs choix pour qui est le plus endormi / le plus éveillé, l'un d'eux peut être affiché.

Il y a neuf visages distincts et cinq niveaux de somnolence:

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

Dans le cas où ce n'est pas clair, le pourcentage de somnolence est calculé en attribuant 1à -complètement endormi, 0.5à =moitié endormi et 0à oéveillé. Ensuite, la somme des deux valeurs oculaires divisée par deux est le pourcentage.

Le code le plus court en octets gagne.

Cas de test

Le plus endormi

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

Le plus éveillé

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

hoSN%2.:z3

Cela imprime l'émoticône la plus endormie. Vérifiez tous les cas de test à la fois dans le compilateur Pyth .

Nous remercions @ Sp3000 pour l'idée d'utiliser le tri .

Comment ça marche

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 octets

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

C'est une fonction qui renvoie le visage le plus éveillé.

Un grand merci à xnor pour avoir fourni de nombreuses astuces tactiques pour raccourcir mon algorithme d'origine.

CJam, 12 octets

q3ew2%{$}$0=

Cela imprime l'émoticône la plus endormie. Essayez ce violon ou cette suite de tests dans l'interpréteur CJam.

Nous remercions @ Sp3000 pour l'idée d'utiliser le tri .

Comment ça marche

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 octets

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

Il s'agit d'une fonction monadique qui prend la chaîne à droite et produit le visage le plus endormi.

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

Prolog, 205 189 octets

Code

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

Explication

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

Exemple

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

Edit: 16 octets enregistrés en unifiant les clauses r avec OR.

Clojure, 82 octets

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

Bonus: la fonction plus petite suivante imprime le même visage, mais avec plus de style!

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

Testez ici.

Rubis, 59 octets

La fonction renvoie le visage le plus endormi, en utilisant l'astuce de tri.

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

Appelé comme ça:

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

Fonctionne sur l'ordre des yeux maladroit en raison du type interne des yeux:

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

Minkolang 0,12 , 119 octets

Au début, j'ai essayé de faire ce court et vraiment golfique. J'ai abandonné et j'ai opté pour quelque chose d'un peu plus "amusant", mais toujours relativement golfique.

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

Essayez-le ici!

Explication

Mais vraiment, cliquez sur le lien ci-dessus et cliquez Slow! En tous cas...

>2@fv

Cela saute le fv, qui sera important plus tard.

$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

Tout ce que cela a été a été de mettre un ^côté des visages qui correspondaient. Alors maintenant, la boîte à codes pourrait ressembler à ceci:

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

Sans les commentaires, bien sûr. Maintenant, le 40wtrou de ver a envoyé le pointeur d'instruction à v, qui le redirige immédiatement vers F. Maintenant, Fc'est une commande "gosub". C'est comme un goto, mais vous pouvez retourner là où vous l'appeliez. Au moment où Fest rencontré, la pile est [3,1], donc elle saute au 1(peut-être) sur la deuxième ligne. Alors que le compteur de programme se dirigeait vers le bas, il continue, poussant 1s sur la pile en cours de route. C'est-à-dire ... jusqu'à ce qu'il atteigne un ^, auquel cas il est redirigé vers le haut, où il repousse chacun 1. Le pointeur d'instruction frappe alors f, ce qui rétablit sa position et sa direction (lorsqu'il a Fété rencontré précédemment). Pour plus de commodité, je vais prendre le code suivant et changer sa disposition. (Le</\ servir à rediriger le pointeur d'instruction selon les besoins.)

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

Je suis en fait assez fier de la façon dont j'ai utilisé plusieurs fonctionnalités uniques à Minkolang que je n'ai pas souvent utilisées auparavant. Principalement le ternaire et le gosub. Quoi qu'il en soit, vous l'avez!

C, 70 octets

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 fonction renvoie le visage le plus éveillé. Il modifie la chaîne d'entrée en place, afin de renvoyer une chaîne terminée par null.

Python 2/3, 54 56 octets

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

Je voulais juste prendre une approche alternative à la réponse récursive de xsot.

Cela prend le meilleur (ou le pire?) Tuple de paires d'yeux adjacents et les joint ensemble.

Remplacez max par min pour retourner le plus endormi (comme c'est le retour le plus éveillé)

Semble fonctionner, en utilisant le test suivant:

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)

Ce qui donne le résultat suivant:

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

s₃ᶠġ₂hᵐoᵒh

Essayez-le en ligne!

Traduit de la réponse Pyth de Dennis.

Mathematica, 61 octets

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

Va pour le plus endormi.

F # 60

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

Renvoie la face la plus éveillée (changement maxpar minla dors)

Perl 5, 127 octets

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

(Je suis sûr que c'est faisable plus brièvement.) Comment cela fonctionne:

1. Saisissez chaque chaîne de trois caractères de la chaîne, avec chevauchement d'un (c'est ce que --posfait le).
2. Ajoutez cette chaîne de trois caractères à un tableau si sa valeur dépasse celle du dernier élément du tableau; ici, la «valeur» n'est que la somme des valeurs de ses personnages en somnolence.
3. Imprime le dernier élément du tableau.

ES6, 81 72 octets

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

Nécessite probablement Chrome 45 ou Firefox 41.

Merci à @ETHproductions pour avoir économisé 9 octets.

> <> , 55 octets

essayez-le ici!

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

Sort le visage le plus éveillé.

Étant donné que les valeurs ASCII pour -, = et o augmentent respectivement, je pourrais l'utiliser à mon avantage. Fondamentalement, il ajoute les valeurs de la partie actuelle et précédente de l'œil, vérifiez si c'est une valeur plus élevée qu'auparavant, si c'est le cas, il enregistre la nouvelle valeur et met à jour la face qui représente, puis boucle jusqu'à la fin de l'entrée. Sort ensuite le visage qui reste. (Je suis très content de voir à quel point tout le code s'intègre bien)

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

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

Essayez-le en ligne!

Saisit chaque ensemble de trois caractères, ignore le .au milieu, mappe l'addition des deux autres à un entier compris entre 0 et 4, concatène celui-ci au recto de la face de l'émoticône, puis trie en fonction de cela. Récupère la dernière entrée (la plus éveillée), supprime le numéro par l'avant et le sort.