Meslektaşım kısa süre önce bana aşağıdaki JavaScript parçasını şaka olarak gönderdi:

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

Kod çalışma saatlerinde yazıldığından, açıkça belli ki şirket kaynaklarının israfıydı. Gelecekte benzer olayları önlemek için çalışma saatlerinin israfını en aza indirmeliyiz. Ve daha kısa bir programın yazılması daha hızlı olduğu yaygın bir bilgi olduğundan, bu kodu mümkün olduğunca kısa tutmamız gerekiyor!

Giriş

Tek bir negatif olmayan tam sayı. Hatalı girişi kullanmamalısınız.

Çıktı

Programınız yukarıdaki betiğinkiyle aynı çıktı üretmelidir. Satır başına bir kelime çıkarmalısınız ve sözcük sayısı orijinal komut dosyasıyla tutarlı olmalıdır.

Görünmez olduklarından, her satırın sonuna (başlangıçta değil) yeni satır olmayan boşluk karakterleri dahil etmek mümkündür. Çıktının en sonunda bir ek yeni satır karakterine izin verilir.

Örnekler

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 bayt

A1 hücresindeki girdiyi varsayar ve Wordwrap biçimlendirmesinin hücre için açık olduğunu varsayar. Dize satır beslemeleri eklemek için Alt + Enter tuşlarını kullanın ve beyaz boşluğu not edin. Yalnızca REPT işlevinin limiti nedeniyle 3570'e kadar olan girişleri tutar (bir hücrenin bu kadar uzun olması için iyi şanslar).

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

Yeniden basma, boşluk için periyotlarla

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

Nasıl çalışır: Desen her 6 sayıyı tekrar eder:

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

Bunların her biri 9 karakterle ifade edilebilir, bu yüzden 54 karakterden (9 * 6) oluşan bir dize, daha sonra Excel'in izin verdiği kadar tekrarlanır. Ardından sol 9 * (giriş sayısı) karakterlerini çıktı olarak alır.

"Ancak ve hiçbiri" için satır beslemesi boşluktan sonra yerleştirilir; bu öğe için.

JavaScript (ES6), 59 57 bayt

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

Çevrimiçi deneyin!

Nasıl?

Biz gider bir özyinelemeli işlevi kullanmak için yerine gelen kadar .1 0 n - $n$$1$$0$$n-1$

Sonuç olarak, testler referans koduna göre kapalı :$1$

• eğer , çıkış "Evet"$n\equiv1\pmod 3$
• eğer , çıkış "Ama"$n\equiv1\pmod 2$
• eğer , çıkış "Hayır"$n\equiv2\pmod 3$

Bu, basit arama ilk girdisi olarak olanak tanır ; burada : tanımlayan bir değişken veya boş bir dize tanımlayabiliriz .$n\equiv0\pmod 3$$s$"But\n"

Diğer iki giriş sırasıyla "Yeah\n" + sve olarak tanımlanır s + "No\n".

Not: gelen yineleme By için , biz tanımlayabiliriz gibi iyi ilk girişte, ama bu mal olacak iki ekstra parantez .0 $n-1$$0$$s$

Yorumlananlar

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 bayt

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

Çevrimiçi deneyin!

Boşluk , 315 304 300 277 276 bayt

Sayesinde @JoKing -11 bayt (7 8'den kullanılan etiket miktarının azaltılması) ve -24 daha bayt (programın genel akışını değiştirmek ve süreç içinde 5 7'den kullanılan etiket miktarının azaltılması) için.

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

Harfler S(boşluk), T(sekme) ve N(yeni satır) yalnızca vurgulama olarak eklenmiştir.
[..._some_action]sadece açıklama olarak eklendi.

Çevrimiçi deneyin (yalnızca ham alanlar, sekmeler ve yeni satırlarla).

Boşluk kesinlikle bu meydan okuma için doğru dil değildir .. In Boşluk döngüler ve her iki-tablolar halinde etiket ile yapılan ve etiketlere atlar ve onlar çünkü kılıfı ise, if-elseif-else durumlarda ancak birden değil o ben demektir Her sürüşten sonra geriye atlamak zorunda kalacak, oldukça uzun olacak, bazı baskıları atlamak için çekleri biraz değiştirmek zorunda kalacağım (teşekkürler @JoKing ).

Sahte kodda açıklama:

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)

Ek açıklama:

Genelde, girişten 0'a kadar döner, yeni bir satır bastırır ve sözcüğü tersine çevirir (bu nedenle "Evet \ n" yerine "\ noN", "\ ntuB", "\ nhaeY", ancak \ n "," Hayır \ n "). Girdi 0'a düştükten ve tüm karakterler yığında olduktan sonra, bu karakterleri tersten yazdıracak (yani doğru çıkış sırası).

Bununla birlikte daha ayrıntılı: Ancak, aralıktaki sözcükleri yazdırmamız gerekse de, aralıkta (input, 0]dönecek [input, 0). Bu nedenle, if(i%3 == 2)"\ noN" onayını kullanabiliriz (veya aslında, if(i%3 != 2)"\ noN" ifadesini atlarsak) ve if(i%2 != 1)"\ ntuB" kontrolünü kullanırız (veya aslında, if(i%2 == 0)"\ ntuB" ifadesini atlarız. ). Sadece bu iki kontrolden sonra, yinelemeyi i1 if(i%3 == 0)oranında azaltırız. Ardından, meydan okuma tanımındaki JS örnek kodundaki gibi "\ nhaeY" ibaresini kontrol edin . Bir etikete gitmek yerine if-check ile atlamak ve 23 byte ile kaydedilmiş if-check ile etiketten geri dönmek.

Ayrıca, Boşluklarda karakter değerleri yığında unicode değerleri olarak depolanır (yani 10yeni satırlar 65için 'A', 97'a', vb.). Karakterleri yazdırmak için yığının üzerinde dolaşmaya ihtiyaç duyduğum için, karakter olarak yazdırmadan önce sayı değerlerine sabit ekleyerek bayt sayısını azaltmak için Whitespace ipucumu kullanabiliyorum .
Bu sabit, 104bu durumda, daha önce bir başka Whitespace cevabını golf oynamak için kullandığım bu Java programı ile üretildi . Kodun bu bölümünün nedeni de bu:

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

değerlerine sahip -94, yeni satır için 7'O', ve için -26N '' için. Sabitini ekleyerek Çünkü 104irade doğru bizim unicode değerlerini vermek 10, 111ve 78sırasıyla bu karakterler için.

Python 3 , 85 82 bayt

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

Çevrimiçi deneyin!

Python 3 , 79 76 bayt

Port Keeta 'in Excel cevap .

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

Çevrimiçi deneyin!

Perl 6 , 63 50 bayt

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

Çevrimiçi deneyin!

Sayı alan ve satır listesini döndüren adsız kod bloğu

Açıklama:

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

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

Çevrimiçi deneyin!

C (gcc) , 60 + 11 = 71 bayt (kullanarak -D$=||puts()

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

Çevrimiçi deneyin!

05AB1E (eski) , 27 25 24 bayt

Kevin Cruijssen sayesinde 1 bayt kaydedildi .

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

Çevrimiçi deneyin!

açıklama

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 bayt

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

Çevrimiçi deneyin!

Python 2 , 97 95 92 90 83 81 bayt

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

Çevrimiçi deneyin!

_{-2 bayt, ovs sayesinde}

Python 3 , 92 90 85 83 bayt

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

Çevrimiçi deneyin!

_{-4 bayt, ovs sayesinde}

Jo King sayesinde -4 byte

Tuval , 27 bayt

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

Burada dene!

Groovy (işlev), 79 bayt

Cevabımı ilk gönderdiğimden beri, burada neyin uygun bir cevap oluşturduğuna dair bazı tarihi tartışmalara baktım. Java'da yalnızca bir yöntem sağladığı kabul edildiğinden (dönüş türü ve parametre bildirimleri dahil), işte daha kısa, Groovy, yöntem dönüş değeri olan yöntem cevap. Kullanımı defdöndürme türü sonucu çıkarılan araçlar.

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

0'dan n-1'e kadar olan aşağıdaki orijinal cevabın aksine, bu durum kendini n'den 1'e kadar çağırır, ancak özyinelemeli çağrıdaki geri kalan hattın girişini azaltır.

Çevrimiçi deneyin!

Groovy (program), 87 bayt

Groovy komut dosyaları belirli bir genel içe aktarma gerektirmez, bu nedenle daha System.out.önce bildirmek zorunda kalmadan Java'nın STDOUT'una yanıtı basan bir program olabilir print. Aynı zamanda toLong(), girdi argümanını makul bir şekilde özdeşleştirmemizi sağlayan bazı ortak yardımcı yöntemler de sağlar .

Temelde Java 10 cevap veriyor, ancak Groovy'nin daha kısa döngü sözdizimini ve truthy ifadelerini değerlendirme yeteneğini kullanıyor.

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

Çevrimiçi deneyin!

Retina 0.8.2 , 45 bayt

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

A`1

Çevrimiçi deneyin! Açıklama:

.+
$*

Girişi unary'ye dönüştürün.

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

Her bir tamsayı 0...n-1için, her biri için, her biri i 1ondan önce Noolan, hangisinin eşdeğeri olduğunu 1hesaplamamız için iki ekstra s olan üç metin satırı oluşturun .(i+2)%3==0i%3==1

+`11B
B

1S önce Bs çiftlerini çıkarın .

111

1Her yerde üçlü gruplar halinde s çıkarın .

A`1

Hala olan tüm satırları silin 1.

Java 10, 100 99 bayt

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

@ OlivierGrégoire sayesinde -1 bayt .

Çevrimiçi deneyin.

Açıklama:

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 bayt

-1 bayt teşekkürler TessellatingHeckler

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

Test komut dosyası ve açıklaması:

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

Çıktı:

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

Basit kod, 72 bayt:

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

Haskell , 71 bayt

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

Çevrimiçi deneyin!

açıklama

Oldukça basit, kalanları kullanmak [1..n]yerine iki bayt [0..n-1]kaydetmiş ve ayarlamış: (?)Sonuç doğruysa, operatör testleri boş bir liste veya verilen dizgeyi tekil olarak döndürerek dört argüman alır.

Dördüncü argümanı körükleyerek, her bir işlevin sonuçlarını birleştirmek (?)için faydalanabiliriz (<>), yani:

(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 # Etkileşimli Derleyici) , 105 99 94 96 89 bayt

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

Çevrimiçi deneyin!

Pip , 37 35 33 bayt

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

(Sonra boşluğa dikkat edin But.) Girişi bir komut satırı argümanı olarak alır. Çevrimiçi deneyin!

açıklama

Bu açıklama önceki sürüm içindir - değişiklik listesi için aşağıya bakın

Jo King'in Perl 6 cevabı esinlenerek . Bu listeyi oluşturuyoruz:

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

ve ilk aelemanlarını döngüsel indeksleme kullanarak çıktılar .

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

Güncelleme: 0/1/2 dizelerini değiştirmek için değiştirme kullanmam gerekmediğini fark ettim - Bu numaraları doğrudan bir listeye indekslemek için kullanabilirim. Bunu yapmak için, çok basamaklı sayıların sayı listelerine bölündüğünden emin olmalıyız (aksi halde, dizin 1 ve 0 yerine dizin 10'u seçeceğiz). Neyse ki, Pip'de keyfi olarak iç içe geçmiş bir listeyi dizin olarak kullanmak, beklendiği gibi çalışır ve sonuçların (iç içe geçmiş) bir listesini verir. 3 girişi için bu veri ilerlemesini elde ederiz ( _yeni bir çizgiyi temsil eder):

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

Daha önce olduğu gibi nihai sonuç bir araya getirilir ve otomatik olarak yazdırılır.

Ataşesi , 48 bayt

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

Çevrimiçi deneyin!

açıklama

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 bayt

Zaten burada daha iyi bir C cevabı var ama bu özyinelemeli ve bana biraz zaman aldı bu yüzden gönderiyorum.

@Ceilingcat ve @JonathanFrech sayesinde 69 bayta kadar

(N-i + 1 yerine n- ~ -i kullanacağımı asla düşünmedim)

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

Çevrimiçi deneyin!

Ruby, 69 72 74 Bayt

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

Çok basit bir cevap, şu anda daha kısa, özyinelemeli bir yöntem için kontrol.

@BWO :) sayesinde iki bayt kaydedildi

Dizeler yerine semboller kullanarak üç bayt daha kaydedildi

Python 3, 93 bayt

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

Bu tam olarak en iyi çözüm değil ama benim üstümde.

Çevrimiçi deneyin!

R, 65 bayt

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

Hafif kusurlu bir programı tekrarlıyor olmamızdan dolayı (her dördüncüsü kaçırıyor "ama" - şartlar yerine kullanılmış olmalı %4 == 1ve şartlar %4 == 3yerine %3), garip bir çağrı kullanmalı cve üs yedide çalışmalıyız. Yine de LOLCODE'dan daha kısa ...

( lhVeri setinde (3,1,2,3,2,1,2) veya buna benzer bir permütasyonun başka bir yerde görünmesini ümit ediyordum ama görünmüyordu)

S-E ,179 150 bayt

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

En zor kısım listeyi oluşturmak değil, ondalık sayıları ayrıştırmaktı.

Sonunda yeni satır gerekmiyorsa 2 bayt kaydedilebilir: c\ → d.

Yine de optimizasyon gerekiyor.

Çevrimiçi deneyin .

açıklama

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

Temiz , 116 bayt

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

Çevrimiçi deneyin!

F #, 108 106 bayt

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

Çevrimiçi deneyin!

-2 değişen bayt i=0 to p-1için i=1 to pve MODULOS ayarlanması. Bunun dışında oldukça açık.

PHP, 65 68 bayt

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

Pipe ile çalıştırın -nRveya çevrimiçi deneyin .

VBA (Excel), 105, 101, 99 Bayt

Düzenleme: Keeta'dan -4 bayt! Teşekkürler!

Chronocidal'dan 2: -2 bayt düzenleyin! Woot! (Test durumlarının yalnızca 10 için çalıştığını fark etti. Şimdi düzeltildi)

Evet, Excel bu sefer VBA'yı yendi. Her neyse. (Senin için geliyoruz)

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

^ Bu, Hemen penceresine yapıştırılır ve hata ayıklama penceresine çıkar

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

Jöle , 22 bayt

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

Satır listesini veren monadik bir Link (yorumlarda bulunmuş gibi görünüyor)

Çevrimiçi deneyin! (altbilgi kullanarak Linki çağırırÇve kullanan yenisatırlar ile birleştiğiYbirlikte o eğer Jelly Smashes her şeyi örtülü baskı beri)

Nasıl?

$2\times3=6$

Şimdi ilk altı değerin:

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

Bu yüzden, sonuçta ortaya çıkan satırlar listesi nbirlikte birleştirilmiş uzunluğa kadar tekrarlanan (veya kesilen) bu değerler olmalıdır .

Şimdi gücünün aşağıdaki olduğuna dikkat edin "Yeah", "But", "No":

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

Yani her periyot, güç grubunun bu 1-indekslenmiş değerleridir "Yeah", "But", "No":

5, 4, 3, 2, 7, 1

Kod, bu listeyi yapar, uzunluğa göre kalıplar n, güç grubuna endeksler ve sonra iç listeleri kaldırır (ayrıca boş dizeleri de kaldırır, çünkü dizeler Jelly'de listelenir) ...

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 bayt

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

Çevrimiçi deneyin!

@Jonathan Frech sayesinde büyük 9 bayt kurtarıldı