Napisać program lub funkcję, która pobiera ciąg znaków -=o., gdzie -=o's i .jest zawsze na przemian, charakter do charakteru. Ciąg będzie miał nieparzystą długość większą niż jeden i zawsze zaczyna się i kończy w jednym z -=o.

Zasadniczo dane wejściowe będą wyglądać jak linia emotikonów, które dzielą oczy w różnych stanach senności, np

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

Twoim celem jest wydrukowanie lub zwrócenie twarzy, która jest albo najbardziej śpiąca, albo najbardziej obudzona (to zależy od ciebie). Jeśli istnieje wiele opcji określających, kto jest najbardziej śpiący / najbardziej przebudzony, wówczas może zostać wyświetlony jeden z nich.

Istnieje dziewięć różnych twarzy i pięć poziomów senności:

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

W przypadku, gdy nie jest to jasne, procent senności jest obliczany przez przypisanie 1do -pełnego uśpienia, 0.5do =półśpienia i 0do oprzebudzenia. Następnie suma dwóch wartości oka podzielonych przez dwa jest procentem.

Najkrótszy kod w bajtach wygrywa.

Przypadki testowe

Najbardziej śpiący

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

Przebudźcie się

-.- 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 bajtów

hoSN%2.:z3

Drukuje najbardziej śpiący emotikon. Sprawdź wszystkie przypadki testowe jednocześnie w kompilatorze Pyth .

Podziękowania dla @ Sp3000 za pomysł użycia sortowania .

Jak to działa

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 bajtów

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

Jest to funkcja zwracająca budzącą się twarz.

Ogromne podziękowania dla xnor za udostępnienie wielu sztuczek taktycznych w celu skrócenia mojego oryginalnego algorytmu.

CJam, 12 bajtów

q3ew2%{$}$0=

Drukuje najbardziej śpiący emotikon. Wypróbuj to skrzypce lub zestaw testowy w interprecie CJam.

Podziękowania dla @ Sp3000 za pomysł użycia sortowania .

Jak to działa

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 bajtów

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

Jest to monadyczna funkcja, która pobiera ciąg po prawej stronie i wyświetla najbardziej zaspaną twarz.

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

Prolog, 205 189 bajtów

Kod

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

Wyjaśnienie

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

Przykład

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

Edycja: Zapisano 16 bajtów poprzez ujednolicenie klauzul r z OR.

Clojure, 82 bajty

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

Bonus: następująca mniejsza funkcja drukuje tę samą twarz, ale w większym stylu!

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

Przetestuj tutaj.

Ruby, 59 bajtów

Funkcja zwraca senną twarz za pomocą sztuczki sortowania.

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

Nazywany tak:

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

Działa na niewygodnej kolejności oczu ze względu na wewnętrzne oczy:

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

Minkolang 0.12 , 119 bajtów

Na początku próbowałem robić to krótko i naprawdę golfowo. Zrezygnowałem i zdecydowałem się na coś bardziej „zabawnego”, ale wciąż stosunkowo golfowego.

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

Wypróbuj tutaj!

Wyjaśnienie

Ale tak naprawdę kliknij powyższy link i kliknij Slow! Tak czy inaczej...

>2@fv

Pomija to fv, co będzie ważne później.

$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

Wszystko, co to zrobiło, znalazło się ^obok pasujących twarzy. Więc teraz codbox może wyglądać tak:

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

Oczywiście bez komentarzy. Teraz 40wtunel czasoprzestrzenny wysłał wskaźnik instrukcji v, na który natychmiast przekierowuje go F. Teraz Fjest poleceniem „gosub”. To jak goto, ale możesz wrócić do miejsca, w którym to nazwałeś. W momencie Fnapotkania stos jest [3,1], więc przeskakuje do 1(być może) w drugim rzędzie. Gdy licznik programu zmierza w dół, kontynuuje, przesuwając 1s na stos po drodze. To jest ... dopóki nie uderzy w ^, w którym to momencie jest przekierowywany z powrotem w górę, gdzie naciska 1ponownie. Następnie wskaźnik instrukcji uderza f, co przywraca jego pozycję i kierunek (kiedy Fwcześniej się napotkano). Dla wygody wezmę następujący kod i zmienię jego układ. (The</\ służą do przekierowania wskaźnika instrukcji w razie potrzeby).

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

Jestem naprawdę dumny z tego, że użyłem wielu funkcji unikalnych dla Minkolang, z których często nie korzystałem. Głównie trójskładnikowy i gosub. W każdym razie, masz!

C, 70 bajtów

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

Funkcja zwraca najbardziej rozbudzoną twarz. Zmienia wejściowy ciąg znaków, aby zwrócić ciąg zakończony znakiem null.

Python 2/3, 54 56 bajtów

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

Po prostu chciałem zastosować alternatywny hals do rekurencyjnej odpowiedzi xsot.

To zajmuje najlepszą (lub najgorszą?) Krotkę sąsiednich par oczu i łączy je razem.

Zamień max na min, aby zwrócić najbardziej śpiący (ponieważ to zwraca najbardziej przebudzony)

Wydaje się działać, stosując następujący 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)

Co daje następujący wynik:

-.- 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 bajtów

s₃ᶠġ₂hᵐoᵒh

Wypróbuj online!

Przetłumaczone z odpowiedzi Dennisa na Pythona.

Mathematica, 61 bajtów

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

Idzie najbardziej senny.

F # 60

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

Zwraca najbardziej obudzić twarz (zmiana maxprzez mindla śpisz)

Perl 5, 127 bajtów

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

(Jestem pewien, że jest to wykonalne w skrócie.) Jak to działa:

1. Chwyć każdy trzyznakowy ciąg z ciągu, z nakładaniem się jednego (to jest to --pos robi).
2. Dołącz ten trzyznakowy ciąg do tablicy, jeśli jego wartość przekracza wartość ostatniego elementu tablicy; tutaj „wartość” jest po prostu sumą wartości postaci w senności.
3. Wydrukuj ostatni element tablicy.

ES6, 81 72 bajtów

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

Prawdopodobnie wymaga Chrome 45 lub Firefox 41.

Dzięki @ETHproductions za oszczędność 9 bajtów.

> <> , 55 bajtów

spróbuj tutaj!

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

Wyprowadza najbardziej rozbudzoną twarz.

Ponieważ wartości ASCII odpowiednio dla -, = i o wzrosły, mogłem to wykorzystać na swoją korzyść. Zasadniczo dodaje wartości bieżącej i poprzedniej części oka, sprawdza, czy jest to wyższa wartość niż wcześniej, jeśli tak, zapisuje nową wartość i aktualizuje reprezentowaną powierzchnię, a następnie zapętla się do końca wejścia. Następnie wyprowadza twarz, która pozostaje. (Jestem bardzo zadowolony z tego, jak dobrze cały kod pasuje na swoim miejscu)

Perl 5 -MList::Util=max -p , 68 bajtów

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

Wypróbuj online!

Pobiera każdy zestaw trzech znaków, ignoruje .środek, mapuje dodanie pozostałych dwóch na liczbę całkowitą z zakresu 0-4, łączy to z przodu twarzy emotikonu, a następnie sortuje według tego. Pobiera ostatni wpis (najbardziej przebudzony), usuwa numer z przodu i wysyła go.