Il mio collega recentemente mi ha inviato il seguente pezzo di JavaScript come uno scherzo:

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

Poiché il codice è stato scritto durante l'orario di lavoro, è stato ovviamente un enorme spreco di risorse aziendali. Per evitare simili eventi in futuro, dobbiamo ridurre al minimo lo spreco di ore lavorate. E poiché è risaputo che un programma più breve è più veloce da scrivere, dobbiamo golfizzare questo codice per essere il più breve possibile!

Ingresso

Un singolo numero intero non negativo. Non è necessario gestire input errati.

Produzione

Il tuo programma deve produrre un output identico a quello dello script sopra. Dovresti generare una parola per riga e il numero di parole dovrebbe essere coerente con lo script originale.

È consentito includere caratteri di spazi bianchi non newline alla fine di ogni riga (ma non all'inizio) poiché sono invisibili. È consentito un carattere di nuova riga aggiuntivo alla fine dell'output.

Esempi

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 byte

Presuppone l'input nella cella A1 e che la formattazione di Wordwrap è attivata per la cella. Utilizzare Alt + Invio per aggiungere avanzamenti di riga all'interno della stringa e annotare lo spazio bianco. Gestisce solo input fino a 3570 a causa del limite della funzione REPT (buona fortuna, però, ottenere una cella così alta).

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

Ristampa, con punti per spazi bianchi

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

Come funziona: il modello si ripete ogni 6 numeri:

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

Ognuno di questi può essere espresso con 9 caratteri, quindi una stringa è composta da 54 caratteri (9 * 6), quindi ripetuta grande quanto Excel consentirà. Quindi prende i caratteri a sinistra 9 * (numero di input) come output.

Linefeed per il "ma e nessuno" viene inserito dopo lo spazio vuoto in modo che Yeah per # 6, # 12, (ecc.) Sia formattato a sinistra anziché a destra e in modo che non vi sia alcun avanzamento riga vuoto aggiunto ogni 6a riga per quell'articolo.

JavaScript (ES6), 59 57 byte

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

Provalo online!

Come?

Usiamo una funzione ricorsiva che va da a anziché da a .1 0 n - $n$$1$$0$$n-1$

Di conseguenza, i test sono disattivati ​​di rispetto al codice di riferimento:$1$

• se , visualizza "Sì"$n\equiv1\pmod 3$
• se , visualizza "Ma"$n\equiv1\pmod 2$
• se , visualizza "No"$n\equiv2\pmod 3$

Questo ci consente di memorizzare il caso più semplice come prima voce del nostro array di ricerca, in cui possiamo definire : una variabile che contiene una o una stringa vuota.$n\equiv0\pmod 3$$s$"But\n"

Le altre due voci sono definite come "Yeah\n" + se s + "No\n"rispettivamente.

Nota: iterando da a , potremmo anche definire nella prima voce, ma costerebbe due parentesi extra .0 $n-1$$0$$s$

Commentate

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 byte

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

Provalo online!

Spazio bianco , 315 304 300 277 276 byte

Grazie a @JoKing per -11 byte (riducendo la quantità di etichette utilizzate da 8 a 7) e -24 più byte (modificando il flusso generale del programma e riducendo la quantità di etichette utilizzate da 7 a 5 nel 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]

Lettere S(spazio), T(scheda) e N(nuova riga) aggiunti solo come evidenziazione.
[..._some_action]aggiunto solo come spiegazione.

Provalo online (solo con spazi non elaborati, schede e nuove righe).

Whitespace non è sicuramente la lingua giusta per questa sfida. In Whitespace sia i loop che le istruzioni if ​​sono fatti con etichette e salti alle etichette, e poiché non sono casi if-elseif-else ma più if-case, significa che io dovrò tornare indietro dopo ogni se, rendendolo abbastanza lungo significa che dovrò modificare leggermente i controlli per saltare alcune stampe (grazie @JoKing ).

Spiegazione in pseudo-codice:

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)

Spiegazione aggiuntiva:

In generale, scorre dall'input fino a 0, spingendo una nuova riga e la parola invertita (quindi nell'ordine "\ noN", "\ ntuB", "\ nhaeY" invece di "Yeah \ n", "Ma \ n "," No \ n "). E dopo che l'input si è ridotto a 0 e tutti i caratteri sono in pila, li stampa in ordine inverso (quindi l'ordine di output corretto).

Più in profondità, tuttavia: sebbene sia necessario stampare parole nell'intervallo (input, 0], verrà invece inserito nell'intervallo [input, 0). Per questo if(i%3 == 2)motivo , possiamo usare il controllo per "\ noN" (o effettivamente, if(i%3 != 2)saltare il push di "\ noN"), e possiamo usare il controllo if(i%2 != 1)per "\ ntuB" (o in realtà, if(i%2 == 0)saltare il push di "\ ntuB" ). Solo dopo questi due controlli diminuiamo l'iterazione idi 1. E quindi if(i%3 == 0)eseguiamo il controllo per inviare "\ nhaeY", simile al codice di esempio JS nella descrizione della sfida. Saltare con i controlli if-not invece di andare su un'etichetta e tornare dall'etichetta con if-checks salvati 23 byte.

Inoltre, in Whitespace i valori dei caratteri sono memorizzati nello stack come valori unicode (ad es. 10Per new-line, 65per 'A', 97per 'a', ecc.). Dato che ho già bisogno di passare in rassegna lo stack per stampare i caratteri, sono anche in grado di utilizzare il mio suggerimento per gli spazi bianchi per ridurre il conteggio dei byte aggiungendo una costante ai valori numerici, prima di stamparli come caratteri.
Questa costante è 104in questo caso, che viene generata con questo programma Java che ho anche usato per golf un'altra mia risposta agli spazi bianchi prima . Questo è anche il motivo per cui questa parte del codice:

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

ha i valori -94per la newline, 7per la 'o' e -26per la 'N'. Perché l'aggiunta della costante di 104darà correttamente i nostri valori unicode e 10, rispettivamente 111, 78per questi caratteri.

Python 3 , 85 82 byte

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

Provalo online!

Python 3 , 79 76 byte

Porto di Keeta 's risposta Excel .

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

Provalo online!

Perl 6 , 63 50 byte

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

Provalo online!

Blocco di codice anonimo che accetta un numero e restituisce un elenco di righe

Spiegazione:

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

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

Provalo online!

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

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

Provalo online!

05AB1E (legacy) , 27 25 24 byte

Salvato 1 byte grazie a Kevin Cruijssen .

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

Provalo online!

Spiegazione

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 byte

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

Provalo online!

Python 2 , 97 95 92 90 83 81 byte

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

Provalo online!

_{-2 byte, grazie agli ovs}

Python 3 , 92 90 85 83 byte

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

Provalo online!

_{-4 byte, grazie agli ovs}

-4 byte, grazie a Jo King

Tela , 27 byte

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

Provalo qui!

Groovy (funzione), 79 byte

Da quando ho inviato inizialmente la mia risposta, ho esaminato alcune discussioni storiche qui su ciò che costituisce una risposta adeguata. Dal momento che sembra comunemente accettato di fornire solo un metodo in Java (incluso il tipo restituito e le dichiarazioni dei parametri), ecco un metodo più breve, Groovy, che ha il valore restituito dal metodo come risposta. L'uso di defsignifica che il tipo restituito viene dedotto.

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

A differenza della risposta originale di seguito, che passa da 0 a n-1, questa si chiama da n in giù a 1, ma diminuisce l'input per il resto della linea nella chiamata ricorsiva.

Provalo online!

Groovy (programma), 87 byte

Gli script Groovy non richiedono alcune importazioni comuni, quindi questo può essere un programma che stampa la risposta allo STDOUT di Java senza doverlo dichiarare System.out.prima print. Fornisce inoltre alcuni metodi di utilità comuni, come questo toLong()che ci consente di analizzare l'argomento di input ragionevolmente in modo consecutivo.

Essenzialmente la risposta di Java 10, ma sfruttando la sintassi del ciclo più breve di Groovy e la capacità di valutare le affermazioni di verità.

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

Provalo online!

Retina 0.8.2 , 45 byte

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

A`1

Provalo online! Spiegazione:

.+
$*

Converti l'input in unario.

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

Per ogni numero intero 0...n-1, genera tre righe di testo, una per ogni parola, ognuna con i 1s prima di essa, ad eccezione di No, che ha due 1s in più in modo da calcolare (i+2)%3==0quale è equivalente i%3==1.

+`11B
B

Rimuovere le coppie di 1s prima di Bs.

111

Rimuovi 1s in gruppi di tre ovunque.

A`1

Elimina tutte le righe che hanno ancora un 1.

Java 10, 100 99 byte

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 grazie a @ OlivierGrégoire .

Provalo online.

Spiegazione:

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 byte

-1 byte grazie a TessellatingHeckler

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

Test script e spiegazione:

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

Produzione:

======
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 semplice, 72 byte:

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

Haskell , 71 byte

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

Provalo online!

Spiegazione

Abbastanza semplice, salvato due byte usando [1..n]invece di [0..n-1]e adattato i rimanenti: i (?)test dell'operatore accettano quattro argomenti, restituendo un elenco vuoto o la stringa fornita come singleton se il risultato è corretto.

Esaminando il quarto argomento di (?)possiamo usare (<>)per concatenare i risultati di ciascuna funzione, ad es .:

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

C # (compilatore interattivo 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":""));}

Provalo online!

Pip , 37 35 33 byte

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

(Nota lo spazio dopo But). Accetta input come argomento della riga di comando. Provalo online!

Spiegazione

Questa spiegazione è per la versione precedente - vedi sotto per il log delle modifiche

Ispirato dalla risposta Perl 6 di Jo King . Costruiamo questo elenco:

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

e produce i primi aelementi usando l'indicizzazione ciclica.

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

Aggiornamento: mi sono reso conto che non ho bisogno di usare sostituire per cambiare 0/1/2 in stringhe - posso usare quei numeri per indicizzare direttamente un elenco. Per fare questo, dobbiamo assicurarci che i numeri a più cifre siano divisi in elenchi delle loro cifre (altrimenti, selezioneremo l'indice 10 anziché gli indici 1 e 0). Fortunatamente, l'utilizzo di un elenco arbitrariamente nidificato come indice in Pip funziona come previsto, fornendo un elenco (nidificato) dei risultati. Per input di 3, otteniamo questa progressione di dati (dove _rappresenta una nuova riga):

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

Come prima, il risultato finale viene concatenato insieme e stampato automaticamente.

Attache , 48 byte

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

Provalo online!

Spiegazione

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 byte

C'è già una risposta C migliore qui, ma questa è ricorsiva e mi ci è voluto un po 'di tempo per mettermi dritto, quindi la sto postando.

Fino a 69 byte grazie sia a @ceilingcat che a @JonathanFrech

(Non penso mai di usare n- ~ -i al posto di 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"));}

Provalo online!

Ruby, 69 72 74 byte

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

Risposta molto diretta, cercando un metodo più breve e ricorsivo in questo momento.

Due byte salvati grazie a @BWO :)

Salvati altri tre byte utilizzando i simboli anziché le stringhe

Python 3, 93 byte

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

Questa non è esattamente la soluzione migliore ma è la mia opinione su di essa.

Provalo online!

R, 65 byte

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

A causa del fatto che stiamo replicando un programma leggermente imperfetto (manca ogni quattro "ma" - avrebbe dovuto usare %4 == 1e %4 == 3piuttosto che %3condizioni), dobbiamo usare una chiamata scomoda ce lavorare nella base sette. Tuttavia, è più corto di LOLCODE ...

(Speravo che (3,1,2,3,2,1,2) o una permutazione simile potesse apparire nell'insieme di lhdati da qualche parte ma non sembra simile)

sed -E ,179 150 byte

/^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 più difficile non è stata quella di costruire l'elenco ma di analizzare effettivamente il numero decimale.

2 byte possono essere salvati se il newline alla fine non è richiesto: c\ → d.

Richiede ancora ottimizzazione.

Provalo online .

Spiegazione

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

Pulito , 116 byte

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

Provalo online!

F #, 108 106 byte

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

Provalo online!

-2 byte cambiando da i=0 to p-1a i=1 to pe modificando i moduli. A parte questo, abbastanza diretto.

PHP, 65 68 byte

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

Esegui come pipe -nRo provalo online .

VBA (Excel), 105, 101, 99 byte

Modifica: -4 byte da Keeta! Grazie!

Modifica 2: -2 byte da Chronocidal! Woot! (Compresi che i casi di test funzionavano solo per 10. Risolto ora)

Sì, questa volta Excel ha battuto VBA. Qualunque cosa. (Veniamo per te)

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

^ Viene incollato nella finestra immediata e restituito alla finestra di debug

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 byte

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

Un collegamento monadico che fornisce un elenco di righe (che sembra essere stato consentito nei commenti)

Provalo online! (il piè di pagina chiama Link usandoÇe si unisce a newline usandoYpoiché la stampa implicita in Jelly distrugge tutto se possibile)

Come?

$2\times3=6$

Ora nota che i primi sei valori sono:

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

Quindi l'elenco di righe risultante dovrebbe essere questi valori ripetuti (o troncati) in lunghezza nconcatenati insieme.

Ora nota che il power-set di "Yeah", "But", "No"è:

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

Quindi ogni periodo corrisponde a questi valori 1 indicizzati del gruppo di potenza di "Yeah", "But", "No":

5, 4, 3, 2, 7, 1

Il codice crea questo elenco, lo modella in lunghezza n, si indicizza nel gruppo di alimentazione e quindi rimuove gli elenchi interni (che rimuove anche le stringhe vuote, poiché le stringhe sono elenchi in 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 byte

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

Provalo online!

Un enorme 9 byte risparmiati grazie a @Jonathan Frech