谁是最困的？

31

编写一个程序或函数，该程序或函数接受一个字符串，-=o.其中-=o'和.'始终交替出现，以字符为单位。字符串的奇数长度将大于1，且始终以之一开始和结束-=o。

基本上，输入看起来像一排表情符号脸，在各种困倦状态下共享眼睛，例如

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

您的目标是打印或返回最困或最清醒的脸部（由您选择）。如果对于谁最睡/最清醒有多种选择，则可以输出其中的任何一个。

有9个不同的面孔和5个嗜睡等级：

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

如果它是不明确的，嗜睡百分比由计算分配1到-了完全睡着了，0.5到=一半睡着了，0到o了清醒。然后，两个眼睛值的总和除以2是百分比。

以字节为单位的最短代码获胜。

测试用例

最困的

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

最清醒

-.- 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
code-golf  string 
— 卡尔文的爱好
source
31
我感觉到-.-
— Kritixi Lithos

Answers:

28

Pyth，12个 10字节

hoSN%2.:z3

这将打印最困的图释。在Pyth编译器中一次验证所有测试用例。

感谢使用 @ Sp3000进行排序的想法。

怎么运行的

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.
— 丹尼斯
source
18
这是什么法术？
— AvZ 2015年
@丹尼斯我是Pyth的新手，所以这可能是错误的方式：为什么不hS%2.:z3呢？
— Helix Quar
5
@helix因为我们想=.-比昏昏欲睡-.o，但对它们进行了另一种排序。我犯了同样的错误。
— xnor
9

Python 2，54 53字节

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

这是一个返回最清醒的脸的函数。

非常感谢xnor提供了许多战术技巧来缩短我的原始算法。

— xsot
source
好吧，我感到很傻，没有意识到符号是按清醒排序的。我认为您可以max通过以下方式递归而不是对其进行迭代：f=lambda s:s[3:]and max(s[:3],f(s[2:]))or s
— xnor 2015年
实际上，我认为这不适用于=.-.o，因为=.-vs -.o是排序规则的例外。
— xnor
实际上，我只是意识到我误读了op。我认为这些面孔是按照在表格中出现的顺序进行排序的。由于这个假设，我的提交因“ = .o.-”而失败。我想我有个解决办法。
— xsot 2015年
@xsot我相信,key=sorted可以解决，但这是11个字符，因此您的字符可能更短。
— xnor
是的，这就是我要解决的问题
— xsot
6

CJam，12个字节

q3ew2%{$}$0=

这将打印最困的图释。在CJam解释器中尝试这种小提琴或此测试套件。

感谢使用 @ Sp3000进行排序的想法。

怎么运行的

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.
— 丹尼斯
source
4

Dyalog APL，35个 28字节

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

这是一个单调函数，采用右侧的字符串并输出最睡的脸。

    {⊃{⍵[⍒{+/'.??o='⍳⍵}¨⍵]}3,/⍵}'o.=.=.-.-.o.o'
-.-
— 小鱼
source
{(⊃⍒3+/'.??o='⍳⍵)⊃3,/⍵}
— user46915
考虑到输入约束，这??也是不必要的。
— user46915
4

序言 205个 189字节

码

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

说明

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

例

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

编辑：通过与OR统一r子句，节省了16个字节。

— 艾米尼亚
source
1

Clojure，82个字节

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

奖励：以下较小的功能可打印相同的面孔，但样式更多！

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

在这里测试。

— 加尔德雷
source
1

Ruby，59个字节

函数使用排序技巧返回最困的面孔。

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

这样称呼：

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

由于内部眼睛种类繁多，因此无法正常使用眼球：

f.call("=.-.o")
# => "=.-"
— 尼尔·斯莱特
source
1

Minkolang 0.12，119字节

起初，我尝试做这个简短而真正的高尔夫运动。我放弃了，去了一些“乐趣”，但还是比较高尔夫。

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

在这里尝试！

说明

但实际上，请单击上面的链接，然后单击Slow！无论如何...

>2@fv

这会跳过fv，这在以后会很重要。

$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

所有所做的事情都放在^相匹配的面孔旁边。因此，现在的代码框可能如下所示：

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

没有评论，当然。现在，40w虫洞将指令指针发送到v，该指令指针立即将其重定向到F。现在，F是一个“ gosub”命令。这就像goto，但是您可以返回到调用它的位置。在F遇到该时间时，堆栈为[3,1]，因此它跳到1第二行上的（也许）。当程序计数器向下移动时，它继续前进，将1s一直沿堆栈推入堆栈。那就是...直到它击到一个^，这时它被重定向回上一步，在那里它1再次推动每个。然后，命中f，，以恢复其位置和方向（F较早时遇到）。为了方便起见，我将采用以下代码并更改其布局。（</\ 用于根据需要重定向指令指针。）

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

实际上，我为自己如何使用Minkolang以前从未使用过的多个功能而感到自豪。主要是三元和gosub。无论如何，那里有！

— El'endia Starman
source
1

C，70字节

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

该函数返回最清醒的脸。它在适当位置修改输入字符串，以便返回以空值结尾的字符串。

— 韩
source
1

Python 2 / 3，54 56字节

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

只是想对xsot的递归答案采取替代方案。

这需要相邻双眼的最佳（或最差？）元组并将它们连接在一起。

用min代替max以返回最困的状态（因为这将返回最清醒的状态）

似乎可以使用以下测试工作：

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)

得到以下结果：

-.- 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
— TLW
source
两个快速的问题：1）当两者都适用时，是否将标签标记为Python 2/3？2）是否f=需要一部分作为此挑战的代码大小的一部分？如果我不这样做，它将创建lambda，然后立即将其丢弃……
— TLW 2015年
1
1）我认为“ Python 2/3”或“ Python”都很好2）如果不需要，f=则当前的共识似乎是默认情况下匿名函数是可以的，因此f=在这种情况下，您可以删除（ xsot需要它，因为它是递归的）
— Sp3000
0

Mathematica，61个字节

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

去最困的一个。

— 军团哺乳动物978
source
除非您每次要重复调用整个代码，否则此功能只能使用一次。功能提交的目的是使它们可重用。调用函数会破坏%它所依赖的全局值。
— 马丁·恩德
0

F＃60

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

返回最清醒的脸（改变max以最睡着min）

— 塞纳许
source
0

Perl 5，127个字节

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

（我确信它可以做得更简短。）它是如何工作的：

  1. 抓取字符串中的每个三个字符的字符串，并使其重叠一（即是这样--pos做的）。
  2. 如果该三字符字符串的值超过数组的最后一个元素的值，则将其追加到数组；在这里，“值”只是其角色在困倦中的值之和。
  3. 打印数组的最后一个元素。
— msh210
source
0

ES6，81 72个字节

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

可能需要Chrome 45或Firefox 41。

感谢@ETHproductions节省了9个字节。

— 尼尔
source
1
不错，但是"=.-"应该用来切换"-.o"；与"=.o"和相同"o.-"。另外，通过将所有内容放在一个字符串中并用逗号分隔，并使用，您也许可以节省一些字节.split`,` 。
— ETHproductions 2015年
使用split可以节省9个字符
— edc65
@ETHproductions抱歉，我没有注意到原来的面孔列表并不是按照困倦的顺序排列的。
— 尼尔
0

> <>，55个字节

在这里尝试！

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

输出最清醒的脸。

由于-，=和o的ASCII值分别增加，因此我可以利用它来发挥自己的优势。基本上，它将当前和上一个眼睛部分的值相加，检查它是否比以前高，如果保存新值并更新代表的脸部，则循环直到输入结束。然后输出剩下的脸。（我很高兴所有代码都适合到位）

— 龙卷风
source
0

Perl -MList::Util=max -p 5、68个字节

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

在线尝试！

抓取每组三个字符，忽略.中间的，将其他两个字符的加法映射到0-4范围内的整数，将其连接到图释脸的前面，然后按此排序。抓住最后一个条目（最清醒），从最前面删除数字，然后输出。

— Xcali
source
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.