Después de ingresar una cadena [longitud 1-20], que solo contiene los caracteres y para sí yn para no, su programa debería generar el resultado (y o n). Entrada de ejemplo: yynynynnydaría salida y.

El resultado se determina combinando las y's yn's de la siguiente manera:

• Y es y n o iguales n o

• Y es y Y es igual a Y ES

• n o y n o es igual a y es

Si la cadena contiene más de 2 caracteres (probablemente ...), el cálculo se vería igual. Ejemplos:

• Y es e Y es y n o iguales n O (porque no hay fusiones con las de los primeros sí a NO. Luego están no y sí a la izquierda y pasa lo mismo otra vez)

• n o y n o y n o es igual a n o (los dos primeros no se fusionan con yes, luego quedan yes y no, que emergen en no)

Ejemplo de entrada con salida:

• yynynynynyyn = n

Consejo: tenga en cuenta que no le importa el orden de los caracteres de su programa. (por ejemplo, puede leer la entrada desde atrás, o desde atrás, mezclar las letras, ordenarlas, lo que sea. Lo que cuenta es la salida correcta) ¡diviértase!

Criterio ganador: este es el código de golf , por lo que el código más corto en bytes gana

Carbón de leña , 6 bytes

§yn№Ｓn

Pruébalo en línea! El enlace es a la versión detallada del código. Explicación:

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

Octava , 29 27 bytes

Gracias a @RickHithcock por señalar un error, ahora corregido. Además, ¡2 bytes de descuento gracias a @StewieGriffin!

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

Pruébalo en línea!

Explicación

El punto de código ASCII de 'y'es impar, y el de 'n'es par. El código

1. agrega 1a cada carácter en la cadena de entrada para hacer 'y'pares e 'n'impares;
2. calcula la suma;
3. reduce el resultado a 1si es par, 2si es impar;
4. índices (basados ​​en 1) en la cadena 'yn'.

JavaScript (ES6), 28 bytes

Toma la entrada como una cadena.

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

Pruébalo en línea!

JavaScript (ES6), 30 bytes

Toma la entrada como una matriz de caracteres.

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

Pruébalo en línea!

Haskell , 33 28 bytes

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

Indiza el recuento de n en la lista infinita "ynynynyn ...". El enfoque anterior (33 bytes) era doblar pares de diferentes elementos a n, de lo contrario y:

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

Pruébalo en línea!

Jalea , 7 bytes

ċ”nị⁾ny

Pruébalo en línea!

ċ número de "n , ị ndex en la cadena ⁾ny . (con módulo 2)

ċḢịɗ⁾ny

Pruébalo en línea!

{ ċ cantidad de, tome la Ḣ ead, luego ị ndex en} cadena ⁾ny .

OCSị⁾ny

Pruébalo en línea!

Similar a la respuesta de Octave anterior. Calcule el valor de O rd, tome el complemento C (para cada valor ord x calcule 1-x ), S um, luego ị ndex en la cadena ⁾ny .

APL (Dyalog Unicode) , 15 bytes

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

Pruébalo en línea!

Nota: TIO por defecto es ⎕IO = 1. Si corre con ⎕IO←0,

APL (Dyalog Unicode) , 13 bytes

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

Pruébalo en línea!

Esta es la función XNOR (a veces llamada EQV, especialmente en los BASIC antiguos.

Descomposición / Análisis:

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

@"yn"l@\n

Pruébalo aquí

Explicación

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

La cadena de entrada se lee desde STDIN y debe tener el formato [yynynynynyyn].

DC no es conocido por su manejo de cadenas, pero aquí tenemos suficiente para que esto funcione. El enfoque aquí es contar los ns, y la salida ysi es par o nimpar. Esto se realiza ejecutando la cadena de entrada como una macro. dcgenerará 'y' (0171) unimplementederrores para todos los ys e intentará desplegar cadenas e imprimirlas para todos los ns. Entonces, primero nos aseguramos de tener un montón (longitud de cadena de entrada total) de cadenas vacías []en la pila para hacer estallar. Luego ejecutamos la cadena de entrada y vemos cuántos []quedan en la pila. La longitud de la cadena original se resta de esto para dar el número total (-ve) de ns. El resto es aritmético para hacer mod 2 y hacer que la salida salga como ASCII yo 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

Pruébalo en línea!

Japt , 8 bytes

"yn"gUèn

Pruébalo en línea!

Explicació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 usa el ajuste de índice, por lo que si Uèndevuelve 2, volverá yal obtener el carácter de "yn".

Perl 6 , 21 bytes

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

Intentalo

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]

Pruébalo en línea!

Java 8, 35 bytes

¡Un decisivo para un lenguaje normal! Yo puedo hacer eso.

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

Pruébalo en línea

J , 10 9 bytes

{&'ny'@=/

Pruébalo en línea!

R , 46 44 bytes

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

Pruébalo en línea!

Bajó 2 bytes gracias a Giuseppe y ngm. Port of the Octave respuesta de Luis Mendo.

Japt, 9 bytes

Oliver me ganó con la solución más corta, así que aquí hay un par que son solo un byte más.

B*aUèÍu¹d

Intentalo

#ndB*UèÍv

Intentalo

Explicaciones

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

Pruébalo en línea!

Creo que este es el programa /// más corto posible, ya que hacer una sustitución de un carácter es inútil (si inserta algo en su lugar) o evita que sea una salida (si no inserta nada). Sin embargo, dado que el programa debe tratar los casos de dos caracteres, esto debería ser mínimo.

Primero elimina todos ylos derechos de un n. Luego reemplaza el doble ns por ys, aprovechando la sustitución LTR. En esta etapa hay muchos ys seguidos de a lo sumo uno n; deduplicamos el ys y si hay un nuso, lo trapeamos hasta el último y.

MATL , 8 bytes

Qs'ny'w)

Pruébalo en línea!

¡Ahorré 2 bytes gracias a Luis Mendo! Anteriormente utilicé el comando de módulo explícito para obtener el índice en el rango 1,2.

Explicación

Esto utiliza el hecho de que MATL tiene indexación modular, lo que significa que el 1er, 3er, 5to ... elemento de la cadena nyson los mismos ( n). Así son el 2do, 4to, 6to ... elemento de la cadena ( 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]

Pruébalo en línea!

Retina , 11 bytes

y

nn

^$
y

Pruébalo en línea!

Jalea ,  8  7 bytes

O‘Sị⁾ny

Pruébalo en línea!

05AB1E , 8 bytes

'n¢„ynsè

Pruébalo en línea!

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

Pruébalo en línea!

Y si tomamos la entrada como una 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;}}

Pruébalo en línea!

Explicación:

(entrada como cadena)

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
}

Rubí , 24 bytes

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

Pruébalo en línea!

Una lambda que toma una cuerda y la devuelve.

Cubix , 24 20 bytes

Ha pasado un tiempo desde que jugué con Cubix, así que ...

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

Pruébalo en línea!

Implementación bastante ingenua que recorre la cadena y compara el carácter con el resultado actual.

Demo interactiva

Esto se desenvuelve en el cubo de la siguiente manera

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

• W shift ip left
• i obtener el personaje inicial
• i? obtener caracteres y probar EOI (-1), también inicio del ciclo
  • si EOI ;o@elimina TOS, genera TOS como carácter y sale.
• de lo contrario -W!restar, desplazar ip hacia la izquierda, probar la verdad
  • si la verdad 'nempuja el carácter n a TOS
  • si falsey |!'yreflexiona, prueba y empuja el personaje y a TOS
• v'.;wredirigir alrededor del cubo empujando y quitando a. carácter y cambio de vuelta al bucle

Scala, 50 bytes

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

Befunge-98 , 13 bytes

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

Pruébalo en línea!

Básicamente invierte un 0 para cada nentrada, y una vez más para una buena medida, luego emite ypara 1y 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

Limpio , 26 23 bytes

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

Pruébalo en línea!

JavaScript, 39 37 bytes

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

Función de reducción simple después de dividir la cadena de entrada.

C (gcc) , 52 50 bytes

Gracias a @Neil por las sugerencias.

Tomé prestada la solución de contar ns, pero en lugar de mantener un conteo, simplemente cambio entre el estado inicial y su inverso en un n.

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

Pruébalo en línea!

Kotlin , 32 bytes

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

Pruébalo en línea!