输入字符串[length 1-20]后，仅包含字符y（是）和n（否），您的程序应输出结果（y或n）。输入示例：yynynynny将输出y。

通过以下方式组合y和n来确定结果：

• y es和n o等于n o

• Ÿ ES和ÿ ES等于ÿ ES

• n o和n o等于y es

如果字符串包含两个以上的字符（可能是...），则计算结果将相同。例子：

• y es和y es和n o等于n o（因为“否”与第一个“是”到“否”合并，然后不存在且“是”，并且同样的情况再次发生）

• n o和n o和n o等于 n o（前两个no合并为yes，然后有yes和no left，出现为no）

输入与输出示例：

• yynynynynyyn = n

提示：请记住，程序运行的字符顺序无关紧要。（例如，您可以从背面读取输入，也可以从后面读取输入，混合字母，对其进行排序，无论如何。最重要的是正确的输出）玩得开心！

获胜标准：这是代码高尔夫球，因此以字节为单位的最短代码获胜。

木炭，6个字节

§yn№Ｓn

在线尝试！链接是详细版本的代码。说明：

    Ｓ   Input string
   № n  Count number of `n`s
§yn     Circularly index into string `yn`
        Implicitly print appropriate character

八度，29 27字节

感谢@RickHithcock指出了一个错误，现在已更正。此外，多亏了@StewieGriffin，减少了2个字节！

@(s)'yn'(mod(sum(s+1),2)+1)

在线尝试！

说明

的ASCII码点'y'是奇数，而的偶数点'n'是偶数。代码

1. 将1输入字符串中的每个字符加到'y'偶数和'n'奇数；
2. 计算总和；
3. 将结果减少到1偶数，2奇数；
4. 在字符串中索引（从1开始）'yn'。

JavaScript（ES6），28个字节

将输入作为字符串。

s=>'ny'[s.split`n`.length&1]

在线尝试！

JavaScript（ES6），30个字节

将输入作为字符数组。

y=>'yn'[n=1,~~eval(y.join`^`)]

在线尝试！

Haskell， 33 28字节

f a=cycle"yn"!!sum[1|'n'<-a]

将n的计数索引到无限列表“ ynynynyn…”。先前的方法（33字节）是将不同元素对折叠为n，否则为y：

f=foldl1(\a b->last$'y':['n'|a/=b])

在线尝试！

果冻，7个字节

ċ”nị⁾ny

在线尝试！

将数字n，ndex插入字符串ny中。（模2）

ċḢịɗ⁾ny

在线尝试！

{ ċ的数量，取Ḣead，然后将ndex放入} stringny中。

OCSị⁾ny

在线尝试！

与上面的八度答案相似。计算O rd值，取C complement（对于每个ord值x计算1-x），S um，然后将n dex添加到字符串ny中。

APL（Dyalog Unicode），15字节

'ny'[1+=/'y'=⍞]

在线尝试！

注意：TIO默认为⎕IO = 1。如果使用⎕IO←0，

APL（Dyalog Unicode），13个字节

'ny'[=/'y'=⍞]

在线尝试！

这是XNOR函数（有时称为EQV，在旧的BASIC中尤其如此）。

分解/分析：

             ⍞  - Accept string input  
         'y'=   - Compare it to the letter `y`. This "converts" the input 
                  string into a vector of 1s and 0s where the 1s correspond 
                  to 'y' and the 0s to 'n'.  
       =/       - XNOR/EQV/equality reduction - converts the vector into a 
                  single boolean value by evaluating e.g., 1 xnor 0 xnor 0 
                  xnor 1 ...  
     1+         - adds one for subscripting in ⎕IO = 1 environment. In 
                  ⎕IO = 0, should be omitted (save 2 bytes)  
    [         ] - subscript indicator - the expression, which should be 
                  either a 1 or 2 (0 or 1 in `⎕IO = 0`), is now going to be 
                  interpreted as a subscript of...  
'ny'            - The string of possible results - a 0/1 is 'n', a 1/2 is 'y'

Pyth，9个字节

@"yn"l@\n

在这里尝试

说明

@"yn"l@\n
     l@\nQ   Get the length of the intersection of the (implicit) input and "n".
@"yn"        Modular index into "yn".

直流 39

?dsiZdsl[[]r1-d0<m]dsmxklixzll-2%B*C1+P

输入字符串是从STDIN读取的，格式应为 [yynynynynyyn]。

dc的字符串处理方式并不为人所知，但在这里，我们足以使它正常工作。这里的方法是对ns 进行计数，并y在偶数或n奇数时输出。这是通过将输入字符串作为宏执行来完成的。 dc将为'y' (0171) unimplemented所有ys 输出错误，并尝试弹出字符串并为所有ns 打印它们。因此，首先我们要确保[]要弹出的堆栈中有很多（总输入字符串长度）空字符串。然后我们执行输入字符串，看看[]堆栈上还剩下多少。从中减去原始字符串的长度即可得出（-ve）的总数ns。剩下的是做mod 2的算术运算，并输出正确的ASCII y或n。

?dsi                                    # Read input string, duplicate, store in register i
    Zdsl                                # Get input length, duplicate, store in register l
        [         ]                     # define macro to:
         []                             #   push empty string
           r                            #   swap empty string and remaining length 
            1-                          #   subtract 1 from length
              d0                        #   duplicate and compare with 0
                <m                      #   if >0 recursively call this macro again
                   dsmx                 # duplicate macro, store in register m and execute
                       k                # discard left-over 0
                        lix             # load input string and execute as macro
                           z            # get stack length
                            ll-         # load string length and subract
                               2%       # mod 2 (result is -ve because difference is -ve)
                                 B*     # multiply by 11 ('y' - 'n')
                                   C1+  # add 121 ('y')
                                      P # print result as ASCII char

在线尝试！

Japt，8字节

"yn"gUèn

在线尝试！

说明：

"yn"gUèn
"yn"       String literal - "yn"
    g      Return the char at index:   
      è      Number of matches where:
       n       "n" is found in
     U         Input

Japt使用索引包装，因此如果Uèn返回2，它将y在从中获取char时返回"yn"。

Perl 6，21个字节

{<y n>[.comb('n')%2]}

尝试一下

展开：

{  # bare block lambda with implicit parameter $_

  # index into the list ('y', 'n')
  <y n>[

    .comb('n') # get every instance of 'n' (implicit method call on $_)
    % 2        # turn it into a count and get the modulus

  ]
}

Python 2，29个字节

lambda s:'yn'[s.count('n')%2]

在线尝试！

Java 8，35字节

普通语言的决定者！我可以的

s->s.matches("y*(ny*ny*)*")?'y':'n'

在线试用

J，10 9字节

{&'ny'@=/

在线尝试！

[R，46 44字节

"if"(sum(1+utf8ToInt(scan(,"")))%%2,"n","y")

在线尝试！

减少了2个字节，这要归功于Giuseppe和ngm。路易斯·门多（Luis Mendo）对八度音阶的回答。

Japt，9个字节

奥利弗（Oliver）用最短的解决方案击败了我，所以这里有一对夫妇，他们的长度仅一个字节。

B*aUèÍu¹d

尝试一下

#ndB*UèÍv

尝试一下

说明

              :Implicit input of string U
B             :11
 *            :Mutiplied by
  a           :  The absolute difference of 11 and
   UèÍ        :    The count of "n" in U
      u       :    Mod 2
       ¹d     :Get the character at that codepoint

              :Implicit input of string U
#n            :110
   B*         :Add 11 multiplied by
        v     :  The parity of
     UèÍ      :    The count of "n" in U
  d           :Get the character at that codepoint

///，24字节

/ny/n//nn/y//yy/y//yn/n/<input>

在线尝试！

我相信这是最短的///程序，因为进行一个字符的替换要么没有用（如果您在其位置插入某些内容），要么阻止它作为输出（如果您什么也不插入）。但是，由于程序必须处理两个字符的情况，因此这应该是最小的。

首先删除的所有y权利n。然后利用LTR替换，n用ys 替换double 。在这个阶段有许多ys，最多是一个n; 我们将对ys进行重复数据删除，如果有n使用它来清除最后一个y。

MATL，8字节

Qs'ny'w)

在线尝试！

感谢Luis Mendo，节省了2个字节！我以前使用显式模量命令来使索引进入范围1,2。

说明

这利用了MATL具有模块化索引的事实，这意味着字符串的1st，3rd，5th ...元素ny相同（n）。字符串（y）的2、4、6 ...元素也是如此。

Q          % Grab input implicitly, and increment each ASCII-value by 1
           % This makes 'n' odd, and 'y' even
 s         % Take the sum of all elements
  'ny'     % Push the string `ny`
      w    % Swap the stack to facilitate the indexing
       )   % Take the n'th element of 'yn' and output it.

Python 2，26个字节

lambda s:'yn'[int(s,35)%2]

在线尝试！

视网膜，11字节

y

nn

^$
y

在线尝试！

果冻， 8  7 字节

O‘Sị⁾ny

在线尝试！

05AB1E，8个字节

'n¢„ynsè

在线尝试！

Java（OpenJDK 8），143字节

a->{char[] u=a.toCharArray();if(u.length==1)return u[0];else{char b=(u[0]==u[1])?'y':'n',i=2;for(;i<u.length;b=(b==u[i++])?'y':'n');return b;}}

在线尝试！

如果我们将输入作为列表：

Java（OpenJDK 8），118字节

u->{if(u.length==1)return u[0];else{char b=(u[0]==u[1])?'y':'n',i=2;for(;i<u.length;b=(b==u[i++])?'y':'n');return b;}}

在线尝试！

说明：

（输入为字符串）

char[] u=a.toCharArray();  //turn string into char array
if(u.length==1){    
    return u[0];      //if single letter, return it
}else{
    char b=(u[0]==u[1])?'y':'n';     //first two XNOR
    for(char i=2;i<u.length;b=(b==u[i++])?'y':'n');   //XNOR each remaining character
return b;    //return final result
}

红宝石，24字节

->s{"yn"[s.count(?n)%2]}

在线尝试！

一个lambda接受一个字符串并返回一个字符串。

Cubix，24 20字节

自从我和Cubix一起玩以来已经有一段时间了，所以...

i;iwW-?;o@..!'yv.n'|

在线尝试！

天真的实现，它逐步遍历字符串并将字符与当前结果进行比较。

互动演示

这将解包到多维数据集，如下所示

    i ;
    i w
W - ? ; o @ . .
! ' y v . n ' |
    . .
    . .

• W 左移ip
• i 得到初始字符
• i? 获取字符并测试EOI（-1），也开始循环
  • 如果EOI ;o@删除了TOS，则将TOS作为字符输出并退出。
• 否则-W!减去，将ip左移，测试真实性
  • 如果真实'n将字符n推到TOS
  • 如果有错误|!'y反映，则测试并将字符y推送至TOS
• v'.;w在立方体周围重定向，推动并移除魔方。角色并右移回循环

Scala，50字节

def?(b:String)=b.reduce((r,l)=>if(r==l)'y'else'n')

Befunge-98，13个字节

~k!aj@,+n'*b!

在线尝试！

基本上，每一个反转0 n在输入，并且一旦更良好的措施，然后输出y用于1和n用于0

~     Get inputted character
 k!   Invert the current value 110 (n) or 121 (y) + 1 times
   aj Jump past the rest of the code
~     Get input again. If no more input, reverse direction
            ! Invert the value once again
       +n'*b  Convert 0/1 to n/y
     @,       Output letter

干净，26 23字节

foldr1\a b|a==b='y'='n'

在线尝试！

JavaScript， 39 37字节

s=>[...s].reduce((x,y)=>x==y?'y':'n')

分割输入字符串后，简单的reduce函数。

C（gcc），52 50字节

感谢@Neil的建议。

我借用了对ns 计数的解决方案，但没有保持计数，我只是在的初始状态和其逆之间切换n。

i;f(char*a){for(i=*a;*++a;i^=*a&1?0:23);return i;}

在线尝试！

科特林，32字节

"yn"[s.filter{it=='n'}.length%2]

在线尝试！