Mi colega me envió recientemente la siguiente pieza de JavaScript en broma:

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

Dado que el código fue escrito durante las horas de trabajo, obviamente fue un gran desperdicio de recursos de la compañía. Para evitar eventos similares en el futuro, debemos minimizar el desperdicio de horas trabajadas. Y como es de conocimiento común que un programa más corto es más rápido de escribir, ¡debemos desarrollar este código para ser lo más corto posible!

Entrada

Un solo entero no negativo. No debe manejar entradas defectuosas.

Salida

Su programa debe producir una salida idéntica a la del script anterior. Debe generar una palabra por línea, y el número de palabras debe ser coherente con el guión original.

Se permite incluir caracteres de espacio en blanco que no sean de nueva línea al final de cada línea (pero no al principio) ya que son invisibles. Se permite un carácter de nueva línea adicional al final de la salida.

Ejemplos

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

Asume la entrada en la celda A1, y ese formato de Wordwrap está activado para la celda. Use Alt + Intro para agregar saltos de línea dentro de la cadena y observe el espacio en blanco. Solo maneja la entrada hasta 3570 debido al límite de la función REPT (aunque, buena suerte, conseguir que una celda sea tan alta).

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

Reimpresión, con puntos para espacios en blanco

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

Cómo funciona: el patrón se repite 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 uno de estos se puede expresar con 9 caracteres, por lo que una cadena se compone de 54 caracteres (9 * 6), luego se repite tan grande como Excel lo permita. Luego toma los 9 * caracteres izquierdos (número de entrada) como salida.

El salto de línea para el "pero y nadie" se coloca después del espacio en blanco para que el Sí para # 6, # 12, (etc.) esté formateado a la izquierda en lugar de a la derecha, y para que no se agregue un salto de línea en blanco cada sexta línea para ese artículo

JavaScript (ES6), 59 57 bytes

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

Pruébalo en línea!

¿Cómo?

Usamos una función recursiva que va de a lugar de a .1 0 n - $n$$1$$0$$n-1$

Como resultado, las pruebas están desactivadas en comparación con el código de referencia:$1$

• si , salida "Sí"$n\equiv1\pmod 3$
• si , salida "Pero"$n\equiv1\pmod 2$
• si , salida "No"$n\equiv2\pmod 3$

Esto nos permite almacenar el caso más simple como la primera entrada de nuestra matriz de búsqueda, donde podemos definir : una variable que contiene una o una cadena vacía.$n\equiv0\pmod 3$$s$"But\n"

Las otras dos entradas se definen como "Yeah\n" + sy s + "No\n"respectivamente.

Nota: Al iterar de a , también podríamos definir en la primera entrada, pero eso costaría dos paréntesis adicionales .0 $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

Pruébalo en línea!

Espacio en blanco , 315 304 300 277 276 bytes

Gracias a @JoKing por -11 bytes (reduciendo la cantidad de etiquetas utilizadas de 8 a 7) y -24 bytes más (cambiando el flujo general del programa y reduciendo la cantidad de etiquetas utilizadas de 7 a 5 en el proceso).

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

Se agregaron letras S(espacio), T(tabulación) y N(nueva línea) solo como resaltado.
[..._some_action]agregado solo como explicación.

Pruébelo en línea (solo con espacios en bruto, pestañas y nuevas líneas).

El espacio en blanco definitivamente no es el lenguaje adecuado para este desafío. En el espacio en blanco, tanto los bucles como las declaraciones if se realizan con etiquetas y saltos a etiquetas, y dado que no son casos if-elseif-else sino múltiples if-cases, significa que yo tendré que saltar hacia atrás después de cada si, por lo que es bastante largo significa que tendré que modificar ligeramente los controles para omitir algunas impresiones (gracias @JoKing ).

Explicación en pseudocó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)

Explicación adicional:

En general, pasa de la entrada a 0, empujando una nueva línea y la palabra invertida (por lo tanto, en el orden "\ noN", "\ ntuB", "\ nhaeY" en lugar de "Sí \ n", "Pero \ n "," No \ n "). Y después de que la entrada se haya reducido a 0 y todos los caracteres estén en la pila, imprimirá esos caracteres en reversa (por lo tanto, el orden de salida correcto).

Sin embargo, más en profundidad: aunque necesitamos imprimir palabras en el rango (input, 0], en su lugar se repetirá [input, 0). Debido a esto, podemos usar la if(i%3 == 2)marca de verificación para "\ noN" (o en realidad, if(i%3 != 2)omitir el empuje de "\ noN"), y usamos la if(i%2 != 1)marca de verificación para "\ ntuB" (o en realidad, if(i%2 == 0)omitir la inserción de "\ ntuB" ) Solo después de estas dos comprobaciones disminuimos la iteración ien 1. Y luego hacemos la comprobación if(i%3 == 0)para presionar "\ nhaeY", similar al código de ejemplo JS en la descripción del desafío. Saltar con cheques if-not en lugar de ir a una etiqueta y regresar de la etiqueta con if-cheques guardados 23 bytes.

Además, en los espacios en blanco, los valores de los caracteres se almacenan en la pila como sus valores unicode (es decir, 10para líneas nuevas, 65para 'A', 97para 'a', etc.). Como ya necesito recorrer la pila para imprimir los caracteres, también puedo usar mi punta de espacio en blanco para reducir el recuento de bytes agregando una constante a los valores numéricos, antes de imprimirlos como caracteres.
Esta constante es 104en este caso, que se genera con este programa Java que también he usado para jugar otra respuesta de Whitespace mía antes . Esa es también la razón por la cual esta parte del 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]

tiene los valores -94para la nueva línea, 7para la 'o' y -26para la 'N'. Debido a la adición de la constante de la 104voluntad correctamente dar a nuestros valores Unicode 10, 111y 78para estos 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:]

Pruébalo en línea!

Python 3 , 79 76 bytes

La respuesta de Excel del Puerto de Keeta .

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

Pruébalo en línea!

Perl 6 , 63 50 bytes

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

Pruébalo en línea!

Bloque de código anónimo que toma un número y devuelve una lista de líneas

Explicación:

{                                                }   # 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");}

Pruébalo en línea!

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

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

Pruébalo en línea!

05AB1E (heredado) , 27 25 24 bytes

Guardado 1 byte gracias a Kevin Cruijssen .

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

Pruébalo en línea!

Explicación

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

Pruébalo en línea!

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

Pruébalo en línea!

_{-2 bytes, gracias a los 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'))]

Pruébalo en línea!

_{-4 bytes, gracias a los ovs}

-4 bytes, gracias a Jo King

Lienzo , 27 bytes.

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

Pruébalo aquí!

Groovy (función), 79 bytes

Desde que inicialmente envié mi respuesta, he examinado algunas discusiones históricas aquí sobre lo que constituye una respuesta adecuada. Dado que parece comúnmente aceptado proporcionar solo un método en Java (incluyendo el tipo de retorno y las declaraciones de parámetros), aquí hay un método más corto, Groovy, que tiene el valor de retorno del método como respuesta. El uso de defsignifica que se infiere el tipo de retorno.

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

A diferencia de la respuesta original a continuación, que se repite desde 0 hasta n-1, esta se llama a sí misma desde n hasta 1, pero disminuye la entrada para el resto de la línea en la llamada recursiva.

Pruébalo en línea!

Groovy (programa), 87 bytes

Los scripts Groovy no requieren ciertas importaciones comunes, por lo que este puede ser un programa que imprime la respuesta a STDOUT de Java sin tener que declararlo System.out.antes print. También proporciona algunos métodos de utilidad comunes, como este, toLong()que nos permite analizar el argumento de entrada de manera razonablemente concisa.

Esencialmente, la respuesta de Java 10, pero aprovechando la sintaxis de bucle más corto de Groovy y la capacidad de evaluar declaraciones verdaderas.

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

Pruébalo en línea!

Retina 0.8.2 , 45 bytes

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

A`1

Pruébalo en línea! Explicación:

.+
$*

Convierta la entrada a unario.

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

Para cada número entero 0...n-1, genere tres líneas de texto, una para cada palabra, cada una con i 1s antes, a excepción de No, que tiene dos 1s adicionales para que calculemos (i+2)%3==0cuál es equivalente a i%3==1.

+`11B
B

Eliminar pares de 1s antes de Bs.

111

Elimine 1s en grupos de tres en todas partes.

A`1

Eliminar todas las líneas que todavía tienen un 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 gracias a @ OlivierGrégoire .

Pruébalo en línea.

Explicación:

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 gracias TessellatingHeckler

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

Prueba de guión y explicación:

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

Salida:

======
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 sencillo, 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]

Pruébalo en línea!

Explicación

Bastante simple, guardó dos bytes usando en [1..n]lugar de [0..n-1]y ajustó los restos: las (?)pruebas del operador toman cuatro argumentos, devolviendo una lista vacía o la cadena provista como un singleton si el resultado es correcto.

Al cursar el cuarto argumento de (?)podemos utilizar (<>)para concatenar los resultados de cada función, es decir:

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

C # (compilador interactivo de Visual C #) , 105 99 94 96 89bytes

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

Pruébalo en línea!

Pip , 37 35 33 bytes

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

(Observe el espacio después But.) Toma la entrada como un argumento de línea de comandos. Pruébalo en línea!

Explicación

Esta explicación es para la versión anterior; consulte a continuación el registro de cambios

Inspirado por Jo King's Perl 6 respuesta . Construimos esta lista:

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

y generar los primeros aelementos de la misma mediante indexación 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)

Actualización: me di cuenta de que no necesito usar reemplazar para cambiar 0/1/2 en cadenas; puedo usar esos números para indexar directamente en una lista. Para hacer esto, debemos asegurarnos de que los números de varios dígitos se dividan en listas de sus dígitos (de lo contrario, seleccionaremos el índice 10 en lugar de los índices 1 y 0). Afortunadamente, el uso de una lista anidada arbitrariamente como índice en Pip funciona como se esperaba, dando una lista (anidada) de resultados. Para la entrada de 3, obtenemos esta progresión de datos (donde _representa una nueva línea):

"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, el resultado final se concatena y se imprime automáticamente.

Adjunto , 48 bytes

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

Pruébalo en línea!

Explicación

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

Ya hay una mejor respuesta en C aquí, pero esta es recursiva y me tomó un tiempo aclararla, así que la publico.

Hasta 69 bytes gracias a @ceilingcat y @JonathanFrech

(Nunca pienso usar n- ~ -i en 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"));}

Pruébalo en línea!

Rubí, 69 72 74 Bytes

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

Respuesta muy directa, buscando un método más corto y recursivo en este momento.

Guardado dos bytes gracias a @BWO :)

Guardado otros tres bytes usando símbolos en lugar de cadenas

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 no es exactamente la mejor solución, pero es mi opinión.

Pruébalo en línea!

R, 65 bytes

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

Debido al hecho de que estamos replicando un programa ligeramente defectuoso (se pierde cada cuarto "pero", debería haber usado %4 == 1y %4 == 3no %3condiciones), tenemos que usar una llamada incómoda cy trabajar en la base siete. Aún así, es más corto que LOLCODE ...

(Esperaba que (3,1,2,3,2,1,2) o una permutación similar pudiera aparecer en el lhconjunto de datos en alguna parte, pero no lo 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\ 

La parte más difícil no fue construir la lista sino analizar el número decimal.

Se pueden guardar 2 bytes si no se requiere la nueva línea al final: c\ → d.

Todavía requiere optimización.

Pruébalo en línea .

Explicación

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

Limpio , 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>""]

Pruébalo en línea!

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

Pruébalo en línea!

-2 bytes cambiando de i=0 to p-1a i=1 to py ajustando módulos. Aparte de eso, bastante sencillo.

PHP, 65 68 bytes

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

Ejecutar como tubería -nRo probarlo en línea .

VBA (Excel), 105, 101, 99 bytes

Editar: -4 bytes de Keeta! ¡Gracias!

Edición 2: -2 bytes de Chronocidal! Woot! (Me di cuenta de que los casos de prueba solo funcionaban para 10. Corregido ahora)

Sí, Excel venció a VBA esta vez. Lo que sea. (Vamos por ti)

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

^ Esto se pega en la ventana Inmediato y sale a la ventana de depuración

Sin golf

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

Jalea , 22 bytes

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

Un enlace monádico que produce una lista de líneas (que parece haberse permitido en los comentarios)

Pruébalo en línea! (el pie de página llama a Link usandoÇy se une a las nuevas líneas usandoYya que la impresión implícita en Jelly rompe todo junto si puede)

¿Cómo?

$2\times3=6$

Ahora tenga en cuenta que los primeros seis valores son:

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

Entonces, la lista resultante de líneas debe ser estos valores repetidos (o truncados) a una longitud nconcatenada juntos.

Ahora tenga en cuenta que el conjunto de potencia de "Yeah", "But", "No"es:

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

Entonces, cada período son estos valores indexados 1 del conjunto de potencias de "Yeah", "But", "No":

5, 4, 3, 2, 7, 1

El código crea esta lista, la moldea a medida n, la indexa en el conjunto de alimentación y luego elimina las listas internas (que también elimina las cadenas vacías, ya que las cadenas son listas en 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))

Pruébalo en línea!

Un enorme 9 bytes guardados gracias a @Jonathan Frech