Meu colega recentemente me enviou a seguinte peça de JavaScript como uma piada:

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

Como o código foi escrito durante o horário de trabalho, era obviamente um enorme desperdício de recursos da empresa. Para evitar ocorrências semelhantes no futuro, devemos minimizar o desperdício de horas trabalhadas. E como é de conhecimento geral que um programa mais curto é mais rápido de escrever, devemos aplicar esse código no menor tempo possível!

Entrada

Um único inteiro não negativo. Você não deve lidar com entradas defeituosas.

Resultado

Seu programa deve produzir uma saída idêntica à do script acima. Você deve produzir uma palavra por linha e o número de palavras deve ser consistente com o script original.

É permitido incluir caracteres de espaço em branco que não sejam de nova linha no final de cada linha (mas não no início), pois são invisíveis. Um caractere de nova linha adicional é permitido no final da saída.

Exemplos

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 bytes

Pressupõe a entrada na célula A1 e a formatação do Wordwrap está ativada para a célula. Use Alt + Enter para adicionar feeds de linha dentro da string e observe o espaço em branco. Somente lida com entrada de até 3570 devido ao limite da função REPT (embora boa sorte seja a obtenção de uma célula tão alta).

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

Reimpressão, com períodos para espaço em branco

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

Como funciona: o padrão se repete a cada 6 números:

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

Cada um deles pode ser expresso com 9 caracteres; portanto, uma seqüência de caracteres é composta por 54 caracteres (9 * 6) e repetida do tamanho que o Excel permitir. Em seguida, são aceitos os 9 caracteres esquerdos * (número de entradas) como saída.

O avanço de linha para o "mas e ninguém" é colocado após o espaço em branco, para que o Sim para # 6, 12, (etc) seja formatado para a esquerda e não para a direita, e para que não haja avanço de linha em branco adicionado a cada 6ª linha para esse item.

JavaScript (ES6), 59 57 bytes

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

Experimente online!

Quão?

Usamos uma função recursiva que vai de a 1 em vez de 0 a n - 1 .$n$$1$$0$$n-1$

Como resultado, os testes são desativados em comparação com o código de referência:$1$

• se , saída"Sim"$n\equiv1\pmod 3$
• se , saída"But"$n\equiv1\pmod 2$
• se , saída"Não"$n\equiv2\pmod 3$

Isso nos permite armazenar o caso mais simples como a primeira entrada da nossa matriz de pesquisa, onde podemos definir s : uma variável contendo umaou uma string vazia.$n\equiv0\pmod 3$$s$"But\n"

As duas outras entradas são definidas como "Yeah\n" + se s + "No\n"respectivamente.

Nota: Ao iterar de a 0 , poderíamos definir s na primeira entrada também, mas isso custaria dois parênteses extras .$n-1$$0$$s$

Comentado

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 bytes

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

Experimente online!

Espaço em branco , 315 304 300 277 276 bytes

Graças ao @JoKing por -11 bytes (reduzindo a quantidade de rótulos usados ​​de 8 para 7) e -24 mais bytes (alterando o fluxo geral do programa e reduzindo a quantidade de rótulos usados ​​de 7 para 5 no processo).

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

Letras S(espaço), T(tabulação) e N(nova linha) adicionadas apenas como destaque.
[..._some_action]adicionado apenas como explicação.

Experimente online (apenas com espaços brutos, guias e novas linhas).

O espaço em branco definitivamente não é o idioma certo para esse desafio. No espaço em branco, os loops e as declarações if são feitos com rótulos e salta para rótulos e, como não são casos if-elseif-else, mas múltiplos if-cases, significa que eu terá que voltar depois de cada if, tornando-o bastante longo , significa que terei que modificar ligeiramente as verificações para pular algumas impressões (obrigado @JoKing ).

Explicação em pseudo-código:

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)

Explicação adicional:

Em geral, ele faz um loop da entrada para 0, pressionando uma nova linha e a palavra invertida (na ordem "\ noN", "\ ntuB", "\ nhaeY" em vez de "Yeah \ n", "But \ n ", "Não"). E depois que a entrada tiver diminuído para 0 e todos os caracteres estiverem na pilha, os caracteres serão impressos no sentido inverso (portanto, a ordem de saída correta).

Mais detalhadamente, no entanto: embora seja necessário imprimir palavras no intervalo (input, 0], ele será repetido no intervalo [input, 0). Por esse if(i%3 == 2)motivo , podemos usar a verificação de "\ noN" (ou, na verdade, if(i%3 != 2)ignorar o envio de "\ noN") e usar a verificação if(i%2 != 1)de "\ ntuB" (ou, na verdade, if(i%2 == 0)ignorar a solicitação de "\ ntuB" ) Somente após essas duas verificações, diminuímos a iteração iem 1. E, em seguida, faça a verificação if(i%3 == 0)para pressionar "\ nhaeY", semelhante ao código de exemplo JS na descrição do desafio. Ignorando as verificações se não, em vez de ir para um rótulo e retornando do rótulo com as verificações se salvas 23 bytes.

Além disso, no espaço em branco, os valores dos caracteres são armazenados na pilha como valores unicode (ou seja, 10para novas linhas, 65para 'A', 97para 'a' etc.). Como já preciso percorrer a pilha para imprimir os caracteres, também posso usar minha dica de espaço em branco para diminuir a contagem de bytes, adicionando uma constante aos valores numéricos, antes de imprimi-los como caracteres.
Essa constante é 104neste caso, que é gerada com este programa Java que eu também usei para obter outra resposta em branco do Whitespace antes . Essa também é a razão pela qual esta parte do código:

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

tem os valores -94para a nova linha, 7para o 'o' e -26para o 'N'. Porque adicionando a constante de 104vontade dar corretamente nossos valores unicode 10, 111e 78para esses caracteres, respectivamente.

Python 3 , 85 82 bytes

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

Experimente online!

Python 3 , 79 76 bytes

Porto de Keeta 's resposta Excel .

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

Experimente online!

Perl 6 , 63 50 bytes

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

Experimente online!

Bloco de código anônimo que pega um número e retorna uma lista de linhas

Explicação:

{                                                }   # 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 bytes

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

Experimente online!

C (gcc) , 60 + 11 = 71 bytes (usando -D$=||puts()

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

Experimente online!

05AB1E (legado) , 27 25 24 bytes

Guardou 1 byte graças a Kevin Cruijssen .

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

Experimente online!

Explicação

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 bytes

lambda n:'\n'.join((["Yeah\nBut","No","But","Yeah","But\nNo"]*n)[:n-n/6])

Experimente online!

Python 2 , 97 95 92 90 83 81 bytes

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

Experimente online!

_{-2 bytes, graças a ovs}

Python 3 , 92 90 85 83 bytes

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

Experimente online!

_{-4 bytes, graças a ovs}

-4 bytes, graças a Jo King

Tela , 27 bytes

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

Experimente aqui!

Groovy (função), 79 bytes

Desde que enviei minha resposta inicialmente, examinei aqui algumas discussões históricas sobre o que constitui uma resposta adequada. Como parece comumente aceito fornecer apenas um método em Java (incluindo declarações de tipo e parâmetro de retorno), aqui está um método Groovy mais curto, que tem o valor de retorno do método como resposta. O uso de defsignifica que o tipo de retorno é inferido.

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

Diferentemente da resposta original abaixo, que passa de 0 a n-1, esta se chama de n até 1, mas diminui a entrada do restante da linha na chamada recursiva.

Experimente online!

Groovy (programa), 87 bytes

Os scripts do Groovy não exigem certas importações comuns, portanto, este pode ser um programa que imprime a resposta para o STDOUT do Java sem precisar declarar System.out.antesprint . Ele também fornece alguns métodos de utilidade comuns, como este, toLong()que nos permitem analisar o argumento de entrada de maneira razoavelmente consistente.

Essencialmente, a resposta do Java 10, mas aproveitando a sintaxe de loop mais curta do Groovy e a capacidade de avaliar declarações de verdade.

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

Experimente online!

Retina 0.8.2 , 45 bytes

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

A`1

Experimente online! Explicação:

.+
$*

Converta a entrada para unário.

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

Para cada número inteiro 0...n-1, gere três linhas de texto, uma para cada palavra, cada uma com i 1s antes, exceto por No, que possui dois 1s extras, para que possamos calcular (i+2)%3==0qual é o equivalente a i%3==1.

+`11B
B

Remova pares de 1s antes de Bs.

111

Remova 1s em grupos de três em qualquer outro lugar.

A`1

Exclua todas as linhas que ainda possuem a 1.

Java 10, 100 99 bytes

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 byte graças a @ OlivierGrégoire .

Experimente online.

Explicação:

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 bytes

-1 byte thanks TessellatingHeckler

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

Script de teste e explicação:

$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"
}

Resultado:

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

Script simples, 72 bytes:

$args|?{$_}|%{0..--$_|%{@('Yeah')[$_%3]
@('But')[$_%2]
@{1='No'}[$_%3]}}

Haskell , 71 bytes

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

Experimente online!

Explicação

Muito simples, salvou dois bytes usando em [1..n]vez de [0..n-1]e ajustou os demais: O operador (?)testa quatro argumentos, retornando uma lista vazia ou a sequência fornecida como um singleton, se o resultado estiver correto.

Currying o quarto argumento de (?)podemos usar (<>)para concatenar os resultados de cada função, ou seja:

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

C # (compilador interativo do Visual C #) , 105 99 94 96 89 bytes

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

Experimente online!

Pip , 37 35 33 bytes

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

(Observe o espaço depois But.) Recebe a entrada como argumento da linha de comando. Experimente online!

Explicação

Esta explicação é para a versão anterior - veja abaixo o changelog

Inspirado na resposta Perl 6 de Jo King . Construímos esta lista:

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

e produza os primeiros aelementos usando indexação cíclica.

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

Atualização: percebi que não preciso usar o comando substituir para alterar 0/1/2 em seqüências de caracteres - posso usar esses números para indexar diretamente em uma lista. Para fazer isso, precisamos garantir que os números de vários dígitos sejam divididos em listas de seus dígitos (caso contrário, selecionaremos o índice 10 em vez dos índices 1 e 0). Felizmente, o uso de uma lista arbitrariamente aninhada como um índice no Pip funciona conforme o esperado, fornecendo uma lista (aninhada) de resultados. Para a entrada 3, obtemos essa progressão de dados (onde _representa uma nova linha):

"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 _"]]

Como antes, o resultado final é concatenado e impresso automaticamente.

Anexo , 48 bytes

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

Experimente online!

Explicação

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 bytes

Já existe um melhor resposta C aqui, mas essa é recursiva e demorei algum tempo para entender, então estou postando.

Até 69 bytes, graças a @ceilingcat e @JonathanFrech

(Eu nunca acho que use n- ~ -i no lugar de 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"));}

Experimente online!

Ruby, 69 72 74 Bytes

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

Resposta muito direta, buscando um método mais curto e recursivo no momento.

Economizou dois bytes graças a @BWO :)

Salvo outros três bytes usando símbolos em vez de cadeias

Python 3, 93 bytes

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

Esta não é exatamente a melhor solução, mas é minha opinião.

Experimente online!

R, 65 bytes

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

Devido ao fato de estarmos replicando um programa ligeiramente defeituoso (ele perde a cada quatro "mas" - ele deveria ter usado %4 == 1e %4 == 3não%3 condições), precisamos usar uma chamada estranha ce trabalhar na base sete. Ainda assim, é mais baixo que LOLCODE ...

(Eu esperava que (3,1,2,3,2,1,2) ou uma permutação semelhante pudesse aparecer no lhconjunto de dados em algum lugar, mas não parece)

sed -E ,179 150 bytes

/^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\ 

A parte mais difícil não foi construir a lista, mas analisar o número decimal.

Podem ser salvos 2 bytes se a nova linha no final não for necessária: c\ → d.

Ainda requer otimização.

Experimente online .

Explicação

/^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

Limpo , 116 bytes

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

Experimente online!

F #, 108 106 bytes

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

Experimente online!

-2 bytes mudando a partir i=0 to p-1de i=1 to pe ajustando modulos. Além disso, bem direto.

PHP, 65 68 bytes

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

Execute como pipe -nRou experimente online .

VBA (Excel), 105, 101, 99 bytes

Edit: -4 bytes do Keeta! Obrigado!

Edite 2: -2 bytes de Cronocida! Woot! (Percebi que os casos de teste funcionavam apenas para 10. Corrigido agora)

Sim, o Excel venceu o VBA desta vez. Tanto faz. (Estamos vindo para você)

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

^ Isto é colado na janela imediata e produz na janela de depuração

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

Gelatina , 22 bytes

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

Um link monádico produzindo uma lista de linhas (que parece ter sido permitida nos comentários)

Experimente online! (o rodapé chama o Link usandoÇe se une a novas linhas usando,Ypois a impressão implícita no Jelly esmaga tudo, se puder)

Quão?

Primeira nota que temos um período de $2\times3=6$ devido à definição do módulo.

Agora observe que os seis primeiros valores são:

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

Portanto, a lista de linhas resultante deve ser esses valores repetidos (ou truncados) para o comprimento nconcatenado juntos.

Agora observe que o conjunto de poder de "Yeah", "But", "No"é:

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

Portanto, cada período são esses valores indexados em 1 do conjunto de poder de "Yeah", "But", "No":

5, 4, 3, 2, 7, 1

O código faz essa lista, molda-a no comprimento n, indexa no conjunto de potência e remove as listas internas (que também remove as strings vazias, já que strings são listas no 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 bytes

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

Experimente online!

Um enorme 9 bytes salvos com agradecimentos a @Jonathan Frech