도전

입력:

2에서 62 사이 의 정수 $b$ (포함)

산출:

숫자 에 대한 적절한 표현을 사용하여 에서 에 해당하는 $1$ 에서 까지의 수를 계산 하십시오.$5000_{10}$$b$

하나:

• 숫자를 로 나눌 수있는 경우 (반올림 됨, 예를 들어 7은 7 / 2 = 3.5, 3.5 + 1 = 4.5, 4로 반올림 됨 ) 숫자 대신 'Fizz'를 출력합니다. .$\lfloor b÷2+1\rfloor$

• 숫자를 (반올림, 예 : 11 / 3 = 3.666, 3.666 + 3 = 6.666, 7로 반올림)로 나눌 수 있으면 'Buzz'를 출력합니다.$\lceil b÷3+3\rceil$

• 짐작할 수 있듯이, 숫자를 둘 다 나눌 수 있으면 'Fizzbuzz'를 출력하십시오.

예

사용 [0-9] , [AZ] 및 [아리조나] 숫자로

(예제를 짧게 유지하기 위해 처음 10 개의 값만 포함했습니다. 일반적으로 각 시퀀스에 4990 개의 항목이 더 있습니다)

입력 : 10 (따라서 'Fizz'= 6 및 'Buzz'= 7)

출력 : 1, 2, 3, 4, 5, Fizz, Buzz, 8, 9, 10

입력 : 2 (따라서 'Fizz'= 2 및 'Buzz'= 4)

출력 : 1, Fizz, 11, Fizzbuzz, 101, Fizz, 111, Fizzbuzz, 1001, Fizz

(나는 그들이 어떻게 작동하는지 더 잘 보여주기 위해 다음의 첫 50 가지 값을 포함시켰다)

입력 : 55 (따라서 'Fizz'= $28_{10}$ = $s_{55}$ 및 'Buzz'= $22_{10}$ = $m_{55}$ )

출력 : 1, 2, 3, 4, 5, 6, 7, 8, 9, a, b, c, d, e, f, g, h, i, j, k, l, Buzz, n, o, p, q, r, Fizz, t, u, v, w, x, y, z, A, B, C, D, E, F, G, H, I, J, K, L, M, N

규칙

• 표준 허점은 금지되어 있습니다
• 이것은 코드 골프이므로 바이트 단위의 최단 답변이 승리합니다.
• 입력 및 출력은 콘솔 또는 함수 인수 / 반환을 통해 가능
• 빈 줄과 마찬가지로 앞 / 뒤 공백이 좋습니다.
• 'Fizz'와 'Buzz'사이의 공백은 허용되지 않습니다.
• 'Fizz'/ 'Buzz'/ 'Fizzbuzz'의 대소 문자 변형은 괜찮습니다.
• 출력은 개행으로 분리되어야합니다.
• 문자로 표시하지 않고 10 진수로 된 '숫자'배열을 반환하면 올바른 순서 여야합니다!

젤리 ,  42 38 34 33 29  32 바이트

엄격한 서식 규칙을 준수하려면 +3

5ȷɓ;8Ä:2,3‘ḍȧ"“Ƈד=%»ḟ0Fȯb@K¥ð€Y

텍스트의 라인 5000하는 정수 시리즈 (숫자), 또는 중 하나를 포함하는 각 라인 출력 전체 프로그램 fizz, buzz또는 fizzbuzz(베이스 (62)를 넘어 미세한 작동).

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

어떻게?

참고
$\lfloor b÷2+1\rfloor\ = \lfloor b÷2\rfloor+1$
... 및
$\lceil b÷3+3\rceil = \lceil b÷3+2\rceil+1 = \lceil (b+6)÷3\rceil+1 = \lfloor (b+8)÷3\rfloor+1$

업데이트 중 ...

5ȷɓ;8Ä:2,3‘ḍȧ"“Ƈד=%»ḟ0Fȯb@ð€ - Link: integer, b
5ȷ                            - 5*10³ = 5000
  ɓ                        ð€ - for €ach n in [1,2,...,5000] get this f(b,n):
    8                         -   eight
   ;                          -   concatenate      -> [b,8]
     Ä                        -   cumulative sums  -> [b,b+8]
       2,3                    -   pair literal        [2,3]
      :                       -   integer division -> [b//2, (b+8)//3]
          ‘                   -   increment        -> [b//2+1, (b+8)//3+1]
           ḍ                  -   divides n?       -> [n is fizzy?, n is buzzy?]
              “Ƈד=%»         -   list of dictionary strings = ['fizz','buzz']
             "                -   zip with:
            ȧ                 -     logical AND    -> [0,0], ['fizz',0], [0,'buzz'],
                              -                       or ['fizz','buzz']
                      0       -   zero
                     ḟ        -   filter discard   -> [], ['fizz'], ['buzz'],
                              -                       or ['fizz','buzz']
                       F      -   flatten          -> [], ['fizz'], ['buzz'],
                              -                       or ['fizzbuzz']
                          @   -   using swapped arguments:
                         b    -     (n) to a list of digits in base (b)  (say, [nb])
                        ȯ     -   logical OR       -> [nb], ['fizz'], ['buzz'],
                              -                       or ['fizzbuzz']

숯 , 40 바이트

ＮθＥ…·¹×⁵φ∨⁺⎇﹪ι⊕÷θ²ωFizz⎇﹪ι÷⁺¹¹θ³ωBuzz⍘ιθ

온라인으로 사용해보십시오! 링크는 자세한 버전의 코드입니다. 설명:

Ｎθ                                      Input `b` into variable `q`
   ¹                                    Literal 1
 …·                                     Inclusive range to
      φ                                 Predefined variable 1000
    ×                                   Multiplied by
     ⁵                                  Literal 5
Ｅ                                       Map to
           ι                            Current value
          ﹪                             Modulo
              θ                         Input value
             ÷                          Floor divide
               ²                        Literal 2
            ⊕                           Incremented
         ⎇                              If nonzero
                ω                       Then predefined empty string
                 Fizz                   Otherwise literal `Fizz`
        ⁺                               Concatenated with
                       ι                Current value
                      ﹪                 Modulo
                            θ           Input value
                         ⁺              Plus
                          ¹¹            Literal 11
                        ÷               Integer divided by
                             ³          Literal 3
                     ⎇                  If nonzero
                              ω         Then predefined empty string
                               Buzz     Otherwise literal `Buzz`
       ∨                                Logical Or
                                    ι   Current value
                                   ⍘    Converted to base
                                     θ  Input value
                                        Implicitly print each result on its own line

R , 163131 바이트

b=scan();for(d in 1:5e3)cat(list(d%/%b^rev(0:log(d,b))%%b,'fizz','buzz','fizzbuzz')[[1+(!d%%((b+2)%/%2))+2*!d%%((b+11)%/%3)]],'\n')

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

23 바이트를 절약 한 @digEmAll에게 감사합니다. 그런 다음 @digEmAll의 노력으로 9를 더 절약했습니다.

자바 스크립트 (ES6)  117  116 바이트

$19_{20}$$19$$21_{20}$$1,1$

b=>(g=n=>n>1?g(n-1)+`
`+((s=n%(b+2>>1)?'':'Fizz',n%(b/3+3.9|0)?s:s+'Buzz')||(g=n=>n?[...g(n/b|0),n%b]:s)(n)):1)(5e3)

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

(TIO의 출력이 폭발하지 않도록 100으로 제한)

파이썬 2 , 116 바이트

b=input()
i=0
exec"a=i=i+1;d=[]\nwhile a:d=[a%b]+d;a/=b\nprint'Fizz'*(i%(b/2+1)<1)+'Buzz'*(i%(~-b/3+4)<1)or d;"*5000

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

또는 0-9a-zA-Z출력 :

파이썬 2 , 143 바이트

b=input()
i=0
exec"a=i=i+1;d=''\nwhile a:d=chr(a%b+48+(a%b>9)*39-a%b/36*58)+d;a/=b\nprint'Fizz'*(i%(b/2+1)<1)+'Buzz'*(i%(~-b/3+4)<1)or d;"*5000

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

05AB1E , 39 37 36 바이트

8+‚U5₄*LεX23S÷>Ö”FizzÒÖ”#×JDõQiyIв]»

@JonathanAllan 의 Jelly 응답 포트를 생성하여 -2 바이트 .

온라인으로 시도 하거나 모든 테스트 사례를 확인하십시오 (그러나 목록 출력 및 5000 대신 첫 100).

설명:

8+               # Add 8 to the (implicit) input
  ‚              # Pair it with the (implicit) input
   U             # Pop and store it in variable `X`
5₄*L             # Create a list in the range [1,5000]
    ε            # Map each value `y` to:
     X23S÷       #  Integer-divide the input by 2, and the input+8 by 3
          >      #  Increase both by 1
           Ö     #  Check for both if they divide value `y` evenly (1 if truthy; 0 if falsey)
     ”FizzÒÖ”    #  Push dictionary string "Fizz Buzz"
             #   #  Split on spaces
              ×  #  Repeat the strings the result amount of times (0 or 1)
               J #  Join both strings together to a single string
     DõQi        #  If this string is empty:
         yIв     #   Push value `y` in Base-input (as list) instead
    ]            # Close the if-statement and map
     »           # Join the list by new-lines (and inner lists by spaces implicitly)
                 # (and output the result implicitly)

내이 05AB1E 팁을 참조하십시오 (섹션 어떻게 사전을 사용하는 방법을? ) 이유를 이해하는 ”FizzÒÖ”것입니다 "Fizz Buzz".

펄 6 , 91 바이트

{$!=0;('Fizz'x++$!%%($_/2+|0+1)~'Buzz'x$!%%(($_+8)/3+|0+1)||[R,] $!.polymod($_ xx*))xx𐄦}

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

밑줄의 문자열 목록 Fizz/Buzz/FizzBuzz또는 역순 으로 정수 목록을 리턴하는 익명 코드 블록 .

R , 138 바이트

function(b,`*`=rep)Map(function(i)"if"((s=paste0("","Fizz"*!i%%(b%/%2+1),"Buzz"*!i%%((b+11)%/%3)))>0,s,i%/%b^((log(i,b)%/%1):0)%%b),1:5e3)

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

C 번호 (카메라 C 번호 인터랙티브 컴파일러) , 180 (171) 바이트

n=>{for(int i=1,p;i<5001;){p=i;var j=new Stack<int>();for(;p>0;p/=n)j.Push(p%n);var s=i%(n/2+1)<1?"Fizz":"";Print(i++%((n+8)/3+1)<1?s+"Buzz":s==""?string.Join("-",j):s);}}

Arnauld의 답변과 같은 출력. 스택을 사용하여 출력을 반전시키는 아이디어를 주신 digEmAll에게 감사드립니다.

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

05AB1E , 34 바이트

Jonathan의 수학적 통찰력 을 사용 하여ceil(n/3+3) =을floor((n+8)//3)+1

ŽJćG8+‚2L>÷>NsÖ…™Ázz'ÒÖ‚×JNIв‚õKн,

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

설명

ŽJćG                                # for N in [1 ...5001)
    8+‚2L>÷>                        # push [input//2+1, (input+8)//3+1]
            NsÖ                     # check each if N is divisible by it
               …™Ázz                # push "fizz"
                    'ÒÖ             # push "buzz"
                       ‚            # pair
                        ×           # repeat a number of times corresponding to the result of the 
                                    # divisibility test
                         J          # join to string
                          NIв‚      # pair with N converted to base <input>
                              õK    # remove empty string
                                н,  # print head of the remaining list