Descrizione della sfida:

Scrivi un programma che richiede all'utente input. L'utente entrerà Goodo Bad. Non è necessario supportare altri input. Se l'utente inserisce Good, stampa Bade viceversa (su stdout ecc.).

Appunti:

1) Non puoi usare nessun'altra coppia di due parole.

2) Il tuo programma deve solo chiedere e stampare una volta.

3) Non è necessario visualizzare la stringa di prompt.

4) L'uscita deve apparire separata dall'ingresso con qualsiasi mezzo.

5) Nessuna funzione è consentita accettando il valore e restituendo il risultato; L'utente deve interagire con il programma.

In bocca al lupo!

Python 3 ,  32  31 byte

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

Provalo online!

Come?

Verifica se l'input avviene 'Good'confrontando 'G'<input().

Usa il fatto che in Python False==0e True==1per usare il risultato come startindice di una porzione di 'GBoaodd'usare un indefinito stope un stepdi 2con 'GBoaodd'[start:stop:step].

Stampa su STDERR (salvando un byte con exital posto di print).

APL (Dyalog Unicode) , 13 byte ^SBCS

Programma completo che richiede input da stdin e stampa su stdout.

'GooBad'~¯1↓⍞

Provalo online!

⍞ richiesta di input da stdin; GoodoBad

¯1↓ rilasciare l'ultimo carattere ( d); GoooBa

'GooBad'~ il multiset sottrae questi personaggi da questi; BadoGood

Turing Machine But Way Peggio ancora , 405 byte

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

Provalo online!

Bene, ci è voluto del tempo.

SPIEGAZIONE NON FINITA :

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 byte

sed s/$1//<<<GoodBad

Provalo online!

8088 Assembly, IBM PC DOS, 25 byte

smontato:

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

Spiegazione:

Osserva la lunghezza della stringa di input (più lo spazio iniziale) che DOS memorizza all'indirizzo di memoria 80He lo aggiunge AL(inizialmente 0 da DOS ). Se esiste un numero dispari di 1bit nella rappresentazione binaria della lunghezza della stringa, il flag di parità della CPU è impostato su dispari e viceversa. Quindi input string ' Bad'length 4( 0000 0100), è parità dispari e input string ' Good'is 5( 0000 0101) è parità pari.

DXè inizialmente impostato per puntare alla stringa 'Good$Bad$'e se la parità è pari (significa che l'input era ' Good') far avanzare il puntatore della stringa di quella lunghezza ( 5), quindi ora punta a 'Bad$'. Se la parità è dispari, non fare nulla poiché indica già 'Good$'. Quindi utilizzare l'API DOS per visualizzare una $stringa terminata sulla console.

Esempio:

Scarica e prova GOODBAD.COM o compilalo dal xxddump:

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

Gelatina , 8 byte

“Ċ³ṫ³»œṣ

Provalo online!

Un programma completo che prevede una stringa formattata in Python come argomento

Come?

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

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

Provalo online!

exit() : restituisce un codice di uscita come output

"C">input(): Controlla se l'input è più grande della stringa Cin ordine alfabetico

and"Good": Se il risultato è True, quindi ritorna conGood

or"Bad" : Altrimenti, ritorna con Bad

C, 39 38 byte

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

Provalo online!

Salvato un byte grazie a @tsh.

Brainfuck , 72 byte

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

Provalo online!

Spiegazione:,> +++++>,>,>,>,

Leggi: "G", 5, "o", "o", "d" o "B", 5, "a", "d", 0

[<<<< [- <->> --- <] <. >> +. >>. >>>] Se l'ultimo carattere non è zero:

Sottrai 5 dalla prima cella una volta e dalla terza cella tre volte. Incrementa cella 3

Celle di output 1, 3, 5.

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

Altrimenti aggiungi 5 alla prima cella una volta e alla terza cella tre volte.

Decrementa cella 3

Celle di output 1, 3, 3, 4

Haskell, 36 34 byte

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

Provalo online!

Modifica: -2 byte grazie a @cole

R , 42 37 35 32 byte

-10 grazie a Giuseppe e AkselA!

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

Provalo online!

sed , 21 16 13 byte

Grazie @Cowsquack per i suggerimenti.

/B/cGood
cBad

Provalo online! Provalo online! Provalo online!

TIL cmetterà in corto circuito l'analisi della linea corrente.

JavaScript 31 byte

Mi piace la risposta di Arnauld, ma vorrei che accettasse l'input dell'utente e fosse eseguibile su StackExchange in questo modo:

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

Befunge-93 , 20 18 byte

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

Provalo online!

-2 byte grazie a Jo King

Rubino , 22 byte

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

Provalo online!

05AB1E , 10 9 byte

”‚¿‰±”áIK

-1 byte grazie a @Emigna .

Provalo online o verifica entrambi i casi di test .

Spiegazione:

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

Vedere questo suggerimento 05AB1E mio (sezione Come utilizzare il dizionario? ) , Di capire perché ”‚¿‰±”è "Good Bad".

Java (JDK) , 124 byte

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

Provalo online!

Molto probabilmente, c'è ancora qualche margine di miglioramento, ma sono completamente nuovo nel golf del codice.

Rubino, 30 28 byte

puts %w|Good Bad|-gets.split

Non il golfista, ma mi piace l'abuso di split per rimuovere la nuova riga finale e convertirla in un array in una sola chiamata.

MODIFICA -2 byte grazie al suggerimento di Value Ink!

Shakespeare Programming Language , 582 byte

(Spazio bianco aggiunto per leggibilità)

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.

Provalo online!

Ottengo la prima lettera dell'input con Open mind. Quindi devo determinare di cosa si tratta. Di tutti i numeri tra B= 66 e G= 71, il mio forzante brutale dice che 66 è il più breve da scrivere ( the sum ofa big cat the cube ofa big big cat), quindi confronto la prima lettera dell'input con 66. La scena che continuo a stampare Goodo la scena V stampa Bad.

Retina 0.8.2 , 20 byte

oo
o
T`G\oaB`Ro
o
oo

Provalo online! Il link include la suite di test. Spiegazione:

oo
o

Trasforma Goodin God.

T`G\oaB`Ro

Trasponi le lettere GoaBcon il rovescio di quella lista, scambiando così Gcon Be ocon a, cioè scambiando Godcon Bad.

o
oo

Trasforma Godin Good.

Stax , 9 8 byte

çEF♫a║▬h

Esegui ed esegui il debug

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

Multiset xor con "GooBa". Algoritmo copiato letteralmente da Luis Mendo

Excel, 24 byte

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

Utilizzando il <Csuggerimento di @ MilkyWay90 .

PHP ,26 23 byte

Un ternario è solo più economico:

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

Provalo online!

Risposta originale, 26 byte

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

Provalo online!

O 21 byte (ma questa è sostanzialmente la risposta di Arnauld )

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

Provalo online!

Gelatina , 9 byte

“GooBa”œ^

Provalo online!

Spiegazione

Differenza simmetrica multiset tra l'input e la stringa “GooBa”.

PowerShell , 22 20 byte

'Good','Bad'-ne$args

Provalo online!

-2 byte grazie a mazzy

Keg , 22 byte

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

Brainfuck , 52 byte

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

Provalo online!

Si basa sul fatto che Bad è una lettera più corta di Good, quindi l'ultimo input è vuoto.

Spiegazione:

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

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

Provalo online!

Utilizza il fatto che in pratica puoi semplicemente inserire l'input come bit e quindi invertire determinati bit per trasformarlo nella lettera opposta.

Spiegazione:

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

Keg , -rt 20 17 15 13 8 7 byte (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)

È una porta della risposta 05AB1E. In sostanza:

• Spinge la stringa "GoodBad"
• Accetta l'input come stringa
• Sottrae l'input dalla stringa spinta. Funziona sostituendo la prima istanza dell'input GoodBadcon niente.
• Stampa implicitamente la stringa risultante.
• La -rtbandiera dice a Keg di leggere i token da destra a sinistra.

Cronologia delle risposte

?G=[øBad|ø‘5Ƴ

Transpiles a quanto segue:

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)

Spiegazione

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

Carbone , 13 byte

¿⁻ＬＳ³Ba¦Goo¦d

Provalo online!

Spiegazione:

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