MathGolf, 5 4 bytes

τ/╠ü

Try it online!

Explanation

τ      Push tau (2*pi)

 /     Divide the first argument (total distance) by tau

  ╠    Reverse divide (computes (distance/tau)/radius)

   ü   Ceiling

APL+WIN, 9 bytes

Prompts for radius followed by distance:

⌈⎕÷○r+r←⎕

Try it online! Courtesy of Dyalog Classic

Explanation:

○r+r←⎕ prompt for radius and double it and multiply by pie



⌈⎕÷ prompt for distance, divide by result above and take ceiling

Java 8, 32 30 bytes

a->b->-~(int)(a/b/Math.PI/'')

Contains unprintable u0002 between the single quotes.

Port of @jOKing's Perl 6 answer.

Try it online.

Perl 6, 15 12 bytes

-3 bytes tjanks to nwellnhof reminding me about tau

*/*/τ+|$+!$

Try it online!

Anonymous Whatever lambda that uses the formula (a/b/tau).floor+1. Tau is two times pi. The two anonymous variables $ are coerced to the number 0, which is used to floor the number +|0 (bitwise or 0) and add one +!$ (plus not zero).

Python 2, 47 45 44 43 bytes

lambda l,r:l/(r+r)//math.pi+l/l

import math

Try it online!

• -2 bytes, thanks to flawr


• -1 byte, thanks to Jonathan Allan

05AB1E, 6 bytes

·/žq/î

Port of @flawr's Python 2 comment.

Takes the input in the order radius,distance.

Try it online or verify all test cases.

Explanation:

·         # Double the first (implicit) input

 /        # Divide the second (implicit) input by it

  žq/     # Divide it by PI

     î    # Ceil it (and output implicitly)

C, 46 bytes

f(float a,float b){return ceil(a/(b+b)/M_PI);}

I'm new to PPCG, so I'm not sure wether I have to count other parts in the byte count, such as the

include <math.h>

needed for the ceil function, which will rise the count to 64 bytes

Catholicon, 8 bytes

ċ//ĊǓĊ`Ė

Explanation:

  /ĊǓĊ    divide the first input by the doubled second input

 /    `Ė  divide that by pi

ċ         ceil

New version (pi builtin made one byte, division parameters swapped), 5 bytes

ċ/π/Ǔ

Stax, 5 bytes

Vt*/e

Run and debug it

Vt*   multiply by tau (2pi)

/     divide

e     ceiling

MathGolf, 6 5 bytes

∞/π/ü

Semi-port of @flawr's Python 2 comment.

Takes the input in the order radius distance.

-1 byte because ceil builtin has just been added, replacing the floor+1.

Try it online.

Explanation:

∞        # Double the first (implicit) input

 /       # Divide the second (implicit) input by it

  π/     # Divide it by PI

    ü    # Ceil (and output implicitly)

C (gcc), 45 47 45 bytes

f(d,r,R)float d,r;{R=ceil(d/r/'G'/'n'*'q');}

A reasonable approximation of pi is 355/113. Since circumference C = 2 * r * PI, we can instead of pi use tau, which is then of course ~710/113. 710 happens to have the convenient factors 2 * 5 * 71, which is compactly expressed as 'G' * 'n'. We add one (r/r) to force rounding to infinity.

Edit: My trick was too clever for its own good: it of course made it fail if the distance was a multiple of the circumference.

Try it online!

Julia 1.0, 20 bytes

f(d,r)=cld(d/π,r+r)

Try it online!

R, 39 32 bytes

-7 bytes Thanks to Giuseppe

function(d,r)ceiling(d/(r+r)/pi)

Try it online!

I feel like this could definitely be golfed, but I am a bit lazy right now to do anything about it

PHP, 47 bytes

<?=ceil($argv[++$i]/M_PI/(($b=end($argv))+$b));

Try it online.

Jelly, 6 bytes

÷÷ØPHĊ

Try it online!

Ruby, 29 bytes

->l,r{(l/Math::PI/r+=r).ceil}

Try it online!

J, 10 9 bytes

>.@%o.@+:

Try it online!

Japt, 7 bytes

/MT/V c

Try it here

JavaScript (Babel Node), 25 bytes

-2 bytes using @flawr comment =D. -1 from @Kevin. -7 from @Shaggy

a=>b=>-~(a/(b+b)/Math.PI)

Try it online!

min, 16 bytes

/ tau / ceil int

Takes the distance and radius put on the stack in that order. Then divides by tau, rounds, and makes int.

Dart, 47 46 bytes

import'dart:math';f(a,b)=>(a/(b+b)/pi).ceil();

Try it online!

• -1 byte thanks to @Shaggy

JavaScript (Babel Node), 23 bytes

s=>r=>-~(s/2/r/Math.PI)

Try it online!

Haskell, 25 bytes

f d r=ceiling(d/(r+r)/pi)

Lua, 61 58 57 49 bytes

function(s,r)return math.ceil(s/(r+r)/math.pi)end

Try it online!

Thanks to KirillL. -8 bytes.

Common Lisp, 36 bytes

(lambda(a b)(ceiling(/ a(+ b b)pi)))

Try it online!

Tcl, 50 bytes

proc N d r {expr ceil($d/(($r+$r)*acos(-$r/$r)))}

Try it online!

Tcl, 53 bytes

proc N d r {expr ceil($d/(($r+$r)*acos(-[incr i])))}

Try it online!

Lack of a pi constant or function makes me lose the golf competition!

PowerShell, 53 52 bytes

-1 byte thanks to @mazzy

param($d,$r);($a=[math])::ceiling($d/($r+$r)/$a::pi)

Takes input from two commandline parameters, distance -d and radius -r.

Mathematica, 8 bytes

 #/(2π r)&

So that

r =22.9;

#/(2π r)& @ 32

gives

(* 0.2224 *)

Clojure, 50 bytes

(fn[a b](int(Math/ceil(/ a Math/PI(count"  ")b))))

An anonymous function that accepts two integers a and b as arguments: the distance and the wheel's radius, respectively.

Try it online!

(count " ") evaluates to 2, so this function implements $lceil dfrac a{2pi b} rceil$.

TI-Basic (83 series), 12 bytes

-int(-Tmax⁻¹min(e^(ΔList(ln(Ans

Takes input as a list of radius and distance in Ans: for example, {0.9999:12.5663:prgmX.

e^(ΔList(ln(Ans will take the ratio of those distances, and min( turns this into a number. Then we divide by Tmax, which is a graphing parameter that's equal to 2π by default. Finally, -int(- takes the ceiling.