Dada uma entrada n, seu programa ou função deve gerar o menor número inteiro positivo k, de forma que o narredondado para o múltiplo mais próximo de kseja maior que n.

Exemplo.

Dada uma entrada 20, o valor da saída deve ser 3:

O múltiplo mais próximo de 1é 20, que não é maior que 20.
O múltiplo mais próximo de 2é 20, que não é maior que 20.
O múltiplo mais próximo de 3é 21, que é maior que 20, portanto, é emitido.

Casos de teste

#Input  #Output
2       3
4       5
6       4
8       3
10      4
12      7
14      3
16      6
18      4
20      3
22      4
24      5
26      3
28      5
30      4
32      3
34      4
36      8
38      3
40      6
42      4
44      3
46      4
48      5
50      3
52      6
54      4
56      3
58      4
60      7
62      3
64      5
66      4
68      3
70      4
72      11
74      3
76      6
78      4
80      3
82      4
84      5
86      3
88      5
90      4
92      3
94      4
96      7
98      3
1000    6

A saída dada a qualquer entrada ímpar deve ser 2.

Regras

n é um número inteiro positivo menor que 2^32
o arredondamento é realizado de modo que, se dois múltiplos de kestão igualmente distantes n, o maior é escolhido ( "o arredondamento diminui para metade" ). Dessa maneira, todo ímpar nproduz uma saída de 2.
Este é o código-golfe , pelo que o código mais curto em cada idioma vence.

code-golf number

— fireflame241
fonte

Editei o formato dos seus casos de teste para facilitar a leitura e tornar mais conciso. Deixe-me saber se você tiver algum problema com isso ou se algum dos novos exemplos estiver desativado. :)

— DJMcMayhem

@Shaggy Done! Eu removi 500 probabilidades e 450 pares da lista.

— fireflame241

Existe um link oeis para esta sequência?

— James K

@ JamesK Não encontrei um quando procurei anteriormente. Possivelmente alguém com uma conta OEIS poderia fazer uma?

— fireflame241

12

Python 3 , 48 38 bytes

Editar: -10 bytes usando recursão

l=lambda x,y=2:y*(x%y>=y/2)or l(x,y+1)

Experimente online!

— Halvard Hummel
fonte

9

Japonês , 6 bytes

@<rX}a

Experimente online!

Explicação:

@    <r X}a
XYZ{U<UrX}a
X              // X = 0; Increments when the condition in between {...} fails
   {     }a    // Return the first integer X where:
    U          //   The input
     <U        //   is less than the input
       rX      //     rounded to the nearest multiple of X

— Oliver
fonte

2

ré um builtin? o_o

— Erik the Outgolfer

@EriktheOutgolfer: Japt também ins embutido para o arredondamento para cima ou para baixo :)

— Shaggy

5

Eu sabia que esse recurso seria útil um dia: D

— ETHproductions

@ Shaggy isso é loucura! o_o_o

— Erik the Outgolfer

@Oliver: Isto tem-me mais convencido a se familiarizar com os métodos de função, agora - a minha própria versão deste foi de 7 bytes:o æ@<rX

— Shaggy

7

MATL , 13 bytes

tQ:yy/Yo*<fX<

Experimente online! Ou verifique todas as entradas de 1para1000 .

Explicação

Considere entrada 6.

t      % Implicit input. Duplicate
       % STACK: 6, 6
Q:     % Add 1, range
       % STACK: 6, [1 2 3 4 5 6 7]
yy     % Duplicate top two elements
       % STACK: 6, [1 2 3 4 5 6 7], 6, [1 2 3 4 5 6 7]
/      % Divide, element-wise
       % STACK: 6, [1 2 3 4 5 6 7], [6 3 2 1.5 1.2 1 0.8571]
Yo     % Round to closest integer. Halves are rounded up
       % STACK: 6, [1 2 3 4 5 6 7], [6 3 2 2 1 1 1]
*      % Multiply, element-wise
       % STACK: 6, [6 6 6 8 5 6 7]
<      % Less than, element-wise
       % STACK: [0 0 0 1 0 0 1]
f      % Find: indices of nonzeros (1-based)
       % STACK: [4 7]
X<     % Minimum of vector. Implicit display
       % STACK: 4

— Luis Mendo
fonte

5

Python 2 , 35 bytes

f=lambda n,i=1:n%i*2/i or-~f(n,i+1)

Experimente online!

— xnor
fonte

5

JavaScript (ES6), 28 25 bytes

n=>g=x=>n%x>=x/2?x:g(-~x)

3 bytes salvos graças ao Arnauld.

Teste-o

o.innerText=(f=

n=>g=x=>n%x>=x/2?x:g(-~x)

)(i.value=64)();oninput=_=>o.innerText=f(+i.value)()

<input id=i type=number><pre id=o>

Expandir snippet

Ou teste todos os números de 1 a 1000 (espere um minuto para executar):

Mostrar snippet de código

f=n=>g=x=>n%x>=x/2?x:g(-~x);[2,3,2,5,2,4,2,3,2,4,2,7,2,3,2,6,2,4,2,3,2,4,2,5,2,3,2,5,2,4,2,3,2,4,2,8,2,3,2,6,2,4,2,3,2,4,2,5,2,3,2,6,2,4,2,3,2,4,2,7,2,3,2,5,2,4,2,3,2,4,2,11,2,3,2,6,2,4,2,3,2,4,2,5,2,3,2,5,2,4,2,3,2,4,2,7,2,3,2,6,2,4,2,3,2,4,2,5,2,3,2,6,2,4,2,3,2,4,2,11,2,3,2,5,2,4,2,3,2,4,2,7,2,3,2,6,2,4,2,3,2,4,2,5,2,3,2,5,2,4,2,3,2,4,2,8,2,3,2,6,2,4,2,3,2,4,2,5,2,3,2,6,2,4,2,3,2,4,2,7,2,3,2,5,2,4,2,3,2,4,2,13,2,3,2,6,2,4,2,3,2,4,2,5,2,3,2,5,2,4,2,3,2,4,2,7,2,3,2,6,2,4,2,3,2,4,2,5,2,3,2,6,2,4,2,3,2,4,2,9,2,3,2,5,2,4,2,3,2,4,2,8,2,3,2,6,2,4,2,3,2,4,2,5,2,3,2,5,2,4,2,3,2,4,2,8,2,3,2,6,2,4,2,3,2,4,2,5,2,3,2,6,2,4,2,3,2,4,2,7,2,3,2,5,2,4,2,3,2,4,2,7,2,3,2,6,2,4,2,3,2,4,2,5,2,3,2,5,2,4,2,3,2,4,2,10,2,3,2,6,2,4,2,3,2,4,2,5,2,3,2,6,2,4,2,3,2,4,2,11,2,3,2,5,2,4,2,3,2,4,2,8,2,3,2,6,2,4,2,3,2,4,2,5,2,3,2,5,2,4,2,3,2,4,2,7,2,3,2,6,2,4,2,3,2,4,2,5,2,3,2,6,2,4,2,3,2,4,2,8,2,3,2,5,2,4,2,3,2,4,2,7,2,3,2,6,2,4,2,3,2,4,2,5,2,3,2,5,2,4,2,3,2,4,2,9,2,3,2,6,2,4,2,3,2,4,2,5,2,3,2,6,2,4,2,3,2,4,2,7,2,3,2,5,2,4,2,3,2,4,2,8,2,3,2,6,2,4,2,3,2,4,2,5,2,3,2,5,2,4,2,3,2,4,2,7,2,3,2,6,2,4,2,3,2,4,2,5,2,3,2,6,2,4,2,3,2,4,2,8,2,3,2,5,2,4,2,3,2,4,2,7,2,3,2,6,2,4,2,3,2,4,2,5,2,3,2,5,2,4,2,3,2,4,2,10,2,3,2,6,2,4,2,3,2,4,2,5,2,3,2,6,2,4,2,3,2,4,2,7,2,3,2,5,2,4,2,3,2,4,2,8,2,3,2,6,2,4,2,3,2,4,2,5,2,3,2,5,2,4,2,3,2,4,2,7,2,3,2,6,2,4,2,3,2,4,2,5,2,3,2,6,2,4,2,3,2,4,2,8,2,3,2,5,2,4,2,3,2,4,2,9,2,3,2,6,2,4,2,3,2,4,2,5,2,3,2,5,2,4,2,3,2,4,2,10,2,3,2,6,2,4,2,3,2,4,2,5,2,3,2,6,2,4,2,3,2,4,2,7,2,3,2,5,2,4,2,3,2,4,2,7,2,3,2,6,2,4,2,3,2,4,2,5,2,3,2,5,2,4,2,3,2,4,2,8,2,3,2,6,2,4,2,3,2,4,2,5,2,3,2,6,2,4,2,3,2,4,2,8,2,3,2,5,2,4,2,3,2,4,2,13,2,3,2,6,2,4,2,3,2,4,2,5,2,3,2,5,2,4,2,3,2,4,2,7,2,3,2,6,2,4,2,3,2,4,2,5,2,3,2,6,2,4,2,3,2,4,2,13,2,3,2,5,2,4,2,3,2,4,2,7,2,3,2,6,2,4,2,3,2,4,2,5,2,3,2,5,2,4,2,3,2,4,2,8,2,3,2,6,2,4,2,3,2,4,2,5,2,3,2,6,2,4,2,3,2,4,2,7,2,3,2,5,2,4,2,3,2,4,2,11,2,3,2,6,2,4,2,3,2,4,2,5,2,3,2,5,2,4,2,3,2,4,2,7,2,3,2,6,2,4,2,3,2,4,2,5,2,3,2,6,2,4,2,3,2,4,2,9,2,3,2,5,2,4,2,3,2,4,2,7,2,3,2,6,2,4,2,3,2,4,2,5,2,3,2,5,2,4,2,3,2,4,2,8,2,3,2,6].forEach((x,y)=>o.innerText+=`\n-----------------------------\n${(++y+"").padStart(7)}  |${(y=f(y)()+"").padStart(8)}  |  ${x==y}`)

<pre id=o>  Input  |  Output  |  Pass</pre>

Expandir snippet

— Shaggy
fonte

5

Próton , 33 bytes

n=>[x for x:2..n+2if n%x>=x/2][0]

Experimente online!

— Mr. Xcoder
fonte

Não sei nada sobre o Proton, mas parece que você pode economizar 3 bytes: Experimente online!

— jferard

Talvez seja uma coincidência, mas isso é exatamente o mesmo que a solução totalmente humana ...: p

— Erik the Outgolfer

@EriktheOutgolfer Nós postamos ao mesmo tempo (na verdade, eu ninjai ele por alguns segundos) com 37 byter, porque Hyper borked os operadores, e quando ele os corrigiu nós dois atualizamos.

— Sr. Xcoder 18/08/19

Eu te ninjai IIRC. : P

— totallyhuman

@totallyhuman Você me ninja'd com 41 byter. Eu publiquei o 37-byter primeiro e ninja'd você com isso por alguns segundos.

— Mr. Xcoder

4

Pitão , 12 11 bytes

hfgy%QTTm+2

Experimente aqui.

— Mr. Xcoder
fonte

4

Próton , 33 bytes

x=>[y for y:2..x+2if x%y>=y/2][0]

Experimente online!

— totalmente humano
fonte

FWIW, por que você removeu ?

— Mr. Xcoder

3

Gelatina , 11 bytes

÷R%1<.¬;1TṂ

Um link monádico que recebe e retorna números inteiros positivos.

Experimente online! ou veja uma suíte de testes .

Quão?

÷R%1<.¬;1TṂ - Link: number, n       e.g. 10
 R          - range(n)               [ 1,2,3     ,4  ,5,6     ,7     ,8   ,9     ,10]
÷           - n divided by           [10,5,3.33..,2.5,2,1.66..,1.42..,1.25,1.11..,1 ]
  %1        - modulo by 1            [ 0,0,0.33..,0.5,0,0.66..,0.42..,0.25,0.11..,0 ]
    <.      - less than 0.5?         [ 1,1,1     ,0  ,1,0     ,1     ,1   ,1     ,1 ]
      ¬     - not                    [ 0,0,0     ,1  ,0,1     ,0     ,0   ,0     ,0 ]
       ;1   - concatenate a 1        [ 0,0,0     ,1  ,0,1     ,0     ,0   ,0     ,0 , 1]
         T  - truthy indices         [            4    ,6                           ,11]
          Ṃ - minimum                4

Nota: A concatenação de 1é apenas para lidar com os casos em que né um dos 1, 2ou 4quando o resultado precisa ser n+1( ‘R÷@%1<.¬TṂtambém funcionaria).

— Jonathan Allan
fonte

3

Haskell , 33 32 bytes

f n=[i|i<-[1..],2*mod n i>=i]!!0

Experimente online!

Guardado um byte graças a w0lf

— jferard
fonte

Você pode usar em !!0vez dehead

— Cristian Lupascu

2

Dyalog APL, 23 22 bytes

{⊃x/⍨⍵<x×⌊.5+⍵÷x←⍳1+⍵}

Experimente online!

— Uriel
fonte

2

Pitão, 5 bytes

fgy%Q

Suíte de teste

Sem arredondamentos embutidos, apenas verificando o primeiro número inteiro positivo T, onde o dobro do mod de entrada T é maior ou igual a T.

Explicação:

fgy%Q
fgy%QTT    Implicit variable introduction.
f          Find the first positive integer T such that the following is truthy:
   %QT     Input % T
  y        Doubled
 g    T    Is greater than or equal to T

— isaacg
fonte

2

Código da máquina x86, 17 bytes

Este código implementa uma solução iterativa básica na forma de uma função reutilizável:

31 F6                   xor    esi, esi
46                      inc    esi         ; set ESI (our temp register) to 1

                     Loop:
89 C8                   mov    eax, ecx    ; copy 'n' to EAX for division
46                      inc    esi         ; eagerly increment temp
99                      cdq                ; extend EAX into EDX:EAX
F7 F6                   div    esi         ; divide EDX:EAX by ESI
01 D2                   add    edx, edx    ; multiply remainder by 2
39 F2                   cmp    edx, esi    ; compare remainder*2 to temp
7C F4                   jb     Loop        ; keep looping if remainder*2 < temp

96                      xchg   eax, esi    ; put result into EAX (1 byte shorter than MOV)
C3                      ret

A função segue a convenção de chamada de chamada rápida , para que o único parâmetro ( n) seja passado no ECXregistrador. O valor de retorno ( k) é, normalmente, retornado no EAXregistro.

Experimente online!

— Cody Gray
fonte

2

Java 8, 42 bytes

Lambda de Integeraté Integer.

n->{for(int f=1;;)if(n%++f*2>=f)return f;}

Experimente Online

Agradecimentos

-1 byte graças a Kevin Cruijssen

— Jakob
fonte

4

Você pode salvar um byte, iniciando f=1e usando ++fno primeiro f, como este:n->{for(int f=1;;)if(n%++f*2>=f)return f;}

— Kevin Cruijssen

1

Perl 5 , 24 + 1 (-p) = 25 bytes

1while$_%++$k<$k/2;$_=$k

Experimente online!

Tenta cada número inteiro $kcomeçando em 1 até encontrar um restante que seja pelo menos metade de $k.

— Xcali
fonte

1

Quarto (gforth) , 45 bytes

: f 1 begin 1+ 2dup mod over 1+ 2/ >= until ;

Experimente online!

Código Explicação

: f             \ start a new word definition
  1             \ start a counter at 1
  begin         \ start an indefinite loop
    1+          \ add 1 to counter
    2dup mod    \ duplicate input value and counter, get remainder of input/counter
    over 1+ 2/  \ get counter/2 (add 1 to force rounding up)
    >=          \ check if remainder is greater than counter/2
  until         \ end loop if true, otherwise go back to beginning
;               \ end word definition

— reffu
fonte

1

05AB1E , 9 bytes

∞.ΔIs/Dò‹

Experimente online!

Explicação

∞.ΔIs/Dò‹ Full code
∞.Δ       Returns the first number for which the following code returns true
             -> stack is [n]
   Is     Push the input and swap the stack -> stack is [input, n]
     /    Divide both of them -> stack is [input/n]
      Dò  Duplicate and round the second -> stack is [input/n, rounded(input/n)]
        ‹ Check if input/n got larger by rounding -> stack is [bool]
             -> if bool is true, abort and return the current number

— Black Owl Kai
fonte

1

Rockstar , 681 bytes

Thought takes Patience and Control
While Patience is as high as Control
Let Patience be without Control

Give back Patience

Rock takes Art
Love is neverending
Sex is bottomless
Put Thought taking Art & Love into your head
If your head is Sex
Give back Art
Else
Limits are inspiration
Put Art with Limits without your head into the rubbish
Give back the rubbish


Listen to Chance
Questions are unstoppable
Until Questions is Chance
Build Questions up
Put Thought taking Chance, Questions into your mind
Answers are independence (but)
Put Questions over Answers into the world
Put Rock taking the world into the world
If your mind is as big as the world
Say Questions
Break it down

Você pode experimentar o rockstar online , mas precisará copiar e colar o código. Ele solicitará um número de entrada.

Eu não fiz a menor contagem de bytes, porque o Rockstar obviamente não é feito para jogar golfe, então tentei usar as letras do Rock 'n' Roll.

Explicação:

Isso é baseado na mesma solução que outras (python, java):

Iterate up from 2:
if n % iterator >= ceil(n/2)
    return iterator

No entanto, primeiro preciso definir as funções de módulo e teto, que por causa da poesia são chamadas de Pensamento e Rocha.

A seguir, uma versão menos poética, com diferentes nomes de variáveis e explicações em que a sintaxe não é clara. Parênteses indicam comentários.

Modulus takes Number and Divisor
While Number is as high as Divisor
Put Number minus Divisor into Number
    (blank line ending While block)
Give back Number (return Number)
    (blank line ending function declaration)
Ceil takes Decimal
Put Modulus taking Decimal, 1 into Remainder
If Remainder is 0
Give back Decimal (return Decimal)
Else
Put Decimal with 1 minus Remainder into Result
Give back Result (return Result)
    (blank line ending if block)
    (blank line ending function declaration)
Listen to Input (Read from STDIN to Input)
Index is 1
Until Index is Input
Build Index up (Increment by 1)
Put Modulus taking Input, Index into LHS
Put Index over 2 into RHS
Put Ceil taking RHS into RHS
If LHS is as big as RHS
Say Index
Break it down (Break from loop)

— IMP1
fonte

0

Gelatina , 18 bytes

ɓ÷Ḟ,¥Ċ$×ạÐṂ⁸Ṁ>⁸µ1#

Experimente online!

Programa completo.

— Erik, o Outgolfer
fonte

3

Full program.Quando não é?

— totallyhuman

@totallyhuman Às vezes, também funciona como uma função.

— Erik the Outgolfer

0

Swift 3 , 51 bytes

{n in(2..<n+2).filter{Float(n%$0)>=Float($0)/2}[0]}

Por algumas razões extremamente bizarras, [0]não funciona online. Aqui está a versão compatível com o compilador on-line (que usa em seu .first!lugar):

{n in(2..<n+2).filter{Float(n%$0)>=Float($0)/2}.first!}

Conjunto de testes (compatível on-line).

— Mr. Xcoder
fonte

0

C # (Mono) , 39 bytes

n=>{int i=1;for(;n%++i*2<i;);return i;}

Experimente online!

— TheLethalCoder
fonte

0

Stax , 7 bytes

ç&╬▼⌐╔ñ

Execute e depure

— recursivo
fonte

Me rodeie, me ajude

Exemplo.

Casos de teste

Regras

Python 3 , 48 38 bytes

Japonês , 6 bytes

Explicação:

MATL , 13 bytes

Explicação

Python 2 , 35 bytes

JavaScript (ES6), 28 25 bytes

Teste-o

Próton , 33 bytes

Pitão , 12 11 bytes

Próton , 33 bytes

Gelatina , 11 bytes

Quão?

Haskell , 33 32 bytes

Dyalog APL, 23 22 bytes

Pitão, 5 bytes

Código da máquina x86, 17 bytes

Java 8, 42 bytes

Agradecimentos

Perl 5 , 24 + 1 (-p) = 25 bytes

Quarto (gforth) , 45 bytes

Código Explicação

05AB1E , 9 bytes

Explicação

Rockstar , 681 bytes

Explicação:

Gelatina , 18 bytes

Swift 3 , 51 bytes

C # (Mono) , 39 bytes

Stax , 7 bytes