Mein Kollege hat mir kürzlich das folgende Stück JavaScript als Scherz geschickt:

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

Da der Code während der Arbeitszeit geschrieben wurde, war dies offensichtlich eine enorme Verschwendung von Unternehmensressourcen. Um ähnliche Ereignisse in Zukunft zu vermeiden, müssen wir die Verschwendung von Arbeitsstunden minimieren. Und da es allgemein bekannt ist, dass ein kürzeres Programm schneller zu schreiben ist, müssen wir diesen Code so kurz wie möglich halten!

Eingang

Eine einzelne nicht negative Ganzzahl. Sie dürfen keine fehlerhaften Eingaben verarbeiten.

Ausgabe

Ihr Programm muss eine Ausgabe erzeugen, die mit der des obigen Skripts identisch ist. Sie sollten ein Wort pro Zeile ausgeben und die Anzahl der Wörter sollte mit dem ursprünglichen Skript übereinstimmen.

Es ist zulässig, am Ende jeder Zeile (aber nicht am Anfang) Nicht-Leerzeichen einzufügen, da sie unsichtbar sind. Ein zusätzliches Zeilenumbruchzeichen ist am Ende der Ausgabe zulässig.

Beispiele

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

Es wird davon ausgegangen, dass die Eingabe in Zelle A1 erfolgt und die Wordwrap-Formatierung für die Zelle aktiviert ist. Verwenden Sie Alt + Eingabetaste, um Zeilenvorschübe in die Zeichenfolge einzufügen und das Leerzeichen zu notieren. Kann aufgrund der eingeschränkten REPT-Funktion nur Eingaben bis zu 3570 verarbeiten.

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

Nachdruck mit Leerzeichen

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

So funktioniert es: Das Muster wiederholt sich alle 6 Zahlen:

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

Jedes dieser Zeichen kann mit 9 Zeichen ausgedrückt werden. Eine Zeichenfolge besteht also aus 54 Zeichen (9 * 6) und wird so oft wiederholt, wie Excel dies zulässt. Dann werden die linken 9 * (Anzahl der eingegebenen) Zeichen als Ausgabe verwendet.

Der Zeilenvorschub für das "aber und keiner" wird nach dem Leerzeichen eingefügt, sodass das Ja für # 6, # 12 (usw.) eher links als rechts formatiert wird und nicht jede 6. Zeile ein Leerzeilenvorschub hinzugefügt wird für diesen Artikel.

JavaScript (ES6), 59-57 Byte

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

Probieren Sie es online!

Wie?

Wir verwenden eine rekursive Funktion, die von ausgeht$n$$1$$0$$n-1$

$1$

• wenn , "Yeah" aus$n\equiv1\pmod 3$
• wenn , "Aber" aus$n\equiv1\pmod 2$
• wenn , Ausgabe "Nein"$n\equiv2\pmod 3$

Dies ermöglicht es uns, den einfacheren Fall als ersten Eintrag unseres Nachschlage-Arrays zu speichern , in dem wir definieren können : eine Variable, die entweder eine leere Zeichenfolge enthält.$n\equiv0\pmod 3$$s$"But\n"

Die beiden anderen Einträge sind als "Yeah\n" + sund definiert s + "No\n".

Hinweis: Wenn Sie von bis iterieren , könnten Sie auch im ersten Eintrag definieren , dies würde jedoch zwei zusätzliche Klammern kosten .$n-1$$0$$s$

Kommentiert

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

Probieren Sie es online!

Whitespace , 315 304 300 277 276 Bytes

Dank @JoKing für -11 Byte (Reduzierung der Anzahl der verwendeten Labels von 8 auf 7) und -24 Byte mehr (Änderung des allgemeinen Programmflusses und Reduzierung der Anzahl der verwendeten Labels von 7 auf 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]

Buchstaben S(Leerzeichen), T(Tabulator) und (Zeilenvorschub) werden Nnur als Hervorhebungen hinzugefügt.
[..._some_action]nur als Erklärung hinzugefügt.

Probieren Sie es online aus (nur mit Leerzeichen, Tabulatoren und Zeilenumbrüchen).

Whitespace ist definitiv nicht die richtige Sprache für diese Herausforderung. In Whitespace werden sowohl Schleifen als auch if-Anweisungen mit Bezeichnungen und Sprüngen zu Bezeichnungen erstellt, und da es sich nicht um if-else-Fälle handelt, sondern um mehrere if-Fälle, bedeutet dies I muss nach jedem if zurückspringen, was bedeutet, dass ich die Checks leicht ändern muss, um einige Ausdrucke zu überspringen (danke @JoKing ).

Erklärung im Pseudocode:

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)

Zusätzliche Erklärung:

Im Allgemeinen wird eine Schleife von der Eingabe bis auf 0 ausgeführt, wobei eine neue Zeile eingefügt und das Wort umgekehrt wird (also in der Reihenfolge "\ noN", "\ ntuB", "\ nhaeY" anstelle von "Yeah \ n", "But \ n "," Nein \ n "). Nachdem die Eingabe auf 0 zurückgesetzt wurde und sich alle Zeichen auf dem Stapel befinden, werden diese Zeichen in umgekehrter Reihenfolge gedruckt (also in der richtigen Ausgabereihenfolge).

Ausführlicher jedoch: Obwohl wir Wörter im Bereich drucken müssen (input, 0], wird [input, 0)stattdessen eine Schleife im Bereich ausgeführt . Aus diesem Grund können wir die Prüfung if(i%3 == 2)für "\ noN" verwenden (oder if(i%3 != 2)das Verschieben von "\ noN" überspringen), und wir können die Prüfung if(i%2 != 1)für "\ ntuB" verwenden (oder if(i%2 == 0)das Verschieben von "\ ntuB" tatsächlich überspringen ). Erst nach diesen beiden Überprüfungen wird die Iteration ium 1 verringert. Anschließend wird überprüft if(i%3 == 0), ob "\ nhaeY" gedrückt wurde, ähnlich wie im JS-Beispielcode in der Beschreibung der Herausforderung. Überspringen mit If-Not-Checks, anstatt zu einem Label zu wechseln, und Zurückkehren vom Label mit If-Checks, die 23 Byte gespeichert haben.

Außerdem werden in Whitespace Zeichenwerte als Unicode-Werte im Stapel gespeichert (dh 10für Zeilenumbrüche, 65für 'A', 97für 'a' usw.). Da ich den Stapel bereits durchlaufen muss, um die Zeichen zu drucken, kann ich auch meinen Whitespace-Tipp verwenden , um die Byteanzahl zu verringern , indem ich den Zahlenwerten eine Konstante hinzufüge, bevor ich sie als Zeichen drucke.
Diese Konstante ist 104in diesem Fall die Konstante , die mit diesem Java-Programm generiert wird, mit dem ich auch schon eine andere Whitespace-Antwort von mir gespielt habe . Das ist auch der Grund, warum dieser Teil des Codes:

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

hat die Werte -94für die Newline, 7für das 'o' und -26für das 'N'. Da das Hinzufügen der Konstante 104korrekt unsere Unicode - Werte geben 10, 111und 78für diese Zeichen sind.

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

Probieren Sie es online!

Python 3 , 79 76 Bytes

Port of Keeta ‚s Excel Antwort .

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

Probieren Sie es online!

Perl 6 , 63 50 Bytes

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

Probieren Sie es online!

Anonymer Codeblock, der eine Nummer annimmt und eine Liste von Zeilen zurückgibt

Erläuterung:

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

Probieren Sie es online!

C (gcc) , 60 + 11 = 71 Bytes (unter Verwendung von -D$=||puts()

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

Probieren Sie es online!

05AB1E (Legacy) , 27 25 24 Byte

Dank Kevin Cruijssen 1 Byte gespeichert .

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

Probieren Sie es online!

Erläuterung

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

Probieren Sie es 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'))]

Probieren Sie es online!

_{-2 Bytes dank 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'))]

Probieren Sie es online!

_{-4 Bytes dank ovs}

-4 Bytes, danke an Jo King

Canvas , 27 Bytes

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

Probieren Sie es hier aus!

Groovy (Funktion), 79 Bytes

Seit ich meine Antwort ursprünglich eingereicht habe, habe ich hier einige historische Diskussionen darüber durchgesehen, was eine geeignete Antwort darstellt. Da es allgemein anerkannt ist, nur eine Methode in Java bereitzustellen (einschließlich Rückgabetyp- und Parameterdeklarationen), ist hier eine kürzere Groovy-Methode, deren Rückgabewert die Antwort ist. Verwendung von defbedeutet, dass der Rückgabetyp abgeleitet wird.

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

Anders als die ursprüngliche Antwort unten, die von 0 bis n-1 durchläuft, ruft diese sich selbst von n bis 1 auf, dekrementiert jedoch die Eingabe für den Rest der Zeile im rekursiven Aufruf.

Probieren Sie es online!

Groovy (Programm), 87 Bytes

Groovy - Skripte erfordert keine bestimmten gemeinsame Importe, so dass dies ein Programm , das Drucken , ohne dass die Antwort auf Java STDOUT sein kann , erklären , System.out.vor print. Es werden auch einige gängige Dienstprogrammmethoden toLong()bereitgestellt, mit denen wir das Eingabeargument einigermaßen konsistent analysieren können.

Im Wesentlichen die Java 10-Antwort, aber unter Ausnutzung der kürzeren Loop-Syntax von Groovy und der Fähigkeit, wahrheitsgemäße Aussagen zu bewerten.

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

Probieren Sie es online!

Retina 0,8,2 , 45 Bytes

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

A`1

Probieren Sie es online! Erläuterung:

.+
$*

Konvertieren Sie die Eingabe in Unary.

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

0...n-1Generieren Sie für jede Ganzzahl drei Textzeilen, eine für jedes Wort mit einem i 1vorangestellten s, mit Ausnahme von Nozwei zusätzlichen 1s, damit wir berechnen, (i+2)%3==0was äquivalent zu ist i%3==1.

+`11B
B

Entfernen Sie Paare von 1s vor Bs.

111

Entferne 1s in Dreiergruppen überall.

A`1

Löschen Sie alle Zeilen mit einem 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 danke an @ OlivierGrégoire .

Probieren Sie es online aus.

Erläuterung:

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

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

Testskript und Erklärung:

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

Ausgabe:

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

Einfaches Skript, 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]

Probieren Sie es online!

Erläuterung

Ziemlich einfach, zwei Bytes gespart, indem [1..n]stattdessen [0..n-1]die restlichen verwendet und angepasst werden: Der Operator (?)testet vier Argumente und gibt eine leere Liste oder die bereitgestellte Zeichenfolge als Singleton zurück, wenn das Ergebnis korrekt ist.

Durch Aufrufen des vierten Arguments von können (?)wir (<>)die Ergebnisse jeder Funktion verketten, dh:

(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 Byte

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

Probieren Sie es online!

Pip , 37 35 33 Bytes

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

(Beachten Sie das Leerzeichen danach But.) Nimmt Eingaben als Befehlszeilenargument entgegen. Probieren Sie es online!

Erläuterung

Diese Erklärung gilt für die vorherige Version - siehe unten für das Änderungsprotokoll

Inspiriert von Jo Kings Perl 6 Antwort . Wir erstellen diese Liste:

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

und die ersten aElemente davon unter Verwendung einer zyklischen Indizierung auszugeben .

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

Update: Ich habe festgestellt, dass ich "Ersetzen" nicht verwenden muss, um 0/1/2 in Zeichenfolgen zu ändern. Mit diesen Zahlen kann ich eine Liste direkt indizieren. Dazu müssen wir sicherstellen, dass die mehrstelligen Nummern in Listen mit ihren Ziffern aufgeteilt sind (andernfalls wählen wir Index 10 anstelle der Indizes 1 und 0). Glücklicherweise funktioniert die Verwendung einer willkürlich verschachtelten Liste als Index in Pip erwartungsgemäß und gibt eine (verschachtelte) Ergebnisliste aus. Für die Eingabe von 3 erhalten wir diesen Datenfortschritt (wobei _eine neue Zeile darstellt):

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

Nach wie vor wird das Endergebnis zusammengefügt und automatisch gedruckt.

Attache , 48 Bytes

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

Probieren Sie es online!

Erläuterung

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

Es gibt hier bereits eine bessere C- Antwort, aber diese ist rekursiv und ich habe einige Zeit gebraucht, um klar zu kommen, also poste ich sie.

Bis zu 69 Bytes dank @ceilingcat und @JonathanFrech

(Ich denke nie daran, n- ~ -i anstelle von n-i + 1 zu verwenden.)

i;f(n){i=n&&n-i>=~n/6&&f(n,i++,puts(i%7%4?i%7%2?"But":"No":"Yeah"));}

Probieren Sie es online!

Rubin, 69 72 74 Bytes

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

Sehr direkte Antwort, die gerade nach einer kürzeren, rekursiven Methode sucht.

Zwei Bytes dank @BWO gespart :)

Weitere drei Bytes mit Symbolen anstelle von Zeichenfolgen gespeichert

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

Dies ist nicht gerade die beste Lösung, aber ich übernehme sie.

Probieren Sie es online!

R, 65 Bytes

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

Aufgrund der Tatsache, dass wir ein leicht fehlerhaftes Programm replizieren (es lässt jedes vierte "aber" aus - es sollte verwendet werden %4 == 1und %4 == 3nicht die %3Bedingungen), müssen wir einen umständlichen Aufruf an die cBasis 7 senden und in dieser arbeiten. Trotzdem ist es kürzer als LOLCODE ...

(Ich hatte gehofft, dass (3,1,2,3,2,1,2) oder eine ähnliche Permutation lhirgendwo im Datensatz erscheinen könnte, aber es sieht nicht so aus)

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\ 

Das Schwierigste war, nicht die Liste zu erstellen, sondern die Dezimalzahl zu analysieren.

2 Bytes können gespeichert werden, wenn die Zeilenumbrüche am Ende nicht benötigt werden: c\ → d.

Muss noch optimiert werden.

Probieren Sie es online aus .

Erläuterung

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

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

Probieren Sie es 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"}

Probieren Sie es online!

-2 Bytes, die sich von i=0 to p-1zu ändern i=1 to pund Module anpassen. Ansonsten ziemlich unkompliziert.

PHP, 65 68 Bytes

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

Laufen Sie als Pipe mit -nRoder versuchen Sie es online .

VBA (Excel), 105, 101, 99 Bytes

Edit: -4 Bytes von Keeta! Vielen Dank!

Editiere 2: -2 Bytes von Chronocidal! Woot! (Es wurde erkannt, dass Testfälle nur für 10 funktionierten. Jetzt behoben)

Ja, Excel hat diesmal VBA geschlagen. Wie auch immer. (Wir kommen für Sie)

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

^ Dies wird in das Direktfenster eingefügt und in das Debug-Fenster ausgegeben

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

Jelly , 22 Bytes

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

Ein monadischer Link mit einer Liste von Zeilen (was in Kommentaren erlaubt zu sein scheint)

Probieren Sie es online! (Die Fußzeile nennt den Link usingÇund verbindet sich mit Newlines using,Yda implizites Drucken in Jelly alles zusammenbricht, wenn es geht.)

Wie?

$2\times3=6$

Beachten Sie nun, dass die ersten sechs Werte sind:

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

In der resultierenden Zeilenliste sollten diese Werte also wiederholt (oder abgeschnitten) werden, um die Länge miteinander zu nverketten.

Beachten Sie nun, dass die Potenz von "Yeah", "But", "No":

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

Also ist jede Periode diese 1-indizierten Werte der Potenzmenge von "Yeah", "But", "No":

5, 4, 3, 2, 7, 1

Der Code erstellt diese Liste, formt sie auf Länge n, indiziert sie im Power-Set und entfernt dann die inneren Listen (wodurch auch die leeren Zeichenfolgen entfernt werden, da Zeichenfolgen Listen in Jelly sind) ...

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

Probieren Sie es online!

Massive 9 Bytes, die dank @Jonathan Frech gespeichert wurden