Après avoir entré une chaîne [longueur 1-20], contenant uniquement les caractères y pour oui et n pour non, votre programme devrait afficher le résultat (y ou n). Exemple d'entrée: yynynynnyproduirait y.

Le résultat est déterminé en combinant les y et les n de la manière suivante:

• y es et n o égaux n o

• y es et y es égaux y es

• n o et n o est égal à y es

Si la chaîne contient plus de 2 caractères (probablement ...), le calcul se ressemblerait. Exemples:

• y es et y es et n o est égal à n o (parce que le non fusionne avec le premier oui à non. alors il n'y a pas et oui à gauche et la même chose se reproduit)

• n o et n o et n o est égal à n o (les deux premiers non fusionnent à oui, puis il y a oui et non à gauche, qui émergent à non)

Exemple d'entrée avec sortie:

• yynynynynyyn = n

Astuce: gardez à l'esprit que l'ordre des caractères sur lesquels votre programme fonctionne ne se soucie pas. (par exemple, vous pouvez lire l'entrée de l'arrière ou de l'arrière, mélanger les lettres, les trier, peu importe. Ce qui compte, c'est la bonne sortie) amusez-vous!

Critères de victoire: c'est le code-golf , donc le code le plus court en octets gagne.

Fusain , 6 octets

§yn№Ｓn

Essayez-le en ligne! Le lien est vers la version détaillée du code. Explication:

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

Octave , 29 27 octets

Merci à @RickHithcock d' avoir signalé une erreur, maintenant corrigée. Aussi, 2 octets de réduction grâce à @StewieGriffin!

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

Essayez-le en ligne!

Explication

Le point de code ASCII de 'y'est impair et celui de 'n'est pair. Le code

1. ajoute 1à chaque caractère dans la chaîne d'entrée pour rendre 'y'pair et 'n'impair;
2. calcule la somme;
3. réduit le résultat à 1si pair, 2si impair;
4. index (basés sur 1) dans la chaîne 'yn'.

JavaScript (ES6), 28 octets

Prend l'entrée sous forme de chaîne.

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

Essayez-le en ligne!

JavaScript (ES6), 30 octets

Prend l'entrée comme un tableau de caractères.

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

Essayez-le en ligne!

Haskell , 33 28 octets

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

Indexe le nombre de n dans la liste infinie "ynynynyn…". L'approche précédente (33 octets) consistait à replier des paires d'éléments différents en n, sinon y:

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

Essayez-le en ligne!

Gelée , 7 octets

ċ”nị⁾ny

Essayez-le en ligne!

ċ ount nombre de ”n , ị ndex dans la chaîne ⁾ny . (avec modulo 2)

ċḢịɗ⁾ny

Essayez-le en ligne!

{ Ċ nombre ontant de prendre la ¯h ead, puis ì ndex dans} chaîne ⁾ny .

OCSị⁾ny

Essayez-le en ligne!

Similaire à la réponse d'Octave ci-dessus. Calculer la valeur O rd, prendre le complément C (pour chaque valeur ord x calculer 1-x ), S um, puis ị ndex dans la chaîne ⁾ny .

APL (Dyalog Unicode) , 15 octets

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

Essayez-le en ligne!

Remarque: TIO par défaut est ⎕IO = 1. Si vous courez avec ⎕IO←0,

APL (Dyalog Unicode) , 13 octets

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

Essayez-le en ligne!

Il s'agit de la fonction XNOR (parfois appelée EQV, en particulier dans les anciens BASIC).

Décomposition / Analyse:

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

@"yn"l@\n

Essayez-le ici

Explication

@"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 chaîne d'entrée est lue depuis STDIN et doit être au format [yynynynynyyn].

dc n'est pas connu pour sa gestion des chaînes, mais nous avons juste assez ici pour que cela fonctionne. L'approche ici consiste à compter les ns et à les sortir ys'ils sont pairs ou nimpairs. Cela se fait en exécutant la chaîne d'entrée en tant que macro. dcaffichera des 'y' (0171) unimplementederreurs pour tous les ys et tentera de faire apparaître des chaînes et de les imprimer pour tous les ns. Donc, d'abord, nous nous assurons que nous avons beaucoup (longueur totale de la chaîne d'entrée) de chaînes vides []sur la pile à éclater. Ensuite, nous exécutons la chaîne d'entrée et voyons combien il en []reste sur la pile. La longueur de chaîne d'origine est soustraite de cela pour donner le nombre total (-ve) de ns. Le reste est arithmétique pour faire le mod 2 et faire sortir la sortie directement en 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

Essayez-le en ligne!

Japt , 8 octets

"yn"gUèn

Essayez-le en ligne!

Explication:

"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 utilise l'index-wrapping, donc s'il Uènrevient 2, il reviendra ylors de la récupération du caractère "yn".

Perl 6 , 21 octets

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

Essayez-le

Étendu:

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

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

Essayez-le en ligne!

Java 8, 35 octets

Un décideur pour une langue régulière! Je peux le faire.

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

Essayez-le en ligne

J , 10 9 octets

{&'ny'@=/

Essayez-le en ligne!

R , 46 44 octets

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

Essayez-le en ligne!

Down 2 octets grâce à Giuseppe et ngm. Réponse de Port of the Octave par Luis Mendo.

Japt, 9 octets

Oliver m'a battu à la solution la plus courte alors voici quelques couples qui sont juste un octet de plus.

B*aUèÍu¹d

Essayez-le

#ndB*UèÍv

Essayez-le

Explications

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

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

Essayez-le en ligne!

Je crois que c'est le programme /// le plus court possible, car faire une substitution à un caractère est inutile (si vous insérez quelque chose à sa place) ou l'empêche d'être une sortie (si vous n'insérez rien). Cependant, étant donné que le programme doit traiter les deux cas de caractères, cela doit être minimal.

Supprime d'abord tous yles droits d'un n. Remplace ensuite le double ns par ys, en profitant de la substitution LTR. À ce stade, il y a plusieurs ys suivis par au plus un n; nous dédupliquons les ys et s'il y a une nutilisation pour éponger le dernier y.

MATL , 8 octets

Qs'ny'w)

Essayez-le en ligne!

Enregistré 2 octets grâce à Luis Mendo! J'ai précédemment utilisé la commande explicite de module pour obtenir l'index dans la plage 1,2.

Explication

Cela utilise le fait que MATL a une indexation modulaire, ce qui signifie que les 1er, 3e, 5e ... éléments de la chaîne nysont les mêmes ( n). Il en va de même pour les 2e, 4e, 6e ... éléments de la chaîne ( 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 octets

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

Essayez-le en ligne!

Rétine , 11 octets

y

nn

^$
y

Essayez-le en ligne!

Gelée ,  8  7 octets

O‘Sị⁾ny

Essayez-le en ligne!

05AB1E , 8 octets

'n¢„ynsè

Essayez-le en ligne!

Java (OpenJDK 8) , 143 octets

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

Essayez-le en ligne!

Et si nous prenons l'entrée comme une liste:

Java (OpenJDK 8) , 118 octets

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

Essayez-le en ligne!

Explication:

(entrée sous forme de chaîne)

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
}

Rubis , 24 octets

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

Essayez-le en ligne!

Un lambda prenant une chaîne et renvoyant une chaîne.

Cubix , 24 20 octets

Cela fait un moment que je n'ai pas joué avec Cubix, alors ...

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

Essayez-le en ligne!

Implémentation assez naïve qui parcourt la chaîne et compare le caractère au résultat actuel.

Démo interactive

Cela se déroule sur le cube comme suit

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

• W décalage ip vers la gauche
• i obtenir le caractère initial
• i? obtenir le caractère et tester EOI (-1), également le début de la boucle
  • si EOI ;o@supprime TOS, sortez TOS comme caractère et quittez.
• sinon -W!soustraire, déplacer l'ip vers la gauche, tester la véracité
  • si véridique, 'npousser le caractère n vers TOS
  • si falsey |!'yréfléchit, teste et pousse le caractère y vers TOS
• v'.;wrediriger autour du cube en poussant et en supprimant a. caractère et se replacer dans la boucle

Scala, 50 octets

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

Befunge-98 , 13 octets

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

Essayez-le en ligne!

Inverse fondamentalement un 0 pour chaque nentrée, et encore une fois pour faire bonne mesure, puis les sorties ypour 1et npour0

~     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

Nettoyer , 26 23 octets

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

Essayez-le en ligne!

JavaScript, 39 37 octets

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

Fonction de réduction simple après division de la chaîne d'entrée.

C (gcc) , 52 50 octets

Merci à @Neil pour les suggestions.

J'ai emprunté la solution de compter ns, mais au lieu de garder un compte, je bascule simplement entre l'état initial et son inverse sur un n.

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

Essayez-le en ligne!

Kotlin , 32 octets

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

Essayez-le en ligne!