Нещодавно мій колега на жарт надіслав мені такий фрагмент 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, (тощо) відформатувався ліворуч, а не праворуч. для цього пункту.

JavaScript (ES6), 59 57 байт

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

Спробуйте в Інтернеті!

Як?

Ми використовуємо рекурсивну функцію, яка переходить від до 1, а не від 0 до n - 1 .$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 більше байтів (зміна загального потоку програми та зменшення кількості міток, використовуваних з 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]додано лише як пояснення.

Спробуйте його в режимі он-лайн (лише із просторами, вкладками та новими рядками).

Whitespace, безумовно, не є правильною мовою для цього виклику. У Whitespace обидва цикли та 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", "Але \ 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 в описі виклику. Пропуск за допомогою чеків, якщо не, замість того, щоб перейти до мітки та повернутися з мітки, якщо-чеки зберегли 23 байти.

Також у символах Whitespace символи зберігаються у стеку як їхні значення Unicode (тобто 10для нових рядків, 65для 'A', 97для 'a' тощо). Оскільки мені вже потрібно перевести цикл на стек для друку символів, я також можу використовувати підказку Whitespace, щоб знизити кількість байтів, додавши константу до значень чисел, перш ніж друкувати їх як символи.
Ця константа є 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:]

Спробуйте в Інтернеті!

Пітон 3 , 79 76 байт

Відповідь Порта Кіти в 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 байт завдяки Kevin Cruijssen .

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, але використання синтаксису коротшого циклу та здатність Гроові оцінювати тверді твердження.

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 байт дякую TessellingHeckler

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

Додавши четвертий аргумент, (?)ми можемо скористатись (<>)для об'єднання результатів кожної функції, тобто:

(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 # Interactive Compiler) , 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 _"]]

Як і раніше, кінцевий результат об'єднують разом і відбивають друком.

Attache , 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! Вуто! (Зрозумів, що тестові справи працювали лише для 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

Желе , 22 байти

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

Монадична посилання, що дає список рядків (що, здається, дозволено в коментарях)

Спробуйте в Інтернеті! (нижній колонтитул викликає Посилання за допомогоюÇта приєднується до нових рядків із використанням,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, індексує в набір потужності, а потім видаляє внутрішні списки (що також видаляє порожні рядки, оскільки рядки є списками в 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