동료가 최근에 다음과 같은 JavaScript를 농담으로 보냈습니다.

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

근무 시간 동안 코드가 작성되었으므로 회사 리소스가 많이 낭비되었습니다. 앞으로 비슷한 상황이 발생하지 않도록하려면 근무 시간 낭비를 최소화해야합니다. 더 짧은 프로그램을 작성하는 것이 빠르다는 것은 일반적인 지식이므로 가능한 한 짧게이 코드를 골프화해야합니다!

입력

음이 아닌 단일 정수 잘못된 입력을 처리해서는 안됩니다.

산출

프로그램은 위 스크립트와 동일한 출력을 생성해야합니다. 한 줄에 한 단어를 출력해야하며 단어 수는 원본 스크립트와 일치해야합니다.

줄 바꿈이 아닌 공백 문자는 각 행의 끝에 표시되지만 처음에는 표시되지 않으므로 공백 문자를 포함 할 수 없습니다. 출력의 맨 끝에 하나의 추가 줄 바꾸기 문자가 허용됩니다.

예

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 바이트

셀 A1에 입력이 있고 셀에 대해 줄 바꿈 서식이 설정되어 있다고 가정합니다. 문자열 내에 줄 바꿈을 추가하고 공백을 확인하려면 Alt + Enter를 사용하십시오. REPT 기능의 한계로 인해 최대 3570 개의 입력 만 처리합니다 (셀을 키가 큰 행운을 빕니다).

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

공백이있는 재 인쇄

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

작동 방식 : 패턴은 6 개의 숫자마다 반복됩니다.

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

이들 각각은 9 문자로 표현 될 수 있으므로 문자열은 54 문자 (9 * 6)로 구성된 다음 Excel에서 허용하는만큼 반복됩니다. 그런 다음 왼쪽 9 * (입력 수) 문자를 출력으로 사용합니다.

"그러나 안함"에 대한 줄 바꿈은 공백 뒤에 위치하므로 # 6, # 12 등의 예는 오른쪽이 아닌 왼쪽으로 서식이 지정되며 6 번째 줄마다 빈 줄 바꿈이 추가되지 않습니다. 해당 항목에 대해.

자바 스크립트 (ES6), 59 57 바이트

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

온라인으로 사용해보십시오!

어떻게?

우리는 에서 아닌 에서 로 돌아가는 재귀 함수를 사용합니다 .1 0 N - $n$$1$$0$$n-1$

결과적으로 테스트는 참조 코드와 비교하여 씩 해제됩니다 .$1$

• 만약 , 출력 "그래"$n\equiv1\pmod 3$
• 만약 , 출력 "하지만"$n\equiv1\pmod 2$
• 만약 , 출력 "아니오"$n\equiv2\pmod 3$

이를 통해 간단한 배열 을 조회 배열의 첫 번째 항목으로 저장할 수 있습니다. 여기서 : 빈 문자열 또는 변수를 보유하는 변수를 정의 할 수 있습니다 .$n\equiv0\pmod 3$$s$"But\n"

다른 두 항목은 각각 "Yeah\n" + s및 로 정의됩니다 s + "No\n".

참고 : 에서 을 반복 하면 첫 번째 항목에도 를 정의 할 수 있지만 두 개의 추가 괄호가 필요 합니다.0 $n-1$$0$$s$

댓글

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 바이트

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

온라인으로 사용해보십시오!

공백 , 315 304 300 277 276 바이트

-11 바이트 (8에서 7로 사용되는 레이블의 양을 줄임)와 -24 바이트 (프로그램의 일반적인 흐름을 변경하고 사용되는 레이블의 양을 7에서 5로 줄임)에 대한 @JoKing 덕분 입니다.

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

문자 S(공백), T(탭) 및 N(줄 바꾸기)가 강조 표시로만 추가되었습니다.
[..._some_action]설명으로 만 추가되었습니다.

온라인으로 시도하십시오 (원시 공백, 탭 및 줄 바꾸기 만).

공백은 확실히이 문제에 대한 올바른 언어가 아닙니다 ..에 공백 루프와 두 명령문은 경우 라벨로 만든 라벨로 이동, 그들이 때문에-경우 경우 경우-ELSEIF-다른 경우지만 여러되지 않습니다 그것이 내가 의미 모든 경우에 뒤로 건너 뛰어야 합니다. 매우 길어 지면 일부 인쇄를 건너 뛰기 위해 검사를 약간 수정해야합니다 ( @JoKing 감사 합니다 ).

의사 코드의 설명 :

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)

추가 설명 :

일반적으로 입력에서 0으로 반복하여 줄 바꿈을 누르고 단어를 뒤집습니다 (따라서 "Yeah \ n", "But \ n 대신"\ noN ","\ ntuB ","\ nhaeY "순서로) ","아니요 \ n "). 그리고 입력이 0으로 반복되고 모든 문자가 스택에 있으면 해당 문자를 역순으로 인쇄하므로 올바른 출력 순서가 표시됩니다.

그러나 더 깊이 : 범위 내의 단어를 인쇄해야하지만 범위 내 (input, 0]에서 반복 [input, 0)됩니다. 이 때문에 if(i%3 == 2)"\ noN" 검사 를 사용 하거나 실제로 if(i%3 != 2)"\ noN"푸시를 건너 뛰고 "\ ntuB"검사 if(i%2 != 1)를 사용 하거나 실제로 if(i%2 == 0)"\ ntuB"푸시를 건너 뜁니다 ). 이 두 번의 확인 후에 만 ​​반복 i을 1 씩 줄입니다. 그런 다음 if(i%3 == 0)챌린지 설명의 JS 예제 코드에서와 같이 "\ nhaeY"를 눌러 확인 합니다. 레이블로 이동하는 대신 if-not 검사로 건너 뛰고 23 바이트가 저장된 if-checks로 레이블에서 돌아갑니다.

또한 공백에서 문자 값은 스택에 유니 코드 값으로 저장됩니다 (예 : 10줄 바꾸기, 65'A', 97'a'등). 문자를 인쇄하기 위해 이미 스택을 반복해야하므로 문자로 인쇄 하기 전에 공백 값을 사용하여 숫자 값에 상수를 추가하여 바이트 수를 낮추는 것도 가능합니다 .
이 상수는 104이 경우이며, 이 Java 프로그램으로 생성되어 이전에 또 다른 공백 응답 을 골프로 사용했습니다 . 이것이 코드의이 부분이되는 이유이기도합니다.

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

값을 갖는 -94상기 개행을 7'O'등에 대한 -26'N'에 대한. 의 지속적인 추가하기 때문에 104뜻을 올바르게 우리의 유니 코드 값을주고 10, 111및 78각각이 문자를.

파이썬 3 , 85 82 바이트

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

온라인으로 사용해보십시오!

파이썬 3 , 79 76 바이트

포트 Keeta 의 엑셀 대답 .

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

온라인으로 사용해보십시오!

펄 6 , 63 50 바이트

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

온라인으로 사용해보십시오!

숫자를 가져와 줄 목록을 반환하는 익명 코드 블록

설명:

{                                                }   # 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 바이트

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

온라인으로 사용해보십시오!

C (gcc) , 60 + 11 = 71 바이트 (사용 -D$=||puts()

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

온라인으로 사용해보십시오!

05AB1E (레거시) , 27 25 24 바이트

Kevin Cruijssen 덕분에 1 바이트를 절약했습니다 .

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

온라인으로 사용해보십시오!

설명

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

파이썬 2 , 73 바이트

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

온라인으로 사용해보십시오!

파이썬 2 , 97 95 92 90 83 81 바이트

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

온라인으로 사용해보십시오!

_{ovs 덕분에 -2 바이트}

파이썬 3 , 92 90 85 83 바이트

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

온라인으로 사용해보십시오!

_{ovs 덕분에 -4 바이트}

Jo King 덕분에 -4 바이트

캔버스 , 27 바이트

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

여기 사용해보십시오!

그루비 (기능), 79 바이트

처음에 답변을 제출 한 후 적절한 답변을 구성하는 내용에 대한 역사적인 토론을 살펴 보았습니다. Java에서 메소드를 리턴하는 것 (반환 유형 및 매개 변수 선언 포함)이 일반적으로 허용되는 것처럼 보이므로 여기에 메소드 리턴 값이 응답 인 더 짧은 Groovy 메소드가 있습니다. 사용은 def반환 유형이 유추되었음을 의미합니다.

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

0에서 n-1까지 반복되는 아래의 원래 답변과 달리이 답변은 n에서 1까지 자체 호출하지만 재귀 호출의 나머지 줄에 대한 입력을 줄입니다.

온라인으로 사용해보십시오!

그루비 (프로그램), 87 바이트

Groovy 스크립트는 특정 공통 임포트를 필요로하지 않기 때문에 System.out.이전 에 선언하지 않고도 Java의 STDOUT에 대한 답변을 인쇄하는 프로그램이 될 수 있습니다 print. 또한 toLong()입력 인수를 합리적으로 간결하게 구문 분석 할 수있는 일반적인 유틸리티 메소드를 제공합니다 .

본질적으로 Java 10 답변이지만 Groovy의 짧은 루프 구문과 진실한 진술을 평가하는 기능을 활용합니다.

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

온라인으로 사용해보십시오!

레티 나 0.8.2 , 45 바이트

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

A`1

온라인으로 사용해보십시오! 설명:

.+
$*

입력을 단항으로 변환하십시오.

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

각 정수를 들어 0...n-1, 세 줄의 텍스트, 각 단어 하나, 각각의 생성 i 1을 제외하고 그 이전의, No두 개의 여분이있는, 1우리가 계산되도록들 (i+2)%3==0에 해당하는가 i%3==1.

+`11B
B

1s 전에 Bs 쌍을 제거하십시오 .

111

1다른 곳에서는 세 그룹으로 된 s를 제거하십시오 .

A`1

가 여전히있는 모든 행을 삭제하십시오 1.

자바 10, 100 99 바이트

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 덕분에 -1 바이트 .

온라인으로 사용해보십시오.

설명:

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 바이트

-1 바이트 덕분에 TessellatingHeckler

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

테스트 스크립트 및 설명 :

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

산출:

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

간단한 스크립트, 72 바이트 :

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

하스켈 , 71 바이트

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

온라인으로 사용해보십시오!

설명

매우 간단 하고 나머지 를 [1..n]대신 사용하여 2 바이트를 저장 [0..n-1]하고 나머지를 조정했습니다. 연산자 (?)테스트는 네 개의 인수를 사용하여 결과가 올바른 경우 빈 목록 또는 제공된 문자열을 단일 값으로 반환합니다.

(?)우리는 네 번째 주장을함으로써 (<>)각 기능의 결과를 연결하는 데 활용할 수 있습니다 .

(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 바이트

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

온라인으로 사용해보십시오!

핍 , 37 35 33 바이트

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

(뒤의 공백에 유의하십시오 But.) 입력을 명령 행 인수로 사용합니다. 온라인으로 사용해보십시오!

설명

이 설명은 이전 버전에 대한 것입니다. 아래의 changelog를 참조하십시오.

Jo King의 Perl 6 답변에서 영감을 얻었습니다 . 이리스트를 구성합니다 :

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

a순환 인덱싱을 사용하여 그 첫 번째 요소를 출력 합니다.

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

업데이트 : 0/1/2를 문자열로 변경하기 위해 replace를 사용할 필요가 없다는 것을 깨달았습니다.이 숫자를 사용하여 목록에 직접 색인을 생성 할 수 있습니다. 이렇게하려면 여러 자리 숫자를 해당 자리 목록으로 분할해야합니다. 그렇지 않으면 인덱스 1과 0 대신 인덱스 10을 선택합니다. 다행히 Pip에서 임의로 중첩 된 목록을 인덱스로 사용하면 예상대로 작동하여 결과 목록이 나타납니다. 3을 입력하면 다음과 같은 데이터 진행이 발생합니다 (여기서 _줄 바꿈 표시).

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

이전과 마찬가지로 최종 결과가 함께 연결되고 자동 인쇄됩니다.

첨부 , 48 바이트

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

온라인으로 사용해보십시오!

설명

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 바이트

여기에 더 나은 C 답변이 있지만이 답변은 재귀 적이며 곧 게시하는 데 시간이 걸렸습니다.

@ceilingcat 및 @JonathanFrech 덕분에 69 바이트까지 감소

(나는 n-i + 1 대신에 n- ~ -i를 사용한다고 생각하지 않습니다)

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

온라인으로 사용해보십시오!

루비, 69 72 74 바이트

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

지금은 더 짧고 재귀적인 방법을 확인하는 매우 간단한 대답입니다.

@BWO 덕분에 2 바이트를 절약했습니다 :)

문자열 대신 기호를 사용하여 3 바이트를 더 절약했습니다.

파이썬 3, 93 바이트

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

이것은 최선의 해결책은 아니지만 제 선택입니다.

온라인으로 사용해보십시오!

R, 65 바이트

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

우리는 약간의 결함이있는 프로그램을 복제 %4 == 1하고 %4 == 3있기 때문에 ( %3조건이 아니라 사용 된 것보다 4 분의 1마다 "하지만" 빠짐), c7 번에 대한 호출을 어색하게해야합니다 . 여전히 LOLCODE보다 짧습니다 ...

((3,1,2,3,2,1,2) 또는 유사한 순열이 lh데이터 세트에 어딘가에 나타날 것으로 기대 했지만 모양이 아닙니다)

sed -E ,179 150 바이트

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

가장 어려운 부분은 목록을 구성하는 것이 아니라 실제로 십진수를 구문 분석하는 것이 었습니다.

마지막 줄 바꿈이 필요하지 않은 경우 2 바이트를 저장할 수 있습니다. c\ → d.

여전히 최적화가 필요합니다.

온라인으로 사용해보십시오 .

설명

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

클린 , 116 바이트

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

온라인으로 사용해보십시오!

F #, 108106 바이트

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

온라인으로 사용해보십시오!

-2에서 변화 바이트 i=0 to p-1로 i=1 to p하고 modulos 조정. 그 외에도 꽤 간단합니다.

PHP, 65 68 바이트

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

파이프로 실행 -nR하거나 온라인으로 사용해보십시오 .

VBA (엑셀), 105, 101, 99 바이트

편집 : Keeta에서 -4 바이트! 감사!

Chronocidal에서 2 : 2 바이트 편집! 우와! (테스트 사례는 10 일 동안 만 작동한다는 사실을 현실화했습니다. 지금 수정되었습니다.)

네, 이번에는 Excel이 VBA를 이겼습니다. 도대체 무엇이. (우리는 당신을 위해오고있다)

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

^ 이것은 직접 실행 창에 붙여 넣어 디버그 창에 출력됩니다.

언 골프

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

젤리 , 22 바이트

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

행 목록을 생성하는 모나드 링크 (주석에 허용 된 것 같습니다)

온라인으로 사용해보십시오! (바닥 글은 Jelly의 암시 적 인쇄가 가능하면 모든 것을 하나로 묶으므로링크를 사용하여 링크를 호출하고 줄Ç바꿈을 사용Y합니다)

어떻게?

$2\times3=6$

이제 처음 6 개의 값은 다음과 같습니다.

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

따라서 결과로 나오는 줄 목록은이 값 n들이 함께 연결된 길이까지 반복되거나 잘 려야합니다.

이제 전원의 설정 "Yeah", "But", "No"은 다음과 같습니다.

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

따라서 각주기는 다음과 같이 1- 인덱싱 된 검정력 값입니다 "Yeah", "But", "No".

5, 4, 3, 2, 7, 1

코드는이 목록을 만들고 길이로 성형 n하고 전원 세트로 색인 한 다음 내부 목록을 제거합니다 (문자열은 젤리의 목록이므로 빈 문자열도 제거합니다) ...

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

파이썬 2 , 93 92 83 바이트

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

온라인으로 사용해보십시오!

@Jonathan Frech 덕분에 엄청난 9 바이트가 절약되었습니다.