Mô tả thử thách:

Viết chương trình yêu cầu người dùng nhập liệu. Người dùng sẽ nhập Goodhoặc Bad. Bạn không phải hỗ trợ bất kỳ đầu vào nào khác. Nếu người dùng nhập Good, in Badvà ngược lại (để xuất bản, v.v.).

Ghi chú:

1) Bạn không thể sử dụng bất kỳ cặp từ nào khác.

2) Chương trình của bạn chỉ phải yêu cầu và in một lần.

3) Bạn không cần hiển thị chuỗi nhắc.

4) Đầu ra phải xuất hiện tách biệt với đầu vào bằng bất kỳ phương tiện nào.

5) Không có chức năng nào được phép chấp nhận giá trị và trả về kết quả; Người dùng phải tương tác với chương trình.

Chúc may mắn!

Python 3 ,  32  31 byte

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

Hãy thử trực tuyến!

Làm sao?

Kiểm tra nếu đầu vào là 'Good'bằng cách so sánh 'G'<input().

Sử dụng thực tế là bằng Python False==0và True==1sử dụng kết quả là startchỉ số của một lát 'GBoaodd'sử dụng không xác định stopvà một stepsố 2với 'GBoaodd'[start:stop:step].

In thành STDERR (lưu một byte với exitvị trí print).

APL (Dyalog Unicode) , 13 byte ^SBCS

Chương trình đầy đủ nhắc nhở đầu vào từ stdin và in ra thiết bị xuất chuẩn.

'GooBad'~¯1↓⍞

Hãy thử trực tuyến!

⍞ nhắc nhở cho đầu vào từ stdin; Goodhoặc làBad

¯1↓ thả ký tự cuối cùng ( d); Goohoặc làBa

'GooBad'~ multiset trừ các ký tự từ những; Badhoặc làGood

Máy Turing nhưng cách tệ hơn , 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

Hãy thử trực tuyến!

Vâng, điều này mất một lúc.

KHAI THÁC KHÔNG GIỚI HẠN :

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

Hãy thử trực tuyến!

8088 hội, IBM PC DOS, 25 byte

Chưa được lắp ráp:

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

Giải trình:

Xem xét độ dài của chuỗi đầu vào (cộng với không gian hàng đầu) mà DOS lưu trữ tại địa chỉ bộ nhớ 80Hvà thêm nó vào AL(ban đầu0 bằng DOS ). Nếu có một số 1bit lẻ trong biểu diễn nhị phân của độ dài chuỗi, cờ chẵn lẻ CPU được đặt thành lẻ và ngược lại. Vì vậy, ' Bad'độ dài chuỗi đầu vào 4( 0000 0100), là chẵn lẻ và chuỗi đầu vào ' Good'là 5( 0000 0101) là chẵn lẻ.

DXban đầu được đặt để trỏ đến chuỗi 'Good$Bad$'và nếu chẵn lẻ (nghĩa là đầu vào là ' Good') tiến con trỏ chuỗi theo độ dài đó ( 5) để bây giờ nó trỏ đến 'Bad$'. Nếu chẵn lẻ là lẻ, không làm gì vì nó đã trỏ đến 'Good$'. Sau đó, sử dụng API DOS để hiển thị một $chuỗi kết thúc vào bàn điều khiển.

Thí dụ:

Tải xuống và kiểm tra GOODBAD.COM hoặc xây dựng từ xxdkết xuất:

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

Thạch , 8 byte

“Ċ³ṫ³»œṣ

Hãy thử trực tuyến!

Một chương trình đầy đủ mong đợi một chuỗi được định dạng Python làm đối số

Làm sao?

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

Con trăn 3 38 37 34 33 byte

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

Hãy thử trực tuyến!

exit() : trả về mã thoát là đầu ra

"C">input(): Kiểm tra xem đầu vào có lớn hơn chuỗi Ctheo thứ tự bảng chữ cái không

and"Good": Nếu kết quả là True, sau đó trả về vớiGood

or"Bad" : Nếu không, trả về với Bad

C, 39 38 byte

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

Hãy thử trực tuyến!

Đã lưu một byte nhờ @tsh.

Haskell, 36 34 byte

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

Hãy thử trực tuyến!

Chỉnh sửa: -2 byte nhờ @cole

cân não , 72 byte

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

Hãy thử trực tuyến!

Giải thích:,> +++++>,>,>,>,

Đọc một trong hai: "G", 5, "o", "o", "d" hoặc "B", 5, "a", "d", 0

[<<<< [- <- >> --- <] <. >> +. >>. >>>] Nếu ký tự cuối cùng không bằng 0:

Trừ 5 từ ô thứ nhất một lần và từ ba ô thứ ba. Ô tăng 3

Các ô đầu ra 1, 3, 5.

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

Nếu không, thêm 5 vào ô đầu tiên một lần và vào ô thứ ba.

Tế bào giảm 3

Các ô đầu ra 1, 3, 3, 4

R , 42 37 35 32 byte

-10 cảm ơn Giuseppe và AkselA!

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

Hãy thử trực tuyến!

sed , 21 16 13 byte

Cảm ơn @Cowsquack cho các gợi ý.

/B/cGood
cBad

Hãy thử trực tuyến! Hãy thử trực tuyến! Hãy thử trực tuyến!

TIL csẽ ngắn mạch phân tích cú pháp của dòng hiện tại.

JavaScript 31 byte

Tôi thích câu trả lời của Arnauld, nhưng tôi muốn nó chấp nhận đầu vào của người dùng và có thể chạy được trên StackExchange như vậy:

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

Befunge-93 , 20 18 byte

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

Hãy thử trực tuyến!

-2 byte nhờ Jo King

Ruby , 22 byte

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

Hãy thử trực tuyến!

05AB1E , 10 9 byte

”‚¿‰±”áIK

-1 byte nhờ @Emigna .

Dùng thử trực tuyến hoặc xác minh cả hai trường hợp thử nghiệm .

Giải trình:

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

Xem mẹo 05AB1E này của tôi (phần Làm thế nào để sử dụng từ điển? ) , Để hiểu tại sao ”‚¿‰±”là "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");}}

Hãy thử trực tuyến!

Nhiều khả năng, vẫn còn một số chỗ cần cải thiện, nhưng tôi hoàn toàn mới đối với việc chơi golf.

Ruby, 30 28 byte

puts %w|Good Bad|-gets.split

Không phải là golf-iest, nhưng tôi thích việc lạm dụng phân tách để xóa dòng mới và chuyển đổi thành một mảng trong một cuộc gọi.

EDIT -2 byte nhờ đề xuất của Value Ink!

Ngôn ngữ lập trình Shakespeare , 582 byte

(Khoảng trắng được thêm vào để dễ đọc)

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.

Hãy thử trực tuyến!

Tôi nhận được chữ cái đầu tiên của đầu vào với Open mind. Sau đó, tôi cần phải xác định nó là gì. Của tất cả các số từ B= 66 và G= 71, vũ phu của tôi quân lực nói 66 là ngắn nhất để write ( the sum ofa big cat the cube ofa big big cat), vì vậy tôi so sánh các chữ cái đầu tiên của đầu vào 66. Cảnh Tôi tiếp tục in Good, hoặc in Scene V Bad.

Võng mạc 0.8.2 , 20 byte

oo
o
T`G\oaB`Ro
o
oo

Hãy thử trực tuyến! Liên kết bao gồm bộ kiểm tra. Giải trình:

oo
o

Biến Goodthành God.

T`G\oaB`Ro

Chuyển các chữ cái GoaBvới mặt trái của danh sách đó, do đó trao đổi Gvới Bvà ovới a, tức là trao đổi Godvới Bad.

o
oo

Biến Godthành Good.

Stax , 9 8 byte

çEF♫a║▬h

Chạy và gỡ lỗi nó

Thực chất replace("BadGood", input, "").

Đa điểm xor với "GooBa". Thuật toán sao chép nguyên văn từ Luis Mendo

Excel, 24 byte

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

Sử dụng <Cđề xuất của @ MilkyWay90 .

PHP ,26 23 byte

Một ternary chỉ là rẻ hơn:

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

Hãy thử trực tuyến!

Câu trả lời gốc, 26 byte

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

Hãy thử trực tuyến!

Hoặc 21 byte (nhưng về cơ bản đây là câu trả lời của Arnauld )

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

Hãy thử trực tuyến!

Thạch , 9 byte

“GooBa”œ^

Hãy thử trực tuyến!

Giải trình

Sự khác biệt đối xứng nhiều lần giữa đầu vào và chuỗi “GooBa”.

PowerShell , 22 20 byte

'Good','Bad'-ne$args

Hãy thử trực tuyến!

-2 byte nhờ mazzy

Keg , 22 byte

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

Brainfuck , 52 byte

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

Hãy thử trực tuyến!

Dựa vào Bad là một chữ cái ngắn hơn Good, vì vậy đầu vào cuối cùng trống.

Giải trình:

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

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

Hãy thử trực tuyến!

Sử dụng thực tế là về cơ bản bạn chỉ có thể nhận đầu vào dưới dạng bit và sau đó đảo ngược các bit nhất định để biến nó thành chữ ngược lại.

Giải trình:

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

Dịch chuyển đến:

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)

Đây là một cổng của câu trả lời 05AB1E. Về cơ bản, nó:

• Đẩy chuỗi "GoodBad"
• Lấy đầu vào dưới dạng chuỗi
• Trừ đầu vào từ chuỗi đẩy. Điều này hoạt động bằng cách thay thế phiên bản đầu tiên của đầu vào bên trong GoodBadbằng không có gì.
• Ngẫu nhiên in chuỗi kết quả.
• Các -rtlá cờ nói Keg đọc thẻ từ phải sang trái.

Trả lời lịch sử

?G=[øBad|ø‘5Ƴ

Transpiles đến như sau:

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)

Giải trình

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

Than , 13 byte

¿⁻ＬＳ³Ba¦Goo¦d

Hãy thử trực tuyến!

Giải trình:

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