Schreiben Sie ein Programm oder eine Funktion , die in einer Zeichenfolge des Zeichens nimmt , -=o.wo die -=o's und .ist immer abwechseln, Zeichen zu Zeichen. Die Zeichenfolge hat eine ungerade Länge von mehr als eins und beginnt und endet immer in einer von -=o.

Grundsätzlich sieht die Eingabe aus wie eine Reihe von Emoticon-Gesichtern, die Augen in verschiedenen Zuständen der Schläfrigkeit teilen, z

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

Ihr Ziel ist es, das Gesicht zu drucken oder zurückzugeben, das entweder das schläfrigste oder das wachste ist (es liegt an Ihnen, was Sie wählen). Wenn es mehrere Möglichkeiten gibt, wer am schläfrigsten oder am wachsten ist, kann eine davon ausgegeben werden.

Es gibt neun verschiedene Gesichter und fünf Schläfrigkeitsstufen:

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

Im Fall ist es nicht klar, wird der Müdigkeits Prozentsatz durch die Zuordnung berechnet , 1um -für voll schlafend, 0.5um =für halb im Schlaf, und 0zu ofür wach. Dann ist die Summe der beiden Augenwerte geteilt durch zwei der Prozentsatz.

Der kürzeste Code in Bytes gewinnt.

Testfälle

Schläfrigste

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

Die meisten wach

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

Dies druckt das schläfrigste Emoticon. Überprüfen Sie alle Testfälle gleichzeitig im Pyth-Compiler .

Die Idee, die Sortierung zu verwenden, geht an @ Sp3000 .

Wie es funktioniert

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)

Dies ist eine Funktion, die das Gesicht zurückgibt, das am meisten wach ist.

Vielen Dank an xnor für die Bereitstellung vieler taktischer Tricks, um meinen ursprünglichen Algorithmus zu verkürzen.

CJam, 12 Bytes

q3ew2%{$}$0=

Dies druckt das schläfrigste Emoticon. Probieren Sie diese Geige oder diese Testsuite im CJam-Interpreter aus.

Die Idee, die Sortierung zu verwenden, geht an @ Sp3000 .

Wie es funktioniert

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,/⍵}

Dies ist eine monadische Funktion, die die Zeichenfolge rechts nimmt und das schläfrigste Gesicht ausgibt.

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

Prolog, 205 189 Bytes

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

Erläuterung

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

Beispiel

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

Bearbeiten: 16 Bytes durch Vereinheitlichen von r-Klauseln mit OR gespeichert.

Clojure, 82 Bytes

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

Bonus: Die folgende kleinere Funktion druckt das gleiche Gesicht, aber mit mehr Stil!

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

Hier testen.

Ruby, 59 Bytes

Die Funktion gibt das schläfrigste Gesicht mit dem Sortiertrick zurück.

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

So genannt:

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

Funktioniert bei unangenehmer Augenordnung aufgrund von inneren Augen:

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

Minkolang 0,12 , 119 Bytes

Zuerst habe ich versucht, dies kurz und richtig golfen zu können. Ich gab auf und ging für etwas mehr "Spaß", aber immer noch relativ golfen.

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

Probieren Sie es hier aus!

Erläuterung

Aber wirklich, klicke auf den Link oben und klicke Slow! Sowieso...

>2@fv

Dies überspringt das fv, was später wichtig sein wird.

$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

Alles, was das tat, war ^, die passenden Gesichter zu markieren. Die Codebox könnte nun so aussehen:

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

Natürlich ohne die Kommentare. Jetzt hat das 40wWurmloch den Befehlszeiger an gesendet v, der ihn sofort weiterleitet F. Nun Fist ein "gosub" -Befehl. Es ist wie ein Goto, aber Sie können dorthin zurückkehren, wo Sie es genannt haben. Zum Zeitpunkt F, an dem der Stack angetroffen wird [3,1], springt er auf die 1(vielleicht) zweite Zeile. Während der Programmzähler nach unten wanderte, schob er 1s auf dem Weg auf den Stapel. Das heißt ... bis es auf ein trifft ^, an welchem ​​Punkt es wieder nach oben umgeleitet wird, wo es jedesmal 1wieder drückt . Der Befehlszeiger dient dannf , wodurch seine Position und Richtung wiederhergestellt werden (als er Ffrüher angetroffen wurde). Der Einfachheit halber nehme ich den folgenden Code und ändere sein Layout. (Das</\ dienen dazu, den Anweisungszeiger nach Bedarf umzuleiten.)

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

Eigentlich bin ich ein bisschen stolz darauf, wie ich mehrere einzigartige Funktionen von Minkolang verwendet habe, die ich vorher noch nicht oft verwendet habe. Hauptsächlich das Ternäre und das Gosub. Wie auch immer, da hast du es!

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

Die Funktion gibt das hellste Gesicht zurück. Es ändert die Eingabezeichenfolge an der richtigen Stelle, um eine nullterminierte Zeichenfolge zurückzugeben.

Python 2/3, 54 56 Bytes

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

Ich wollte nur eine Alternative zu xsots rekursiver Antwort suchen.

Dies nimmt das beste (oder das schlechteste?) Tupel benachbarter Augenpaare und verbindet sie miteinander.

Ersetzen Sie max durch min, um die schläfrigsten zu erhalten (da dies die wachsten Ergebnisse liefert).

Scheint mit dem folgenden Test zu funktionieren:

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)

Was das folgende Ergebnis ergibt:

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

Probieren Sie es online!

Übersetzt aus Dennis 'Pyth-Antwort.

Mathematica, 61 Bytes

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

Geht für das schläfrigste.

F # 60

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

Gibt das wachste Gesicht zurück (ändern maxum minfür das schläfrigste)

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]

(Ich bin sicher, dass es in Kürze machbar ist.) So funktioniert es:

1. Nimm jede dreistellige Zeichenfolge aus der Zeichenfolge, mit einer Überlappung von eins (das ist es, was der --posmacht).
2. Hängen Sie diese dreistellige Zeichenfolge an ein Array an, wenn ihr Wert den Wert des letzten Elements des Arrays überschreitet. hier ist "Wert" nur die Summe der Werte seiner Charaktere in Schläfrigkeit.
3. Gibt das letzte Element des Arrays aus.

ES6, 81 72 Bytes

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

Benötigt wahrscheinlich Chrome 45 oder Firefox 41.

Vielen Dank an @ETHproductions für die Einsparung von 9 Bytes.

> <> , 55 Bytes

versuch es hier!

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

Gibt das meiste Wachgesicht aus.

Da die ASCII-Werte für -, = und o jeweils zunehmen, könnte ich das zu meinem Vorteil nutzen. Grundsätzlich werden die Werte des aktuellen und des vorherigen Augenteils addiert, überprüft, ob es sich um einen höheren Wert als zuvor handelt. Wenn dies der Fall ist, wird der neue Wert gespeichert und die entsprechende Fläche aktualisiert. Anschließend wird eine Schleife bis zum Ende der Eingabe ausgeführt. Gibt dann das verbleibende Gesicht aus. (Ich bin sehr erfreut darüber, wie gut der gesamte Code passt)

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

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

Probieren Sie es online!

Ergreift jede Gruppe von drei Zeichen, ignoriert die .in der Mitte, ordnet die Addition der beiden anderen zu einer Ganzzahl im Bereich von 0 bis 4 zu, verkettet diese mit der Vorderseite des Emoticon-Gesichts und sortiert sie danach. Nimmt den letzten Eintrag (meistens wach), entfernt die Nummer von vorne und gibt sie aus.