Determinare Sì o No?

19

Dopo aver inserito una stringa [lunghezza 1-20], contenente solo i caratteri y per yes e n per no, il programma dovrebbe generare il risultato (y o n). Esempio di input: yynynynnyverrebbe emesso y.

Il risultato è determinato combinando y's e n's nel modo seguente:

  • y es e n o uguali n o

  • y es e y es uguale y es

  • n o e n o uguale y es

Se la stringa contiene più di 2 caratteri (probabilmente ...), il calcolo sarebbe lo stesso. Esempi:

  • y es e y es e n o uguali n o (perché i no si fonde con i primi sì a no. Poi ci sono no e sì a sinistra e la stessa cosa accade di nuovo)

  • n o e n o e n o uguale a n o (i primi due no si uniscono a sì, quindi ci sono sì e no rimasti, che emergono a no)

Esempio di input con output:

  • yynynynynyyn = n

Suggerimento: tieni presente che l'ordine dei caratteri su cui funziona il tuo programma non importa. (ad esempio puoi leggere l'input da dietro o da dietro, mescolare le lettere, ordinarle, qualunque cosa. Ciò che conta è l'output corretto) divertiti!

Criteri vincenti: si tratta di code-golf , quindi vince il codice più breve in byte.

code-golf  decision-problem 
— Squareoot
fonte
3
Congratulazioni per la prima sfida con specifiche chiare! (anche se è un peccato che ad alcuni membri della community non piacciano le sfide "troppo banali" ...)
— user202729
3
— user202729
7
Possiamo produrre una coppia alternativa? Dire 1per ye 0per n.
— Oliver,
5
Possiamo prendere un input come un elenco di caratteri, cioè["y", "n", "n"]
— Okx,
3
Dato che il duplicato di questa sfida è stato fortemente ridimensionato, non credo sia molto utile chiuderlo come duplicato. Semmai, la sfida più vecchia dovrebbe essere un duplicato di questa poiché è politica di lasciare aperta la sfida migliore . Ho riaperto questa sfida
— DJMcMayhem

Risposte:

9

Carbone , 6 byte

§yn№Ｓn

Provalo online! Il collegamento è alla versione dettagliata del codice. Spiegazione:

    Ｓ   Input string
   № n  Count number of `n`s
§yn     Circularly index into string `yn`
        Implicitly print appropriate character
— Neil
fonte
1
Spiega come funziona, per favore?
— Malady,
@Malandy Link è la versione dettagliata del codice.
— Adám,
1
@Adám In realtà di solito ne aggiungo uno, tuttavia l'ho appena interrotto in una pausa di lavoro e ho dimenticato di modificarne uno.
— Neil
14

Ottava , 29 27 byte

Grazie a @RickHithcock per aver segnalato un errore, ora corretto. Inoltre, 2 byte di sconto grazie a @StewieGriffin!

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

Provalo online!

Spiegazione

Il punto di codice ASCII di 'y'è dispari e quello di 'n'è pari. Il codice

  1. aggiunge 1ad ogni carattere nella stringa di input per rendere 'y'pari e 'n'dispari;
  2. calcola la somma;
  3. riduce il risultato a 1se pari, 2se dispari;
  4. indici (basati su 1) nella stringa 'yn'.
— Luis Mendo
fonte
Probabilmente mi manca qualcosa di ovvio, ma questo sembra funzionare allo stesso modo in alcuni casi di test limitati per -4 byte. Probabilmente è terribilmente sbagliato perché non conosco Octave!
— Dom Hastings,
2
@DomHastings Non è riuscito per yynynynny indicato nell'OP, dovrebbe restituire y, ma restituisce n
— Skidsdev,
9

JavaScript (ES6), 28 byte

Accetta l'input come stringa.

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

Provalo online!

JavaScript (ES6), 30 byte

Accetta input come una matrice di caratteri.

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

Provalo online!

— Arnauld
fonte
31:: s=>'yn'[s.match(/n/g).length&1]P
— ASCII
@ ASCII-only Ciò fallirebbe su stringhe che non ne contengono almeno una n.
— Arnauld,
Oh, lo sarebbe. Oops> _>
— ASCII
8

Haskell , 33 28 byte

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

Indicizza il conteggio di n nell'elenco infinito "ynynynyn ...". L'approccio precedente (33 byte) era piegare coppie di elementi diversi su n, altrimenti y:

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

Provalo online!

— Angs
fonte
1
L'approccio precedente può essere eseguito in 30 byte. Provalo online!
— Mago del grano,
7

Gelatina , 7 byte

ċ”nị⁾ny

Provalo online!

ċ numero ount di “n , ho NDICE nella stringa ⁾ny . (con modulo 2)

ċḢịɗ⁾ny

Provalo online!

{ Ċ il numero ount di prendere la H ead, poi ho NDICE in} stringa ⁾ny .

OCSị⁾ny

Provalo online!

Simile alla risposta di Ottava sopra. Calcola il valore O , prendi il complemento C (per ogni valore ord x calcola 1-x ), S um, quindi ị ndex nella stringa ⁾ny .

— user202729
fonte
Era la mia soluzione fasulla che mi confondeva!
— Jonathan Allan,
7

APL (Dyalog Unicode) , 15 byte

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

Provalo online!

Nota: per impostazione predefinita TIO è ⎕IO = 1. Se eseguito con ⎕IO←0,

APL (Dyalog Unicode) , 13 byte

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

Provalo online!

Questa è la funzione XNOR (a volte chiamata EQV, specialmente nei vecchi BASIC.

Decomposizione / Analisi:

             ⍞  - 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
fonte
Mentre XOR ignora 0s e capovolge su 1s, XNOR ignora 1s e capovolge su 0s, “inizialmente” essendo a 1 invece di 0 come XOR.
— FrownyFrog,
@FrownyFrog - Suppongo che potresti guardarlo in quel modo ... o potresti vederlo come un controllo per vedere se entrambi i suoi valori di input sono uguali.
— Jeff Zeitlin,
6

Pyth, 9 byte

@"yn"l@\n

Provalo qui

Spiegazione

@"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 stringa di input viene letta da STDIN e deve essere nel modulo [yynynynynyyn].

dc non è noto per la sua gestione delle stringhe, ma qui abbiamo abbastanza per farlo funzionare. L'approccio qui è quello di contare le ns e produrre yse pari o nse dispari. Questo viene fatto eseguendo la stringa di input come macro. dcgenererà 'y' (0171) unimplementederrori per tutti gli ys e tenterà di far apparire le stringhe e stamparle per tutti gli ns. Quindi, per prima cosa ci assicuriamo di avere un sacco (lunghezza totale della stringa di input) di stringhe vuote []nello stack da pop. Quindi eseguiamo la stringa di input e vediamo quanti ne []rimangono nello stack. La lunghezza della stringa originale viene sottratta da questo per dare il numero (-ve) totale di ns. Il resto è aritmetico per fare mod 2 e far uscire l'uscita proprio come 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

Provalo online!

— Trauma digitale
fonte
6

Japt , 8 byte

"yn"gUèn

Provalo online!

Spiegazione:

"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 il wrapping dell'indice, quindi se Uènritorna 2, tornerà yquando ottiene il carattere da "yn".

— Oliver
fonte
Identico a quello che avevo.
— Shaggy,
5

Perl 6 , 21 byte

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

Provalo

Allargato:

{  # 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
fonte
5

Java 8, 35 byte

Un decisore per una lingua normale! Posso farlo.

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

Provalo online

— Jakob
fonte
5

J , 10 9 byte

{&'ny'@=/

Provalo online!

— FrownyFrog
fonte
1
Utilizzo molto intelligente della riduzione!
— Adám,
Soluzioni davvero carine!
— Galen Ivanov,
Forniresti una decomposizione delle / entrambe le soluzioni (come ho fatto con la mia soluzione APL)? (Per inciso, dovresti davvero pubblicare la soluzione APL come soluzione separata dalla soluzione J, anche se l'algoritmo è lo stesso.)
— Jeff Zeitlin,
{&'ny'@=/salva un byte.
— algoritmo
@algorithmshark ohhh grazie!
— FrownyFrog
3

R , 46 44 byte

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

Provalo online!

Giù 2 byte grazie a Giuseppe e ngm. Risposta di Port of the Octave di Luis Mendo.

— Jayce
fonte
È più facile lasciarsi ispirare dalla risposta di Ottava; mentre Octave ha il vantaggio che le stringhe vengono convertite più facilmente nei loro punti di codice, penso che si possa trasferire l'approccio lì per un paio di byte in meno.
— Giuseppe,
sum(utf8ToInt(scan(,""))%%2)%%2salva un byte.
— ngm
@ngm @Giuseppe purtroppo nè anche così bisogna aggiungere prima + 1 ..
— JayCe
3

Japt, 9 byte

Oliver mi ha battuto alla soluzione più breve, quindi ecco un paio che è solo un byte in più.

B*aUèÍu¹d

Provalo

#ndB*UèÍv

Provalo

spiegazioni

              :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
— ispido
fonte
3

/// , 24 byte

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

Provalo online!

Credo che questo sia il programma /// più breve possibile, poiché effettuare una sostituzione di un carattere o è inutile (se si inserisce qualcosa al suo posto) o impedisce che sia un output (se non si inserisce nulla). Tuttavia, poiché il programma deve affrontare i casi di due personaggi, questo dovrebbe essere minimo.

Innanzitutto rimuove tutti yi diritti di un n. Sostituisce quindi le doppie ns con ys, sfruttando la sostituzione LTR. In questa fase ci sono molti ys seguiti al massimo da uno n; dedupliciamo la ys e se c'è un nuso per pulire l'ultimo y.

— boboquack
fonte
3

MATL , 8 byte

Qs'ny'w)

Provalo online!

Salvato 2 byte grazie a Luis Mendo! In precedenza ho usato il comando esplicito modulo per ottenere l'indice nell'intervallo 1,2.

Spiegazione

Questo utilizza il fatto che MATL ha un indice modulare, il che significa che il 1 °, 3 °, 5 ° ... elemento della stringa nysono gli stessi ( n). Quindi sono il 2 °, 4 °, 6 ° ... elemento della stringa ( 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
fonte
1
'yn'3)dà y...? Questo è un design intelligente Luis =) Grazie per i suggerimenti! :)
— Stewie Griffin,
— Luis Mendo,
2

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

Provalo online!

E se prendiamo l'input come un elenco:

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

Provalo online!

Spiegazione:

(input come stringa)

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
fonte
Non è necessaria la parentesi ai tuoi ternary-if (-4 byte), puoi rimuovere lo spazio a char[]u(-1 byte); e if(u.length==1)può essere if(u.length<2)(-1 byte). Probabilmente c'è di più nel golf, ma non ho davvero il tempo in questo momento. :)
— Kevin Cruijssen
2

Cubix , 24 20 byte

È passato un po 'di tempo da quando ho suonato con Cubix, quindi ...

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

Provalo online!

Implementazione abbastanza ingenua che attraversa la stringa e confronta il carattere con il risultato corrente.

Demo interattiva

Questo si svolge sul cubo come segue

    i ;
    i w
W - ? ; o @ . .
! ' y v . n ' |
    . .
    . .
  • W sposta ip a sinistra
  • i ottieni il personaggio iniziale
  • i? ottenere carattere e test per EOI (-1), anche l'inizio del ciclo
    • se EOI ;o@rimuove TOS, genera TOS come carattere ed esce.
  • altrimenti -W!sottrarre, spostare ip a sinistra, verificare la verità
    • se in verità 'nspingere il personaggio n in TOS
    • se la falsità si |!'yriflette, prova e invia il carattere y a TOS
  • v'.;wreindirizzare attorno al cubo spingendo e rimuovendo a. personaggio e spostamento a destra nel loop
— MickyT
fonte
2

Scala, 50 byte

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

Befunge-98 , 13 byte

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

Provalo online!

Fondamentalmente inverte uno 0 per ogni ninput, e ancora una volta per una buona misura, quindi output yper 1e nper0

~     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
fonte
2

JavaScript, 39 37 byte

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

Semplice riduzione della funzione dopo aver diviso la stringa di input.

— user3335941
fonte
1
Benvenuti in PPCG! Il codice presuppone che l'input sia nella variabile s, che qui non è un metodo di input valido . Puoi invece rendere la tua risposta una funzione lambda prendendo l'input come argomento anteponendo la s=>tua risposta per 42 byte.
— dzaima,
suggerimento golf: sostituire s.split('')con [...s]per 37 byte:s=>[...s].reduce((x,y)=>x==y?'y':'n')
— dzaima,
2

C (gcc) , 52 50 byte

Grazie a @Neil per i suggerimenti.

Ho preso in prestito la soluzione del conteggio di ns, ma invece di mantenere un conteggio, mi giro tra lo stato iniziale e il suo inverso su un n.

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

Provalo online!

— ErikF
fonte
*a&1?0:23salva un byte e ne return isalva un altro.
— Neil,
Suggeriscii;f(char*a){for(i=*a;*++a;i^=*a&1?:23);a=i;}
— plafoniera il
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.