Viết chương trình hoặc hàm lấy một chuỗi các ký tự -=o.trong đó các ký tự -=ovà .luôn luôn xen kẽ, ký tự thành ký tự. Chuỗi sẽ có độ dài lẻ lớn hơn một và luôn luôn bắt đầu và kết thúc bằng một -=o.

Về cơ bản, đầu vào sẽ trông giống như một dòng các biểu tượng cảm xúc chia sẻ đôi mắt trong nhiều trạng thái buồn ngủ khác nhau, ví dụ:

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

Mục tiêu của bạn là in hoặc trả lại khuôn mặt buồn ngủ nhất hoặc tỉnh táo nhất (tùy thuộc vào bạn mà bạn chọn). Nếu có nhiều lựa chọn cho người buồn ngủ nhất / tỉnh táo nhất thì bất kỳ một trong số họ có thể là đầu ra.

Có chín khuôn mặt khác nhau và năm mức độ buồn ngủ:

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

Trong trường hợp nó không rõ ràng, tỷ lệ buồn ngủ được tính bằng cách gán 1để -cho đầy đủ ngủ, 0.5để =cho nửa ngủ, và 0để ocho tỉnh táo. Khi đó tổng của hai giá trị mắt chia cho hai là tỷ lệ phần trăm.

Mã ngắn nhất tính bằng byte thắng.

Các trường hợp thử nghiệm

Buồn ngủ nhất

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

Thức tỉnh nhất

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

Bình thường, 12 10 byte

hoSN%2.:z3

Điều này in biểu tượng cảm xúc buồn ngủ nhất. Xác minh tất cả các trường hợp thử nghiệm cùng một lúc trong Trình biên dịch Pyth .

Tín dụng đến @ Sp3000 cho ý tưởng sử dụng phân loại .

Làm thế nào nó hoạt động

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 byte

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

Đây là một chức năng trả về khuôn mặt tỉnh táo nhất.

Rất cám ơn xnor đã cung cấp nhiều thủ thuật chiến thuật để rút ngắn thuật toán ban đầu của tôi.

CJam, 12 byte

q3ew2%{$}$0=

Điều này in biểu tượng cảm xúc buồn ngủ nhất. Hãy thử fiddle hoặc bộ thử nghiệm này trong trình thông dịch CJam.

Tín dụng đến @ Sp3000 cho ý tưởng sử dụng phân loại .

Làm thế nào nó hoạt động

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.

APL Dyalog, 35 28 byte

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

Đây là một hàm đơn âm lấy chuỗi bên phải và đưa ra khuôn mặt buồn ngủ nhất.

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

Prolog, 205 189 byte

Mã

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

Giải trình

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

Thí dụ

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

Chỉnh sửa: Đã lưu 16 byte bằng cách thống nhất các mệnh đề r với OR.

Clojure, 82 byte

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

Phần thưởng: chức năng nhỏ hơn sau đây in cùng một khuôn mặt, nhưng với phong cách hơn!

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

Kiểm tra tại đây.

Ruby, 59 byte

Chức năng trả về khuôn mặt buồn ngủ nhất, sử dụng thủ thuật sắp xếp.

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

Được gọi như thế này:

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

Hoạt động theo thứ tự mắt khó xử do loại mắt bên trong:

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

Chồn 0,12 , 119 byte

Lúc đầu, tôi đã thử làm điều này ngắn và thực sự golf. Tôi đã từ bỏ và đi tìm thứ gì đó "vui vẻ" hơn một chút, nhưng vẫn tương đối chơi gôn.

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

Hãy thử nó ở đây!

Giải trình

Nhưng thực sự, nhấp vào liên kết ở trên và nhấp Slow! Dù sao...

>2@fv

Điều này bỏ qua fv, sẽ quan trọng sau này.

$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

Tất cả những gì đã làm được đặt ^bên cạnh những khuôn mặt phù hợp. Vì vậy, bây giờ codebox có thể trông như thế này:

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

Không có ý kiến, tất nhiên. Bây giờ, 40wwormhole đã gửi con trỏ lệnh tới v, nó ngay lập tức chuyển hướng nó lên F. Bây giờ, Flà một lệnh "gosub". Nó giống như một chiếc goto, nhưng bạn có thể trở lại nơi bạn gọi nó. Tại thời điểm Fgặp phải, ngăn xếp là [3,1], vì vậy nó nhảy đến 1(có thể) trên hàng thứ hai. Khi bộ đếm chương trình đang hướng xuống dưới, nó tiếp tục, đẩy 1s lên ngăn xếp dọc đường. Đó là ... cho đến khi nó chạm vào một điểm ^, tại đó nó được chuyển hướng trở lại, nơi nó đẩy nhau 1lần nữa. Con trỏ lệnh sau đó nhấn f, khôi phục vị trí và hướng của nó (khi Fđã gặp trước đó). Để thuận tiện, tôi sẽ lấy đoạn mã sau và thay đổi bố cục của nó. (Các</\ phục vụ để chuyển hướng con trỏ lệnh khi cần thiết.)

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

Tôi thực sự tự hào về cách tôi đã sử dụng nhiều tính năng độc đáo cho Minkolang mà tôi chưa từng sử dụng trước đây. Chủ yếu là chim nhạn và gosub. Dù sao đi nữa bạn đã có nó rồi!

C, 70 byte

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

Hàm trả về khuôn mặt tỉnh táo nhất. Nó sửa đổi chuỗi đầu vào tại chỗ, để trả về một chuỗi kết thúc null.

Python 2/3, 54 56 byte

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

Chỉ muốn thực hiện một chiến thuật thay thế cho câu trả lời đệ quy của xsot.

Điều này cần đến cặp mắt tốt nhất (hoặc tệ nhất?) Và nối chúng lại với nhau.

Thay max bằng min để trả lại trạng thái buồn ngủ nhất (vì điều này sẽ trả lại sự tỉnh táo nhất)

Có vẻ như để làm việc, sử dụng thử nghiệm sau đây:

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)

Cho kết quả như sau:

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

s₃ᶠġ₂hᵐoᵒh

Hãy thử trực tuyến!

Dịch từ câu trả lời Pyth của Dennis.

Toán học, 61 byte

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

Đi cho người buồn ngủ nhất.

F # 60

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

Trả lại khuôn mặt tỉnh táo nhất (thay đổi maxbằng cách minngủ ngon nhất)

Perl 5, 127 byte

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

(Tôi chắc chắn rằng nó có thể thực hiện ngắn gọn hơn.) Cách thức hoạt động:

1. Lấy từng chuỗi ba ký tự từ chuỗi, với một chuỗi trùng nhau (đó là những gì --posđang làm).
2. Nối chuỗi ba ký tự đó vào một mảng nếu giá trị của nó vượt quá chuỗi phần tử cuối cùng của mảng; ở đây, "giá trị" chỉ là tổng giá trị của các ký tự trong trạng thái buồn ngủ.
3. In phần tử cuối cùng của mảng.

ES6, 81 72 byte

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

Có thể yêu cầu Chrome 45 hoặc Firefox 41.

Cảm ơn @ETHproductions đã lưu 9 byte.

> <> , 55 byte

thử nó ở đây

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

Đầu ra khuôn mặt tỉnh táo nhất.

Vì các giá trị ASCII cho -, = và o tăng tương ứng, tôi có thể sử dụng điều đó cho lợi thế của mình. Về cơ bản, nó bổ sung các giá trị của phần mắt hiện tại và trước đó, kiểm tra xem nó có giá trị cao hơn trước không, nếu nó lưu giá trị mới và cập nhật khuôn mặt đại diện nào, sau đó lặp lại cho đến khi kết thúc đầu vào. Sau đó xuất ra khuôn mặt còn lại. (Tôi rất hài lòng về cách tất cả các mã phù hợp tại chỗ)

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

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

Hãy thử trực tuyến!

Lấy mỗi bộ gồm ba ký tự, bỏ qua .ở giữa, ánh xạ thêm hai ký tự kia vào một số nguyên trong phạm vi 0-4, nối nó với mặt trước của mặt biểu tượng cảm xúc, sau đó sắp xếp theo đó. Lấy mục cuối cùng (tỉnh táo nhất), xóa số từ phía trước và xuất nó.