Déterminer oui ou non?

19

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.

code-golf  decision-problem 
— Squareoot
source
3
Félicitations pour le premier défi avec des spécifications claires! (même s'il est regrettable que certains membres de la communauté n'aiment pas les défis "trop ​​triviaux" ....)
— user202729
3
— user202729
7
Pouvons-nous produire une paire alternative? Dites 1pour yet 0pour n.
— Oliver
5
Pouvons-nous prendre la saisie comme une liste de caractères, c'est["y", "n", "n"]
— Okx
3
Étant donné que le doublon de ce défi a été fortement rejeté, je ne pense pas qu'il soit très utile de le fermer en double. Si quoi que ce soit, l'ancien défi devrait être un double de celui-ci, car il est de la politique de laisser le meilleur défi ouvert . J'ai rouvert ce défi
— DJMcMayhem

Réponses:

9

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
— Neil
source
1
Expliquez comment cela fonctionne, s'il vous plaît?
— Malady
@Malandy Link est une version verbeuse du code.
— Adám
1
@ Adám En fait, j'en ajoute habituellement un, mais je venais juste de me lancer dans une pause et j'ai oublié d'en éditer un.
— Neil
14

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'.
— Luis Mendo
source
Il me manque probablement quelque chose d'évident, mais cela semble fonctionner de la même manière dans quelques cas de test limités pour -4 octets. C'est probablement très mal parce que je ne connais pas Octave!
— Dom Hastings
2
@DomHastings Échoue pour yynynynny donné dans l'OP, devrait retourner y, mais renvoie n
— Skidsdev
8

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!

— Angs
source
1
Votre approche précédente peut se faire en 30 octets. Essayez-le en ligne!
— Wheat Wizard
7

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 .

— user202729
source
C'était ma fausse solution qui m'a dérouté!
— Jonathan Allan
7

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'
— Jeff Zeitlin
source
Alors que XOR ignore les 0 et bascule sur 1, XNOR ignore les 1 et bascule sur 0, «initialement» étant à 1 au lieu de 0 comme XOR.
— FrownyFrog
@FrownyFrog - Je suppose que vous pouvez le voir de cette façon ... ou vous pouvez le voir comme une vérification pour voir si ses deux valeurs d'entrée sont les mêmes.
— Jeff Zeitlin
6

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

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!

— Traumatisme numérique
source
6

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

— Oliver
source
Identique à ce que j'avais.
— Shaggy
5

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

  ]
}
— Brad Gilbert b2gills
source
5

J , 10 9 octets

{&'ny'@=/

Essayez-le en ligne!

— FrownyFrog
source
1
Utilisation très intelligente de la réduction!
— Adám
Solution (s) vraiment sympa (s)!
— Galen Ivanov
Pourriez-vous s'il vous plaît fournir une décomposition des / les deux solutions (comme je l'ai fait avec ma solution APL)? (Par ailleurs, vous devriez vraiment publier la solution APL en tant que solution distincte de la solution J, même si l'algorithme est le même.)
— Jeff Zeitlin
{&'ny'@=/enregistre un octet.
— algorithmshark
@algorithmshark ohhh merci!
— FrownyFrog
3

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.

— JayCe
source
Il est plus facile de s'inspirer de la réponse d'Octave; alors qu'Octave a l'avantage que les chaînes sont converties en leurs points de code plus facilement, je pense que vous pouvez y porter l'approche pendant quelques octets.
— Giuseppe
sum(utf8ToInt(scan(,""))%%2)%%2enregistre un octet.
— ngm
@ngm @Giuseppe nest malheureusement même si vous devez ajouter + 1 en premier ..
— JayCe
3

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
— Hirsute
source
3

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

— boboquack
source
3

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.
— Stewie Griffin
source
1
'yn'3)donne y...? Maintenant, c'est un design intelligent Luis =) Merci pour les conseils! :)
— Stewie Griffin
— Luis Mendo
2

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
}
— X1M4L
source
Vous n'avez pas besoin de la parenthèse à vos ifs ternaires (-4 octets), vous pouvez supprimer l'espace à char[]u(-1 octet); et if(u.length==1)peut être if(u.length<2)(-1 octet). Il y a probablement plus au golf, mais je n'ai pas vraiment le temps en ce moment. :)
— Kevin Cruijssen
2

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
— MickyT
source
2

Scala, 50 octets

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

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
— Jo King
source
2

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.

— user3335941
source
1
Bienvenue chez PPCG! Votre code suppose que l'entrée est dans la variable s, ce qui n'est pas une méthode d'entrée valide ici. Vous pouvez à la place faire de votre réponse une fonction lambda prenant l'entrée comme argument en ajoutant s=>à votre réponse 42 octets.
— dzaima
suggestion de golf: remplacer s.split('')par [...s]pour 37 octets:s=>[...s].reduce((x,y)=>x==y?'y':'n')
— dzaima
2

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!

— ErikF
source
*a&1?0:23enregistre un octet et return ienregistre un autre.
— Neil
Suggérezi;f(char*a){for(i=*a;*++a;i^=*a&1?:23);a=i;}
— plafondcat
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.