Número de rotações

10

Tarefa

Escreva uma função ou um programa para encontrar o número de rotações necessárias para uma roda percorrer uma determinada distância, considerando seu raio.

Regras

A entrada pode ter 2 números racionais positivos e pode ser obtida em qualquer formato conveniente.

Ambas as entradas são da mesma unidade.

Não deve haver nenhum dígito de 0 a 9 no seu código.

A saída será um número inteiro (no caso de flutuação, arredondar para o infinito)

Isso é código-golfe, então o código mais curto ganha

Exemplos

distance radius  output
10       1       2
50       2       4
52.22    4       3
3.4      0.08    7
12.5663  0.9999  3
code-golf restricted-source Vedant Kandoi
fonte
5
Você provavelmente deve adicionar que os dígitos também são proibidos nas opções do compilador (ou em qualquer outro lugar): se você limitar essa restrição ao código, com o gcc, podemos fazer algo como -DP=3.14nos sinalizadores do compilador, que definiriam Pcomo uma aproximação de pi, o que provavelmente é não o que você destina
Annyo

Respostas:

6

MathGolf , 5 4 bytes

τ/╠ü

Experimente online!

Explicação

τ      Push tau (2*pi)
 /     Divide the first argument (total distance) by tau
  ╠    Reverse divide (computes (distance/tau)/radius)
   ü   Ceiling
maxb
fonte
4

APL + WIN, 9 bytes

Solicita o raio seguido pela distância:

⌈⎕÷○r+r←⎕

Experimente online! Cortesia de Dyalog Classic

Explicação:

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

⌈⎕÷ prompt for distance, divide by result above and take ceiling
Graham
fonte
⌈⎕÷○+⍨⎕trabalha para 7 bytes.
J. Sallé 22/11
@ J.Sallé Obrigado, mas infelizmente o meu antigo intérprete APL + WIN não tem o ⍨ operador
Graham
4

Java 8, 32 e 30 bytes

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

Contém imprimível \u0002entre aspas simples.

Porto da resposta Perl 6 do @jOKing .

Experimente online.

Kevin Cruijssen
fonte
Esse é o dígito '1' no seu código? Eu acho que isso pode não ser permitido.
ouflak
4
Looks @ouflak como ele pode ser corrigido como este .
Erik the Outgolfer
@ouflak Woops, isso foi um erro muito estúpido .. Usar o imprimível para não usar o dígito 2e depois usar o dígito 1... Felizmente, Erik está certo de que um simples unário negativo tem o mesmo efeito que +1(frequentemente usado livrar-se dos parênteses, pois o negativo e o unário têm maior precedência do que a maioria dos outros operadores).
21718 Kevin Kevin Krijssen em
4

Perl 6 , 15 12 bytes

-3 bytes tjanks para nwellnhof, lembrando-me sobre tau

*/*/τ+|$+!$

Experimente online!

Anônimo Qualquer que seja a lambda que use a fórmula (a/b/tau).floor+1. Tau é duas vezes pi. As duas variáveis ​​anônimas $são coagidas ao número 0, que é usado para +|0somar o número (bit a bit ou 0) e adicionar um +!$(mais não zero).

Brincadeira
fonte
Não deve haver dígitos de 0 a 9 no seu código.
Titus
@ Titus Não acredito que esqueci isso. Obrigado, consertado!
Jo rei
Os dígitos nos expoentes também são permitidos?
precisa saber é
3

Python 2 , 47 45 44 43 bytes

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

Experimente online!

  • -2 bytes, graças ao flawr
  • -1 byte, graças a Jonathan Allan
TFeld
fonte
Como é garantido que as entradas são (estritamente) positivas e racionais, nunca chegamos ao limite de exigir um número exato de rotações, então acho que podemos fazer l/(r+r)//pi+l/le salvar um byte.
Jonathan Allan
@JonathanAllan Thanks :) #
TFeld
2

C, 46 bytes

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

Sou novo no PPCG, portanto, não tenho certeza se preciso contar outras partes na contagem de bytes, como o 

include <math.h>

necessário para a função ceil, que aumentará a contagem para 64 bytes

bznein
fonte
Bem-vindo ao PPCG! Esta é uma boa primeira resposta. Sim, você precisa contar #includee afins para o total de bytes. Um link para um conjunto de testes on-line é sempre apreciado, aqui está um que você está livre para incorporar em seu post: tio.run/...
OOBalance
Dígitos do @OOBalance não são permitidos no código para este desafio;)
Annyo
@Annyo Eu sabia que estava esquecendo alguma coisa :(
OOBalance
2

Catholicon , 8 bytes

ċ//ĊǓĊ`Ė

Explicação:

  /ĊǓĊ    divide the first input by the doubled second input
 /    `Ė  divide that by pi
ċ         ceil

Nova versão (pi construído em um byte, parâmetros de divisão trocados), 5 bytes

ċ/π/Ǔ
Okx
fonte
2

J , 10 9 bytes

>.@%o.@+:

Experimente online!

Galen Ivanov
fonte
11
+1 para o uso elegante do gancho diádico
Jonah
@Jonah Obrigado!
Galen Ivanov
2

Stax , 5 bytes

Vt*/e

Execute e depure

Vt*   multiply by tau (2pi)
/     divide
e     ceiling
recursivo
fonte
2

MathGolf , 6 5 bytes

∞/π/ü

Semi-porta do comentário Python 2 de @flawr .
Recebe a entrada na ordem radius distance.

-1 byte porque o ceilbuilt-in acaba de ser adicionado, substituindo o floor+1.

Experimente online .

Explicação:

∞        # Double the first (implicit) input
 /       # Divide the second (implicit) input by it
  π/     # Divide it by PI
    ü    # Ceil (and output implicitly)
Kevin Cruijssen
fonte
2

C (gcc) , 45 47 45 bytes

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

Uma aproximação razoável de pi é 355/113. Como a circunferência C = 2 * r * PI, podemos, em vez de pi, usar tau, que, é claro, é ~ 710/113. 710 passa a ter os fatores convenientes 2 * 5 * 71, que são compactados como 'G' * '\n'. Nós adicionamos um ( r/r) para forçar o arredondamento para o infinito.

Edit: Meu truque era muito inteligente para o seu próprio bem: é claro que fazia falhar se a distância fosse um múltiplo da circunferência.

Experimente online!

gastropner
fonte
2

R , 39 32 bytes

-7 bytes Graças a Giuseppe

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

Experimente online!

Eu sinto que isso definitivamente poderia ser jogado, mas estou um pouco preguiçoso agora para fazer qualquer coisa sobre isso

Sumner18
fonte
2

min , 16 bytes

/ tau / ceil int

Toma a distância e o raio colocados na pilha nessa ordem. Em seguida, divide por tau, arredonda e faz int.

Panda0nEarth
fonte
1

JavaScript (Nó Babel) , 25 bytes

-2 bytes usando @flawr comment = D. -1 de @Kevin. -7 de @Shaggy

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

Experimente online!

Luis felipe De jesus Munoz
fonte
Apenas a=>b=>Math.ceil(a/(b+b)/Math.PI)tem 32 bytes. :)
Kevin Cruijssen
25 bytes
Salsicha
1

Haskell, 25 bytes

f d r=ceiling(d/(r+r)/pi)
memorando
fonte
Você pode definir um operador em (!)vez de fe usá-lo em ceiling$vez de ceiling(..)economizar 3 bytes: Experimente online!
ბიმო
1

Lua , 61 58 57 49 bytes

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

Experimente online!

Graças a KirillL. -8 bytes.

ouflak
fonte
Eu não sei muito Lua (talvez por isso ainda é muito longo), mas parece ser mais curto em função: 49 bytes
Kirill L.
@KirillL., Ainda estou aprendendo as regras aqui. O desafio do OP é bastante aberto na entrada. Então, minha pergunta é: teríamos que contar sua chamada de programa () contra a contagem de bytes? Caso contrário, o seu é definitivamente um bom pedaço.
Ouflak # 22/18
Um estilo bastante comum de envio aqui é uma função anônima (para que não tenhamos que contar o nome, a menos que seja recursivo), que gera pelo seu valor de retorno. A seção de rodapé com chamadas de função e impressão real no console é então basicamente usada para visualizar os resultados e não conta para a sua pontuação. BTW, você pode adicionar mais exemplos de teste do OP ao rodapé, para que eles possam ser visualizados convenientemente de uma só vez. Observe que, em alguns casos, um programa completo pode realmente ser um golfista!
22418 Kirill L.
1

Tcl , 50 bytes

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

Experimente online!

Tcl , 53 bytes

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

Experimente online!

A falta de uma constante ou função pi me faz perder a competição de golfe!

sergiol
fonte
Preciso remover o .0 no final de cada saída? Isso me faria consumir mais bytes!
Sergiol # 22/18
11
[incr i]é bastante inteligente, mas acho que você pode usar $d/$dou $r/$rnão.
david
Economizei alguns bytes graças à idéia de @ david!
Sergiol # 22/18
1

PowerShell, 53 52 51 bytes

-1 byte graças a @mazzy
-1 byte depois que percebi que não precisava de um ponto e vírgula após o param()bloco

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

Experimente online!

Recebe entrada de dois parâmetros da linha de comando, distância -de raio -r.

Gabriel Mills
fonte
? param($d,$r);($a=[math])::ceiling($d/($r+$r)/$a::pi)
Mazzy
0

JavaScript (Nó Babel), 23 bytes

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

Experimente online!

Igor Sowinski
fonte
2
Não deve haver dígitos de 0 a 9 no seu código.
Dennis
0

Clojure , 50 bytes

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

Uma função anônima que aceita dois números inteiros ae bcomo argumentos: a distância e o raio da roda, respectivamente.

Experimente online!

(count " ")2⌈a2πb⌉

TheGreatGeek
fonte
0

TI-Basic (série 83), 12 bytes

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

Leva a entrada como uma lista de raio e distância em Ans: por exemplo {0.9999:12.5663:prgmX,.

e^(ΔList(ln(Anstomará a proporção dessas distâncias e min(transformará isso em um número. Em seguida, dividimos por Tmax, que é um parâmetro gráfico que é igual a 2π por padrão. Finalmente, -int(-pega o teto.

Misha Lavrov
fonte