交换“好”和“坏”

17

挑战说明：

编写一个要求用户输入的程序。用户将输入Good或Bad。您不必支持任何其他输入。如果用户输入Good，则打印Bad，反之亦然（到标准输出等）。

笔记：

1）您不能使用其他两个单词对。

2）您的程序只需要询问并打印一次。

3）您不需要显示提示字符串。

4）无论如何，输出必须看起来与输入分开。

5）不允许函数接受值并返回结果；用户必须与该程序进行交互。

祝好运！

code-golf  string  interactive 
— 伊沙格汗
source
9
我们可以编写一个将输入作为参数而不是提示输入的函数吗？
— ADAM
8
请编辑有关是否允许使用功能的问题。我强烈建议您不要将输入限制为STDIN，除非您有充分的理由（而且我看不到）
— 乔·金
2
要求用户输入（stdin等）表明仅允许STDIN或交互式输入。请更改为所有默认的I / O方法
— MilkyWay90
1
“请用户输入”，这应该是一个明确的问题吗？因为空的CLI提示符实际上并没有要求任何内容……
— user0721090601 '19
5
此限制的目的是什么？不允许函数接受该值并返回结果；用户必须与程序进行交互
— mbomb007 '19

Answers:

46

Python 3中， 32  31个字节

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

在线尝试！

怎么样？

测试输入是否'Good'通过比较'G'<input()。

使用以下事实：在Python中False==0，True==1将结果用作undefined 和of的with start的切片的索引。'GBoaodd'stopstep2'GBoaodd'[start:stop:step]

打印到STDERR（用exit代替保存一个字节print）。

— 乔纳森·艾伦
source
真是个把戏！无法理解其工作原理。
— 伊沙克·汗
可以使用lambda缩短字节吗？
— MilkyWay90
@ MilkyWay90根据问题，它必须是接受输入的程序。
— 乔纳森·艾伦，
默认情况下，@ A__是，尽管OP进行了评论，但建议在此处予以否决。
— 乔纳森·艾伦，
4
太糟糕了，“好”和“坏”共享一个“ d”，或者您可以做'GoodBad'.strip(input())一个短一点的字节。
— xnor19年
15

APL（Dyalog Unicode），13 字节SBCS

完整的程序，提示从stdin输入并打印到stdout。

'GooBad'~¯1↓⍞

在线尝试！

⍞ 提示从stdin输入信息；Good要么Bad

¯1↓ 删除最后一个字符（d）; Goo要么Ba

'GooBad'~ 多集从这些字符中减去那些字符；Bad要么Good

— 亚当
source
5
为什么downvote‽
— 亚当
1
代码是否具有GooBad或GoodBad？
— NoOneIsHere
我认为应该有GooBad，因为添加字符``d''将使该帖子增加14个字节。
@NoOneIsHere谢谢。固定。
— 阿达姆，
12

图灵机但更糟，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
— 银河系90
source
4
毫无疑问，“ Turing-Machine-But-Way-Worse”无疑是我最喜欢的esolang。
— MikeTheLiar
@MikeTheLiar谢谢！
— MilkyWay19年
@A__favorite/disliked/"Turing-Machine-But-Way-Worse" is, without a doubt, my new favorite esolang.
— MilkyWay90
“您已经终止了” ArnoldC，是吗？
— TemporalWolf
@TemporalWolf是我，ArnoldC！
— MilkyWay19年
8

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字符串长度的二进制表示中的位数为奇数，则CPU奇偶校验标志设置为奇数，反之亦然。因此，输入字符串的' 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$
— 640KB
source
7

果冻，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
— 乔纳森·艾伦
source
1
看起来OP已响应，输入不限于STDIN。
— 暴民埃里克（Erik the Outgolfer）
6

Python 3， 38 37 34 33字节

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

在线尝试！

exit() ：返回退出代码作为输出

"C">input()：检查输入是否大于C字母顺序的字符串

and"Good"：如果结果为True，则返回Good

or"Bad" ：否则，返回 Bad

2
— ADAM
2
exit(input()[3:]and"Bad"or"Good")也适用于相同的字节数。
— 尼尔，
5

brainfuck，72个字节

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

在线尝试！

说明：，> +++++>，>，>，>，

读取：“ G”，5，“ o”，“ o”，“ d”或“ B”，5，“ a”，“ d”，0

[<<<< [-<->> --- <] <。>> +。>>。>>>]如果最后一个字符不为零：

从第一个单元格减去5，从第三个单元格减去三次。增量单元格3

输出单元1、3、5

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

否则，将5一次添加到第一个单元格，三次添加到第三个单元格。

递减单元格3

输出单元格1、3、3、4

— 海伦娜
source
那是一个很好的解决方案。您可以通过在输入中不使用换行符来将其缩短一点。，> +++++>，>，>，[<<< [-<->> --- <] <。>> +。>>。>>] <[<< [-<+ >> +++ <] <。>>-..>。>]]
— Dorian
是的，我意识到那里有一些需要优化的地方，但是我发现很难解释遵守规则4的必要条件
— Helena
4

R，42 37 35 32字节

-10感谢Giuseppe和AkselA！

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

在线尝试！

— 罗伯特·S。
source
1
没问题。我认识很多其他R高尔夫球手的名字，因此如果我看到他们的名字是最新的，我经常单击帖子。:-)
— 朱塞佩
1
使用"C"而不是第一个"Bad"，如此答案将节省另外几个字节。
— 朱塞佩
1
出于好奇，会不会`if`(readline()>"C","Bad","Good")是一个有效的答案？我是这个游戏及其规则的新手。
— AkselA
2
@AkselA是的，但我也建议您使用scan(,"")而不是readline()。欢迎前来golfR的R高尔夫球聊天室，如果您有任何具体的R-问题:-)
— 朱塞佩
2
@AkselA另请参阅R中的高尔夫技巧以获取一些特定技巧；如果您阅读的话，里面就有隐藏的宝石：-)
— 朱塞佩
3

JavaScript 31字节

我喜欢Arnauld的回答，但我希望它接受用户输入并可以像这样在StackExchange上运行：

alert(prompt()[3]?'Bad':'Good')
展开摘要

— ADJenks
source
3

红宝石，22字节

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

在线尝试！

— 国标
source
这个问题确实说“请用户输入”，但是最简单的方法是用替换lambda，p gets因此长度相同。（我的原始评论说，您可以节省2个字节，但我没有考虑打印结果）
— DaveMongoose
3
如果实际上我们要讨论的是一个完整的程序，要求用户输入，那么使用该-p标志将给出最有效的答案：$_=$_>?F?:Bad:"Good"20个字节。在线尝试！
— 价值墨水
3

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

— 凯文·克鲁伊森
source
我可以看到许多其他的变体，但是它们最终都以相同的字节数结束：(
— Emigna
1
实际上，您可以使用保存一个字节á。
— Emigna '19
@Emigna当然不错。现在，我知道á我不敢相信自己没有考虑过，但与此同时，我知道我永远也不会想到。;） 谢谢！（是的，我也有一些10字节的替代方案。）
— Kevin Cruijssen
1
甚至不需要á，”‚¿Bad”IK它也是
— 9。– Grimmy
3

Java（JDK），124个字节

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

在线尝试！

最有可能的是，仍有一些改进的空间，但是我完全不喜欢打高尔夫球。

— 费利克斯·博纳克（Felix Bohnacker）
source
2
欢迎！考虑添加解释和/或链接到在线解释器，您可以在其中运行代码。（有关示例，请参见其他答案。）纯代码答案往往会自动标记为低质量。
— mbomb007 '19
4
长度部分可能只是!="Bad"
— Jo King
— OlivierGrégoire19年
3

Ruby，30个 28字节

puts %w|Good Bad|-gets.split

不是最高尔夫的，但是我喜欢使用split来删除尾随的换行符并在一次调用中转换为数组。

编辑-2个字节，这要归功于Value Ink的建议！

— 戴夫猫鼬
source
打印"Good"或"Bad"（带引号）；我不确定是否允许。
— 约旦
1
滥用在puts单独的行上打印数组的每个元素的事实。它比贵3个字节p，但由于您取出[0]，然后不再需要parens节省了2个字节，因此它变得均匀了。在线尝试！
— 价值墨水
@ValueInk谢谢！这一变化也解决了约旦的问题，因此是双赢的。
— DaveMongoose
3

莎士比亚编程语言，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进行了比较。场景我继续打印Good，或者场景V打印Bad。

— 你好再见
source
2

Excel，24个字节

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

使用@ MilkyWay90的<C建议。

— 韦尼施
source
2

果冻，9字节

“GooBa”œ^

在线尝试！

说明

输入和字符串之间的多集对称差异“GooBa”。

— 路易斯·门多
source
@JonathanAllan谢谢。编辑
— 路易斯·门多
我看不到任何输入必须通过STDIN
— 的迹象
@EriktheOutgolfer不幸的是，编写问题的整个方式暗示着我们必须有一个程序，该程序在运行时会要求输入（即使不必显示任何提示）。也请参阅OP的答案。如果您想让他们对其进行更改（尽管要注意，他们并没有在评论中回答第一个类似但稍有不同的问题）
— Jonathan Allan
看起来OP已响应，输入不限于STDIN。
— 暴民埃里克（Erik the Outgolfer）
@EriktheOutgolfer谢谢！回滚
— Luis Mendo
2

桶，22字节

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

brainfuck，52个字节

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

在线尝试！

由于Bad的字母比Good的字母短，因此最后一个输入为空。

说明：

,>,,<<,       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
— 乔·金
source
2

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
— 乔·金
source
2

桶，-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标志告诉Keg从右到左读取令牌。

回答历史

?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"
— lyxal
source
1
太好了，我不能打那么长的球...我支持你的回答。
@A__，就像我已经投票给你的一样
— Lyxal
我的答案比你的差很多。您不应该赞成我的答案...
是否有最新的桶装文档？
— EdgyNerd '19
@EdgyNerd不是。自从我更新文档以来已经有一段时间了。有关新事物的大多数信息，可以在chat / 这里找到
— Lyxal，
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.