Dada una entrada n, su programa o función debe generar el número entero positivo más pequeño de kmodo que nredondeado al múltiplo más cercano de ksea mayor que n.

Ejemplo.

Dada una entrada 20, el valor de salida debe ser 3:

El múltiplo más cercano de 1es 20, que no es mayor que 20.
El múltiplo más cercano de 2es 20, que no es mayor que 20.
El múltiplo más cercano de 3es 21, que es mayor que 20, por lo que se emite.

Casos de prueba

#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

La salida dada cualquier entrada impar debe ser 2.

Reglas

n es un entero positivo menor que 2^32
El redondeo se realiza de tal manera que si dos múltiplos de kestán igualmente distantes n, se elige el mayor ( "redondear a la mitad hacia arriba" ). De esta manera, cada impar nproduce una salida de 2.
Este es el código de golf , por lo que gana el código más corto en cada idioma .

code-golf number

— fireflame241
fuente

He editado el formato de sus casos de prueba para que sea más fácil de leer y más conciso. Avíseme si tiene algún problema con esto o si alguno de los nuevos ejemplos está desactivado. :)

— DJMcMayhem

@Shaggy Hecho! Eliminé 500 cuotas y 450 pares de la lista.

— fireflame241

¿Hay un enlace oeis para esta secuencia?

— James K

@JamesK No encontré uno cuando busqué antes. ¿Posiblemente alguien con una cuenta OEIS podría crear una?

— fireflame241

12

Python 3 , 48 38 bytes

Editar: -10 bytes usando recursividad

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

Pruébalo en línea!

— Halvard Hummel
fuente

9

Japt , 6 bytes

@<rX}a

Pruébalo en línea!

Explicación:

@    <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
fuente

2

res un incorporado? o_o

— Erik the Outgolfer

@EriktheOutgolfer: Japt también tiene incorporados para redondear hacia arriba o hacia abajo :)

— Shaggy

55

Yo sabía que esta característica sería útil algún día: D

— ETHproductions

@ Shaggy eso es una locura! o_o_o

— Erik the Outgolfer

@Oliver: Esto me tiene más convencido de familiarizarme con los métodos de función, ahora - mi propia versión de esto era de 7 bytes:o æ@<rX

— Shaggy

7

MATL , 13 bytes

tQ:yy/Yo*<fX<

Pruébalo en línea! O verifique todas las entradas de 1a1000 .

Explicación

Considere la 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
fuente

5

Python 2 , 35 bytes

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

Pruébalo en línea!

— xnor
fuente

5

JavaScript (ES6), 28 25 bytes

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

3 bytes guardados gracias a Arnauld.

Pruébalo

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 fragmento

O pruebe todos los números del 1-1000 (espere un minuto para ejecutar):

Mostrar fragmento 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 fragmento

— Lanudo
fuente

5

Protón , 33 bytes

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

Pruébalo en línea!

— Sr. Xcoder
fuente

No sé nada sobre Proton, pero parece que puedes guardar 3 bytes: ¡ Pruébalo en línea!

— jferard

Tal vez sea una coincidencia, pero esto es exactamente lo mismo que la solución totalmente humana ...: p

— Erik the Outgolfer

@EriktheOutgolfer Lo publicamos al mismo tiempo (de hecho, lo ninja por unos segundos) con 37 bytes, porque Hyper borked a los operadores, y cuando los arregló los dos los actualizamos.

— Sr. Xcoder

Uhh, te ninja IIRC. : P

— totalmente humano

@totallyhuman Usted me ninja con un 41 byter. Publiqué el 37-byter primero y te ninja con eso por unos segundos.

— Sr. Xcoder

4

Pyth , 12 11 bytes

hfgy%QTTm+2

Pruébalo aquí

— Sr. Xcoder
fuente

4

Protón , 33 bytes

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

Pruébalo en línea!

— totalmente humano
fuente

FWIW, ¿por qué lo eliminaste ?

— Sr. Xcoder

3

Jalea , 11 bytes

÷R%1<.¬;1TṂ

Un enlace monádico que toma y devuelve enteros positivos.

Pruébalo en línea! o ver un conjunto de pruebas .

¿Cómo?

÷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: La concatenación de 1es sólo para manejar los casos en que nes uno de 1, 2o 4cuando el resultado tiene que ser n+1( ‘R÷@%1<.¬TṂtambién funcionaría).

— Jonathan Allan
fuente

3

Haskell , 33 32 bytes

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

Pruébalo en línea!

Guardado un byte gracias a w0lf

— jferard
fuente

Puedes usar en !!0lugar dehead

— Cristian Lupascu

2

Dyalog APL, 23 22 bytes

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

Pruébalo en línea!

— Uriel
fuente

2

Pyth, 5 bytes

fgy%Q

Banco de pruebas

Sin redondeo incorporado, solo verificando el primer entero positivo T, donde el doble de mod de entrada T es mayor o igual a T.

Explicación:

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
fuente

2

Código de máquina x86, 17 bytes

Este código implementa una solución básica e iterativa en forma de una función reutilizable:

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

La función sigue la convención de llamada de llamada rápida , de modo que el parámetro único ( n) se pasa en el ECXregistro. El valor de retorno ( k) es, por lo general, devuelto en el EAXregistro.

Pruébalo en línea!

— Cody Gray
fuente

2

Java 8, 42 bytes

Lambda de Integera Integer.

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

Pruébalo en línea

Expresiones de gratitud

-1 byte gracias a Kevin Cruijssen

— Jakob
fuente

44

Puede guardar un byte comenzando f=1y usando ++fel primero f, así: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

Pruébalo en línea!

Intenta cada número entero $kcomenzando en 1 hasta que encuentra un resto que es al menos la mitad de $k.

— Xcali
fuente

1

Adelante (gforth) , 45 bytes

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

Pruébalo en línea!

Explicación del Código

: 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
fuente

1

05AB1E , 9 bytes

∞.ΔIs/Dò‹

Pruébalo en línea!

Explicación

∞.Δ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
fuente

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

Puede probar rockstar en línea , pero deberá copiar y pegar el código. Le pedirá un número de entrada.

No busqué el conteo de bytes más bajo, porque Rockstar obviamente no está hecho para jugar al golf, por lo que intenté buscar letras de Rock 'n' Roll.

Explicación:

Esto se basa en la misma solución que otros (python, java):

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

Sin embargo, primero necesito definir las funciones de módulo y techo, que por el bien de la poesía se llaman pensamiento y roca.

La siguiente es una versión menos poética con diferentes nombres de variables y explicaciones donde la sintaxis no está clara. Los paréntesis denotan comentarios.

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
fuente

0

Jalea , 18 bytes

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

Pruébalo en línea!

Programa completo

— Erik el Outgolfer
fuente

3

Full program.Cuando no lo es

— totalmente humano

@totallyhuman A veces también funciona como una función.

— Erik the Outgolfer

0

Swift 3 , 51 bytes

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

Por algunas razones extremadamente extrañas, [0]no funciona en línea. Aquí está la versión compatible con el compilador en línea (que usa en su .first!lugar):

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

Test Suite (compatible en línea).

— Sr. Xcoder
fuente

0

C # (Mono) , 39 bytes

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

Pruébalo en línea!

— TheLethalCoder
fuente

0

Stax , 7 bytes

ç&╬▼⌐╔ñ

Ejecutar y depurarlo

— recursivo
fuente

A mi alrededor, ayúdame

Ejemplo.

Casos de prueba

Reglas

Python 3 , 48 38 bytes

Japt , 6 bytes

Explicación:

MATL , 13 bytes

Explicación

Python 2 , 35 bytes

JavaScript (ES6), 28 25 bytes

Pruébalo

Protón , 33 bytes

Pyth , 12 11 bytes

Protón , 33 bytes

Jalea , 11 bytes

¿Cómo?

Haskell , 33 32 bytes

Dyalog APL, 23 22 bytes

Pyth, 5 bytes

Código de máquina x86, 17 bytes

Java 8, 42 bytes

Expresiones de gratitud

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

Adelante (gforth) , 45 bytes

Explicación del Código

05AB1E , 9 bytes

Explicación

Rockstar , 681 bytes

Explicación:

Jalea , 18 bytes

Swift 3 , 51 bytes

C # (Mono) , 39 bytes

Stax , 7 bytes