Описание задачи:

Напишите программу, которая запрашивает у пользователя ввод. Пользователь введет Goodили Bad. Вам не нужно поддерживать какой-либо другой ввод. Если пользователь входит Good, распечатайте Badи наоборот (на стандартный вывод и т. Д.).

Примечания:

1) Вы не можете использовать любую другую пару из двух слов.

2) Ваша программа должна спросить и распечатать только один раз.

3) Вам не нужно отображать строку приглашения.

4) Выход должен казаться отделенным от входа любым способом.

5) Запрещается принимать функцию и возвращать результат; Пользователь должен взаимодействовать с программой.

Удачи!

Python 3 ,  32  31 байт

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

Попробуйте онлайн!

Как?

Проверяет, является ли вход 'Good'путем сравнения 'G'<input().

Использует тот факт , что в Python False==0и True==1использовать результат в качестве startиндекса среза с 'GBoaodd'использованием неопределенного stopи stepиз 2с 'GBoaodd'[start:stop:step].

Печать в STDERR (сохранение байта exitвместо print).

APL (Dyalog Unicode) , 13 байтов ^SBCS

Полная программа, которая запрашивает ввод от стандартного ввода и печатает на стандартный вывод.

'GooBad'~¯1↓⍞

Попробуйте онлайн!

⍞ запрос ввода от stdin; GoodилиBad

¯1↓ удалить последний символ ( d); GooилиBa

'GooBad'~ мультимножество вычитает эти символы из них; BadилиGood

Машина Тьюринга, но намного хуже , 405 байтов

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

Попробуйте онлайн!

Ну, это заняло некоторое время.

Незаконченное объяснение :

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

Баш, 20 байт

sed s/$1//<<<GoodBad

Попробуйте онлайн!

Сборка 8088, IBM PC DOS, 25 байтов

разобранное:

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

Объяснение:

Просматривает длину входной строки (плюс начальный пробел), которую DOS хранит по адресу памяти 80H, и добавляет ее AL(изначально 0 в DOS ). Если 1в двоичном представлении длины строки присутствует нечетное число битов, флаг четности ЦП устанавливается на нечетное, и наоборот. Таким образом , входной строки ' Bad'длины 4( 0000 0100), является нечетность и входная строка ' Good'является 5( 0000 0101) даже на четность.

DXизначально установлен для указания на строку 'Good$Bad$', и если четность четна (что означает, что ввод был ' Good'), передвиньте указатель строки на эту длину ( 5), так что теперь он указывает на 'Bad$'. Если четность нечетна, ничего не делайте, поскольку она уже указывает на 'Good$'. Затем используйте DOS API для отображения $завершенной строки на консоли.

Пример:

Скачайте и протестируйте GOODBAD.COM или соберите из xxdдампа:

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

Желе , 8 байт

“Ċ³ṫ³»œṣ

Попробуйте онлайн!

Полная программа ожидает строку в формате Python в качестве аргумента

Как?

“Ċ³ṫ³»œṣ - 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 байта

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

Попробуйте онлайн!

exit() : возвращает код выхода в качестве вывода

"C">input(): Проверяет, больше ли ввод, чем строка Cв алфавитном порядке

and"Good": Если результат есть True, то возвращается сGood

or"Bad" : В противном случае возвращается с Bad

C 39 38 байт

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

Попробуйте онлайн!

Сохранено один байт благодаря @tsh.

мозговой отрыв , 72 байта

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

Попробуйте онлайн!

Объяснение:,> +++++>,>,>,>,

Прочитайте: «G», 5, «o», «o», «d» или «B», 5, «a», «d», 0

[<<<< [- <- >> --- <] <. >> +. >>. >>>] Если последний символ не равен нулю:

Вычтите 5 из первой ячейки один раз и из третьей ячейки трижды. Инкремент ячейка 3

Выходные ячейки 1, 3, 5.

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

В противном случае добавьте 5 к первой ячейке один раз и к третьей ячейке трижды.

Ячейка декремента 3

Выходные ячейки 1, 3, 3, 4

Haskell, 36 34 байта

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

Попробуйте онлайн!

Редактировать: -2 байта благодаря @cole

R , 42 37 35 32 байта

-10 спасибо Джузеппе и АкселА!

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

Попробуйте онлайн!

sed , 21 16 13 байт

Спасибо @Cowsquack за подсказки.

/B/cGood
cBad

Попробуйте онлайн! Попробуйте онлайн! Попробуйте онлайн!

TIL cзакоротит разбор текущей строки.

JavaScript 31 байт

Мне нравится ответ Арно, но я хотел бы, чтобы он принимал пользовательский ввод и мог быть запущен в StackExchange следующим образом:

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

Befunge-93 , 20 18 байт

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

Попробуйте онлайн!

-2 байта благодаря Джо Кингу

Рубин , 22 байта

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

Попробуйте онлайн!

05AB1E , 10 9 байтов

”‚¿‰±”áIK

-1 байт благодаря @Emigna .

Попробуйте онлайн или проверьте оба теста .

Объяснение:

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

Посмотрите эту подсказку 05AB1E (раздел Как пользоваться словарем? ) , Чтобы понять, почему ”‚¿‰±”это так "Good Bad".

Java (JDK) , 124 байта

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

Попробуйте онлайн!

Скорее всего, есть еще возможности для совершенствования, но я совершенно новичок в коде в гольф.

Рубин, 30 28 байт

puts %w|Good Bad|-gets.split

Не в гольфе, но мне нравится злоупотребление сплитом для удаления завершающего перевода строки и преобразования в массив за один вызов.

РЕДАКТИРОВАТЬ -2 байта благодаря предложению Value Ink!

Язык программирования Шекспира , 582 байта

(Пробелы добавлены для удобства чтения)

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.

Попробуйте онлайн!

Я получаю первую букву ввода с Open mind. Тогда мне нужно определить, что это такое. Из всех чисел от B= 66 до G= 71 мой брутфорсер говорит, что 66 - самое короткое для записи ( the sum ofa big cat the cube ofa big big cat), поэтому я сравниваю первую букву ввода с 66. Сцена I продолжает печатать Good, или Сцена V печатает Bad.

Сетчатка 0.8.2 , 20 байт

oo
o
T`G\oaB`Ro
o
oo

Попробуйте онлайн! Ссылка включает тестовый набор. Объяснение:

oo
o

Превратись Goodв God.

T`G\oaB`Ro

Транспонировать буквы GoaBс обратной стороны этого списка, таким образом, обмениваясь Gс Bи oс a, то есть обмениваясь Godс Bad.

o
oo

Превратись Godв Good.

Stax , 9 8 байт

çEF♫a║▬h

Запустите и отладьте его

По сути replace("BadGood", input, "").

Мультисет XOR с "GooBa". Алгоритм дословно скопирован с Луиса Мендо

Excel, 24 байта

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

Используя предложение @ MilkyWay90 <C.

PHP ,26 23 байта

Троица просто дешевле:

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

Попробуйте онлайн!

Оригинальный ответ, 26 байт

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

Попробуйте онлайн!

Или 21 байт (но это в основном ответ Арно )

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

Попробуйте онлайн!

Желе , 9 байт

“GooBa”œ^

Попробуйте онлайн!

объяснение

Мультисимметричная разность между входом и строкой “GooBa”.

PowerShell , 22 20 байт

'Good','Bad'-ne$args

Попробуйте онлайн!

-2 байта благодаря маззи

Кег , 22 байта

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

брейкфук , 52 байта

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

Попробуйте онлайн!

Полагается, что «Плохо» на одну букву короче «Хорошо», поэтому последний ввод пуст.

Объяснение:

,>,,<<,       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 байтов

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

Попробуйте онлайн!

Использует тот факт, что вы можете просто принять входные данные как биты, а затем инвертировать определенные биты, чтобы превратить его в противоположную букву.

Объяснение:

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

Кег , -rt 20 17 15 13 8 7 байт (SBCS)

-᠀‘5ƳP↫

Транспортирует к:

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)

Это порт ответа 05AB1E. По сути, это:

• Толкает строку "GoodBad"
• Принимает ввод в виде строки
• Вычитает входные данные из заданной строки. Это работает, заменяя первый экземпляр ввода внутри GoodBadничего.
• Неявно печатает полученную строку.
• -rtФлаг говорит бочонок читать лексемы справа налево.

История ответов

?G=[øBad|ø‘5Ƴ

Транспортирует к следующему:

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)

объяснение

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

Древесный уголь , 13 байт

¿⁻ＬＳ³Ba¦Goo¦d

Попробуйте онлайн!

Объяснение:

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