Sau khi nhập một chuỗi [độ dài 1-20], chỉ chứa các ký tự y cho có và n cho không, chương trình của bạn sẽ xuất kết quả (y hoặc n). Ví dụ đầu vào: yynynynnysẽ xuất y.

Kết quả được xác định bằng cách kết hợp y và n theo cách sau:

• y es và n o bằng n o

• y es và y es bằng y es

• n o và n o bằng y es

Nếu chuỗi chứa nhiều hơn 2 ký tự (có thể ...), phép tính sẽ giống nhau. Ví dụ:

• y es và y es và n o bằng n o (vì không hợp nhất với đầu tiên có thành không. sau đó không còn và có còn lại và điều tương tự lại xảy ra)

• n o và n o và n o bằng n o (hai số không đầu tiên hợp nhất thành có, sau đó có có và không còn lại, xuất hiện thành không)

Ví dụ đầu vào với đầu ra:

• yynynynynyyn = n

Mẹo: hãy nhớ rằng thứ tự các ký tự chương trình của bạn không hoạt động. (ví dụ: bạn có thể đọc đầu vào từ phía sau hoặc từ phía sau, trộn các chữ cái, sắp xếp nó, bất cứ thứ gì. Số đếm là ouptput chính xác) hãy vui vẻ!

Tiêu chí chiến thắng: đây là mã golf , vì vậy mã ngắn nhất trong byte thắng.

Than , 6 byte

§yn№Ｓn

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. Giải trình:

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

Octave , 29 27 byte

Cảm ơn @RickHithcock đã chỉ ra một lỗi, giờ đã sửa. Ngoài ra, giảm 2 byte nhờ @StewieGriffin!

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

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

Giải trình

Điểm mã ASCII 'y'là số lẻ và điểm 'n'chẵn. Mật mã

1. thêm 1vào mỗi char trong chuỗi đầu vào để tạo 'y'chẵn và 'n'lẻ;
2. tính tổng;
3. giảm kết quả xuống 1nếu chẵn, 2nếu lẻ;
4. lập chỉ mục (dựa trên 1) vào chuỗi 'yn'.

JavaScript (ES6), 28 byte

Đưa đầu vào dưới dạng một chuỗi.

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

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

JavaScript (ES6), 30 byte

Đưa đầu vào như một mảng các ký tự.

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

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

Haskell , 33 28 byte

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

Lập chỉ mục số n trong danh sách vô hạn "ynynynyn." Cách tiếp cận trước đó (33 byte) là gấp các cặp phần tử khác nhau thành n, nếu không thì y:

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

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

Thạch , 7 byte

ċ”nị⁾ny

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

ount số của n n , ị ndex vào chuỗi ⁾ny . (với modulo 2)

ċḢịɗ⁾ny

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

{ C số ount của, lấy H ead, sau đó ị Ndex vào} chuỗi ⁾ny .

OCSị⁾ny

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

Tương tự như câu trả lời Octave ở trên. Tính giá trị O , lấy phép tính C (với mỗi giá trị ord x tính 1-x ), S um, sau đó ị ndex thành chuỗi ⁾ny .

APL (Dyalog Unicode) , 15 byte

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

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

Lưu ý: TIO mặc định là ⎕IO = 1. Nếu chạy với ⎕IO←0,

APL (Dyalog Unicode) , 13 byte

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

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

Đây là chức năng XNOR (đôi khi được gọi là EQV, đặc biệt là trong các BASIC cũ.

Phân tích / Phân tích:

             ⍞  - 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'

Bình thường, 9 byte

@"yn"l@\n

Hãy thử nó ở đây

Giải trình

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

đc , 39

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

Chuỗi đầu vào được đọc từ STDIN và phải ở dạng [yynynynynyyn].

dc không được biết đến với việc xử lý chuỗi của nó, nhưng chúng ta có đủ ở đây để làm việc này. Cách tiếp cận ở đây là đếm ns và đầu ra ynếu chẵn hoặc nlẻ. Điều này được thực hiện bằng cách thực hiện chuỗi đầu vào dưới dạng macro. dcsẽ xuất 'y' (0171) unimplementedlỗi cho tất cả các ys và cố gắng bật chuỗi và in chúng cho tất cả các ns. Vì vậy, trước tiên, chúng tôi đảm bảo rằng chúng tôi có rất nhiều (tổng chiều dài chuỗi đầu vào) của chuỗi trống []trên ngăn xếp để bật. Sau đó, chúng tôi thực hiện chuỗi đầu vào và xem có bao nhiêu []còn lại trên ngăn xếp. Độ dài chuỗi ban đầu được trừ đi từ này để cho tổng số (-ve) của ns. Phần còn lại là số học để làm mod 2 và có đầu ra xuất hiện đúng như ASCII yhoặc 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

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

Japt , 8 byte

"yn"gUèn

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

Giải trình:

"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 sử dụng gói chỉ mục, vì vậy nếu Uèntrả về 2, nó sẽ trả về ykhi lấy char từ đó "yn".

Perl 6 , 21 byte

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

Thử nó

Mở rộng:

{  # 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 byte

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

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

Java 8, 35 byte

Một người quyết định cho một ngôn ngữ thông thường! Tôi có thể làm điều đó.

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

Dùng thử trực tuyến

J , 10 9 byte

{&'ny'@=/

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

R , 46 44 byte

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

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

Xuống 2 byte nhờ Giuseppe và ngm. Cảng câu trả lời Octave của Luis Mendo.

Japt, 9 byte

Oliver đánh tôi với giải pháp ngắn nhất vì vậy đây là một cặp chỉ dài hơn một byte.

B*aUèÍu¹d

Thử nó

#ndB*UèÍv

Thử nó

Giải thích

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

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

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

Tôi tin rằng đây là chương trình /// ngắn nhất có thể, vì việc thay thế một ký tự là vô ích (nếu bạn chèn một cái gì đó vào vị trí của nó) hoặc ngăn không cho nó là đầu ra (nếu bạn không chèn gì). Tuy nhiên, vì chương trình phải giải quyết hai trường hợp nhân vật, nên điều này là tối thiểu.

Đầu tiên loại bỏ tất cả ycác quyền của một n. Sau đó thay thế ns kép bằng ys, lợi dụng thay thế LTR. Ở giai đoạn này có nhiều ys theo sau nhiều nhất là một n; chúng tôi lặp lại các ys và nếu có nsử dụng nó để lau lần cuối y.

MATL , 8 byte

Qs'ny'w)

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

Đã lưu 2 byte nhờ Luis Mendo! Trước đây tôi đã sử dụng lệnh modulus rõ ràng để đưa chỉ mục vào phạm vi 1,2.

Giải trình

Điều này sử dụng thực tế là MATL có lập chỉ mục mô-đun, có nghĩa là phần tử thứ 1, 3, 5 ... của chuỗi nylà giống nhau ( n). Vì vậy, phần tử thứ 2, 4, 6 ... của chuỗi ( y).

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 byte

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

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

Võng mạc , 11 byte

y

nn

^$
y

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

Thạch ,  8  7 byte

O‘Sị⁾ny

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

05AB1E , 8 byte

'n¢„ynsè

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

Java (OpenJDK 8) , 143 byte

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

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

Và nếu chúng ta lấy đầu vào làm danh sách:

Java (OpenJDK 8) , 118 byte

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

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

Giải trình:

(nhập dưới dạng chuỗi)

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
}

Ruby , 24 byte

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

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

Một lambda lấy một chuỗi và trả lại một chuỗi.

Hình khối , 24 20 byte

Đã được một thời gian kể từ khi tôi chơi với Cubix, vì vậy ...

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

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

Thực hiện khá ngây thơ mà bước qua chuỗi và so sánh nhân vật với kết quả hiện tại.

Demo tương tác

Điều này mở ra cho khối như sau

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

• W thay đổi ip trái
• i lấy ký tự ban đầu
• i? nhận ký tự và kiểm tra EOI (-1), cũng bắt đầu vòng lặp
  • nếu EOI ;o@loại bỏ TOS, xuất ra Tosh dưới dạng ký tự và thoát.
• -W!trừ khác , thay đổi ip trái, kiểm tra cho sự thật
  • nếu sự thật 'nđẩy nhân vật n đến ĐKDV
  • Nếu falsey |!'yphản ánh, kiểm tra và đẩy nhân vật y đến ĐKDV
• v'.;wchuyển hướng xung quanh khối đẩy và loại bỏ a. nhân vật và dịch chuyển trở lại vào vòng lặp

Scala, 50 byte

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

Befunge-98 , 13 byte

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

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

Về cơ bản đảo ngược 0 cho mỗi nđầu vào, và một lần nữa cho thước đo tốt, sau đó đầu ra ycho 1và ncho0

~     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

Sạch , 26 23 byte

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

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

JavaScript, 39 37 byte

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

Hàm giảm đơn giản sau khi tách chuỗi đầu vào.

C (gcc) , 52 50 byte

Cảm ơn @Neil vì những gợi ý.

Tôi đã mượn giải pháp đếm ns, nhưng thay vì giữ một số đếm, tôi chỉ lật giữa trạng thái ban đầu và nghịch đảo của nó trên một n.

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

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

Kotlin , 32 byte

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

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