Desafio

Entrada:

Um número inteiro $b$ entre 2 e 62 (inclusive).

Resultado:

Conte de $1$ ao equivalente a $5000_{10}$ na base $b$ , usando qualquer representação razoável para os dígitos.

Contudo:

• Se o número é divisível por $\lfloor b÷2+1\rfloor$ (arredondado para baixo, por exemplo, a base 7 seria 7/2 = 3,5, 3,5 + 1 = 4,5, arredondado para 4 ), em seguida, imprima 'Fizz' em vez do número.

• Se o número é divisível por $\lceil b÷3+3\rceil$ (arredondado para cima, por exemplo, 11/3 = 3,666, 3,666 + 3 = 6,666, arredondado para 7 ), então produza 'Buzz'.

• Como você provavelmente pode adivinhar, se o seu número é divisível por ambos, imprima 'Fizzbuzz'.

Exemplos

Usando [0-9] , [AZ] e [az] como dígitos

(Incluí apenas os 10 primeiros valores para manter os exemplos curtos - normalmente, existem 4990 itens a mais em cada sequência)

Entrada: 10 (então 'Fizz' = 6 e 'Buzz' = 7)

Saída: 1, 2, 3, 4, 5, Fizz, Buzz, 8, 9, 10

Entrada: 2 (então 'Fizz' = 2 e 'Buzz' = 4)

Saída: 1, Fizz, 11, Fizzbuzz, 101, Fizz, 111, Fizzbuzz, 1001, Fizz

(Incluí os 50 primeiros valores para mostrar melhor como eles funcionam)

Entrada: 55 (então 'Fizz' = $28_{10}$ = $s_{55}$ e 'Buzz' = $22_{10}$ = $m_{55}$ )

Saída: 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

Regras

• As brechas padrão são proibidas
• Este é o Code Golf, então a resposta mais curta em bytes ganha
• A entrada e a saída podem ser através do console ou argumentos / retornos de função
• O espaço em branco à esquerda / à direita é bom, assim como as linhas vazias
• Espaços entre 'Fizz' e 'Buzz' não são permitidos
• Qualquer variante de maiúscula de 'Fizz' / 'Buzz' / 'Fizzbuzz' está correta.
• As saídas devem ser separadas por novas linhas.
• Se você retornar uma matriz de 10 dígitos da base 10 em vez de representá-los com caracteres, eles deverão estar na ordem correta!

Geléia ,  42 38 34 33 29  32 bytes

+3 para aderir a regras estritas de formatação

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

Um programa completo que imprime 5000 linhas de texto, cada linha contendo uma série de números inteiros (os dígitos) ou um dos fizz, buzzou fizzbuzz(funciona bem para além base 62).

Experimente online!

Como?

$\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$

atualizando ...

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

Carvão , 40 bytes

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

Experimente online! Link é a versão detalhada do código. Explicação:

Ｎθ                                      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 , 163 131 bytes

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

Experimente online!

Obrigado a @digEmAll por salvar 23 bytes. Depois, aprimorei os esforços do @ digEmAll para economizar mais 9.

JavaScript (ES6),  117  116 bytes

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

Experimente online!

(limitado a 100 para que a saída do TIO não exploda)

Python 2 , 116 bytes

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

Experimente online!

Ou com 0-9a-zA-Zsaída:

Python 2 , 143 bytes

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

Experimente online!

05AB1E , 39 37 36 bytes

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

-2 bytes, criando uma porta da resposta Jelly de @JonathanAllan .

Experimente online ou verifique todos os casos de teste (mas como saída da lista e com os 100 primeiros em vez de 5000).

Explicação:

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)

Veja esta dica 05AB1E meu (seção Como usar o dicionário? ) Para entender por que ”FizzÒÖ”é "Fizz Buzz".

Perl 6 , 91 bytes

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

Experimente online!

Bloco de código anônimo que retorna uma lista de cadeias de caracteres Fizz/Buzz/FizzBuzzou uma lista invertida de números inteiros na base.

R , 138 bytes

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)

Experimente online!

C # (compilador interativo do Visual C #) , 180 171 bytes

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

Saídas como a resposta de Arnauld. Agradecemos a digEmAll pela idéia de usar uma pilha para reverter a saída.

Experimente online!

05AB1E , 34 bytes

Usa o insight matemático de Jonathan que ceil(n/3+3)=floor((n+8)//3)+1

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

Experimente online!

Explicação

Ž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