Po wprowadzeniu ciągu [długość 1-20], zawierającego tylko znaki y dla tak i n dla nie, twój program powinien wypisać wynik (y lub n). Przykładowe dane wejściowe: yynynynnywyprowadziłoby y.

Wynik określa się, łącząc y i n w następujący sposób:

• y es i n o równa się n o

• y es i y es równa się y es

• n o i n o równa się y es

Jeśli ciąg zawiera więcej niż 2 znaki (prawdopodobnie ...), obliczenia wyglądałyby tak samo. Przykłady:

• y es i y es i n o równa się n (ponieważ „nie” łączy się z pierwszym „tak” i „nie”, nie ma już „tak” i „tak” i to samo dzieje się ponownie)

• n o i n o i n o jest równe n o (pierwsze dwa nie łączą się w tak, wtedy są tak i nie ma, które pojawiają się na nie)

Przykładowe dane wejściowe z danymi wyjściowymi:

• yynynynynyyn = n

Wskazówka: pamiętaj, że kolejność znaków, w których program działa, nie ma znaczenia. (na przykład możesz odczytać dane z tyłu lub z tyłu, wymieszać litery, posortować, cokolwiek. Liczy się poprawna wydajność). Baw się dobrze!

Kryteria wygranej: to jest golf golfowy , więc wygrywa najkrótszy kod w bajtach.

Węgiel , 6 bajtów

§yn№Ｓn

Wypróbuj online! Link jest do pełnej wersji kodu. Wyjaśnienie:

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

Oktawa , 29 27 bajtów

Dzięki @RickHithcock za wskazanie błędu, teraz poprawionego. Również 2 bajty wyłączone dzięki @StewieGriffin!

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

Wypróbuj online!

Wyjaśnienie

Punkt kodowy ASCII 'y'jest nieparzysty, a ten 'n'jest parzysty. Kod

1. dodaje 1do każdego znaku w ciągu wejściowym, aby 'y'parzyste i 'n'nieparzyste;
2. oblicza sumę;
3. zmniejsza wynik do 1parzystego, 2jeśli nieparzystego;
4. indeksuje (na podstawie 1) do łańcucha 'yn'.

JavaScript (ES6), 28 bajtów

Pobiera dane wejściowe jako ciąg.

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

Wypróbuj online!

JavaScript (ES6), 30 bajtów

Pobiera dane wejściowe jako tablicę znaków.

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

Wypróbuj online!

Haskell , 33 28 bajtów

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

Indeksuje liczbę n do nieskończonej listy „ynynynyn…”. Poprzednie podejście (33 bajty) składało pary różnych elementów do n, w przeciwnym razie y:

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

Wypróbuj online!

Galaretka , 7 bajtów

ċ”nị⁾ny

Wypróbuj online!

c numer ount z „n , í ndex do strun ⁾ny . (z modułem 2)

ċḢịɗ⁾ny

Wypróbuj online!

{ C liczby ount o, podejmują h EAD, następnie í ndex w} ciąg ⁾ny .

OCSị⁾ny

Wypróbuj online!

Podobne do powyższej odpowiedzi Octave. Oblicz O rd wartość mieć C omplement (dla każdej wartości ord x oblicz 1-x ), Ś um, a ı ndex do łańcucha ⁾ny .

APL (Dyalog Unicode) , 15 bajtów

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

Wypróbuj online!

Uwaga: Domyślnie TIO to ⎕IO = 1. Jeśli uruchomić z ⎕IO←0,

APL (Dyalog Unicode) , 13 bajtów

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

Wypróbuj online!

Jest to funkcja XNOR (czasami nazywana EQV, szczególnie w starych BASIC-ach).

Rozkład / analiza:

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

@"yn"l@\n

Wypróbuj tutaj

Wyjaśnienie

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

dc , 39

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

Łańcuch wejściowy jest odczytywany ze STDIN i powinien być w formie [yynynynynyyn].

dc nie jest znane z obsługi ciągów, ale mamy tu tylko tyle, żeby to zadziałało. Podejściem tutaj jest policzenie ns i wyjście, yjeśli parzyste lub nnieparzyste. Odbywa się to poprzez wykonanie ciągu wejściowego jako makra. dcwyświetli 'y' (0171) unimplementedbłędy dla wszystkich ys i spróbuje wyskoczyć łańcuchy i wydrukować je dla wszystkich ns. Najpierw upewniamy się, że mamy dużo (całkowitą długość łańcucha wejściowego) pustych łańcuchów []na stosie do pop. Następnie wykonujemy ciąg wejściowy i sprawdzamy, ile []pozostało na stosie. Odejmuje się oryginalną długość łańcucha, aby uzyskać (-ve) całkowitą liczbę ns. Reszta jest arytmetyczna, aby wykonać mod 2 i mieć wyjście wyprowadzone jako ASCII ylub 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

Wypróbuj online!

Japt , 8 bajtów

"yn"gUèn

Wypróbuj online!

Wyjaśnienie:

"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żywa owijania indeksu, więc jeśli Uènzwróci 2, zwróci się ypo otrzymaniu char "yn".

Perl 6 , 21 bajtów

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

Spróbuj

Rozszerzony:

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

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

Wypróbuj online!

Java 8, 35 bajtów

Decyduje się na zwykły język! Mogę to zrobić.

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

Wypróbuj online

J , 10 9 bajtów

{&'ny'@=/

Wypróbuj online!

R , 46 44 bajtów

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

Wypróbuj online!

Zmniejsz 2 bajty dzięki Giuseppe i ngm. Odpowiedź Port of the Octave autorstwa Luisa Mendo.

Japt, 9 bajtów

Oliver pobił mnie do najkrótszego rozwiązania, więc oto kilka, które są tylko bajt dłużej.

B*aUèÍu¹d

Spróbuj

#ndB*UèÍv

Spróbuj

Objaśnienia

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

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

Wypróbuj online!

Uważam, że jest to najkrótszy możliwy program ///, ponieważ podstawienie jednoznakowe albo jest bezużyteczne (jeśli wstawisz coś na swoim miejscu), albo uniemożliwia, że ​​będzie to wyjście (jeśli nic nie wstawisz). Ponieważ jednak program musi obsługiwać dwa przypadki znaków, powinno to być minimalne.

Najpierw usuwa wszystkie yprawa z n. Następnie zamienia podwójne ns na ys, wykorzystując podstawienie LTR. Na tym etapie jest ich wiele, ya najwyżej jeden n; deduplikujemy ys, a jeśli istnieje, nużyj go do zetknięcia ostatniego y.

MATL , 8 bajtów

Qs'ny'w)

Wypróbuj online!

Zaoszczędzono 2 bajty dzięki Luisowi Mendo! Wcześniej użyłem jawnego polecenia modułu, aby wprowadzić indeks do zakresu1,2 .

Wyjaśnienie

Wykorzystuje to fakt, że MATL ma modułowe indeksowanie, co oznacza, że ​​1, 3, 5 ... element łańcucha nysą takie same ( n). Podobnie jak 2., 4., 6.… element string ( 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 bajtów

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

Wypróbuj online!

Siatkówka , 11 bajtów

y

nn

^$
y

Wypróbuj online!

Galaretka ,  8  7 bajtów

O‘Sị⁾ny

Wypróbuj online!

05AB1E , 8 bajtów

'n¢„ynsè

Wypróbuj online!

Java (OpenJDK 8) , 143 bajty

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

Wypróbuj online!

A jeśli weźmiemy dane jako listę:

Java (OpenJDK 8) , 118 bajtów

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

Wypróbuj online!

Wyjaśnienie:

(wprowadź jako ciąg)

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 bajty

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

Wypróbuj online!

Lambda bierze łańcuch i zwraca łańcuch.

Cubix , 24 20 bajtów

Minęło trochę czasu, odkąd grałem z Cubix, więc ...

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

Wypróbuj online!

Dość naiwna implementacja, która przechodzi przez łańcuch i porównuje znak z bieżącym wynikiem.

Interaktywna prezentacja

To rozpakowuje się na kostkę w następujący sposób

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

• W przesuń ip w lewo
• i uzyskać początkowy znak
• i? zdobądź znak i przetestuj EOI (-1), także początek pętli
  • jeśli EOI ;o@usunie TOS, wypisze TOS jako znak i wyjdzie.
• jeszcze -W! odejmij, przesuń ip w lewo, sprawdź prawdę
  • jeśli to prawda 'n pchnięcie znaku n do TOS
  • jeśli falsey |!'yodbija, przetestuj i pchnij znak y do TOS
• v'.;wprzekieruj wokół kostki wypychając i usuwając a. i wracając do pętli

Scala, 50 bajtów

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

Befunge-98 , 13 bajtów

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

Wypróbuj online!

Zasadniczo odwraca wartość 0 dla każdego nz danych wejściowych i jeszcze raz dla dobrej miary, a następnie wyprowadza ydla 1i ndla0

~     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

Czysty , 26 23 bajtów

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

Wypróbuj online!

JavaScript, 39 37 bajtów

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

Prosta funkcja redukcji po podzieleniu ciągu wejściowego.

C (gcc) , 52 50 bajtów

Dzięki @Neil za sugestie.

Pożyczyłem rozwiązanie zliczania ns, ale zamiast utrzymywać zliczanie, po prostu przerzucam pomiędzy stanem początkowym a odwrotnym na n.

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

Wypróbuj online!

Kotlin , 32 bajty

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

Wypróbuj online!