Descrição do Desafio:

Escreva um programa que solicite entrada ao usuário. O usuário digitará Goodou Bad. Você não precisa dar suporte a nenhuma outra entrada. Se o usuário entrar Good, imprima Bade vice-versa (para stdout etc).

Notas:

1) Você não pode usar nenhum outro par de duas palavras.

2) Seu programa precisa solicitar e imprimir apenas uma vez.

3) Você não precisa exibir a sequência de prompt.

4) A saída deve aparecer separada da entrada por qualquer meio.

5) Nenhuma função é permitida aceitando o valor e retornando o resultado; O usuário deve interagir com o programa.

Boa sorte!

Python 3 ,  32  31 bytes

exit('GBoaodd'['G'<input()::2])

Experimente online!

Quão?

Testa se a entrada é 'Good'comparada 'G'<input().

Usa o fato de que em Python False==0e True==1para usar o resultado como o startíndice de uma fatia de 'GBoaodd'usar um indefinido stope um stepde 2com 'GBoaodd'[start:stop:step].

Imprime em STDERR (salvando um byte exitno lugar de print).

APL (Dyalog Unicode) , ^{SBCS de} 13 bytes

Programa completo que solicita a entrada de stdin e imprime no stdout.

'GooBad'~¯1↓⍞

Experimente online!

⍞ prompt para entrada de stdin; GoodouBad

¯1↓ solte o último caractere ( d); GooouBa

'GooBad'~ multiset subtrai esses caracteres desses; BadouGood

Máquina de Turing, mas muito pior , 405 bytes

0 0 0 1 1 0 0
1 1 1 1 2 0 0
0 2 0 1 3 0 0
0 3 0 1 4 0 0
0 4 0 1 5 0 0
1 5 0 1 6 0 0
0 5 1 1 h 0 0
1 6 1 1 7 0 0
1 7 0 1 8 1 0
0 8 0 1 9 0 0
1 9 1 1 9 0 0
0 9 0 1 a 0 0
1 a 0 1 a 0 0
0 a 0 0 b 0 0
0 b 1 1 c 1 0
0 c 0 0 d 0 0
1 d 0 0 e 0 0
0 e 0 0 f 0 0
0 f 1 1 g 1 1
1 h 1 1 i 0 0
0 i 1 1 j 1 0
0 j 0 1 k 0 0
1 k 1 1 k 0 0
0 k 0 1 l 0 0
0 l 1 1 l 0 0
1 l 1 0 m 1 0
1 m 1 1 n 1 0
1 n 1 1 o 0 0
0 o 0 1 p 1 1

Experimente online!

Bem, isso levou um tempo.

EXPLICAÇÃO INACABADA :

0 0 0 1 1 0 0 Start going to the sixth bit
1 1 1 1 2 0 0
0 2 0 1 3 0 0
0 3 0 1 4 0 0
0 4 0 1 5 0 0 End going to the sixth bit
1 5 0 1 6 0 0 If the sixth bit is 1, then it is Good. Start transforming "G" to "B" and go to state 6
0 5 1 1 h 0 0 Else, it is Bad. Start transforming "B" to "G" and go to state h
1 6 1 1 7 0 0 Keep on transforming "G" to "B"
1 7 0 1 8 1 0 End transforming and print "B"
0 8 0 1 9 0 0 We are in the first "o" in "Good". Start moving into the 5th bit.
1 9 1 1 9 0 0
0 9 0 1 a 0 0
1 a 0 1 a 0 0 Do some looping magic and start transforming "o" to "a"
0 a 0 0 b 0 0 End looping magic
0 b 1 1 c 1 0 End transforming and print "a"
0 c 0 0 d 0 0 
1 d 0 0 e 0 0 Start transforming "a" to "d"
0 e 0 0 f 0 0 
0 f 1 1 g 1 1 Stop transforming, print "d", and terminate
1 h 1 1 i 0 0 Continue transforming "B" to "G"
0 i 1 1 j 1 0 Stop transforming and print out "G"
0 j 0 1 k 0 0 Start going into position to print out "oo"
1 k 1 1 k 0 0
0 k 0 1 l 0 0 Move more efficiently using LOOPING MAGIC1!1111111 
0 l 1 1 l 0 0 looping magic end, start transforming
1 l 1 0 m 1 0 end transforming and print out out "o"
1 m 1 1 n 1 0 print out "o" again
1 n 1 1 o 0 0 get into the "d" byte
0 o 0 1 p 1 1 print "d" and execute YOU HAVE BEEN TERMINATED

bash, 20 bytes

sed s/$1//<<<GoodBad

Experimente online!

8088 Assembly, IBM PC DOS, 25 bytes

Desmontado:

BA 0110     MOV  DX, OFFSET GB  ; point DX to 'Good','Bad' string 
D1 EE       SHR  SI, 1          ; point SI to DOS PSP (80H) 
02 04       ADD  AL, [SI]       ; add input string length to AL, set parity flag 
7B 02       JNP  DISP           ; if odd parity, input was 'Bad' so jump to display 'Good'
02 D0       ADD  DL, AL         ; otherwise add string length as offset for 'Bad' string 
        DISP: 
B4 09       MOV  AH, 9          ; DOS display string function 
CD 21       INT  21H            ; call DOS API, write string to console 
C3          RET                 ; return to DOS 
        GB  DB  'Good$','Bad$'

Explicação:

Examina o comprimento da string de entrada (mais o espaço inicial) que o DOS armazena no endereço de memória 80He o adiciona AL(inicialmente 0 pelo DOS ). Se houver um número ímpar de 1bits na representação binária do comprimento da string, o sinalizador de paridade da CPU será definido como ímpar e vice-versa. Portanto, o ' Bad'comprimento da string de entrada 4( 0000 0100) é paridade ímpar e a string de entrada ' Good'é 5( 0000 0101) é paridade par.

DXé inicialmente definido para apontar para a string 'Good$Bad$'e, se a paridade for par (o que significa que a entrada foi ' Good'), avance o ponteiro da string por esse comprimento ( 5), de modo que agora aponte para 'Bad$'. Se a paridade for ímpar, não faça nada, pois já aponta para 'Good$'. Em seguida, use a API do DOS para exibir uma $sequência terminada no console.

Exemplo:

Faça o download e teste o GOODBAD.COM ou crie a partir do xxddump:

0000000: ba10 01d1 ee02 047b 0202 d0b4 09cd 21c3  .......{......!.
0000010: 476f 6f64 2442 6164 24                   Good$Bad$

Geléia , 8 bytes

“Ċ³ṫ³»œṣ

Experimente online!

Um programa completo esperando uma string formatada em Python como argumento

Quão?

“Ċ³ṫ³»œṣ - Main Link: list of characters, S
“Ċ³ṫ³»   - compression of dictionary words "Good"+"Bad" = ['G','o','o','d','B','a','d']
      œṣ - split on sublists equal to S
         - implicit, smashing print

Python 3, 38. 37. 34 33 bytes

exit("C">input()and"Good"or"Bad")

Experimente online!

exit() : retorna um código de saída como saída

"C">input(): Verifica se a entrada é maior que a sequência Cna ordem alfabética

and"Good": Se o resultado for True, retornará comGood

or"Bad" : Caso contrário, retorna com Bad

C, 39 38 bytes

main(){puts("Good\0Bad"+getchar()%6);}

Experimente online!

Guardou um byte graças a @tsh.

brainfuck , 72 bytes

,>+++++>,>,>,>,[<<<<[-<->>---<]<.>>+.>>.>>>]<[<<<[-<+>>+++<]<.>>-..>.>>]

Experimente online!

Explicação:,> +++++>,>,>,>,

Leia: "G", 5, "o", "o", "d" ou "B", 5, "a", "d", 0

[<<<< [- <->> --- <] <. >> +. >>. >>>] Se o último caractere não for zero:

Substrato 5 da primeira célula uma vez e da terceira célula três vezes. Célula de incremento 3

Células de saída 1, 3, 5.

<[<<< [- <+ >> +++ <] <. >> - ..>. >>]

Caso contrário, adicione 5 à primeira célula uma vez e à terceira célula três vezes.

Célula de redução 3

Células de saída 1, 3, 3, 4

Haskell, 36 34 bytes

interact g
g"Bad"="Good"
g _="Bad"

Experimente online!

Edit: -2 bytes graças a @cole

R , 42 37 35 32 bytes

-10 graças a Giuseppe e AkselA!

`if`(scan(,'')>'C','Bad','Good')

Experimente online!

sed , 21 16 13 bytes

Obrigado @Cowsquack pelas dicas.

/B/cGood
cBad

Experimente online! Experimente online! Experimente online!

TIL cirá causar um curto-circuito na análise da linha atual.

JavaScript 31 bytes

Eu gosto da resposta de Arnauld, mas gostaria que ela aceitasse a entrada do usuário e pudesse ser executada no StackExchange da seguinte maneira:

alert(prompt()[3]?'Bad':'Good')

Befunge-93 , 20 18 bytes

"BadooGB"~-_#@,,<,

Experimente online!

-2 bytes graças a Jo King

Ruby , 22 bytes

->n{n>?F?"Bad":"Good"}

Experimente online!

05AB1E , 10 9 bytes

”‚¿‰±”áIK

-1 byte graças a @Emigna .

Experimente online ou verifique os dois casos de teste .

Explicação:

”‚¿‰±”     # Push dictionary string "Good Bad"
      á    # Only keep letters (to remove the space)
       IK  # Remove the input
           # (output the result implicitly)

Veja esta dica 05AB1E meu (seção Como usar o dicionário? ) , Para entender por que ”‚¿‰±”é "Good Bad".

Java (JDK) , 124 bytes

interface G{static void main(String[]a){System.out.print(new java.util.Scanner(System.in).next().length()>3?"Bad":"Good");}}

Experimente online!

Provavelmente, ainda há espaço para melhorias, mas sou totalmente novo no código do golfe.

Ruby, 30 28 bytes

puts %w|Good Bad|-gets.split

Não é o golfe, mas eu gosto do abuso de divisão para remover a nova linha à direita e converter em uma matriz em uma chamada.

EDITE -2 bytes graças à sugestão da Value Ink!

Linguagem de programação de Shakespeare , 582 bytes

(Espaço em branco adicionado para facilitar a leitura)

G.Ajax,.Puck,.Act I:.Scene I:.[Enter Ajax and Puck]Ajax:
Open mind.Be you nicer the sum ofa big cat the cube ofa big big cat?If solet usScene V.
You is the sum ofthe sum ofyou a big big cat a cat.Speak thy.You is the sum ofyou twice twice twice the sum ofa big big cat a cat.Speak thy.Speak thy.You is the square oftwice the sum ofa big big cat a cat.Let usScene X.
Scene V:.Ajax:
You is the sum ofthe sum ofyou a big big pig a pig.Speak thy.You is the sum ofyou the sum ofa big big big big big cat a pig.Speak thy.You is the sum ofyou the sum ofa big cat a cat.
Scene X:.Ajax:Speak thy.

Experimente online!

Recebo a primeira letra da entrada com Open mind. Então eu preciso determinar o que é. De todos os números entre B= 66 e G= 71, meu calculador bruto diz que 66 é o mais curto para escrever ( the sum ofa big cat the cube ofa big big cat), então eu comparo a primeira letra da entrada com 66. A cena que eu continuo imprimindo Goodou a cena V imprimem Bad.

Retina 0.8.2 , 20 bytes

oo
o
T`G\oaB`Ro
o
oo

Experimente online! O link inclui o conjunto de testes. Explicação:

oo
o

Transformar Goodem God.

T`G\oaB`Ro

Transponha as letras GoaBcom o verso dessa lista, trocando Gcom Be ocom a, ou seja, trocando Godcom Bad.

o
oo

Transformar Godem Good.

Stax , 9 8 bytes

çEF♫a║▬h

Execute e depure

Essencialmente replace("BadGood", input, "").

Multiset xor com "GooBa". Algoritmo copiado literalmente de Luis Mendo

Excel, 24 bytes

=IF(A1>"C","Bad","Good")

Usando a <Csugestão de @ MilkyWay90 .

PHP ,26 23 bytes

Um ternário é apenas mais barato:

<?=$argn==Bad?Goo:Ba?>d

Experimente online!

Resposta original, 26 bytes

<?=[Ba,Goo][$argn==Bad]?>d

Experimente online!

Ou 21 bytes (mas essa é basicamente a resposta de Arnauld )

<?=$argn[3]?Ba:Goo?>d

Experimente online!

Geléia , 9 bytes

“GooBa”œ^

Experimente online!

Explicação

Diferença simétrica multiset entre a entrada e a sequência “GooBa”.

PowerShell , 22 20 bytes

'Good','Bad'-ne$args

Experimente online!

-2 bytes graças ao mazzy

Barril , 22 bytes

?^_^_o=[^aB^_|^ooG^]

brainfuck , 52 bytes

,>,,<<,[>-----.<---.+++.<<]>[+++++.+[-<-->]<-..>>.>]

Experimente online!

Depende de Má ser uma letra menor que Boa, portanto, a última entrada está vazia.

Explicação:

,>,,<<,       Get input into the first three cells
[             If the last letter was not empty (i.e. Good)
 >-----.      Decrement 'G' to 'B' and print
 <---.        Decrement 'd' to 'a' and print
 +++.         Increment back to 'd' and print
>>]           End loop
>[            If it is Bad instead
 +++++.       Increment 'B' to 'G' and print
 +[-<-->]<-.. Manipulate into  'o' and print twice
 >>.          Print 'd'
>]            End loop

Boolfuck , 47 bytes

+>,+;>,;,+;>;;;+;+;+[;<;;;,;+;;+;<];;+;+;;+;;+;

Experimente online!

Usa o fato de que você pode basicamente receber a entrada como bits e inverter certos bits para transformá-la na letra oposta.

Explicação:

+>,+;>,;,+;>;;;+;+;+    Print the first letter by inverting the first and third bits of the input
                        'B' = 01000010
                        'G' = 11100010
                        This leaves the tape as
                            1 1 1 1' in the case of Bad
                            1 0 0 1' in the case of Good
                        By making the center cells the inverted bits
[;<;;;,;+;;+;<]         Print the center letters by looping over the two pairs of cells
                        0 1' results in 'a' = 10000110
                        1 1' results in 'o' = 11110110 by printing the 1 in the 2-4th places
                        1 1 1 1' loops twice, while 1 0 0 1' only loops once
;;+;+;;+;;+;            Finally print 'd' = 00100110

Barril , -rt 20 17 15 13 8 7 bytes (SBCS)

-᠀‘5ƳP↫

Transpiles para:

from KegLib import *
from Stackd import Stack
stack = Stack()
printed = False
iterable(stack, 'GoodBad')
string_input(stack)
maths(stack, '-')

if not printed:
    printing = ""
    for item in stack:
        if type(item) in [str, Stack]:
            printing += str(item)
        elif type(item) == Coherse.char:
            printing += item.v

        elif item < 10 or item > 256:
            printing += str(item)
        else:
            printing += chr(item)
    print(printing)

É uma porta da resposta 05AB1E. Essencialmente, ele:

• Empurra a corda "GoodBad"
• Recebe entrada como uma string
• Subtrai a entrada da string pressionada. Isso funciona substituindo a primeira instância da entrada GoodBadpor nada.
• Imprime implicitamente a sequência resultante.
• A -rtbandeira diz ao Keg para ler os tokens da direita para a esquerda.

Histórico de respostas

?G=[øBad|ø‘5Ƴ

Transpiles para o seguinte:

from KegLib import *
from Stackd import Stack
stack = Stack()
printed = False
Input(stack)
character(stack, 'G')
comparative(stack, '=')
if bool(stack.pop()):
    empty(stack)
    character(stack, 'B')
    character(stack, 'a')
    character(stack, 'd')

else:
    empty(stack)
    iterable(stack, 'Good')

if not printed:
    printing = ""
    for item in stack:
        if type(item) is Stack:
            printing += str(item)

        elif type(item) is str:
            printing += custom_format(item)
        elif type(item) == Coherse.char:
            printing += item.v

        elif item < 10 or item > 256:
            printing += str(item)
        else:
            printing += chr(item)
    print(printing)

Explicação

?G=[øBad|ø‘5Ƴ

?            #Get input from user
 G=          #If the first letter is "G"
   [øBad     #Clear the stack and push "Bad"
        |    #Else,
         ø‘5Ƴ#Clear the stack and push the compressed string "Good"

Carvão vegetal , 13 bytes

¿⁻ＬＳ³Ba¦Goo¦d

Experimente online!

Explicação:

¿⁻ＬＳ³          If length of input minus 3 is truthy:
      Ba¦         print Ba
         Goo¦       else print Goo
             d        print d