¿Determinando sí o no?

19

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 , por lo que el código más corto en bytes gana

Squareoot
fuente
3
¡Felicitaciones por el primer desafío con especificaciones claras! (aunque es lamentable que a algunos miembros de la comunidad no les gusten los desafíos "demasiado triviales" ...)
user202729
3
Muy similar .
user202729
77
¿Podemos generar un par alternativo? Di 1por yy 0para n.
Oliver
55
¿Podemos tomar la entrada como una lista de caracteres, es decir["y", "n", "n"]
Okx
3
Dado que el duplicado de este desafío fue fuertemente rechazado, no creo que sea muy útil cerrar esto como un duplicado. En todo caso, el desafío anterior debería ser un duplicado de este ya que es política dejar abierto el mejor desafío
Reabrí

Respuestas:

9

Carbón de leña , 6 bytes

§yn№Sn

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

    S   Input string
   № n  Count number of `n`s
§yn     Circularly index into string `yn`
        Implicitly print appropriate character
Neil
fuente
1
Explica cómo funciona, por favor.
Malady
@Malandy Link es una versión detallada del código.
Adám
1
@ Adám En realidad, generalmente agrego uno, sin embargo, acababa de eliminarlo en un receso de trabajo y olvidé editar uno.
Neil
14

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'.
Luis Mendo
fuente
Probablemente me falta algo obvio, pero esto parece funcionar de la misma manera en algunos casos de prueba limitados para -4 bytes. ¡Probablemente está muy mal porque no conozco a Octave!
Dom Hastings
2
@DomHastings falla para yynynynny dado en el OP, debería devolver y, pero devuelve n
Skidsdev
9

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!

Arnauld
fuente
31:: s=>'yn'[s.match(/n/g).length&1]P
Solo ASCII
@ Solo ASCII Esto fallaría en cadenas que no contienen al menos una n.
Arnauld
Oh, lo haría Oops> _>
Solo ASCII
8

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!

Angs
fuente
1
Su enfoque anterior se puede hacer en 30 bytes. Pruébalo en línea!
Wheat Wizard
7

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 .

usuario202729
fuente
¡Fue mi falsa solución confundirme!
Jonathan Allan
7

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'
Jeff Zeitlin
fuente
Mientras XOR ignora 0s y gira 1s, XNOR ignora 1s y gira 0s, "inicialmente" está en 1 en lugar de 0 como XOR.
FrownyFrog
@FrownyFrog - Supongo que podría mirarlo de esa manera ... o podría verlo como un cheque para ver si sus dos valores de entrada son iguales.
Jeff Zeitlin
6

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

fuente
6

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!

Trauma digital
fuente
6

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

Oliver
fuente
Idéntico a lo que tenía.
Shaggy
5

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

  ]
}
Brad Gilbert b2gills
fuente
5

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

Jakob
fuente
5

J , 10 9 bytes

{&'ny'@=/

Pruébalo en línea!

FrownyFrog
fuente
1
Muy inteligente uso de reducción!
Adám
Muy buena solución (s)!
Galen Ivanov
¿Podría proporcionar una descomposición de las / ambas soluciones (como hice con mi solución APL)? (Por cierto, realmente debería publicar la solución APL como una solución separada de la solución J, incluso si el algoritmo es el mismo).
Jeff Zeitlin
{&'ny'@=/Guarda un byte.
algorithmshark
@algorithmshark ohhh gracias!
FrownyFrog
3

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.

JayCe
fuente
Es más fácil inspirarse con la respuesta de Octave; Si bien Octave tiene la ventaja de que las cadenas se convierten en sus puntos de código más fácilmente, creo que puede transferir el enfoque allí por un par de bytes hacia abajo.
Giuseppe
sum(utf8ToInt(scan(,""))%%2)%%2ahorra un byte.
ngm
@ngm @Giuseppe lamentablemente naún tiene que agregar + 1 primero ..
JayCe
3

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
Lanudo
fuente
3

/// , 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.

boboquack
fuente
3

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.
Stewie Griffin
fuente
1
'yn'3)da y...? Ahora que es un diseño inteligente Luis =) ¡Gracias por los consejos! :)
Stewie Griffin
Fue la sugerencia de Dennis :-)
Luis Mendo
2

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
}
X1M4L
fuente
No necesita el paréntesis en sus ternary-ifs (-4 bytes), puede eliminar el espacio en char[]u(-1 byte); y if(u.length==1)puede ser if(u.length<2)(-1 byte). Probablemente hay más para el golf, pero realmente no tengo tiempo en este momento. :)
Kevin Cruijssen
2

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
MickyT
fuente
2

Scala, 50 bytes

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

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
Jo King
fuente
2

Limpio , 26 23 bytes

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

Pruébalo en línea!

frobnicator
fuente
2
Puede guardar 3 bytes utilizando guardias lambda : foldr1\a b|a==b='y'='n'. (Por cierto, por desgracia, por lo general las importaciones son parte del código de bytes.)
2

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.

usuario3335941
fuente
1
Bienvenido a PPCG! Su código asume que la entrada está en la variable s, que no es un método de entrada válido aquí. En su lugar, puede hacer que su respuesta sea una función lambda tomando la entrada como argumento al anteponer s=>su respuesta a 42 bytes.
dzaima
golf sugerencia: sustituir s.split('')con [...s]de 37 bytes:s=>[...s].reduce((x,y)=>x==y?'y':'n')
dzaima
2

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!

ErikF
fuente
*a&1?0:23guarda un byte y return iguarda otro.
Neil
Sugeriri;f(char*a){for(i=*a;*++a;i^=*a&1?:23);a=i;}
ceilingcat