Descripción del desafío:

Escriba un programa que le pida al usuario su aporte El usuario ingresará Goodo Bad. No tiene que admitir ninguna otra entrada. Si el usuario ingresa Good, imprima Bady viceversa (stdout, etc.).

Notas:

1) No puede usar ningún otro par de dos palabras.

2) Su programa solo tiene que preguntar e imprimir una vez.

3) No necesita mostrar la cadena de solicitud.

4) La salida debe aparecer separada de la entrada por cualquier medio.

5) No se permite ninguna función para aceptar el valor y devolver el resultado; El usuario debe interactuar con el programa.

¡Buena suerte!

Python 3 ,  32  31 bytes

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

Pruébalo en línea!

¿Cómo?

Comprueba si la entrada es 'Good'mediante comparación 'G'<input().

Utiliza el hecho de que en Python False==0y True==1para usar el resultado como el startíndice de una porción de 'GBoaodd'usar un undefined stopy a stepof 2with 'GBoaodd'[start:stop:step].

Imprime en STDERR (guardando un byte con exiten lugar de print).

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

Programa completo que solicita la entrada de stdin e imprime en stdout.

'GooBad'~¯1↓⍞

Pruébalo en línea!

⍞ solicitud de entrada de stdin; GoodoBad

¯1↓ suelte el último caracter ( d); GoooBa

'GooBad'~ multiset restan esos caracteres de estos; BadoGood

Máquina de Turing pero mucho peor , 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

Pruébalo en línea!

Bueno, esto tomó un tiempo.

EXPLICACIÓN SIN TERMINAR :

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

Pruébalo en línea!

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$'

Explicación:

Mira la longitud de la cadena de entrada (más el espacio inicial) que DOS almacena en la dirección de memoria 80Hy la agrega AL(inicialmente 0 por DOS ). Si hay un número impar de 1bits en la representación binaria de la longitud de la cadena, el indicador de paridad de la CPU se establece en impar y viceversa. Entonces, la ' Bad'longitud de la cadena de entrada 4( 0000 0100) es paridad impar y la cadena de entrada ' Good'es 5( 0000 0101) es paridad par.

DXinicialmente se establece para que apunte a la cadena 'Good$Bad$', y si la paridad es par (lo que significa que la entrada fue ' Good') avance el puntero de la cadena por esa longitud ( 5) para que ahora apunte a 'Bad$'. Si la paridad es extraña, no haga nada ya que ya apunta 'Good$'. Luego use la API de DOS para mostrar una $cadena terminada en la consola.

Ejemplo:

Descargue y pruebe GOODBAD.COM o compile desde el xxdvolcado:

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

Jalea , 8 bytes

“Ċ³ṫ³»œṣ

Pruébalo en línea!

Un programa completo que espera una cadena con formato Python como argumento

¿Cómo?

“Ċ³ṫ³»œṣ - 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")

Pruébalo en línea!

exit() : devuelve un código de salida como salida

"C">input(): Comprueba si la entrada es más grande que la cadena Cen orden alfabético

and"Good": Si el resultado es True, entonces regresa conGood

or"Bad" : De lo contrario, vuelve con Bad

C, 39 38 bytes

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

Pruébalo en línea!

Guardado un byte gracias a @tsh.

brainfuck , 72 bytes

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

Pruébalo en línea!

Explicación:,> +++++>,>,>,>,

Lea ya sea: "G", 5, "o", "o", "d" o "B", 5, "a", "d", 0

[<<<< [- <->> --- <] <. >> +. >>. >>>] Si el último carácter no es cero:

Resta 5 de la primera celda una vez y de la tercera celda tres veces. Incremento celda 3

Celdas de salida 1, 3, 5.

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

De lo contrario, agregue 5 a la primera celda una vez y a la tercera celda tres veces.

Decremento celda 3

Celdas de salida 1, 3, 3, 4

Haskell, 36 34 bytes

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

Pruébalo en línea!

Editar: -2 bytes gracias a @cole

R , 42 37 35 32 bytes

-10 gracias a Giuseppe y AkselA!

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

Pruébalo en línea!

sed , 21 16 13 bytes

Gracias @Cowsquack por las sugerencias.

/B/cGood
cBad

Pruébalo en línea! Pruébalo en línea! Pruébalo en línea!

TIL ccortocircuitará el análisis de la línea actual.

JavaScript 31 bytes

Me gusta la respuesta de Arnauld, pero me gustaría que acepte la entrada del usuario y se pueda ejecutar en StackExchange de esta manera:

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

Befunge-93 , 20 18 bytes

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

Pruébalo en línea!

-2 bytes gracias a Jo King

Ruby , 22 bytes

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

Pruébalo en línea!

05AB1E , 10 9 bytes

”‚¿‰±”áIK

-1 byte gracias a @Emigna .

Pruébelo en línea o verifique ambos casos de prueba .

Explicación:

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

Ver este consejo 05AB1E mío (sección Cómo usar el diccionario? ) , Para entender por qué ”‚¿‰±”es "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");}}

Pruébalo en línea!

Lo más probable es que todavía haya margen de mejora, pero soy completamente nuevo en el golf de código.

Rubí, 30 28 bytes

puts %w|Good Bad|-gets.split

No es el más golfista, pero me gusta el abuso de split para eliminar la nueva línea final y convertirla en una matriz en una sola llamada.

¡EDITE -2 bytes gracias a la sugerencia de Value Ink!

Lenguaje de programación Shakespeare , 582 bytes

(Espacio en blanco agregado para facilitar la lectura)

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.

Pruébalo en línea!

Me sale la primera letra de la entrada con Open mind. Entonces necesito determinar qué es. De todos los números entre B= 66 y G= 71, mi fuerza bruta dice que 66 es el más corto de escribir ( the sum ofa big cat the cube ofa big big cat), por lo que comparo la primera letra de la entrada con 66. La escena I continúa imprimiendo Goodo la escena V imprime Bad.

Retina 0.8.2 , 20 bytes

oo
o
T`G\oaB`Ro
o
oo

Pruébalo en línea! El enlace incluye un conjunto de pruebas. Explicación:

oo
o

Conviértete Gooden God.

T`G\oaB`Ro

Transponga las letras GoaBcon el reverso de esa lista, intercambiando así Gcon By ocon a, es decir, intercambiando Godcon Bad.

o
oo

Conviértete Goden Good.

Stax , 9 8 bytes

çEF♫a║▬h

Ejecutar y depurarlo

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

Multiset xor con "GooBa". Algoritmo copiado textualmente de Luis Mendo

Excel, 24 bytes

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

Usando la <Csugerencia de @ MilkyWay90 .

PHP ,26 23 bytes

Un ternario es simplemente más barato:

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

Pruébalo en línea!

Respuesta original, 26 bytes.

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

Pruébalo en línea!

O 21 bytes (pero esta es básicamente la respuesta de Arnauld )

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

Pruébalo en línea!

Jalea , 9 bytes

“GooBa”œ^

Pruébalo en línea!

Explicación

Diferencia simétrica de varios conjuntos entre la entrada y la cadena “GooBa”.

PowerShell , 22 20 bytes

'Good','Bad'-ne$args

Pruébalo en línea!

-2 bytes gracias a mazzy

Barril , 22 bytes

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

brainfuck , 52 bytes

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

Pruébalo en línea!

Se basa en que Bad sea una letra más corta que Good, por lo que la última entrada está vacía.

Explicación:

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

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

Pruébalo en línea!

Utiliza el hecho de que básicamente puedes tomar la entrada como bits y luego invertir ciertos bits para convertirla en la letra opuesta.

Explicación:

+>,+;>,;,+;>;;;+;+;+    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 a:

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)

Es un puerto de la respuesta 05AB1E. Esencialmente:

• Empuja la cuerda "GoodBad"
• Toma la entrada como una cadena
• Resta la entrada de la cadena empujada. Esto funciona reemplazando la primera instancia de la entrada dentro GoodBadcon nada.
• Imprime implícitamente la cadena resultante.
• La -rtbandera le dice a Keg que lea los tokens de derecha a izquierda.

Historial de respuestas

?G=[øBad|ø‘5Ƴ

Transpila a lo siguiente:

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)

Explicación

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

Carbón , 13 bytes

¿⁻ＬＳ³Ba¦Goo¦d

Pruébalo en línea!

Explicación:

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