Herausforderung

Eingang:

Eine ganze Zahl zwischen 2 und 62 (einschließlich).$b$

Ausgabe:

von bis zum Äquivalent von in Basis , wobei Sie eine angemessene Darstellung für die Ziffern verwenden.$1$$5000_{10}$$b$

Jedoch:

• Wenn die Zahl durch teilbar ist (abgerundet, z. B. wäre Basis 7 7/2 = 3,5, 3,5 + 1 = 4,5, auf 4 gerundet ), geben Sie 'Fizz' anstelle der Zahl aus .$\lfloor b÷2+1\rfloor$

• Wenn die Zahl durch (aufgerundet, z. B. 11/3 = 3,666, 3,666 + 3 = 6,666, auf 7 gerundet ), geben Sie 'Buzz' aus.$\lceil b÷3+3\rceil$

• Wie Sie wahrscheinlich erraten können, geben Sie 'Fizzbuzz' aus, wenn Ihre Zahl durch beide teilbar ist.

Beispiele

Verwenden Sie [0-9] , [AZ] und [az] als Ziffern

(Ich habe nur die ersten 10 Werte angegeben, um die Beispiele kurz zu halten - normalerweise gibt es 4990 weitere Elemente in jeder Sequenz)

Eingabe: 10 (also 'Fizz' = 6 und 'Buzz' = 7)

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

Eingabe: 2 (also 'Fizz' = 2 und 'Buzz' = 4)

Ausgabe: 1, Fizz, 11, Fizzbuzz, 101, Fizz, 111, Fizzbuzz, 1001, Fizz

(Ich habe die ersten 50 Werte der folgenden Werte angegeben, um besser zu zeigen, wie sie funktionieren.)

Eingabe: 55 (also 'Fizz' = = und 'Buzz' = = )$28_{10}$$s_{55}$$22_{10}$$m_{55}$

Ausgabe: 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.

Regeln

• Standardlücken sind verboten
• Dies ist Code Golf, also gewinnt die kürzeste Antwort in Bytes
• Die Eingabe und Ausgabe kann über die Konsole oder über Funktionsargumente / -rückgaben erfolgen
• Führender / nachfolgender Leerraum ist in Ordnung, ebenso wie leere Zeilen
• Leerzeichen zwischen 'Fizz' und 'Buzz' sind nicht zulässig
• Jede Großschreibung von 'Fizz' / 'Buzz' / 'Fizzbuzz' ist in Ordnung.
• Ausgaben sollten durch Zeilenumbrüche getrennt werden.
• Wenn Sie ein Array von Basis-10-Ziffern zurückgeben, anstatt sie mit Zeichen darzustellen, müssen sie in der richtigen Reihenfolge sein!

Gelee ,  42 38 34 33 29  32 Bytes

+3, um strenge Formatierungsregeln einzuhalten

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

Ein volles Programm , das druckt 5000 Textzeilen, wobei jede Zeile eine Reihe von ganzen Zahlen (die Ziffern) oder eines enthält fizz, buzzoder fizzbuzz(funktioniert jenseits Basis 62).

Probieren Sie es online aus!

Wie?

Beachten Sie, dass ... und
$\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$

Aktualisierung...

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

Holzkohle , 40 Bytes

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

Probieren Sie es online aus! Der Link führt zur ausführlichen Version des Codes. Erläuterung:

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

Probieren Sie es online aus!

Vielen Dank an @digEmAll für das Speichern von 23 Bytes. Ich habe dann @ digEmAlls Bemühungen, weitere 9 zu retten, weiter golfen lassen.

JavaScript (ES6),  117  116 Byte

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

Probieren Sie es online aus!

(auf 100 begrenzt, damit der TIO-Ausgang nicht explodiert)

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

Probieren Sie es online aus!

Oder mit 0-9a-zA-ZAusgabe:

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

Probieren Sie es online aus!

05AB1E , 39 37 36 Bytes

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

-2 Bytes durch Erstellen eines Ports mit @ JonathanAllans Jelly-Antwort .

Probieren Sie es online aus oder überprüfen Sie alle Testfälle (jedoch als Listenausgabe und mit den ersten 100 statt 5000).

Erläuterung:

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)

Sehen Sie diese 05AB1E Spitze von mir (Abschnitt Wie das Wörterbuch benutzen? ) Zu verstehen , warum ”FizzÒÖ”ist "Fizz Buzz".

Perl 6 , 91 Bytes

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

Probieren Sie es online aus!

Anonymer Codeblock, der eine Liste von Zeichenfolgen Fizz/Buzz/FizzBuzzoder eine umgekehrte Liste von Ganzzahlen in der Basis zurückgibt .

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)

Probieren Sie es online aus!

C # (Visual C # Interactive Compiler) , 180 171 Byte

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

Ausgaben wie Arnauld's Antwort. Vielen Dank an digEmAll für die Idee, einen Stack zum Umkehren der Ausgabe zu verwenden.

Probieren Sie es online aus!

05AB1E , 34 Bytes

Verwendet Jonathans mathematische Einsicht, dass ceil(n/3+3)=floor((n+8)//3)+1

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

Probieren Sie es online aus!

Erläuterung

Ž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