Determinando Sim ou Não?

19

Depois de inserir uma string [comprimento 1-20], contendo apenas os caracteres y para yes en para não, seu programa deve gerar o resultado (y ou n). Exemplo de entrada: yynynynnygeraria y.

O resultado é determinado pela combinação de y e n da seguinte maneira:

  • y es e n o igual a n o

  • y es e y es é igual a y es

  • n o e n o é igual a y es

Se a sequência contiver mais de 2 caracteres (provavelmente ...), o cálculo será o mesmo. Exemplos:

  • y es e y es e n o igual a n (porque o no se funde com o primeiro sim a não. então não há nenhum e sim sobrando e a mesma coisa acontece novamente)

  • n o e n o e n o é igual a n (os dois primeiros não se fundem em sim, então há sim e não sobrando, que emergem em não)

Exemplo de entrada com saída:

  • yynynynynyyn = n

Dica: lembre-se de que a ordem dos caracteres do seu programa não funciona. (por exemplo, você pode ler a entrada de trás ou de trás, misturar as letras, classificar, o que for. O que conta é a saída correta) divirta-se!

Critérios de vitória: trata-se de código-golfe , pelo que o código mais curto em bytes ganha.

code-golf  decision-problem 
— Squareoot
fonte
3
Parabéns pelo primeiro desafio com especificações claras! (embora seja lamentável que alguns membros da comunidade não gostem de desafios "muito triviais" ...) #
— user202729
3
— User202729
7
Podemos produzir um par alternativo? Diga 1para ye 0para n.
— 22418 Oliver
5
Podemos tomar entrada como uma lista de caracteres, ou seja,["y", "n", "n"]
— Okx
3
Como a duplicação desse desafio foi fortemente reduzida, não acho muito útil encerrá-la como duplicada. Se qualquer coisa, o desafio mais velho deve ser um duplicado de um presente desde a sua política de deixar o melhor desafio aberto Eu reaberto este desafio
— DJMcMayhem

Respostas:

9

Carvão , 6 bytes

§yn№Ｓn

Experimente online! Link é a versão detalhada do código. Explicação:

    Ｓ   Input string
   № n  Count number of `n`s
§yn     Circularly index into string `yn`
        Implicitly print appropriate character
— Neil
fonte
1
Explique como funciona, por favor?
— Malady
@ Link
— Adám 23/05/19
1
@ Adám Na verdade, eu costumo acrescentar um, porém eu tinha apenas correu esta fora em uma ruptura de trabalho e esqueceu de editar um no.
— Neil
14

Oitava , 29 27 bytes

Obrigado a @RickHithcock por apontar um erro, agora corrigido. Além disso, com 2 bytes de desconto, graças a @StewieGriffin!

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

Experimente online!

Explicação

O ponto de código ASCII de 'y'é ímpar e o de 'n'é par. O código

  1. adiciona 1a cada caractere na sequência de entrada para tornar 'y'par e 'n'ímpar;
  2. calcula a soma;
  3. reduz o resultado para 1se for par, 2se for ímpar;
  4. índices (com base em 1) na cadeia 'yn'.
— Luis Mendo
fonte
Provavelmente estou perdendo algo óbvio, mas isso parece funcionar da mesma maneira em alguns casos de teste limitados para -4 bytes. Provavelmente está muito errado, porque eu não conheço Octave!
— Dom Hastings
2
@DomHastings Falha no yynynynny dado no OP, deve retornar y, mas retorna n
— Skidsdev 23/05
7

Geléia , 7 bytes

ċ”nị⁾ny

Experimente online!

não número de ”n , ” ndex na string ⁾ny . (com módulo 2)

ċḢịɗ⁾ny

Experimente online!

{ Ċ número ount de, pegue a H ead, então I NDEX em} corda ⁾ny .

OCSị⁾ny

Experimente online!

Semelhante à resposta do Octave acima. Calcular O rd valor, tomar a C omplement (para cada valor ord x calcule 1-x ), S um, então i NDEX em cadeia ⁾ny .

— user202729
fonte
Foi a minha solução falsa me confundindo!
— Jonathan Allan
7

APL (Dyalog Unicode) , 15 bytes

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

Experimente online!

Nota: O TIO é padronizado como ⎕IO = 1. Se executado com ⎕IO←0,

APL (Dyalog Unicode) , 13 bytes

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

Experimente online!

Essa é a função XNOR (às vezes chamada EQV, especialmente em BASICs antigos.

Decomposição / Análise:

             ⍞  - 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
Enquanto o XOR ignora 0s e vira em 1s, XNOR ignora 1s e vira em 0s, "inicialmente" sendo 1 e não 0 como XOR.
— FrownyFrog
@FrownyFrog - Suponho que você possa vê-lo dessa maneira ... ou pode ser visto como uma verificação para ver se os dois valores de entrada são os mesmos.
— Jeff Zeitlin
6

Pitão, 9 bytes

@"yn"l@\n

Experimente aqui

Explicação

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

String de entrada é lida a partir do STDIN e deve ser na forma [yynynynynyyn].

dc não é conhecido por seu tratamento de strings, mas temos aqui o suficiente para fazer com que isso funcione. A abordagem aqui é contar os se a nsaída yfor par ou nímpar. Isso é feito executando a sequência de entrada como uma macro. dcirá gerar 'y' (0171) unimplementederros para todos os se ytentar pop strings e imprimi-los para todos os ns. Portanto, primeiro garantimos que temos (comprimento total da string de entrada) de strings vazias []na pilha para aparecer. Em seguida, executamos a string de entrada e vemos quantas []restam na pilha. O comprimento da string original é subtraído para fornecer o número total de (-ve) ns. O resto é aritmético para fazer o mod 2 e ter a saída correta como 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

Experimente online!

— Trauma Digital
fonte
6

Japonês , 8 bytes

"yn"gUèn

Experimente online!

Explicação:

"yn"gUèn
"yn"       String literal - "yn"
    g      Return the char at index:   
      è      Number of matches where:
       n       "n" is found in
     U         Input

O Japt usa quebra de índice, portanto, se Uènretornar 2, retornará yao obter o char "yn".

— Oliver
fonte
Idêntico ao que eu tinha.
— Shaggy
5

Perl 6 , 21 bytes

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

Tente

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

Java 8, 35 bytes

Uma decisão para uma linguagem regular! Eu posso fazer isso.

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

Experimente Online

— Jakob
fonte
5

J , 10 9 bytes

{&'ny'@=/

Experimente online!

— FrownyFrog
fonte
1
Uso muito inteligente de redução!
— Adám 23/05/19
Soluções realmente agradáveis!
— Galen Ivanov
Você poderia fornecer uma decomposição das / ambas as soluções (como fiz com a minha solução APL)? (Aliás, você deve realmente colocar a solução APL como uma solução separada da solução J, mesmo que o algoritmo é o mesmo.)
— Jeff Zeitlin
{&'ny'@=/salva um byte.
— algorithmshark
@algorithmshark ohhh thanks!
— FrownyFrog
3

R , 46 44 bytes

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

Experimente online!

Abaixo de 2 bytes, graças a Giuseppe e ngm. Porto da Oitava resposta por Luis Mendo.

— JayCe
fonte
É mais fácil se inspirar na resposta da oitava; Embora o Octave tenha a vantagem de que as seqüências de caracteres são convertidas em seus pontos de código com mais facilidade, acho que você pode portar a abordagem para lá por alguns bytes.
— Giuseppe
sum(utf8ToInt(scan(,""))%%2)%%2salva um byte.
— Ng
@ngm @Giuseppe infelizmente né assim mesmo tem que adicionar + 1 em primeiro lugar ..
— Jayce
3

Japonês, 9 bytes

Oliver me levou para a solução mais curta, então aqui estão algumas que são apenas um byte a mais.

B*aUèÍu¹d

Tente

#ndB*UèÍv

Tente

Explicações

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

/// , 24 bytes

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

Experimente online!

Eu acredito que este é o programa mais curto possível ///, pois fazer uma substituição de um caractere é inútil (se você inserir algo em seu lugar) ou impede que ele seja uma saída (se você não inserir nada). No entanto, como o programa deve lidar com os dois casos de caracteres, isso deve ser mínimo.

Primeiro remove todos os ydireitos de um n. Em seguida, substitui ns duplo por ys, aproveitando a substituição LTR. Nesta fase, existem muitos ys seguidos por no máximo um n; desduplicamos os yse, se houver umn usá-lo para limpar o último y.

— boboquack
fonte
3

MATL , 8 bytes

Qs'ny'w)

Experimente online!

Guardado 2 bytes graças a Luis Mendo! Eu usei anteriormente o comando módulo explícito para obter o índice no intervalo 1,2.

Explicação

Isso usa o fato de que o MATL possui indexação modular, o que significa que o primeiro, terceiro, quinto ... elemento da sequência nyé o mesmo ( n). O mesmo ocorre com o 2º, 4º, 6º ... elemento da string ( 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...? Agora que design inteligente Luis =) Obrigado pelas dicas! :)
— Stewie Griffin
— 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;}}

Experimente online!

E se considerarmos a entrada como uma 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;}}

Experimente online!

Explicação:

(entrada como 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
}
— X1M4L
fonte
Você não precisa de parênteses no seu ternário-ifs (-4 bytes), pode remover o espaço em char[]u(-1 byte); e if(u.length==1)pode ser if(u.length<2)(-1 byte). Provavelmente há mais coisas para jogar golfe, mas eu realmente não tenho tempo agora. :)
— Kevin Cruijssen
2

Cubix , 24 20 bytes

Faz um tempo desde que eu joguei com o Cubix, então ...

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

Experimente online!

Implementação bastante ingênua que percorre a cadeia e compara o caractere com o resultado atual.

Demonstração interativa

Isso desenrola no cubo da seguinte maneira

    i ;
    i w
W - ? ; o @ . .
! ' y v . n ' |
    . .
    . .
  • W shift ip left
  • i obter o caractere inicial
  • i? obter caractere e testar EOI (-1), também iniciar o loop
    • se o EOI ;o@remover os TOS, envie-os como caractere e saia.
  • mais -W!subtraia, mude o ip para a esquerda, teste para a verdade
    • se for verdade, 'npressione o caractere n para TOS
    • se falsey |!'yrefletir, teste e envie o caractere y para TOS
  • v'.;wredirecionar ao redor do cubo empurrando e removendo a. personagem e mudando de volta para o loop
— MickyT
fonte
2

Scala, 50 bytes

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

Befunge-98 , 13 bytes

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

Experimente online!

Inverte basicamente um 0 para cada nentrada e, mais uma vez, para uma boa medida, em seguida, gera ypara 1e 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
— Brincadeira
fonte
2

JavaScript, 39 37 bytes

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

Função de redução simples após dividir a sequência de entrada.

— user3335941
fonte
1
Bem-vindo ao PPCG! Seu código assume que a entrada está na variável s, que não é um método de entrada válido aqui. Em vez disso, você pode transformar sua resposta em uma função lambda, recebendo a entrada como argumento, acrescentando s=>à sua resposta 42 bytes.
— Dzaima 23/05
sugestão golfe: substituir s.split('')com [...s]para 37 bytes:s=>[...s].reduce((x,y)=>x==y?'y':'n')
— dzaima
2

C (gcc) , 52 50 bytes

Obrigado a @Neil pelas sugestões.

Peguei emprestada a solução da contagem ns, mas, em vez de manter uma contagem, apenas alterno entre o estado inicial e seu inverso em um n.

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

Experimente online!

— ErikF
fonte
*a&1?0:23salva um byte e return isalva outro.
— Neil
Sugeriri;f(char*a){for(i=*a;*++a;i^=*a&1?:23);a=i;}
— roofcat 26/06
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.