Mon collègue m'a récemment envoyé le code JavaScript suivant comme une blague:

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

Comme le code était écrit pendant les heures de travail, il s’agissait manifestement d’un énorme gaspillage de ressources de la part de l’entreprise. Pour éviter que de tels incidents ne se reproduisent à l’avenir, nous devons minimiser le gaspillage des heures travaillées. Et comme il est de notoriété publique qu'un programme plus court est plus rapide à écrire, nous devons jouer ce code pour qu'il soit le plus court possible!

Contribution

Un seul entier non négatif. Vous ne devez pas gérer une entrée défectueuse.

Sortie

Votre programme doit produire une sortie identique à celle du script ci-dessus. Vous devez générer un mot par ligne et le nombre de mots doit être cohérent avec le script d'origine.

Il est permis d'inclure des caractères d'espacement non newline à la fin de chaque ligne (mais pas au début) car ils sont invisibles. Un caractère de nouvelle ligne supplémentaire est autorisé à la toute fin de la sortie.

Exemples

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 octets

Suppose une entrée dans la cellule A1 et que la mise en forme Wordwrap est activée pour cellule. Utilisez Alt + Entrée pour ajouter des sauts de ligne dans la chaîne et notez les espaces. Ne gère que les entrées jusqu’à 3570 en raison de la limite de la fonction REPT (bonne chance toutefois pour une cellule aussi haute).

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

Réimpression, avec des points pour les espaces

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

Comment ça marche: Le motif se répète tous les 6 chiffres:

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

Chacun de ceux-ci pouvant être exprimé avec 9 caractères, une chaîne est composée de 54 caractères (9 * 6), puis répétée aussi grande que le permet Excel. Ensuite, les 9 * (nombre d’entrées) de gauche sont générés en sortie.

Un saut de ligne pour le "mais aucun" est placé après le blanc afin que le Yeah pour les # 6, 12, (etc) soit formaté à gauche plutôt qu'à droite, et qu'il n'y ait pas de saut de ligne vierge ajouté toutes les 6 lignes pour cet article.

JavaScript (ES6), 59 57 octets

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

Essayez-le en ligne!

Comment?

Nous utilisons une fonction récursive qui va de à plutôt que de à .1 0 n - $n$$1$$0$$n-1$

En conséquence, les tests sont décalés de par rapport au code de référence:$1$

• si , "Yeah"$n\equiv1\pmod 3$
• si , "Mais"$n\equiv1\pmod 2$
• si , "Non"$n\equiv2\pmod 3$

Cela nous permet de stocker la cas simple comme première entrée de notre tableau de recherche, où nous pouvons définir : une variable contenant soit une chaîne, soit une chaîne vide.$n\equiv0\pmod 3$$s$"But\n"

Les deux autres entrées sont définies comme "Yeah\n" + set s + "No\n"respectivement.

Remarque: en itérant de à , nous pourrions également définir dans la première entrée, mais cela coûterait deux parenthèses supplémentaires .0 $n-1$$0$$s$

Commenté

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 octets

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

Essayez-le en ligne!

Espace blanc , 315 304 300 277 276 octets

Merci à @JoKing pour -11 octets (réduction du nombre d'étiquettes utilisées de 8 à 7) et -24 octets supplémentaires (modification du flux général du programme et réduction du nombre d'étiquettes utilisées de 7 à 5 dans le processus).

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

Lettres S(espace), T(tabulation) et N(nouvelle ligne) ajoutées uniquement en surbrillance.
[..._some_action]ajouté comme explication seulement.

Essayez-le en ligne (avec des espaces bruts, des onglets et des nouvelles lignes uniquement).

Est certainement pas Whitespace la bonne langue pour ce défi .. Dans les deux boucles et Whitespace si-déclarations sont faites avec des étiquettes et des sauts aux étiquettes, et puisqu'ils ne sont pas si-elseif-else cas , mais si plusieurs-cas, cela signifie que je devra revenir en arrière après chaque si, ce qui veut dire que je devrai modifier légèrement les contrôles pour éviter certaines impressions (merci à @JoKing ).

Explication en pseudo-code:

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)

Explication supplémentaire:

En général, il passe de l’entrée à 0, poussant une nouvelle ligne et le mot inversé (donc dans l’ordre "\ noN", "\ ntuB", "\ nhaeY" au lieu de "Yeah \ n", "Mais \ n ", "Non"). Et une fois que l'entrée a été bouclée jusqu'à 0 et que tous les caractères sont sur la pile, les caractères sont inversés (ainsi le bon ordre de sortie).

Plus en profondeur cependant: bien que nous ayons besoin d’imprimer des mots dans la plage (input, 0], il sera mis en boucle dans la plage [input, 0). Pour cette raison, nous pouvons utiliser la vérification if(i%3 == 2)de "\ noN" (ou en fait, if(i%3 != 2)ignorer la poussée de "\ noN"), et la vérification if(i%2 != 1)de "\ ntuB" (ou en fait, if(i%2 == 0)ignorer la poussée de "\ ntuB" ) Seulement après ces deux vérifications, nous réduisons l'itération ide 1. Ensuite, cochez la if(i%3 == 0)case "\ nhaeY", comme dans l'exemple de code JS de la description du défi. Sauter avec des vérifications if-not au lieu de passer à une étiquette et revenir de l’étiquette avec if-checks sauvegardé 23 octets.

En outre, dans l’espace blanc, les valeurs des caractères sont stockées dans la pile sous forme de valeurs unicode (par exemple, 10pour les nouvelles lignes, 65pour 'A', 97pour 'a', etc.). Comme j'ai déjà besoin de boucler la pile pour imprimer les caractères, je peux également utiliser mon astuce Whitespace pour réduire le nombre d'octets en ajoutant une constante aux valeurs numériques avant de les imprimer en tant que caractères.
Cette constante est 104dans ce cas, générée avec ce programme Java que j'ai également utilisé pour jouer au golf une autre de mes réponses à Whitespace auparavant . C'est aussi la raison pour laquelle cette partie du code:

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

a les valeurs -94pour la nouvelle ligne, 7pour le «o» et -26pour le «N». Du fait d' ajouter la constante de 104volonté correctement donner nos valeurs unicode 10, 111et 78pour ces caractères respectivement.

Python 3 , 85 à 82 octets

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

Essayez-le en ligne!

Python 3 , 79 76 octets

Port de Keeta de réponse Excel .

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

Essayez-le en ligne!

Perl 6 , 63 50 octets

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

Essayez-le en ligne!

Bloc de code anonyme qui prend un nombre et renvoie une liste de lignes

Explication:

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

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

Essayez-le en ligne!

C (gcc) , 60 + 11 = 71 octets (utilisation -D$=||puts()

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

Essayez-le en ligne!

05AB1E (ancien) , 27 25 24 octets

Sauvé 1 octet grâce à Kevin Cruijssen .

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

Essayez-le en ligne!

Explication

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 octets

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

Essayez-le en ligne!

Python 2 , 97 95 92 90 83 81 octets

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

Essayez-le en ligne!

_{-2 octets, grâce aux ovs}

Python 3 , 92 90 85 83 octets

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

Essayez-le en ligne!

_{-4 octets, grâce aux ovs}

-4 octets, merci à Jo King

Toile , 27 octets

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

Essayez-le ici!

Groovy (fonction), 79 octets

Depuis le début de ma réponse, j’ai parcouru quelques discussions historiques sur ce qui constitue une réponse appropriée. Comme il semble communément accepté de ne fournir qu’une méthode en Java (y compris les déclarations de type et de paramètre de retour), voici une méthode plus courte, Groovy, dont la valeur de retour est la réponse. L'utilisation de defsignifie que le type de retour est inféré.

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

Contrairement à la réponse originale ci-dessous, qui passe de 0 à n-1, celle-ci s’appelle de n à 1, mais décrémente l’entrée pour le reste de la ligne dans l’appel récursif.

Essayez-le en ligne!

Groovy (programme), 87 octets

Les scripts Groovy ne nécessitent pas certaines importations communes, il peut donc s'agir d'un programme imprimant la réponse à STDOUT de Java sans avoir à déclarer System.out.avant print. Il fournit également des méthodes d’utilité communes, telles que celle- toLong()ci, qui nous permet d’analyser raisonnablement l’argument d’entrée.

En gros, Java 10 répond, mais en utilisant la syntaxe de boucle plus courte et la capacité de Groovy à évaluer les déclarations véridiques.

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

Essayez-le en ligne!

Retina 0.8.2 , 45 octets

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

A`1

Essayez-le en ligne! Explication:

.+
$*

Convertir l'entrée en unaire.

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

Pour chaque entier 0...n-1, générez trois lignes de texte, une pour chaque mot, chacune précédée de i 1s, à l'exception de No, qui a deux 1s supplémentaires pour calculer l' (i+2)%3==0équivalent de i%3==1.

+`11B
B

Supprimer les paires de 1s avant que Bs.

111

Supprimez 1s en groupes de trois partout ailleurs.

A`1

Supprimer toutes les lignes qui ont encore un 1.

Java 10, 100 à 99 octets

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 octet grâce à @ OlivierGrégoire .

Essayez-le en ligne.

Explication:

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 octets

-1 octet merci TessellatingHeckler

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

Script de test et explication:

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

Sortie:

======
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 simple, 72 octets:

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

Haskell , 71 octets

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

Essayez-le en ligne!

Explication

Assez simple, sauvegardé deux octets en utilisant à la [1..n]place de [0..n-1]et ajusté les restes: L'opérateur (?)test prend quatre arguments, renvoyant une liste vide ou la chaîne fournie sous forme de singleton si le résultat est correct.

En currying le quatrième argument de (?)nous pouvons utiliser (<>)pour concaténer les résultats de chaque fonction, à savoir:

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

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

Essayez-le en ligne!

Pip , 37 35 33 octets

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

(Notez l'espace après But.) Prend l'entrée en tant qu'argument de ligne de commande. Essayez-le en ligne!

Explication

Cette explication concerne la version précédente - voir ci-dessous le journal des modifications.

Inspiré par Jo King's Perl 6 answer . Nous construisons cette liste:

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

et en sortir les premiers aéléments en utilisant une indexation cyclique.

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

Mise à jour: Je me suis rendu compte que je n'avais pas besoin de remplacer pour changer 0/1/2 en chaînes - je pouvais utiliser ces nombres pour indexer directement dans une liste. Pour ce faire, nous devons nous assurer que les nombres à plusieurs chiffres sont divisés en listes de chiffres (sinon, nous choisirons l'index 10 au lieu des index 1 et 0). Heureusement, l'utilisation d'une liste imbriquée de manière arbitraire en tant qu'index dans Pip fonctionne comme prévu, donnant une liste (imbriquée) de résultats. Pour une entrée de 3, nous obtenons cette progression de données (où _représente une nouvelle ligne):

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

Comme auparavant, le résultat final est concaténé et imprimé automatiquement.

Attaché , 48 octets

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

Essayez-le en ligne!

Explication

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 octets

Il y a déjà une meilleure réponse C ici, mais celle-ci est récursive et il m'a fallu un certain temps pour comprendre, alors je la poste.

Jusqu'à 69 octets grâce à @ceilingcat et @JonathanFrech

(Je ne pense jamais utiliser n- ~ -i à la place 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"));}

Essayez-le en ligne!

Ruby, 69 ans 72 74 Octets

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

Réponse très simple, en recherchant une méthode plus courte et récursive pour le moment.

Sauvegardé deux octets grâce à @BWO :)

Sauvegardé trois autres octets en utilisant des symboles au lieu de chaînes

Python 3, 93 octets

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

Ce n'est pas exactement la meilleure solution, mais c'est mon point de vue.

Essayez-le en ligne!

R, 65 octets

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

Étant donné que nous reproduisons un programme légèrement défectueux (il manque chaque quart "mais" - il aurait dû utiliser %4 == 1et %4 == 3non pas des %3conditions), nous devons utiliser un appel maladroit cet travailler en base sept. C'est quand même plus court que LOLCODE ...

(J'espérais que (3,1,2,3,2,1,2) ou une permutation similaire pourrait apparaître lhquelque part dans le jeu de données mais cela ne ressemble pas à ça)

sed -E ,179 150 octets

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

Le plus difficile était de ne pas construire la liste mais bien d’analyser le nombre décimal.

2 octets peuvent être enregistrés si la nouvelle ligne à la fin n'est pas requise: c\ → d.

Nécessite encore une optimisation.

Essayez-le en ligne .

Explication

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

Propre , 116 octets

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

Essayez-le en ligne!

F #, 108 106 octets

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

Essayez-le en ligne!

-2 octets passant de i=0 to p-1à i=1 to pet ajustant les modulos. En dehors de cela, assez simple.

PHP, 65 68 octets

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

Exécuter en pipe -nRou essayer en ligne .

VBA (Excel), 105, 101, 99 octets

Edit: -4 octets de Keeta! Merci!

Éditez 2: -2 octets de Chronocidal! Woot! (Réalisé que les cas de test ne fonctionnaient que pour 10. Corrigé maintenant)

Oui, Excel a battu VBA cette fois. Peu importe. (Nous venons pour vous)

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

^ Ceci est collé dans la fenêtre Immediate et sort dans la fenêtre de débogage

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

Gelée , 22 octets

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

Un lien monadique donnant une liste de lignes (qui semble avoir été autorisé dans les commentaires)

Essayez-le en ligne! (le pied de page appelle le lien en utilisantÇet rejoint les nouvelles lignes en utilisantYdepuis l'impression implicite dans Jelly écrase tout si possible)

Comment?

$2\times3=6$

Notez maintenant que les six premières valeurs sont:

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

La liste de lignes résultante doit donc contenir ces valeurs répétées (ou tronquées) à la longueur nconcaténée.

Notez maintenant que le pouvoir de "Yeah", "But", "No"est:

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

Donc, chaque période correspond aux valeurs 1-indexées de la puissance de "Yeah", "But", "No":

5, 4, 3, 2, 7, 1

Le code crée cette liste, la moule en longueur n, indexe dans le jeu de puissance, puis supprime les listes internes (ce qui supprime également les chaînes vides, car les chaînes sont des listes dans 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 octets

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

Essayez-le en ligne!

Un énorme 9 octets sauvé grâce à @Jonathan Frech