Depois de inserir uma string [comprimento 1-20], contendo apenas os caracteres y para yes en para não, seu programa deve gerar o resultado (y ou n). Exemplo de entrada: yynynynnygeraria y.

O resultado é determinado pela combinação de y e n da seguinte maneira:

• y es e n o igual a n o

• y es e y es é igual a y es

• n o e n o é igual a y es

Se a sequência contiver mais de 2 caracteres (provavelmente ...), o cálculo será o mesmo. Exemplos:

• y es e y es e n o igual a n (porque o no se funde com o primeiro sim a não. então não há nenhum e sim sobrando e a mesma coisa acontece novamente)

• n o e n o e n o é igual a n (os dois primeiros não se fundem em sim, então há sim e não sobrando, que emergem em não)

Exemplo de entrada com saída:

• yynynynynyyn = n

Dica: lembre-se de que a ordem dos caracteres do seu programa não funciona. (por exemplo, você pode ler a entrada de trás ou de trás, misturar as letras, classificar, o que for. O que conta é a saída correta) divirta-se!

Critérios de vitória: trata-se de código-golfe , pelo que o código mais curto em bytes ganha.

Carvão , 6 bytes

§yn№Ｓn

Experimente online! Link é a versão detalhada do código. Explicação:

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

Oitava , 29 27 bytes

Obrigado a @RickHithcock por apontar um erro, agora corrigido. Além disso, com 2 bytes de desconto, graças a @StewieGriffin!

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

Experimente online!

Explicação

O ponto de código ASCII de 'y'é ímpar e o de 'n'é par. O código

1. adiciona 1a cada caractere na sequência de entrada para tornar 'y'par e 'n'ímpar;
2. calcula a soma;
3. reduz o resultado para 1se for par, 2se for ímpar;
4. índices (com base em 1) na cadeia 'yn'.

JavaScript (ES6), 28 bytes

Recebe a entrada como uma sequência.

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

Experimente online!

JavaScript (ES6), 30 bytes

Recebe a entrada como uma matriz de caracteres.

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

Experimente online!

Haskell , 33 28 bytes

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

Indexa a contagem de n na lista infinita "ynynynyn…". A abordagem anterior (33 bytes) foi dobrar pares de elementos diferentes para n, caso contrário y:

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

Experimente online!

Geléia , 7 bytes

ċ”nị⁾ny

Experimente online!

não número de ”n , ” ndex na string ⁾ny . (com módulo 2)

ċḢịɗ⁾ny

Experimente online!

{ Ċ número ount de, pegue a H ead, então I NDEX em} corda ⁾ny .

OCSị⁾ny

Experimente online!

Semelhante à resposta do Octave acima. Calcular O rd valor, tomar a C omplement (para cada valor ord x calcule 1-x ), S um, então i NDEX em cadeia ⁾ny .

APL (Dyalog Unicode) , 15 bytes

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

Experimente online!

Nota: O TIO é padronizado como ⎕IO = 1. Se executado com ⎕IO←0,

APL (Dyalog Unicode) , 13 bytes

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

Experimente online!

Essa é a função XNOR (às vezes chamada EQV, especialmente em BASICs antigos.

Decomposição / Análise:

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

Pitão, 9 bytes

@"yn"l@\n

Experimente aqui

Explicação

@"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

String de entrada é lida a partir do STDIN e deve ser na forma [yynynynynyyn].

dc não é conhecido por seu tratamento de strings, mas temos aqui o suficiente para fazer com que isso funcione. A abordagem aqui é contar os se a nsaída yfor par ou nímpar. Isso é feito executando a sequência de entrada como uma macro. dcirá gerar 'y' (0171) unimplementederros para todos os se ytentar pop strings e imprimi-los para todos os ns. Portanto, primeiro garantimos que temos (comprimento total da string de entrada) de strings vazias []na pilha para aparecer. Em seguida, executamos a string de entrada e vemos quantas []restam na pilha. O comprimento da string original é subtraído para fornecer o número total de (-ve) ns. O resto é aritmético para fazer o mod 2 e ter a saída correta como ASCII you 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

Experimente online!

Japonês , 8 bytes

"yn"gUèn

Experimente online!

Explicação:

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

O Japt usa quebra de índice, portanto, se Uènretornar 2, retornará yao obter o char "yn".

Perl 6 , 21 bytes

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

Tente

Expandido:

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

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

Experimente online!

Java 8, 35 bytes

Uma decisão para uma linguagem regular! Eu posso fazer isso.

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

Experimente Online

J , 10 9 bytes

{&'ny'@=/

Experimente online!

R , 46 44 bytes

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

Experimente online!

Abaixo de 2 bytes, graças a Giuseppe e ngm. Porto da Oitava resposta por Luis Mendo.

Japonês, 9 bytes

Oliver me levou para a solução mais curta, então aqui estão algumas que são apenas um byte a mais.

B*aUèÍu¹d

Tente

#ndB*UèÍv

Tente

Explicações

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

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

Experimente online!

Eu acredito que este é o programa mais curto possível ///, pois fazer uma substituição de um caractere é inútil (se você inserir algo em seu lugar) ou impede que ele seja uma saída (se você não inserir nada). No entanto, como o programa deve lidar com os dois casos de caracteres, isso deve ser mínimo.

Primeiro remove todos os ydireitos de um n. Em seguida, substitui ns duplo por ys, aproveitando a substituição LTR. Nesta fase, existem muitos ys seguidos por no máximo um n; desduplicamos os yse, se houver umn usá-lo para limpar o último y.

MATL , 8 bytes

Qs'ny'w)

Experimente online!

Guardado 2 bytes graças a Luis Mendo! Eu usei anteriormente o comando módulo explícito para obter o índice no intervalo 1,2.

Explicação

Isso usa o fato de que o MATL possui indexação modular, o que significa que o primeiro, terceiro, quinto ... elemento da sequência nyé o mesmo ( n). O mesmo ocorre com o 2º, 4º, 6º ... elemento da 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 bytes

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

Experimente online!

Retina , 11 bytes

y

nn

^$
y

Experimente online!

Geléia ,  8  7 bytes

O‘Sị⁾ny

Experimente online!

05AB1E , 8 bytes

'n¢„ynsè

Experimente online!

Java (OpenJDK 8) , 143 bytes

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

Experimente online!

E se considerarmos a entrada como uma lista:

Java (OpenJDK 8) , 118 bytes

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

Experimente online!

Explicação:

(entrada como string)

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 bytes

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

Experimente online!

Um lambda pegando uma string e retornando uma string.

Cubix , 24 20 bytes

Faz um tempo desde que eu joguei com o Cubix, então ...

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

Experimente online!

Implementação bastante ingênua que percorre a cadeia e compara o caractere com o resultado atual.

Demonstração interativa

Isso desenrola no cubo da seguinte maneira

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

• W shift ip left
• i obter o caractere inicial
• i? obter caractere e testar EOI (-1), também iniciar o loop
  • se o EOI ;o@remover os TOS, envie-os como caractere e saia.
• mais -W!subtraia, mude o ip para a esquerda, teste para a verdade
  • se for verdade, 'npressione o caractere n para TOS
  • se falsey |!'yrefletir, teste e envie o caractere y para TOS
• v'.;wredirecionar ao redor do cubo empurrando e removendo a. personagem e mudando de volta para o loop

Scala, 50 bytes

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

Befunge-98 , 13 bytes

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

Experimente online!

Inverte basicamente um 0 para cada nentrada e, mais uma vez, para uma boa medida, em seguida, gera ypara 1e npara0

~     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

Limpo , 26 23 bytes

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

Experimente online!

JavaScript, 39 37 bytes

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

Função de redução simples após dividir a sequência de entrada.

C (gcc) , 52 50 bytes

Obrigado a @Neil pelas sugestões.

Peguei emprestada a solução da contagem ns, mas, em vez de manter uma contagem, apenas alterno entre o estado inicial e seu inverso em um n.

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

Experimente online!

Kotlin , 32 bytes

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

Experimente online!