Nach der Eingabe eines Strings [Länge 1-20], der nur die Zeichen y für yes und n für no enthält, sollte Ihr Programm das Ergebnis (y oder n) ausgeben. Eingabebeispiel: yynynynnywürde y ausgeben.

Das Ergebnis wird durch folgende Kombination von y und n ermittelt:

• y n und n o equals n o

• y n und y n gleich y n

• n o und n o gleich y n

Wenn die Zeichenfolge mehr als 2 Zeichen enthält (wahrscheinlich ...), würde die Berechnung gleich aussehen. Beispiele:

• y n und y n und n o equals n o (weil das keine verschmilzt mit dem ersten ja bis Nr. dann gibt es keine und ja links und das gleiche passiert wieder)

• n o und n o und n o equals n o (die ersten beiden Neins Zusammenführung ja, dann gibt es ja und nein links, die nicht auftauchen)

Beispiel Eingabe mit Ausgabe:

• yynynynynyyn = n

Tipp: Beachten Sie, dass die Reihenfolge der Zeichen, in der Ihr Programm ausgeführt wird, keine Rolle spielt. (zum Beispiel können Sie die Eingabe von hinten oder von hinten lesen, die Buchstaben mischen, sortieren, was auch immer. Was zählt, ist die richtige Ausgabe) Viel Spaß!

Gewinnkriterien: Dies ist Code-Golf , also gewinnt der kürzeste Code in Byte.

Holzkohle , 6 Bytes

§yn№Ｓn

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Erläuterung:

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

Oktave , 29 27 Bytes

Vielen Dank an @RickHithcock für den Hinweis auf einen Fehler, der jetzt korrigiert wurde. Außerdem 2 Bytes weniger dank @StewieGriffin!

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

Probieren Sie es online!

Erläuterung

Der ASCII-Codepunkt von 'y'ist ungerade und der von 'n'ist gerade. Der Code

1. fügt 1zu jedem Zeichen in der Eingabezeichenfolge Gerade 'y'und 'n'Ungerade hinzu;
2. berechnet die Summe;
3. reduziert das Ergebnis auf 1gerade, 2wenn auch ungerade;
4. Indexe (1-basiert) in die Zeichenfolge 'yn'.

JavaScript (ES6), 28 Byte

Übernimmt die Eingabe als Zeichenfolge.

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

Probieren Sie es online!

JavaScript (ES6), 30 Byte

Nimmt die Eingabe als Array von Zeichen.

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

Probieren Sie es online!

Haskell , 33 28 Bytes

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

Indiziert die Anzahl von n in die unendliche Liste "ynynynyn ...". Vorheriger Ansatz (33 Bytes) war das Falten von Paaren verschiedener Elemente zu n, ansonsten zu y:

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

Probieren Sie es online!

Gelee , 7 Bytes

ċ”nị⁾ny

Probieren Sie es online!

ċ ount Anzahl von „n , í ndex in den String ⁾ny . (mit Modulo 2)

ċḢịɗ⁾ny

Probieren Sie es online!

{ Ċ ount Anzahl, nehmen Sie die H ead, dann ich ndex in} String ⁾ny .

OCSị⁾ny

Probieren Sie es online!

Ähnlich wie bei der obigen Oktavantwort. Berechnen O rd Wert, nehmen Sie die C omplement (für jeden ord Wert x berechnen 1-x ), S & mgr ; m, dann í ndex in Zeichenfolge ⁾ny .

APL (Dyalog Unicode) , 15 Byte

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

Probieren Sie es online!

Hinweis: TIO ist standardmäßig auf eingestellt ⎕IO = 1. Wenn mit ausgeführt ⎕IO←0,

APL (Dyalog Unicode) , 13 Bytes

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

Probieren Sie es online!

Dies ist die XNOR-Funktion (manchmal auch EQV genannt, insbesondere in alten BASICs).

Zersetzung / 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 Bytes

@"yn"l@\n

Probieren Sie es hier aus

Erläuterung

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

Die Eingabezeichenfolge wird aus STDIN gelesen und sollte in der Form vorliegen [yynynynynyyn].

dc ist nicht für sein String-Handling bekannt, aber wir haben hier gerade genug, um dies zum Laufen zu bringen. Der Ansatz hier ist, das ns zu zählen und auszugeben, yob gerade oder nungerade. Dies erfolgt durch Ausführen der Eingabezeichenfolge als Makro. dcGibt 'y' (0171) unimplementedFehler für alle ys aus und versucht, Zeichenfolgen zu platzieren und sie für alle ns zu drucken . Als erstes stellen wir sicher, dass genügend leere Zeichenfolgen (Gesamtlänge der eingegebenen Zeichenfolgen) []auf dem Stapel vorhanden sind, die abgelegt werden sollen. Dann führen wir die Eingabezeichenfolge aus und sehen, wie viele []auf dem Stapel übrig sind. Die ursprüngliche Stringlänge wird davon abgezogen, um die (-ve) Gesamtzahl von ns zu erhalten. Der Rest ist arithmetisch für Mod 2 und die Ausgabe erfolgt direkt als ASCII yoder 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

Probieren Sie es online!

Japt , 8 Bytes

"yn"gUèn

Probieren Sie es online!

Erläuterung:

"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 verwendet Index-Wrapping. Wenn also etwas Uènzurückgegeben wird 2, wird es zurückgegeben, ywenn das Zeichen abgerufen wird "yn".

Perl 6 , 21 Bytes

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

Versuch es

Erweitert:

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

Probieren Sie es online!

Java 8, 35 Bytes

Ein Entscheider für eine reguläre Sprache! Ich kann das machen.

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

Probieren Sie es online

J , 10 9 Bytes

{&'ny'@=/

Probieren Sie es online!

R , 46 44 Bytes

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

Probieren Sie es online!

2 Bytes weniger dank Giuseppe und ngm. Port of the Octave Antwort von Luis Mendo.

Japt, 9 Bytes

Oliver hat mich bis zur kürzesten Lösung geschlagen, also sind hier ein paar, die nur ein Byte länger sind.

B*aUèÍu¹d

Versuch es

#ndB*UèÍv

Versuch es

Erklärungen

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

Probieren Sie es online!

Ich glaube, dies ist das kürzestmögliche Programm, da eine Ein-Zeichen-Ersetzung entweder nutzlos ist (wenn Sie etwas an seiner Stelle einfügen) oder verhindert, dass es eine Ausgabe ist (wenn Sie nichts einfügen). Dies sollte jedoch minimal sein, da das Programm die beiden Zeichenfälle behandeln muss.

Entfernt zuerst alle ys von einem n. Ersetzt dann das Doppelte ns durch ys und nutzt die LTR-Substitution. In diesem Stadium gibt es viele ys gefolgt von höchstens einem n; wir deduplizieren die ys und wenn es eine nVerwendung gibt, wischen sie die letzte yauf.

MATL , 8 Bytes

Qs'ny'w)

Probieren Sie es online!

2 Bytes gespart dank Luis Mendo! Ich habe zuvor den Befehl explicit modulus verwendet, um den Index in den Bereich zu bringen 1,2.

Erläuterung

Dies nutzt die Tatsache, dass MATL eine modulare Indizierung hat, was bedeutet, dass das 1., 3., 5. ... Element des Strings nydasselbe ist ( n). Sind also das 2., 4., 6. ... Element des Strings ( 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]

Probieren Sie es online!

Retina , 11 Bytes

y

nn

^$
y

Probieren Sie es online!

Gelee ,  8  7 Bytes

O‘Sị⁾ny

Probieren Sie es online!

05AB1E , 8 Bytes

'n¢„ynsè

Probieren Sie es online!

Java (OpenJDK 8) , 143 Byte

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

Probieren Sie es online!

Und wenn wir den Input als Liste nehmen:

Java (OpenJDK 8) , 118 Byte

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

Probieren Sie es online!

Erläuterung:

(Eingabe als 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]}

Probieren Sie es online!

Ein Lambda, der eine Schnur nimmt und eine Schnur zurückgibt.

Cubix , 24 20 Bytes

Es ist schon eine Weile her, seit ich mit Cubix gespielt habe, also ...

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

Probieren Sie es online!

Ziemlich naive Implementierung, die die Zeichenfolge durchläuft und den Charakter mit dem aktuellen Ergebnis vergleicht.

Interaktive Demo

Dies wird wie folgt auf den Würfel gewickelt

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

• W ip nach links verschieben
• i Erhalte den Anfangsbuchstaben
• i? Hole Charakter und teste auf EOI (-1), auch Start der Schleife
  • Wenn EOI ;o@TOS entfernen, TOS als Zeichen ausgeben und beenden .
• sonst -W!subtrahieren, ip nach links verschieben, auf wahrheit prüfen
  • wenn wahrheitsgemäß, 'nschieben Sie das Zeichen n zu TOS
  • Wenn Falsey |!'yreflektiert, teste und schiebe das Zeichen y zu TOS
• v'.;wumleiten um den Würfel schieben und entfernen a. Charakter und rechts zurück in die Schleife verschieben

Scala, 50 Bytes

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

Befunge-98 , 13 Bytes

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

Probieren Sie es online!

Invertiert grundsätzlich eine 0 für jeden nEingang und noch einmal für einen guten Takt und gibt dann yfür 1und nfür aus0

~     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

Sauber , 26 23 Bytes

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

Probieren Sie es online!

JavaScript, 39 37 Bytes

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

Einfache Reduktionsfunktion nach Aufteilen der Eingabezeichenfolge.

C (gcc) , 52–50 Bytes

Danke an @Neil für die Vorschläge.

Ich habe mir die Lösung des Zählens von ns geliehen , aber anstatt eine Zählung durchzuführen, wechsle ich einfach zwischen dem Anfangszustand und seinem Inversen auf ein n.

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

Probieren Sie es online!

Kotlin , 32 Bytes

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

Probieren Sie es online!