是的，但是没有，是的

46

我的同事最近给我发送了以下JavaScript玩笑：

let butScript = (nrOfButs) => {
    for(var i = 0; i < nrOfButs; i++){
        if(i % 3 == 0){
            console.log("Yeah")
        }
        if(i % 2 == 0){
            console.log("But")
        }
        if(i % 3 == 1){
            console.log("No")
        }
    }
}

由于代码是在工作时间编写的，因此显然浪费了公司大量资源。为了防止将来再次发生类似事件，我们必须将工作时间的浪费降到最低。并且由于众所周知，较短的程序编写起来会更快，因此我们必须精挑细选这段代码！

输入项

单个非负整数。您不得处理错误的输入。

输出量

您的程序必须产生与上述脚本相同的输出。您应该每行输出一个单词，单词的数量应与原始脚本一致。

允许在每行的末尾（但不能在开头）包含非换行符，因为它们是不可见的。在输出的最后允许一个额外的换行符。

例子

Input: 0
Output:


Input: 1
Output:
Yeah
But

Input: 2
Output:
Yeah
But
No

Input: 10
Output:
Yeah
But
No
But
Yeah
But
No
Yeah
But
No
But
Yeah
code-golf  string 
— 马克斯
source
3
我们可以返回行列表吗？
— Jo King
10
与这样有趣的家伙一起工作必须很有趣！：s稍微严肃一点：该nrOfButs变量的名称很差并且具有误导性。无论如何，还是不错的简单挑战。
— Arnauld
10
如果最后一行是“上帝不能相信你刚刚说的话！”，我们能获得奖金吗？
— Ciaran_McCarthy
3
@EriktheOutgolfer if的下降谷，如果满足其条件，则继续在当前循环中继续。
— dzaima
4
最澳大利亚的代码高尔夫了吗？除了应该是“ nah”
— Nacht-恢复莫妮卡

Answers:

48

Excel，78个字节

假定在单元格A1中输入，并且该单元格的Wordwrap格式已打开。使用Alt + Enter在字符串中添加换行符并注意空格。由于REPT功能的限制，最多只能处理3570个输入（但很幸运，单元格应该很高）。

=LEFT(REPT("Yeah
But
No      
But     
Yeah    
But
No           
",595),A1*9)

重新打印，并带有空格

=LEFT(REPT("Yeah
But
No......
But.....
Yeah....
But
No...........
",595),A1*9)

工作原理：模式每6个数字重复一次： 

0 = Yeah and But      Yeah + linefeed + But + linefeed
1 = No                No + 6 whitespace + line feed
2 = But               But + 5 whitespace + linefeed
3 = Yeah              Yeah + 4 whitespace + linefeed
4 = But and No        But + linefeed + No + 3 whitespace
5 = Blank             8 whitespace + linefeed

每个字符串都可以用9个字符表示，因此字符串由54个字符（9 * 6）组成，然后重复使用Excel允许的最大长度。然后，将剩下的9 *（输入数量）个字符作为输出。

将“但不”的换行符放置在空格之后，以便将＃6，＃12等的格式设置为左侧而不是右侧，并且每6行不添加空白换行符对于那个项目。

输出量

— 凯塔
source
1
我无法验证这一点，但是您的描述使它看起来正确。您可以添加一些示例输入/输出对吗？一种比较荒谬的语言，但是答案还是不错的。
— maxb
16
@maxb在击败其他语言时不能那么荒谬。
— Keeta
1
很好的解释和很酷的技术。也可以在LibreOffice Calc中使用，但可能需要使用一些格式。+1
— ElPedro
20

JavaScript（ES6），59 57字节

f=n=>n?f(n-1)+[s=n&1?`But
`:'',`Yeah
`+s,s+`No
`][n%3]:''

在线尝试！

怎么样？

我们使用从到1而不是从0到n − 1的递归函数。n10n−1

结果，与参考代码相比，测试偏离了：1

  • 如果，输出“是”n≡1(mod3)
  • 如果，则输出“ But”n≡1(mod2)
  • 如果，则输出“否”n≡2(mod3)

这使我们可以将较简单的情况为查找数组的第一个条目，在这里我们可以定义：一个包含或为空字符串的变量。秒n≡0(mod3)s"But\n"

另外两个条目分别定义为"Yeah\n" + s和s + "No\n"。

注意：通过从到迭代，我们也可以在第一个条目中定义，但这会花费两个额外的括号。0 小号n−10s

已评论

f = n =>            // n = input
  n ?               // if n is not equal to 0:
    f(n - 1) +      //   prepend the result of a recursive call with n - 1
    [               //   define our lookup array:
      s = n & 1 ?   //     1st entry: if n is odd:
        `But\n`     //       set s to "But"
      :             //     else:
        '',         //       set s to an empty string
      `Yeah\n` + s, //     2nd entry: "Yeah" followed by s
      s + `No\n`    //     3rd entry: s followed by "No"
    ][n % 3]        //   append the correct entry for this iteration
  :                 // else:
    ''              //   return an empty string and stop recursion
— Arnauld
source
16

LOLCODE 257字节

HAI 1.2
I HAS A B
GIMMEH B
B IS NOW A NUMBR
I HAS A C ITZ 0
IM IN YR L UPPIN YR C TIL BOTH SAEM B AN C
I HAS A D ITZ MOD OF C AN 3
D
WTF?
OMG 0
VISIBLE "Yeah"
OIC
MOD OF C AN 2
WTF?
OMG 0
VISIBLE "But"
OIC
D
WTF?
OMG 1
VISIBLE "No"
OIC
IM OUTTA YR L
KTHXBYE

在线尝试！

— 乔西亚·瑞安（JosiahRyanW）
source
2
它看起来很棒（我讨厌编写这个代码！），但是在测试用例10中，第二个“ No”和第三个“ But”被翻转了……所以，是的，但是没有：D
— seadoggie01
2
糟糕，以为我可以在那里进行优化。这是一个棘手的模式。我现在修复了。
— JosiahRyanW
1
我喜欢它的阅读方式
— LocustHorde
4
是否VISIBLE "But"表示该程序缺少裤子？
— JDL
12

空格，315个 304 300 277 276字节

感谢@JoKing提供-11个字节（将使用的标签数量从8个减少到7个）和-24个更多的字节（将程序的一般流程更改为该过程中使用的标签数量从7个减少到5个）。

[S S S N
_Push_0][T  N
T   T   _Read_STDIN_as_integer][N
S S N
_Create_Label_LOOP][S S S N
_Push_0][T  T   T   _Retrieve][N
T   S S N
_If_negative_jump_to_Label_PRINT][S S S N
_Push_0][T  T   T   _Retrieve][S S S T  T   N
_Push_3][T  S T T   _Modulo][S S S T    S N
_Push_2][T  S S T   _Subtract][N
T   T   T   N
_If_negative_jump_to_Label_SKIP_NO][S S T   T   S T T   T   T   S N
_Push_-94_\n][S S S T   T   T   N
_Push_7_o][S S T    T   T   S T S N
_Push_-26_N][N
S S T   N
_Create_Label_SKIP_NO][S S S N
_Push_0][T  T   T   _Retrieve][S S S T  S N
_Push_2][T  S T T   _Modulo][N
T   S S S N
_If_0_jump_to_Label_SKIP_BUT][S S T T   S T T   T   T   S N
_Push_-94_\n][S S S T   T   S S N
_Push_12_t][S S S T T   S T N
_Push_13_u][S S T   T   S S T   T   S N
_Push_-38_B][N
S S S S N
_Create_Label_RETURN_FROM_BUT][S S S N
_Push_0][S N
S _Duplicate_0][S N
S _Duplicate_0][T   T   T   _Retrieve][S S S T  N
_Push_1][T  S S T   _Subtract][T    T   S _Store][T T   T   _Retrieve][S S S T  T   N
_Push_3][T  S T T   _Modulo][N
T   S S T   N
_If_0_jump_to_Label_YEAH][N
S N
N
_Jump_to_Label_LOOP][N
S S S T N
_Create_Label_YEAH][S S T   T   S T T   T   T   S N
_Push_-94_\n][S S S N
_Push_0_h][S S T    T   T   T   N
_Push_-7_a][S S T   T   T   N
_Push_-3_e][S S T   T   T   T   T   N
_Push_-15_Y][N
S N
N
_Jump_to_Label_LOOP][N
S S S N
_Create_Label_PRINT][S S S T    T   S T S S S N
_Push_104][T    S S S _Add][T   N
S S _Print_as_character][N
S N
N
_Jump_to_Label_LOOP]

字母S（空格），T（制表符）和N（换行符）仅作为突出显示而添加。
[..._some_action]仅作为说明添加。

在线尝试（仅使用空格，制表符和换行符）。

空格绝对不是解决此问题的正确语言。在空格中，循环和if语句都是使用标签进行的，然后跳转到标签，并且由于它们不是if-elseif-else情况，而是多个if-case，所以我每次之后都将不得不跳回去，这使得它很长，这意味着我将不得不略微修改支票以跳过一些打印（感谢@JoKing）。

伪代码中的解释：

Read STDIN as integer, and store it in the heap
Start LOOP:
  Integer i = retrieve integer from heap
  If(i is negative):
    Call function PRINT
  If(i modulo-3 is NOT 2):
    Jump to Label SKIP_NO
  Push "\noN" to the stack
  Label: SKIP_NO
  If(i modulo-2 is 0):
    Jump to Label SKIP_BUT
  Push "\ntuB" to the stack
  Label: SKIP_BUT
  i = i - 1
  Replace i in the heap with this updated value
  If(i modulo-3 is 0):
    Call function YEAH
  Go to next iteration of LOOP

function YEAH:
  Push "\nhaeY" to the stack
  Go to next iteration of LOOP

function PRINT:
  Print top of the stack as character to STDOUT
  Go to next iteration of LOOP (which will enter the if and then
                                comes back to this PRINT again)

附加说明：

通常，它从输入循环到0，推入一个换行符，然后单词反转（因此顺序为“ \ noN”，“ \ ntuB”，“ \ nhaeY”而不是“是”，“但是” “，”否\ n“）。在输入循环到0并且所有字符都在堆栈上之后，它将反向打印这些字符（因此输出顺序正确）。

但是，更深入：尽管我们需要在范围内打印单词(input, 0]，但它将在范围内循环[input, 0)。因此，我们可以if(i%3 == 2)对“ \ noN” 使用检查（或者实际上，if(i%3 != 2)跳过对“ \ noN”的推送），对我们使用if(i%2 != 1)“ \ ntuB” 检查（或者实际上，if(i%2 == 0)跳过对“ \ ntuB”的推送） ）。仅在这两项检查之后，我们才将迭代次数i减少1。然后进行检查if(i%3 == 0)以压入“ \ nhaeY”，类似于质询描述中的JS示例代码。使用if-not检查跳过，而不是转到标签，然后使用if-checks从标签返回保存的23个字节。

同样，在空格中，字符值作为其Unicode值存储在堆栈中（即，10对于换行符，65“ A”，97“ a”等）。由于我已经需要遍历堆栈来打印字符，因此在将它们打印为字符之前，我还可以使用空格提示通过在数字值上添加常量来降低字节数。在这种情况下，
此常量是104使用此Java程序生成的，而我以前也曾用它来寻找我的另一个Whitespace答案。这也是这部分代码的原因：

[S S T  T   S T T   T   T   S N
_Push_-94_\n][S S S T   T   T   N
_Push_7_o][S S T    T   T   S T S N
_Push_-26_N]

具有-94换行符，7“ o”和-26“ N”的值。因为添加的不断104将正确地给我们的Unicode值10，111以及78分别为这些字符。

— 凯文·克鲁伊森
source
1
我最肯定没有想到空格的答案。做得好！
— maxb
@maxb谢谢！不幸的是，由于需要8个标签，它比预期的要长很多。.但是我已经很高兴它可以工作了。:)
— Kevin Cruijssen
如果条件为假，是否可以通过跳到下一个if语句来将标签减半？例如if i modulo-3 != 1 jump to next if else push NO
— Jo King
1
@JoKing啊，等等，我误解了您的伪代码的一部分。我的第一个问题是在true i之前不检索if(i is 0) call PRINT，但是您的另一个问题是i在减去之前先检查，然后跳过打印。实际上很聪明。将继续实施。
— 凯文·克鲁伊森
1
好吧，如果您跳到循环的开始，它将再次运行if语句，然后直接跳回到print函数。如果将循环标签更改为空标签，则可能会节省一个字节
— Jo King
11

Perl 6的，63 50个字节

{<<"Yeah But"No But Yeah"But No">>[^$_ X%6].words}

在线尝试！

带有数字并返回行列表的匿名代码块

说明：

{                                                }   # Anonymous code block
 <<"Yeah But"No But Yeah"But No">>  # Create the list of strings:
                                     # Yeah But
                                     # No
                                     # But
                                     # Yeah
                                     # But No
                                  [       ]  # Index into this list
                                   ^$_  # The range from 0 to n-1
                                       X%6  # All modulo 6
                                           .words  # Convert the list to a string 
                                                   # Which joins by spaces
                                                   # And split by whitespace
— 乔·金
source
8

05AB1E（旧版），27 25 24字节

感谢Kevin Cruijssen保存了1个字节。

F”¥æ€³€¸”#N3ÖNÈN3%‚‚˜Ï`»

在线尝试！

说明

F                          # for N in [0 ... input] do:
 ”¥æ€³€¸”#                 # push ['Yeah', 'But', 'No']
          N3Ö              # push N % 3 == 0
             NÈ            # push N % 2 == 0
               N3%         # push N % 3
                  ‚‚˜      # add the 3 numbers to a list
                     Ï     # keep only the strings whose corresponding value  
                           # in the int list is true (1)
                      `»   # push strings separately to stack and join stack on newlines
— 艾米尼亚
source
亲爱的，你把我打败了。无论如何，您的时间都较短，因此请向我+1。。很好的使用×，还没想到呢！
— 凯文·克鲁伊森
哇，我希望对此做一个解释。我个人最好的成绩是CJam中的44个字节。
— maxb
@maxb：我当然会添加一个解释。我只是在检查是否可以
— 再打一点
您Θ现在可以删除不再使用的×，因为Ï它将仅查看1s，因此它将忽略2（0当然）。
— 凯文·克鲁伊森
@KevinCruijssen：谢谢！不知道我怎么想念的：P
— Emigna '18
6

Python 2中，97个 95 92 90 83 81字节

lambda n:[w for i in range(n)for w in'Yeah','But','No'if('N'in w)==i%(3-(w<'N'))]

在线尝试！

-2个字节，多亏了ovs

Python 3中，92个 90 85 83字节

lambda n:[w for i in range(n)for w in['Yeah','But','No']if('N'in w)==i%(3-(w<'N'))]

在线尝试！

-4个字节，多亏了ovs

-4个字节，感谢Jo King

— 场
source
通过合并两者并返回行列表来获得86个字节
— Jo King
@JoKing谢谢，不知道写时我可以返回而不是打印。
— TFeld
82个字节：len(w)<3-> 'N'in w，81个字节：len(w)%2->(w<'N')
— ovs
6

Groovy（功能），79字节

自从最初提交我的答案以来，我在这里进行了一些历史性讨论，以了解什么是合适的答案。由于似乎通常只提供Java方法（包括返回类型和参数声明），因此这里是一个简短的Groovy方法，其方法返回值就是答案。使用def手段意味着可以推断出返回类型。

def a(int n){n?a(--n)+(n%3?'':'Yeah\n')+(n%2?'':'But\n')+(n%3==1?'No\n':''):''}

与下面的原始答案不同（从0循环到n-1），该变量将自己从n循环调用为1，但递归调用中该行其余部分的输入递减。

在线尝试！

Groovy（程序），87字节

Groovy脚本并不需要一些共同的进口，所以这可能是一个程序打印答案Java的标准输出，而不必申报System.out.之前print。它还提供了一些常用的实用方法，例如这样toLong()，使我们能够合理地解析输入参数。

本质上是Java 10的答案，但利用了Groovy较短的循环语法和评估真实陈述的能力。

args[0].toLong().times{print((it%3?'':'Yeah\n')+(it%2?'':'But\n')+(it%3==1?'No\n':''))}

在线尝试！

— 大天使
source
欢迎来到PPCG！很棒的第一答案！我自己尚未编写任何Groovy的代码，但我建议您在TIO上运行您的代码吗？这样，它就可以被其他人验证并为所有人所享用。
— maxb
1
@maxb谢谢！我添加了一个:)
— archangel.mjj
不错的第一答案，也欢迎来到PPCG。
— ElPedro
5

视网膜0.8.2，45字节

.+
$*
1
$`Yeah¶$`But¶$`11No¶
+`11B
B
111

A`1

在线尝试！说明：

.+
$*

将输入转换为一元。

1
$`Yeah¶$`But¶$`11No¶

对于每个整数0...n-1，生成三行文本，每个单词一行，每行i 1前都有s，除了No，它有两个额外的1s，因此我们计算出(i+2)%3==0它等于i%3==1。

+`11B
B

在1s之前删除对B。

111

1在其他所有位置以三为一组删除。

A`1

删除所有仍带有的行1。

— 尼尔
source
哦，既然我看到11No¶要进行计算了(i+2)%3==0（所以所有三个都是if检查==0），它看起来是如此明显，但是我自己不会想到这一点，因此它实际上非常巧妙。向我+1，很好的答案！
— 凯文·克鲁伊森
5

Java 10、100 99字节

n->{for(int i=0;i<n;)System.out.print((i%3<1?"Yeah\n":"")+(i%2<1?"But\n":"")+(++i%3>1?"No\n":""));}

-1个字节感谢@OlivierGrégoire。

在线尝试。

说明：

n->{                   // Method with integer parameter and no return-type
  for(int i=0;i<n;)    //  Loop `i` in the range [0, `n`)
    System.out.print(  //   Print to STDOUT:
      (i%3<1?          //    If `i` is divisible by 3:
        "Yeah\n"       //     Print "Yeah" with newline
      :"")+(i%2<1?     //    If `i` is even:
        "But\n"        //     Print "But" with newline
      :"")+(++i%3>1?   //    If `i` modulo-3 is 1:
        "No\n"         //     Print "No" with newline
      :                //    If none of the above three if's applied to the current `i`:
       ""));}          //     Print nothing for the current `i`
— 凯文·克鲁伊森
source
1
++i%3>1可能会为您节省一个字节
— OlivierGrégoire18
@OlivierGrégoire啊，当然。谢谢！
— 凯文·克鲁伊森
5

Powershell，75 74 72 67 66字节

-1个字节，感谢TessellatingHeckler

param($n)(" Yeah
But No But Yeah But
No "*$n-split' ')[1..$n]-ne''

测试脚本和说明：

$f = {

param($n)(" Yeah
But No But Yeah But
No "*$n-split' ')[1..$n]-ne''

# 1. repeat the string $n times
# 2. split by space
# 3. get elements from 1 to $n
# some elements are multiline strings, some elements are $null:
# ($null,"Yeah`nBut","But","No","But","Yeah","But`nNo",$null,...)
# 4. remove $null elements from result array

}

# Output results
@(
    0,1,2,10
) | % {
    &$f $_
    "======"
}

# Advanced test
@(
    ,(0,'')
    ,(1,'Yeah But')
    ,(2,'Yeah But No')
    ,(3,'Yeah But No But')
    ,(4,'Yeah But No But Yeah')
    ,(5,'Yeah But No But Yeah But No')
    ,(6,'Yeah But No But Yeah But No')
    ,(7,'Yeah But No But Yeah But No Yeah But')
    ,(8,'Yeah But No But Yeah But No Yeah But No')
    ,(9,'Yeah But No But Yeah But No Yeah But No But')
    ,(10,'Yeah But No But Yeah But No Yeah But No But Yeah')
    ,(20,'Yeah But No But Yeah But No Yeah But No But Yeah But No Yeah But No But Yeah But No Yeah But No')
) | % {
    $n,$e = $_
    $r = &$f $n
    $r = $r-split"`n"       # simplify test string
    "$($e-eq$r): $n : $r"
}

输出：

======
Yeah
But
======
Yeah
But
No
======
Yeah
But
No
But
Yeah
But
No
Yeah
But
No
But
Yeah
======
True: 0 :
True: 1 : Yeah But
True: 2 : Yeah But No
True: 3 : Yeah But No But
True: 4 : Yeah But No But Yeah
True: 5 : Yeah But No But Yeah But No
True: 6 : Yeah But No But Yeah But No
True: 7 : Yeah But No But Yeah But No Yeah But
True: 8 : Yeah But No But Yeah But No Yeah But No
True: 9 : Yeah But No But Yeah But No Yeah But No But
True: 10 : Yeah But No But Yeah But No Yeah But No But Yeah
True: 20 : Yeah But No But Yeah But No Yeah But No But Yeah But No Yeah But No But Yeah But No Yeah But No

简单的脚本，72个字节：

$args|?{$_}|%{0..--$_|%{@('Yeah')[$_%3]
@('But')[$_%2]
@{1='No'}[$_%3]}}
— 疯狂的
source
1
好答案！由于不包含在线解释器，是否可以在答案中添加一些输出？
— maxb
答案脚本块不返回======。它Yeah,But,No仅生成字符串。测试脚本显示一个分隔符，以便仅读取结果。
— mazzy
哈希表的用法很聪明。我将需要记住这一点。
— AdmBorkBork
— TessellatingHeckler，
1
@mazzy我可以重新格式化您的，但仍然无法超过67（用真实的换行符代替两个\ n）(" Yeah\nBut No But Yeah But\nNo "*($j="$args")|% s*t 32)[1..$j]-ne''
— TessellatingHeckler
4

Haskell，71个字节

f n=[1..n]>>=(3?1)"Yeah"<>(2?1)"But"<>(3?2)"No"
(a?b)c n=[c|n`mod`a==b]

在线尝试！

说明

非常简单，使用[1..n]代替[0..n-1]并调整了余数，节省了两个字节：运算符(?)测试采用四个参数，如果结果正确，则返回一个空列表或提供的字符串作为单例。

通过引用第四个参数，(?)我们可以利用(<>)来连接每个函数的结果，即：

(3?1)"Yeah" <> (2?1)"But" <> (3?2)"No" ≡ \i-> (3?1)"Yeah" i ++ (2?1)"But" i ++ (3?2)"No" i
— ბიმო
source
4

点，37 35 33字节

"But 
Yeah
No
"<>5@:^[t2io02x]@<a

（请注意But。之后的空格。）将输入作为命令行参数。在线尝试！

说明

该说明适用于先前版本-更改日志请参见下文

受到Jo King的Perl 6答案的启发。我们构造以下列表：

[
 "Yeah
 But
 ";
 "No
 ";
 "But
 ";
 "Yeah
 ";
 "But
 No
 ";
 ""
]

并a使用循环索引输出它的第一个元素。

[t2io02x]R,3["But""Yeah""No"].n@<:a
                                     i is 0; o is 1; t is 10; x is ""; n is newline;
                                     a is 1st cmdline arg (implicit)
[       ]                            Construct this list of scalars:
 t                                    10
  2                                   2
   i                                  0
    o                                 1
     02                               02
       x                              <empty string>
         R                           Treating each of these as a string, we're going to
                                     replace:
          ,3                          0, 1, and 2 (respectively)
                                     with the corresponding values from this list:
            ["But""Yeah""No"].n       These strings, each with a newline appended
                                     We now have constructed the list shown above
                               @<:a  Take the first a elements from this list, with
                                     cyclical indexing (the : is for parsing reasons)
                                     Concatenate them together and print (implicit)

更新：我意识到我不需要使用replace来将0/1/2更改为字符串-我可以使用这些数字直接将其索引到列表中。为此，我们必须确保将多位数字拆分为数字列表（否则，我们将选择索引10而不是索引1和0）。幸运的是，使用任意嵌套的列表作为Pip中的索引可以按预期工作，从而给出（嵌套）结果列表。对于输入3，我们得到以下数据级数（其中_表示换行符）：

"But _Yeah_No_"<>5                       ["But _"; "Yeah_"; "No_"]
                     [t2io02x]           [10; 2; 0; 1; 02; ""]
                              @<a        [10; 2; 0]
                    ^                    [[1; 0]; [2]; [0]]
                  @:                     [["Yeah_"; "But _"]; ["No_"]; ["But _"]]

和以前一样，最终结果被连接在一起并自动打印。

— DLosc
source
4

附件，48字节

Flat##{Mask[_%3'2'3=0'0'1,$Yeah'$But'$No]}=>Iota

在线尝试！

说明

Flat##{Mask[_%3'2'3=0'0'1,$Yeah'$But'$No]}=>Iota   input: an integer
      {                                  }=>Iota   over each number from 0 to that integer exclusive
       Mask[             ,$Yeah'$But'$No]          select values from that array according to:
            _%3'2'3                                    whether or not the input mod 3, 2, 3
                   =0'0'1                              is 0, 0, 1
Flat##                                             flatten the intermediate results
— 科纳·奥布莱恩
source
4

C（gcc），77 71 74 72 69字节

这里已经有一个更好的C答案了，但是这个是递归的，花了我一些时间才明白，所以我发布了它。

@ceilingcat和@JonathanFrech都减少到69个字节

（我从不认为可以使用n-〜-i代替n-i + 1）

i;f(n){i=n&&n-i>=~n/6&&f(n,i++,puts(i%7%4?i%7%2?"But":"No":"Yeah"));}

在线尝试！

— 克莱布朗
source
@JonathanFrech不错，但不适用于零或5
— cleblanc 18/09/18
@cleblanc哦，对不起。没意识到...至少删除j节省了您两个字节。
— 乔纳森·弗雷希
1
70个字节 -包含@ceilingcat的一个保存字节。
— 乔纳森·弗雷希
1
n-~-i等效于n-i+1-不i<n+1-因此实际上不保存任何字节...
— Jonathan Frech
3

Ruby，69岁 72 74 字节数

->y{puts *(1..y).map{|i|[i%3==1&&:Yeah,i%2>0&&:But,i%3>1&&:No]-[!0]}}

非常简单的答案，现在检查一种较短的递归方法。

@BWO节省了两个字节:)

通过使用符号而不是字符串节省了另外三个字节

— 哈瓦德·尼格德（HåvardNygård）
source
3

Python 3，93个字节

[print("Yeah\n"*(i%3<1)+"But\n"*(i%2<1)+"No\n"*(i%3==1),end="")for i in range(int(input()))]

这并不是最好的解决方案，但这是我的责任。

在线尝试！

— 乔希·B。
source
1
如果您已经有一个表达式，则可以在列表推导中使用，但是列表推导仅存在于唤起该表达式的副作用，因此普通的for循环需要较少的字节。
— 乔纳森·弗雷希
3

R，65个字节

cat(c("yeah","but","no")[c(3,1:3,2,1,2)][1:scan()%%7+1],sep="\n")

由于这样的事实，我们正在复制略有瑕疵的程序（它错过了每月的第四个“但是” -它应该使用%4 == 1和%4 == 3，而不是%3条件），我们必须使用一个尴尬的调用c和工作基地七人。不过，它比LOLCODE短...

（我希望（3,1,2,3,2,1,2）或类似的排列可能出现在lh数据集中的某个地方，但看起来并不像）

— JDL
source
3

SED-E，179 150字节

/^0/!s:$:g:
:l;y:abcdefg:bcdefga:
/[ae]/iYeah
/[bdf]/iBut
/[cg]/iNo
s:.$:-&:;:s;s:0-:-9:;ts;h
y:123456789:012345678:;G
s:.*(.)-.*\n(.*).-:\2\1:;tl;c\

最困难的部分不是构造列表，而是实际解析十进制数。

如果不需要末尾的换行符，则可以节省2个字节：c\ → d。

仍然需要优化。

在线尝试。

说明

/^0/!                            | if the input number doesn`t begin with a '0'…
     s:$:g:                      | …then append a 'g' to it and proceed
                                 |
:l;                              | loop label 'l':
   y:abcdefg:bcdefga:            | shift all occurences of [abcdef] 1 letter forward, and all 'g'-s to 'a'-s
                                 |
/[ae]/                           | if there`s an 'a' or 'e' in the input…
      iYeah                      | …output 'Yeah'
                                 |
/[bdf]/                          | if there`s a 'b' or 'd' or 'f' in the input…
       iBut                      | …output 'But'
                                 |
/[cg]/                           | if there`s a 'c' or 'g' in the input…
      iNo                        | …output 'No' 
                                 |
s:.$:-&:;                        | insert '-' before the last character
         :s;                     | loop label 's':
            s:0-:-9:;            | transform the next consecutive '0' in the end of the number to '9', if any
                     ts;         | loop to 's' if more consecutive zeroes are available
                        h        | copy the result to the temporary buffer
                                 |
y:123456789:012345678:;          | decrement all digits except '0' (N.B.: digits, not numbers)
                       G         | append the temporary buffer to the result
                                 |
s:.*(.)-.*\n(.*).-:\2\1:;        | cut and replace the digit left to the last consecutive 0 in the original
                                 | number pasted from the temporary buffer, then discard all other digits decremented
                         tl;     | …then loop to 'l' if the number is ≥0
                            c\   | insert a carriage return and exit
— hidefromkgb
source
你能补充一些解释吗？
— user285259 '18
1
@ user285259完成。
— hidefromkgb
2

F＃，108106字节

let v p=seq{for i=1 to p do
 if i%3=1 then yield"Yeah"
 if i%2=1 then yield"But"
 if i%3=2 then yield"No"}

在线尝试！

-2个字节，从更改为i=0 to p-1，i=1 to p并调整模数。除此之外，还很简单。

— 西亚兰·麦卡锡
source
1
我在TIO链接中遇到某种构建错误，也许是测试代码中的语法错误？
— maxb
感谢那。我最初的解决方案直接打印到控制台，但是后来我尝试返回一个序列，结果证明它短了约2个字节。因此，我更改了TIO中的代码，但忘记更新页脚-仍然期望该v功能可以打印所有内容。
— Ciaran_McCarthy
2
使用剃除2个字节i=1 to p（自然调整模数）。反向范围为空。：）
真好！我添加了。谢谢！:)
— Ciaran_McCarthy
2

PHP，65 68字节

while($i<$argn)echo["Yeah
"][$i%3],["But
"][$i%2],["No
"][~-$i++%3];

与管道一起运行-nR或在线尝试。

— 提图斯
source
看起来不错，但中间会产生一个额外的换行符，n = 10
— maxb
@maxb感谢您的提示。我可以用9个额外的字节来修复它；但是另一种方法更短。
— 泰特斯（Titus）
2

VBA（Excel）中，105，101， 99字节

编辑：从Keeta -4字节！谢谢！

编辑2：来自Chronocidal的-2个字节！！（意识到测试用例仅适用于10个。现已修复）

是的，Excel这次击败了VBA。随你。（我们为您而来）

d=vbCr:For i=1To[a1]:a=i Mod 3:?IIf(a=1,"Yeah"+d,"")IIf(i/2=i\2,"","But"+d)IIf(a=2,"No"+d,"");:Next

^将其粘贴到立即窗口中并输出到调试窗口

不打高尔夫球

d = vbCr
'For 1 to the value in A1 (using 0 gave extra values, and VBA skips the for loop if 0)
For i = 1 To [a1]    'aka: Range("A1").value
    a = i mod 3
    '? is the same as Print (Debug.Print when not in the Immediate Window)
    Print IIf(a = 1, "Yeah" + d, "") _ '<-- Just a line continuation
          'Keeta taught me that the \ operator is division with truncation,
          '     so if they are equal then there is no remainder!
          IIf(i / 2 = i \ 2, "", "But" + d) _
          IIf(a = 2, "No" + d, "");
    'Print usually prints a newline, but it still outputs if the string is blank...
    '   So we append a newline -if true- and use a semi-colon to kill the newline
Next
— seadoggie01
source
@Keeta是个好主意，但是没有...如果您看我的第一个代码，我使用[a1]表示范围/单元格.value :)我应该更清楚地说明那是一个解释，对不起：/
— seadoggie01 18/09/14
1
是的，我看到了，并试图删除评论。如何使用i / 3 = i \ 3代替i mod 3 = 0（与mod 2 = 0相同）。还没有尝试过，但是行得通吗？
— Keeta
@Keeta我之前从未见过\运算符...我不这么认为，它返回除法运算的值而没有余数...就像我认为的Mod的反面一样
— seadoggie01
一种是整数除法，一种是浮点数。7/3 = 2.3333，其中7 \ 3 = 2（截除）。6/3应该是2，而6 \ 3也应该是2，所以只要余数为零，它就应该起作用。
— Keeta
1
VBA将自动串联函数输出，因此您可以在函数输出&之间删除IIf(..)额外的2个字节
— Chronocidal
2

果冻，22 字节

5Rż7FṚṁị“'⁴\ÆẓNƇ»ḲŒP¤Ẏ

单声道链接生成行列表（似乎允许在注释中使用）

在线尝试！（页脚使用调用LinkÇ并使用换行，Y因为Jelly中的隐式打印将所有内容粉碎在一起）

怎么样？

2×3=6

现在注意前六个值是：

["Yeah", "But"]
["No"]
["But"]
["Yeah"]
["But", "No"]
[]

因此，结果行列表应将这些值重复（或截断）到一定长度，并将它们n串联在一起。

现在注意，的幂集"Yeah", "But", "No"为：

[]
["Yeah"]
["But"]
["No"]
["Yeah", "But"]
["Yeah", "No"]
["But", "No"]
["Yeah", "But", "No"]

因此，每个周期都是的幂集的这些1索引值"Yeah", "But", "No"：

5, 4, 3, 2, 7, 1

该代码创建此列表，将其成型为length n，索引到幂集，然后删除内部列表（由于字符串是Jelly中的列表，因此也删除了空字符串）...

5Rż7FṚṁị“'⁴\ÆẓNƇ»ḲŒP¤Ẏ - Link: integer, n   e.g. 10
5                      - literal five            5
 R                     - range                   [1,2,3,4,5]
   7                   - literal seven           7
  ż                    - zip together            [[1,7],[2],[3],[4],[5]]
    F                  - flatten                 [1,7,2,3,4,5]
     Ṛ                 - reverse                 [5,4,3,2,7,1]
      ṁ                - mould like (n)          [5,4,3,2,7,1,5,4,3,2]
                    ¤  - nilad followed by link(s) as a nilad:
        “'⁴\ÆẓNƇ»      -   compressed string     "Yeah But No"
                 Ḳ     -   split at spaces       ["Yeah","But","No"]
                  ŒP   -   power-set             [[],["Yeah"],["But"],["No"],["Yeah","But"],["Yeah","No"],["But","No"],["Yeah","But","No"]]
       ị               - index into              [["Yeah","But"],["No"],["But"],["Yeah"],["But","No"],[],["Yeah","But"],["No"],["But"],["Yeah"]]
                     Ẏ - tighten                 ["Yeah","But","No","But","Yeah","But","No","Yeah","But","No","But","Yeah"]
— 乔纳森·艾伦
source
我怀疑会比这更短。很棒的答案，很好的解释，做得很好！
— maxb
2

Python 2中，93个 92 83字节

lambda i:''.join('Yeah\n'*(x%3<1)+'But\n'*(x%2<1)+'No\n'*(x%3==1)for x in range(i))

在线尝试！

多亏@Jonathan Frech节省了9个字节

— 埃尔佩德罗
source
您可以使用字符串重复代替元组索引- ('','Yeah\n')[x%3<1]等效于"Yeah\n"*(x%3<1)。
— 乔纳森·弗雷希
@JonathanFrech-非常酷！类似的技术也可以应用于其他情况。非常感谢！
— ElPedro
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.