[Question]
  [
**Challenge Description:**
Write a program that asks the user for input. The user will enter `Good` or `Bad`. You do not have to support any other input. If the user enters `Good`, print `Bad` and vice versa (to stdout etc).
**Notes:**
*1)* You cannot use any other pair of two words.
*2)* Your program only has to ask and print once.
*3)* You do not need to display prompt string.
*4)* The output must appear separated from the input by any means.
*5)* No function is allowed accepting the value and returning the result; User must interact with the program.
*Good luck!*
  
[Answer]
# [Python 3](https://docs.python.org/3/), ~~32~~ 31 bytes
```
exit('GBoaodd'['G'<input()::2])
```
**[Try it online!](https://tio.run/##K6gsycjPM/7/P7Uis0RD3d0pPzE/JUU9Wt1d3SYzr6C0REPTysooVvP/f6fEFAA "Python 3 – Try It Online")**
### How?
Tests if input is `'Good'` by comparing `'G'<input()`.
Uses the fact that in Python `False==0` and `True==1` to use the result as the `start` index of a slice of `'GBoaodd'` using an undefined `stop` and a `step` of `2` with `'GBoaodd'[start:stop:step]`.
Prints to STDERR (saving a byte with `exit` in place of `print`).
[Answer]
# [APL (Dyalog Unicode)](https://www.dyalog.com/), 13 [bytes](https://codegolf.meta.stackexchange.com/a/9429/43319 "When can APL characters be counted as 1 byte each?")[SBCS](https://github.com/abrudz/SBCS ".dyalog files using a single byte character set")
Full program that prompts for input from stdin and prints to stdout.
```
'GooBad'~¯1↓⍞
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT///qKO94L@6e36@U2KKet2h9YaP2iY/6p0HEv@vAAYFXEDZFC4YB6gOAA "APL (Dyalog Unicode) – Try It Online")
`⍞` prompt for input from stdin; `Good` or `Bad`
`¯1↓` drop the last character (`d`); `Goo` or `Ba`
`'GooBad'~` multiset subtract those characters from these; `Bad` or `Good`
[Answer]
## bash, 20 bytes
```
sed s/$1//<<<GoodBad
```
[Try it online!](https://tio.run/##S0oszvj/vzg1RaFYX8VQX9/GxsY9Pz/FKTHl////QBIA)
[Answer]
# [Turing Machine But Way Worse](https://github.com/MilkyWay90/Turing-Machine-But-Way-Worse), 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
```
[Try it online!](https://tio.run/##TZBbDoMgFET/uwqWIPXJCroOH7VVUPrRxOVTOc5HcxMmx5k7GL7bcBwpFSaPPefUmzXX3KECtaYUlVAlqqBaezXUyKtpectroFbUkuzyjWeyg5w8R9KpxeH18vo/Ki41g2hgb1TniDdpDzVPJVEzi2b2Xvm85f/NtMhboFWdK7d7dXo8r6THC6KAF5QMvOxGi0Wt2UU7FLUXafnkbyk9Ypx@ "Turing Machine But Way Worse – Try It Online")
Well, this took a while.
**UNFINISHED EXPLANATION**:
```
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
```
[Answer]
# 8088 Assembly, IBM PC DOS, 25 bytes
**Unassembled:**
```
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$'
```
**Explanation:**
Looks at the length of input string (plus leading space) that DOS stores at memory address `80H`, and adds it to `AL` (initially `0` [by DOS](http://www.fysnet.net/yourhelp.htm)). If there is an odd number of `1` bits in the binary representation of the string length, the CPU parity flag is set to odd, and vice-versa. So input string `' Bad'` length `4` (`0000 0100`), is odd parity and input string `' Good'` is `5` (`0000 0101`) is even parity.
`DX` is initially set to point to the string `'Good$Bad$'`, and if parity is even (meaning input was `' Good'`) advance the string pointer by that length (`5`) so it now points to `'Bad$'`. If parity is odd, do nothing since it already points to `'Good$'`. Then use DOS API to display a `$` terminated string to console.
**Example:**
[![enter image description here](https://i.stack.imgur.com/uw5Ze.png)](https://i.stack.imgur.com/uw5Ze.png)
Download and test [GOODBAD.COM](https://stage.stonedrop.com/ppcg/GOODBAD.COM) or build from `xxd` dump:
```
0000000: ba10 01d1 ee02 047b 0202 d0b4 09cd 21c3  .......{......!.
0000010: 476f 6f64 2442 6164 24                   Good$Bad$
```
[Answer]
## Python 3, ~~38~~ ~~37~~ ~~34~~ 33 bytes
```
exit("C">input()and"Good"or"Bad")
```
[Try it online!](https://tio.run/##K6gsycjPM/7/P7Uis0RDyVnJLjOvoLREQzMxL0XJPT8/RSm/SMkpMUVJ8/9/EBcA)
`exit()` : returns an exit code as output
`"C">input()` : Checks whether the input is larger than the string `C` in the alphabetical order
`and"Good"` : If the result is `True`, then returns with `Good`
`or"Bad"` : Otherwise, returns with `Bad`
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 8 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
```
“Ċ³ṫ³»œṣ
```
**[Try it online!](https://tio.run/##ASAA3/9qZWxsef//4oCcxIrCs@G5q8KzwrvFk@G5o////0JhZA "Jelly – Try It Online")**
A full program expecting a Python formatted string as an argument
### How?
```
“Ċ³ṫ³»œṣ - 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
```
[Answer]
# C, ~~39~~ 38 bytes
```
main(){puts("Good\0Bad"+getchar()%6);}
```
[Try it online!](https://tio.run/##S9ZNT07@/z83MTNPQ7O6oLSkWEPJPT8/JcbAKTFFSTs9tSQ5I7FIQ1PVTNO69v9/oCAA "C (gcc) – Try It Online")
Saved one byte thanks to @tsh.
[Answer]
# [brainfuck](https://github.com/TryItOnline/brainfuck), 72 bytes
```
,>+++++>,>,>,>,[<<<<[-<->>---<]<.>>+.>>.>>>]<[<<<[-<+>>+++<]<.>>-..>.>>]
```
[Try it online!](https://tio.run/##SypKzMxLK03O/v9fx04bBOx0IDDaBgiidW107ex0dXVtYm307Oy0gRiI7GJtoiGS2nYgTRBJXT09kGTs//9OiSlc/wE "brainfuck – Try It Online")
Explanation:
,>+++++>,>,>,>,
Read either: 
"G", 5, "o", "o", "d" or
"B", 5, "a", "d", 0
[<<<<[-<->>---<]<.>>+.>>.>>>]
If the last character is not zero:
Substract 5 from the first cell once and from the third cell thrice.
Increment cell 3
Output cells 1, 3, 5.
<[<<<[-<+>>+++<]<.>>-..>.>>]
Otherwise add 5 to the first cell once and to the third cell thrice. 
Decrement cell 3
Output cells 1, 3, 3, 4
[Answer]
# [R](https://www.r-project.org/), ~~42~~ ~~37~~ ~~35~~ 32 bytes
-10 thanks to Giuseppe and AkselA!
```
`if`(scan(,'')>'C','Bad','Good')
```
[Try it online!](https://tio.run/##K/r/PyEzLUGjODkxT0NHXV3TTt1ZXUfdKTEFSLrn56eoa/4HUf8B "R – Try It Online")
[Answer]
# [sed](https://www.gnu.org/software/sed/), ~~21 16~~  13 bytes
*Thanks @Cowsquack for the hints.*
```
/B/cGood
cBad
```
~~[Try it online!](https://tio.run/##K05N0U3PK/3/v1jfPT9f3ylR37qEqxhEg7j//wPJFC6nxBQA "sed – Try It Online")
[Try it online!](https://tio.run/##K05N0U3PK/3/v1jfKVHfPT9f37qEK9kpMeX/fyAnhQvIAgA "sed – Try It Online")~~
[Try it online!](https://tio.run/##K05N0U3PK/3/X99JP9k9Pz@FK9kpMeX/fzATyAIA "sed – Try It Online")
TIL `c` will short-circuit the current line's parsing.
[Answer]
# [Retina](https://github.com/m-ender/retina/wiki/The-Language), 10 bytes
```
:`GoodBad
```
[Try it online!](https://tio.run/##K0otycxLNPz/3yrBPT8/xSkxhev/fyAJAA "Retina – Try It Online")
`:` swaps the input and the regex, so this computes `'GoodBad'.replace(input, '')`.
[Answer]
## Haskell, ~~36~~ 34 bytes
```
interact g
g"Bad"="Good"
g _="Bad"
```
[Try it online!](https://tio.run/##y0gszk7Nyfmfm5iZZxvzPzOvJLUoMblEIZ0rXckpMUXJVsk9Pz9FiStdId4WLPD/P5D8l5yWk5he/F83uaAAAA "Haskell – Try It Online")
Edit: -2 bytes thanks to @cole
[Answer]
# JavaScript 31 bytes
I like Arnauld's answer, but I would like it to accept user input and be runnable on StackExchange like so:
```
alert(prompt()[3]?'Bad':'Good')
```
[Answer]
# [Shakespeare Programming Language](https://github.com/TryItOnline/spl), 582 bytes
(Whitespace added for readability)
```
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.
```
[Try it online!](https://tio.run/##nVBRCoJAEL3KHED2AP6EQoQQFAhSRB/rOpapq7m7lKe3XZXUMoo@dpiZnffmvRFl1jQr4lzo3SJbxVKLOEyCZxOfIUeTHJZcYgVmBCiPwEwdTWVvSuSQJzwiLkJdKOAJ05PyjCBUDkVMIUxOwKhse0yF@Gz2HwsvBlFkKEGJbmNA9popESOaITNLJnhd6Uj8EmmqEfU72EDkTQubxheNn@jmia@KVsbKL1zrkbddf9XAbi9u/@y01I@a@NXpjJbx63T9QTQ6TmeltzDQNI1Lowc "Shakespeare Programming Language – Try It Online")
I get the first letter of the input with `Open mind`. Then I need to determine what it is. Of all the numbers between `B`=66 and `G`=71, my brute forcer says 66 is the shortest to write (`the sum ofa big cat the cube ofa big big cat`), so I compare the first letter of the input to 66. Scene I continues to print `Good`, or Scene V prints `Bad`.
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 13 bytes
```
¿⁻ＬＳ³Ba¦Goo¦d
```
[Try it online!](https://tio.run/##ASYA2f9jaGFyY29hbP//wr/igbvvvKzvvLPCs0JhwqZHb2/CpmT//0JhZA "Charcoal – Try It Online")
### Explanation:
```
¿⁻ＬＳ³          If length of input minus 3 is truthy:
      Ba¦         print Ba
         Goo¦       else print Goo
             d        print d
```
[Answer]
# [Befunge-93](https://github.com/catseye/Befunge-93), ~~20~~ 18 bytes
```
"BadooGB"~-_#@,,<,
```
[Try it online!](https://tio.run/##S0pNK81LT/3/X8kpMSU/391JqU43XtlBR8dG5/9/oBAA "Befunge-93 – Try It Online")
*-2 bytes thanks to Jo King*
[Answer]
# [Ruby](https://www.ruby-lang.org/), 22 bytes
```
->n{n>?F?"Bad":"Good"}
```
[Try it online!](https://tio.run/##KypNqvyfZvtf1y6vOs/O3s1eySkxRclKyT0/P0Wp9n9BaUmxQlo0WDCWC8YDS8b@BwA "Ruby – Try It Online")
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), ~~10~~ 9 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
```
”‚¿‰±”áIK
```
-1 byte thanks to *@Emigna*.
[Try it online](https://tio.run/##yy9OTMpM/f//UcPcRw2zDu1/1LDh0EYg5/BCT@///50SUwA) or [verify both test cases](https://tio.run/##yy9OTMpM/f@oYe6jhlmH9j9q2HBoI5CjXFZpr6TwqG2SgpI9huThhZXe/3X@AwA).
**Explanation:**
```
”‚¿‰±”     # Push dictionary string "Good Bad"
      á    # Only keep letters (to remove the space)
       IK  # Remove the input
           # (output the result implicitly)
```
[See this 05AB1E tip of mine (section *How to use the dictionary?*)](https://codegolf.stackexchange.com/a/166851/52210), to understand why `”‚¿‰±”` is `"Good Bad"`.
[Answer]
# [Java (JDK)](http://jdk.java.net/), 124 bytes
```
interface G{static void main(String[]a){System.out.print(new java.util.Scanner(System.in).next().length()>3?"Bad":"Good");}}
```
[Try it online!](https://tio.run/##LYyxCsIwEEB/JWRKBrO4KSi49AMySocjOevF9iLptSql3x4ruD0ej5dghl2Kj1qJBcsNAqpmGQWEgpozRTUAsfFSiLtrC3bxn1FwcHkS99ykGMaXStvGTUK98wGYsZh/Rmwd41uMdT1yJ3djT/uzvkDUB93kHLU9rmutP/wC "Java (JDK) – Try It Online")
Most likely, there‘s still some room for improvement, but I‘m entirely new to code golfing.
[Answer]
# Ruby, 30 28 bytes
```
puts %w|Good Bad|-gets.split
```
Not the golf-iest, but I like the abuse of split to remove the trailing newline and convert to an array in one call.
EDIT -2 bytes thanks to Value Ink's suggestion!
[Answer]
# [GolfScript](http://www.golfscript.com/golfscript/), 11 bytes
```
"GoodBad"\/
```
[Try it online!](https://tio.run/##S8/PSStOLsosKPn/X8k9Pz/FKTFFKUb//38gDQA "GolfScript – Try It Online")
## Explanation
```
"GoodBad"   # Define the lookup table "GoodBad"
         \  # Swap the input so that it can be used by /
          / # Split the lookup table by occurences of the input
            # Implicit print, smashing
```
[Answer]
# C (gcc), 48 bytes
```
main(){puts(getchar()-66?"Bad":"Good");}
```
[Try It Online!](https://tio.run/##S9ZNT07@/7842jLWOjcxM09Ds7qgtKRYo7ikKDm3QCM9FcTW1FFySkxR0rQHU1ZK7vn5QJ517f//AA)
The program only actually takes one character as input, although `getchar` reads until a newline is found unlike `getch` which only *lets* you input a single character. It checks if there's a difference between that character and the ascii code for 'B' (66), printing "Bad" if there is and "Good" if there isn't.
[Answer]
# JavaScript, ~~35~~ ~~32~~ 31 bytes
-3 bytes thanks to [@xigoi](https://codegolf.stackexchange.com/users/98955)
-1 byte thanks to [@l4m2](https://codegolf.stackexchange.com/users/76323)
```
alert(prompt()[3]?'Bad':'Good')
```
[Answer]
# [Retina 0.8.2](https://github.com/m-ender/retina/wiki/The-Language/a950ad7d925ec9316e3e2fb2cf5d49fd15d23e3d), 20 bytes
```
oo
o
T`G\oaB`Ro
o
oo
```
[Try it online!](https://tio.run/##K0otycxL/P8/P58rnyskwT0mP9EpIQjEyc///989Pz@FyykxBQA "Retina 0.8.2 – Try It Online") Link includes test suite. Explanation:
```
oo
o
```
Turn `Good` into `God`.
```
T`G\oaB`Ro
```
Transpose the letters `GoaB` with the reverse of that list, thus exchanging `G` with `B` and `o` with `a`, i.e. exchanging `God` with `Bad`.
```
o
oo
```
Turn `God` into `Good`.
[Answer]
# [Stax](https://github.com/tomtheisen/stax), ~~9~~ 8 [bytes](https://github.com/tomtheisen/stax/blob/master/docs/packed.md#packed-stax)
```
çEF♫a║▬h
```
[Run and debug it](https://staxlang.xyz/#p=8745460e61ba1668&i=Good%0ABad&a=1&m=2)
~~Essentially `replace("BadGood", input, "")`.~~
Multiset xor with "GooBa". Algorithm copied verbatim from [Luis Mendo](https://codegolf.stackexchange.com/a/187826/527)
[Answer]
# Java, 30 bytes
```
s->s.charAt(0)>66?"Bad":"Good"
```
[TIO](https://tio.run/##dYyxDoIwFEV3vuKFqR1onBgkYnTAyYnRODxbqkVoSVtIDOHba4msTvcm99zT4oRZK96Bd@gcXFFpmBOlfWMl8gaqufZW6SdIshVHiyUZxkenODiPPsZklIA@Xjfmdge0T0ejqQIJh@Cy0jH@QnvyZEfLPD@mZxTpPr0YI9JQJPXH@aZnZvRsiAbfaSKZJL@d0v/Aqln3ZQlf)
[Answer]
# [Perl 5](https://www.perl.org/) `-p`, 15 bytes
```
$_=/B/?Good:Bad
```
[Try it online!](https://tio.run/##K0gtyjH9/18l3lbfSd/ePT8/xcopMeX/fxDrX35BSWZ@XvF/3QIA "Perl 5 – Try It Online")
[Answer]
# Excel, 24 bytes
```
=IF(A1>"C","Bad","Good")
```
Using @MilkyWay90's `<C` suggestion.
[Answer]
# [PHP](https://php.net/), ~~26~~ 23 bytes
A ternary is just cheaper:
```
<?=$argn==Bad?Goo:Ba?>d
```
[Try it online!](https://tio.run/##K8go@P/fxt5WJbEoPc/W1ikxxd49P9/KKdHeLuX/fyAz5V9@QUlmfl7xf103AA "PHP – Try It Online")
**Original answer, 26 bytes**
```
<?=[Ba,Goo][$argn==Bad]?>d
```
[Try it online!](https://tio.run/##K8go@P/fxt422ilRxz0/PzZaJbEoPc/W1ikxJdbeLuX/f6Bgyr/8gpLM/Lzi/7puAA "PHP – Try It Online")
**Or 21 bytes (but this is basically [Arnauld's answer](https://codegolf.stackexchange.com/questions/187816/swapping-good-and-bad/187836#187836))**
```
<?=$argn[3]?Ba:Goo?>d
```
[Try it online!](https://tio.run/##K8go@P/fxt5WJbEoPS/aONbeKdHKPT/f3i7l/38gnfIvv6AkMz@v@L@uGwA "PHP – Try It Online")
]