Недавно мой коллега прислал мне следующий фрагмент 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

Excel, 78 байт

Предполагается ввод в ячейку A1, и что форматирование Wordwrap включено для ячейки. Используйте Alt + Enter, чтобы добавить перевод строки внутри строки и отметить пробел. Только обрабатывает ввод до 3570 из-за ограничения функции REPT (удачи, хотя получаю клетку такой высокой высоты).

=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-ю строку не добавлялся пустой перевод строки. для этого пункта.

JavaScript (ES6), 59 57 байт

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

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

Как?

Мы используем рекурсивную функцию, которая идет от до а не от до .1 0 n - $n$$1$$0$$n-1$

В результате тесты отключены на по сравнению с эталонным кодом:$1$

• если , выведите «Да»$n\equiv1\pmod 3$
• если , выведите «Но»$n\equiv1\pmod 2$
• если , выведите «Нет»$n\equiv2\pmod 3$

Это позволяет нам хранить более простой случай в качестве первой записи нашего массива поиска, где мы можем определить : переменную, содержащую либо пустую строку, либо.$n\equiv0\pmod 3$$s$"But\n"

Две другие записи определены как "Yeah\n" + sи s + "No\n"соответственно.

Примечание: итерируя от до , мы могли бы точно так же определить в первой записи, но это стоило бы две дополнительные скобки .0 $n-1$$0$$s$

комментарии

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

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

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

Пробелы , 315 304 300 277 276 байт

Благодаря @JoKing за -11 байт (сокращение количества используемых меток с 8 до 7) и -24 байт (изменение общего потока программы и уменьшение количества используемых меток в процессе).

[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]добавлено только для пояснения.

Попробуйте онлайн (только с необработанными пробелами, вкладками и новыми строками).

Пробельные символы определенно не являются подходящим языком для этой задачи. В Whitespace оба цикла и операторы if создаются с метками и переходами к меткам, и, поскольку они не являются случаями if-elseif-else, а являются множественными случаями if, это означает, что я придется каждый раз возвращаться назад, делая его довольно длинным, это означает, что мне придется немного изменить проверки, чтобы пропустить некоторые отпечатки (спасибо @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)

Дополнительное объяснение:

Как правило, он переходит от ввода к нулю, нажимая на новую строку, и слово переворачивается (поэтому в порядке "\ noN", "\ ntuB", "\ nhaeY" вместо "Да \ n", "Но \ n" "," Нет \ 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-проверками 23 байта.

Кроме того, в пробелах символьные значения хранятся в стеке в качестве значений Юникода (то есть 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правильно дать наши ценности Юникода 10, 111и 78для этих символов соответственно.

Python 3 , 85 82 байта

def f(n):
 for i in range(n):yield from['Yeah'][i%3:]+['But'][i%2:]+['No'][i%3^1:]

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

Python 3 , 79 76 байт

Порт Keeta «s ответ Excel .

lambda n:(f"""Yeah
But
No      
But     
Yeah    
But
No{'':11}
"""*n)[:9*n]

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

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

C (gcc) , 75 байтов

f(o,_){for(_=0;o-_;_++%3-1||puts("No"))_%3||puts("Yeah"),1&_||puts("But");}

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

C (gcc) , 60 + 11 = 71 байт (с использованием -D$=||puts()

f(o,_){for(_=0;o-_;_++%3-1 $"No"))_%3 $"Yeah"),1&_ $"But");}

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

05AB1E (наследие) , 27 25 24 байта

Сохранено 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

Python 2 , 73 байта

lambda n:'\n'.join((["Yeah\nBut","No","But","Yeah","But\nNo"]*n)[:n-n/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 байта, благодаря овсу}

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 байта, благодаря овс}

-4 байта, спасибо Джо Кингу

Холст , 27 байт

｛╷⌐３％‽YeahＰ｝２％‽ButＰ｝３％╷‽NoＰ

Попробуй это здесь!

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 скрипты не требуют определенного общего импорта, так что это может быть программой печати ответа на STDOUT 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':''))}

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

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

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

A`1

Попробуйте онлайн! Объяснение:

.+
$*

Преобразовать ввод в унарный.

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

Для каждого целого числа 0...n-1сгенерируйте три строки текста, по одной для каждого слова, каждая с i 1s перед ним, за исключением No, у которого есть два дополнительных 1s, так что мы вычисляем, (i+2)%3==0что эквивалентно i%3==1.

+`11B
B

Удалить пары 1s перед Bs.

111

Удалите 1s в группах по три везде.

A`1

Удалить все строки, которые все еще имеют 1.

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`

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]}}

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]и скорректировав оставшиеся: Оператор (?)test принимает четыре аргумента, возвращая пустой список или предоставленную строку в виде одиночного значения, если результат верен.

Выражая четвертый аргумент, (?)мы можем использовать (<>)конкатенацию результатов каждой функции, а именно:

(3?1)"Yeah" <> (2?1)"But" <> (3?2)"No" ≡ \i-> (3?1)"Yeah" i ++ (2?1)"But" i ++ (3?2)"No" i

C # (интерактивный компилятор Visual C #) , 105 99 94 96 89 байт

i=>{for(int x=0;x<i;)Write((x%3<1?"Yeah\n":"")+(x%2<1?"But\n":"")+(x++%3==1?"No\n":""));}

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

Пип , 37 35 33 байта

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

(Обратите внимание на пробел после But.) Принимает ввод в качестве аргумента командной строки. Попробуйте онлайн!

объяснение

Это объяснение для предыдущей версии - см. Ниже список изменений

Вдохновлен 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)

Обновление: я понял, что мне не нужно использовать замену, чтобы изменить 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 _"]]

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

Атташе , 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

C (gcc) , 77 71 74 72 69 байт

Здесь уже есть лучший ответ на C, но этот рекурсивный, и мне потребовалось некоторое время, чтобы разобраться, поэтому я публикую его.

До 69 байтов благодаря @ceilingcat и @JonathanFrech

(Я никогда не думаю использовать 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"));}

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

Руби, 69 72 74 Б

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

Очень простой ответ, проверяющий более короткий, рекурсивный метод прямо сейчас.

Сохранено два байта благодаря @BWO :)

Сохранены еще три байта с использованием символов вместо строк

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()))]

Это не совсем лучшее решение, но это мое мнение.

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

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где-то появиться в наборе данных, но это не похоже на это)

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

Чисто , 116 байт

import StdEnv,Data.List
r=cycle
$n=[e\\_<-[1..n]&a<-r["Yeah","",""]&b<-r["But",""]&c<-r["","No",""],e<-[a,b,c]|e>""]

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

F #, 108 106 байт

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и корректируются по модулю. Кроме того, довольно просто.

PHP, 65 68 байт

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

Запустите как трубу с -nRили попробуйте онлайн .

VBA (Excel), 105, 101, 99 байт

Изменить: -4 байта от Keeta! Спасибо!

Редактировать 2: -2 байта от Chronocidal! Woot! (Понял, что тестовые случаи работали только на 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

^ Это вставляется в окно Immediate и выводит в окно отладки

Ungolfed

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

Желе , 22 байта

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

Монадическая ссылка, выдающая список строк (что, по-видимому, разрешено в комментариях)

Попробуйте онлайн! (нижний колонтитул вызывает Link используяÇи соединяется с использованием новых строк,Yпоскольку неявная печать в Jelly разбивает все вместе, если это возможно)

Как?

$2\times3=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

Код создает этот список, формирует его по длине n, индексирует в power-set, а затем удаляет внутренние списки (что также удаляет пустые строки, поскольку строки являются списками в 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"]

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

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

Огромные 9 байтов сохранены благодаря @Jonathan Frech