10
\$\begingroup\$

Task

Write a function or a program to find the number of rotations required by a wheel to travel a given distance, given its radius.

Rules

Input can be 2 positive rational numbers and can be taken in any convenient format.

Both inputs are of same unit.

There must not be any digits 0-9 in your code.

The output will be an integer (in case of float, round to infinity)

This is code-golf so shortest code wins

Examples

distance radius  output
10       1       2
50       2       4
52.22    4       3
3.4      0.08    7
12.5663  0.9999  3
|improve this question
\$\endgroup\$
  • 5
    \$\begingroup\$ You probably should add that digits are also forbidden in compiler options (or anywhere else): if you limit this constraint to code only, with gcc we can do something like -DP=3.14 in compiler flags, that would define P as an approximation of pi, which is probably not what you intended \$\endgroup\$ – Annyo Nov 21 '18 at 16:50

34 Answers 34

1 2
6
\$\begingroup\$

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
|improve this answer
\$\endgroup\$
4
\$\begingroup\$

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
|improve this answer
\$\endgroup\$
  • \$\begingroup\$ ⌈⎕÷○+⍨⎕ works for 7 bytes. \$\endgroup\$ – J. Sallé Nov 22 '18 at 13:04
  • \$\begingroup\$ @J.Sallé Thanks but unfortunately my ancient APL+WIN interpreter does not have the ⍨ operator \$\endgroup\$ – Graham Nov 22 '18 at 15:51
4
\$\begingroup\$

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.

|improve this answer
\$\endgroup\$
  • \$\begingroup\$ Is that the digit '1' in your code? I think that might not be allowed. \$\endgroup\$ – ouflak Nov 21 '18 at 14:18
  • 4
    \$\begingroup\$ @ouflak Looks like it can be fixed like this. \$\endgroup\$ – Erik the Outgolfer Nov 21 '18 at 14:22
  • \$\begingroup\$ @ouflak Woops, that was a pretty stupid mistake.. Using the unprintable so I don't use the digit 2, and then just use digit 1... Luckily Erik is indeed right that a simple negative unary has the same effect as +1 (often used to get rid of parenthesis since the negative and unary have higher precedence than most other operators). \$\endgroup\$ – Kevin Cruijssen Nov 21 '18 at 18:21
4
\$\begingroup\$

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

|improve this answer
\$\endgroup\$
  • \$\begingroup\$ There must not be any digits 0-9 in your code. \$\endgroup\$ – Titus Nov 21 '18 at 13:35
  • \$\begingroup\$ @Titus I can't believe I forgot that. Thanks, fixed! \$\endgroup\$ – Jo King Nov 21 '18 at 13:37
  • \$\begingroup\$ Are digits in exponents also allowed? \$\endgroup\$ – ouflak Nov 21 '18 at 14:21
3
\$\begingroup\$

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
|improve this answer
\$\endgroup\$
  • \$\begingroup\$ Since inputs have been guaranteed to be both (strictly) positive and rational we never hit the edge-case of requiring an exact number of rotations, so I think we can do l/(r+r)//pi+l/l and save a byte. \$\endgroup\$ – Jonathan Allan Nov 21 '18 at 13:50
  • \$\begingroup\$ @JonathanAllan Thanks :) \$\endgroup\$ – TFeld Nov 21 '18 at 14:16
2
\$\begingroup\$

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)
|improve this answer
\$\endgroup\$
2
\$\begingroup\$

PHP, 47 bytes

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

Try it online.

|improve this answer
\$\endgroup\$
2
\$\begingroup\$

Ruby, 29 bytes

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

Try it online!

|improve this answer
\$\endgroup\$
2
\$\begingroup\$

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

|improve this answer
\$\endgroup\$
  • \$\begingroup\$ Welcome to PPCG! This is a nice first answer. Yes, you do need to count #include and the like towards your byte total. A link to an online test suite is always appreciated, here's one you are free to incorporate into your post: tio.run/… \$\endgroup\$ – O.O.Balance Nov 21 '18 at 14:53
  • \$\begingroup\$ @O.O.Balance Digits are not allowed in the code for this challenge ;) \$\endgroup\$ – Annyo Nov 21 '18 at 15:25
  • \$\begingroup\$ @Annyo I knew I was forgetting something :( \$\endgroup\$ – O.O.Balance Nov 21 '18 at 15:26
2
\$\begingroup\$

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

ċ/π/Ǔ
|improve this answer
\$\endgroup\$
2
\$\begingroup\$

J, 10 9 bytes

>.@%o.@+:

Try it online!

|improve this answer
\$\endgroup\$
  • 1
    \$\begingroup\$ +1 for elegant use of dyadic hook \$\endgroup\$ – Jonah Jan 22 at 3:30
  • \$\begingroup\$ @Jonah Thank you! \$\endgroup\$ – Galen Ivanov Jan 22 at 7:12
2
\$\begingroup\$

Stax, 5 bytes

Vt*/e

Run and debug it

Vt*   multiply by tau (2pi)
/     divide
e     ceiling
|improve this answer
\$\endgroup\$
2
\$\begingroup\$

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)
|improve this answer
\$\endgroup\$
2
\$\begingroup\$

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!

|improve this answer
\$\endgroup\$
2
\$\begingroup\$

Julia 1.0, 20 bytes

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

Try it online!

|improve this answer
\$\endgroup\$
2
\$\begingroup\$

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

|improve this answer
\$\endgroup\$
2
\$\begingroup\$

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.

|improve this answer
\$\endgroup\$
1
\$\begingroup\$

Jelly, 6 bytes

÷÷ØPHĊ

Try it online!

|improve this answer
\$\endgroup\$
1
\$\begingroup\$

Japt, 7 bytes

/MT/V c

Try it here

|improve this answer
\$\endgroup\$
1
\$\begingroup\$

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!

|improve this answer
\$\endgroup\$
  • \$\begingroup\$ Just a=>b=>Math.ceil(a/(b+b)/Math.PI) is 32 bytes. :) \$\endgroup\$ – Kevin Cruijssen Nov 21 '18 at 13:06
  • \$\begingroup\$ 25 bytes \$\endgroup\$ – Shaggy Nov 21 '18 at 17:09
1
\$\begingroup\$

Dart, 47 46 bytes

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

Try it online!

  • -1 byte thanks to @Shaggy
|improve this answer
\$\endgroup\$
  • \$\begingroup\$ 46 bytes \$\endgroup\$ – Shaggy Nov 22 '18 at 12:30
1
\$\begingroup\$

Haskell, 25 bytes

f d r=ceiling(d/(r+r)/pi)
|improve this answer
\$\endgroup\$
  • \$\begingroup\$ You can define an operator (!) instead of f and use ceiling$ instead of ceiling(..)which saves you 3 bytes: Try it online! \$\endgroup\$ – ბიმო Dec 8 '18 at 15:15
1
\$\begingroup\$

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.

|improve this answer
\$\endgroup\$
  • \$\begingroup\$ I don't know much Lua (so maybe it's still too long), but it appears to be shorter as a function: 49 bytes \$\endgroup\$ – Kirill L. Nov 22 '18 at 11:18
  • \$\begingroup\$ @KirillL., I'm still learning the rules here. The OP's challenge is pretty open on the input. So my question is, would we have to count your program call() against the byte count? If not, your's definitely shaves off a nice chunk. \$\endgroup\$ – ouflak Nov 22 '18 at 11:43
  • \$\begingroup\$ A quite common style of submission here is an anonymous function (so that we don't have to count the name, unless it is recursive), which outputs by its return value. The footer section with function calls and actual printing to console is then basically used for visualizing the results and doesn't count towards your score. BTW, you may add more of the OP's test examples to the footer, so that they can be conveniently viewed all at once. Note that in some cases a full program may actually turn out to be golfier! \$\endgroup\$ – Kirill L. Nov 22 '18 at 11:58
1
\$\begingroup\$

Common Lisp, 36 bytes

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

Try it online!

|improve this answer
\$\endgroup\$
1
\$\begingroup\$

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!

|improve this answer
\$\endgroup\$
  • \$\begingroup\$ Do I need to remove the .0 at end of each output? It would make me consume more bytes! \$\endgroup\$ – sergiol Nov 22 '18 at 18:55
  • 1
    \$\begingroup\$ [incr i] is quite clever but I think you can use $d/$d or $r/$r instead. \$\endgroup\$ – david Nov 22 '18 at 20:17
  • \$\begingroup\$ Saved some bytes thanks to @david's idea! \$\endgroup\$ – sergiol Nov 22 '18 at 22:56
1
\$\begingroup\$

PowerShell, 53 52 51 bytes

-1 byte thanks to @mazzy
-1 byte after I realized I don't need a semicolon after the param() block

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

Try it online!

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

|improve this answer
\$\endgroup\$
  • \$\begingroup\$ ? param($d,$r);($a=[math])::ceiling($d/($r+$r)/$a::pi) \$\endgroup\$ – mazzy Nov 24 '18 at 5:54
0
\$\begingroup\$

JavaScript (Babel Node), 23 bytes

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

Try it online!

|improve this answer
\$\endgroup\$
  • 2
    \$\begingroup\$ There must not be any digits 0-9 in your code. \$\endgroup\$ – Dennis Nov 22 '18 at 12:55
0
\$\begingroup\$

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{2\pi b} \rceil\$.

|improve this answer
\$\endgroup\$
0
\$\begingroup\$

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.

|improve this answer
\$\endgroup\$
0
\$\begingroup\$

Pari/GP, 23 bytes

(d,r)->ceil(d/(r+r)/Pi)

Try it online!

|improve this answer
\$\endgroup\$
1 2

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.