Description du défi:

Écrivez un programme qui demande à l'utilisateur une entrée. L'utilisateur entrera Goodou Bad. Vous ne devez prendre en charge aucune autre entrée. Si l'utilisateur entre Good, imprimez Badet vice versa (pour sortie standard, etc.).

Remarques:

1) Vous ne pouvez utiliser aucune autre paire de deux mots.

2) Votre programme ne doit demander et imprimer qu'une seule fois.

3) Vous n'avez pas besoin d'afficher la chaîne d'invite.

4) La sortie doit apparaître séparée de l'entrée par tout moyen.

5) Aucune fonction n'est autorisée à accepter la valeur et à renvoyer le résultat; L'utilisateur doit interagir avec le programme.

Bonne chance!

Python 3 ,  32  31 octets

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

Essayez-le en ligne!

Comment?

Teste si l'entrée est 'Good'en comparant 'G'<input().

Utilise le fait que Python False==0et True==1d'utiliser le résultat comme l' startindice d'une tranche de l' 'GBoaodd'aide d' un non défini stopet stepde 2avec 'GBoaodd'[start:stop:step].

Imprime vers STDERR (sauvegarde d'un octet avec exità la place de print).

APL (Dyalog Unicode) , 13 octets ^SBCS

Programme complet qui demande l'entrée de stdin et imprime sur stdout.

'GooBad'~¯1↓⍞

Essayez-le en ligne!

⍞ invite pour l'entrée de stdin; GoodouBad

¯1↓ déposez le dernier caractère ( d); GooouBa

'GooBad'~ multiset soustraire ces caractères de ceux-ci; BadouGood

Turing Machine But Way Pire , 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

Essayez-le en ligne!

Eh bien, cela a pris du temps.

EXPLICATION NON FINIE :

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 octets

sed s/$1//<<<GoodBad

Essayez-le en ligne!

Assemblage 8088, IBM PC DOS, 25 octets

Non assemblé:

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

Explication:

Examine la longueur de la chaîne d'entrée (plus l'espace de tête) que DOS stocke à l'adresse mémoire 80Het l'ajoute AL(initialement 0 par DOS ). S'il y a un nombre impair de 1bits dans la représentation binaire de la longueur de chaîne, l'indicateur de parité CPU est défini sur impair, et vice-versa. Ainsi, la ' Bad'longueur de chaîne d'entrée 4( 0000 0100) est une parité impaire et la chaîne d'entrée ' Good'est 5( 0000 0101) est une parité paire.

DXest initialement défini pour pointer vers la chaîne 'Good$Bad$', et si la parité est paire (ce qui signifie que l'entrée était ' Good'), faites avancer le pointeur de chaîne de cette longueur ( 5) de sorte qu'il pointe maintenant vers 'Bad$'. Si la parité est impaire, ne faites rien car elle pointe déjà vers 'Good$'. Utilisez ensuite l'API DOS pour afficher une $chaîne terminée sur la console.

Exemple:

Téléchargez et testez GOODBAD.COM ou compilez à partir du xxdvidage:

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

Gelée , 8 octets

“Ċ³ṫ³»œṣ

Essayez-le en ligne!

Un programme complet qui attend une chaîne au format Python comme argument

Comment?

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

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

Essayez-le en ligne!

exit() : retourne un code de sortie en sortie

"C">input(): Vérifie si l'entrée est plus grande que la chaîne Cdans l'ordre alphabétique

and"Good": Si le résultat est True, retourne avecGood

or"Bad" : Sinon, retourne avec Bad

C, 39 38 octets

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

Essayez-le en ligne!

Un octet enregistré grâce à @tsh.

brainfuck , 72 octets

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

Essayez-le en ligne!

Explication:,> +++++>,>,>,>,

Lire soit: "G", 5, "o", "o", "d" ou "B", 5, "a", "d", 0

[<<<< [- <->> --- <] <. >> +. >>. >>>] Si le dernier caractère n'est pas zéro:

Soustrayez 5 de la première cellule une fois et de la troisième cellule trois fois. Incrémenter la cellule 3

Cellules de sortie 1, 3, 5.

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

Sinon, ajoutez 5 à la première cellule une fois et à la troisième cellule trois fois.

Décrémenter la cellule 3

Cellules de sortie 1, 3, 3, 4

Haskell, 36 34 octets

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

Essayez-le en ligne!

Edit: -2 octets grâce à @cole

R , 42 37 35 32 octets

-10 merci à Giuseppe et AkselA!

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

Essayez-le en ligne!

sed , 21 16 13 octets

Merci @Cowsquack pour les conseils.

/B/cGood
cBad

Essayez-le en ligne! Essayez-le en ligne! Essayez-le en ligne!

TIL ccourt-circuite l'analyse de la ligne actuelle.

JavaScript 31 octets

J'aime la réponse d'Arnauld, mais j'aimerais qu'elle accepte les entrées de l'utilisateur et soit exécutable sur StackExchange comme suit:

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

Befunge-93 , 20 18 octets

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

Essayez-le en ligne!

-2 octets grâce à Jo King

Rubis , 22 octets

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

Essayez-le en ligne!

05AB1E , 10 9 octets

”‚¿‰±”áIK

-1 octet grâce à @Emigna .

Essayez-le en ligne ou vérifiez les deux cas de test .

Explication:

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

Voir cette astuce de la mine de 05AB1E (section Comment utiliser le dictionnaire? ) , De comprendre pourquoi ”‚¿‰±”est "Good Bad".

Java (JDK) , 124 octets

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

Essayez-le en ligne!

Très probablement, il y a encore de la place pour des améliorations, mais je suis entièrement nouveau dans le golf de code.

Rubis, 30 28 octets

puts %w|Good Bad|-gets.split

Pas le golf-iest, mais j'aime l'abus de split pour supprimer la nouvelle ligne de fin et la convertir en un tableau en un seul appel.

MODIFIER -2 octets grâce à la suggestion de Value Ink!

Langage de programmation Shakespeare , 582 octets

(Espace blanc ajouté pour plus de lisibilité)

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.

Essayez-le en ligne!

J'obtiens la première lettre de l'entrée avec Open mind. Ensuite, je dois déterminer de quoi il s'agit. De tous les nombres entre B= 66 et G= 71, mon brute forcer dit que 66 est le plus court à écrire ( the sum ofa big cat the cube ofa big big cat), donc je compare la première lettre de l'entrée à 66. La scène I continue à imprimer Good, ou la scène V s'imprime Bad.

Retina 0.8.2 , 20 octets

oo
o
T`G\oaB`Ro
o
oo

Essayez-le en ligne! Le lien inclut une suite de tests. Explication:

oo
o

Transformez Gooden God.

T`G\oaB`Ro

Transposer les lettres GoaBau verso de cette liste, échangeant ainsi Gavec Bet oavec a, c'est-à-dire échangeant Godavec Bad.

o
oo

Transformez Goden Good.

Stax , 9 8 octets

çEF♫a║▬h

Exécuter et déboguer

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

Xor multiset avec "GooBa". Algorithme copié textuellement de Luis Mendo

Excel, 24 octets

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

Utilisation de la <Csuggestion de @ MilkyWay90 .

PHP ,26 23 octets

Un ternaire est juste moins cher:

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

Essayez-le en ligne!

Réponse originale, 26 octets

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

Essayez-le en ligne!

Ou 21 octets (mais c'est essentiellement la réponse d'Arnauld )

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

Essayez-le en ligne!

Gelée , 9 octets

“GooBa”œ^

Essayez-le en ligne!

Explication

Différence symétrique multiset entre l'entrée et la chaîne “GooBa”.

PowerShell , 22 20 octets

'Good','Bad'-ne$args

Essayez-le en ligne!

-2 octets grâce à mazzy

Keg , 22 octets

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

brainfuck , 52 octets

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

Essayez-le en ligne!

S'appuie sur Bad étant une lettre plus courte que Good, donc la dernière entrée est vide.

Explication:

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

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

Essayez-le en ligne!

Utilise le fait que vous pouvez simplement prendre l'entrée en bits, puis inverser certains bits pour la transformer en la lettre opposée.

Explication:

+>,+;>,;,+;>;;;+;+;+    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 octets (SBCS)

-᠀‘5ƳP↫

Transpile vers:

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)

C'est un portage de la réponse 05AB1E. Essentiellement, il:

• Pousse la chaîne "GoodBad"
• Prend l'entrée sous forme de chaîne
• Soustrait l'entrée de la chaîne poussée. Cela fonctionne en remplaçant la première instance de l'entrée à l'intérieur GoodBadpar rien.
• Imprime implicitement la chaîne résultante.
• Le -rtdrapeau indique à Keg de lire les jetons de droite à gauche.

Historique des réponses

?G=[øBad|ø‘5Ƴ

Transmet les éléments suivants:

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)

Explication

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

Fusain , 13 octets

¿⁻ＬＳ³Ba¦Goo¦d

Essayez-le en ligne!

Explication:

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