Étant donné une entrée n, votre programme ou fonction doit sortir le plus petit entier positif ktel que narrondi au multiple le plus proche de ksoit supérieur à n.

Exemple.

Étant donné une entrée 20, la valeur de sortie doit être 3:

Le plus proche multiple de 1est 20, qui n'est pas supérieur à 20.
Le plus proche multiple de 2est 20, qui n'est pas supérieur à 20.
Le multiple le plus proche de 3est 21, qui est supérieur à 20, il est donc produit.

Cas de test

#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 sortie donnée n'importe quelle entrée impaire doit être 2.

Règles

n est un entier positif inférieur à 2^32
l'arrondi est effectué de telle sorte que si deux multiples de ksont également éloignés de n, le plus grand est choisi ( "arrondir les moitiés vers le haut" ). De cette façon, chaque impair ndonne une sortie de 2.
C'est le code-golf , donc le code le plus court dans chaque langue l' emporte.

code-golf number

— fireflame241
source

J'ai modifié le format de vos cas de test pour le rendre plus facile à lire et plus concis. Faites-moi savoir si vous avez des problèmes avec cela, ou si l'un des nouveaux exemples est désactivé. :)

— DJMcMayhem

@Shaggy Done! J'ai supprimé 500 cotes et 450 égalités de la liste.

— fireflame241

Existe-t-il un lien oeis pour cette séquence?

— James K

@JamesK Je n'en ai pas trouvé lors de ma recherche précédente. Peut-être que quelqu'un avec un compte OEIS pourrait en créer un?

— fireflame241

12

Python 3 , 48 38 octets

Modifier: -10 octets en utilisant la récursivité

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

Essayez-le en ligne!

— Halvard Hummel
source

9

Japt , 6 octets

@<rX}a

Essayez-le en ligne!

Explication:

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

2

rest un intégré? o_o

— Erik the Outgolfer

@EriktheOutgolfer: Japt a également des fonctions intégrées pour arrondir vers le haut ou vers le bas :)

— Shaggy

5

Je savais que cette fonctionnalité serait utile un jour: D

— ETHproductions

@Shaggy c'est fou! o_o_o

— Erik the Outgolfer

@Oliver: Cela m'a plus convaincu de me familiariser avec les méthodes de fonction, maintenant - ma propre version en était de 7 octets:o æ@<rX

— Shaggy

7

MATL , 13 octets

tQ:yy/Yo*<fX<

Essayez-le en ligne! Ou vérifiez toutes les entrées de 1à1000 .

Explication

Tenez compte des commentaires 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
source

5

Python 2 , 35 octets

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

Essayez-le en ligne!

— xnor
source

5

JavaScript (ES6), 28 25 octets

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

3 octets économisés grâce à Arnauld.

Essaye-le

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>

Développer l'extrait

Ou testez tous les nombres de 1-1000 (Donnez-lui une minute pour exécuter):

Afficher l'extrait de code

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>

Expand snippet

— Hirsute
source

5

Proton , 33 octets

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

Essayez-le en ligne!

— M. Xcoder
source

Je ne sais rien de Proton, mais il semble que vous puissiez économiser 3 octets: essayez-le en ligne!

— jferard

Peut-être une coïncidence, mais c'est exactement la même chose que la solution totalement humaine ...: p

— Erik the Outgolfer

@EriktheOutgolfer Nous l'avons posté en même temps (en fait, je l'ai ninja de quelques secondes) avec 37 octets, car Hyper a bouché les opérateurs, et quand il les a corrigés, nous avons tous les deux mis à jour.

— M. Xcoder du

Euh, je vous ai ninja IIRC. : P

— totalement humain

@totallyhuman You ninja'd me with a 41-byter. J'ai posté le 37 octets en premier et vous avez ninja avec celui-ci de quelques secondes.

— M. Xcoder

4

Pyth , 12 11 octets

hfgy%QTTm+2

Essayez-le ici.

— M. Xcoder
source

4

Proton , 33 octets

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

Essayez-le en ligne!

— totalement humain
source

FWIW, pourquoi avez-vous supprimé ?

— M. Xcoder

3

Gelée , 11 octets

÷R%1<.¬;1TṂ

Un lien monadique prenant et retournant des entiers positifs.

Essayez-le en ligne! ou consultez une suite de tests .

Comment?

÷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

Note: La concaténation 1est juste pour traiter les cas où nest l' un des 1, 2ou 4lorsque le résultat doit être n+1( ‘R÷@%1<.¬TṂtravaillerions aussi).

— Jonathan Allan
source

3

Haskell , 33 32 octets

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

Essayez-le en ligne!

Un octet enregistré grâce à w0lf

— jferard
source

Vous pouvez utiliser à la !!0place dehead

— Cristian Lupascu

2

Dyalog APL, 23 22 octets

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

Essayez-le en ligne!

— Uriel
source

2

Pyth, 5 octets

fgy%Q

Suite de tests

Aucun arrondi intégré, il suffit de vérifier le premier entier positif T, où le double du mod d'entrée T est supérieur ou égal à T.

Explication:

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
source

2

Code machine x86, 17 octets

Ce code implémente une solution basique et itérative sous la forme d'une fonction réutilisable:

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 fonction suit la convention d'appel fastcall , de sorte que le paramètre unique ( n) est passé dans le ECXregistre. La valeur de retour ( k) est, comme d'habitude, retournée dans le EAXregistre.

Essayez-le en ligne!

— Cody Grey
source

2

Java 8, 42 octets

Lambda de Integerà Integer.

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

Essayez-le en ligne

Remerciements

-1 octet grâce à Kevin Cruijssen

— Jakob
source

4

You can save a byte by starting f=1 and using ++f on the first f, like this: 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

Try it online!

Tries each integer $k starting at 1 until it finds a remainder that is at least half of $k.

— Xcali
source

1

Forth (gforth), 45 bytes

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

Try it online!

Code Explanation

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

1

05AB1E , 9 octets

∞.ΔIs/Dò‹

Try it online!

Explication

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

— Chouette noire Kai
source

1

Rockstar , 681 octets

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

Vous pouvez essayer rockstar en ligne , mais vous devrez copier et coller le code sur. Il vous demandera un numéro d'entrée.

Je n'ai pas opté pour le nombre d'octets le plus bas, car Rockstar n'est évidemment pas fait pour le golf, alors j'ai plutôt essayé de choisir les paroles de Rock 'n' Roll.

Explication:

Ceci est basé sur la même solution que les autres (python, java):

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

Cependant, je dois d'abord définir les fonctions de module et de plafond, qui pour la poésie s'appellent Thought and Rock.

Ce qui suit est une version moins poétique avec différents noms de variables et des explications où la syntaxe n'est pas claire. Les parenthèses indiquent les commentaires.

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
source

0

Gelée , 18 octets

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

Essayez-le en ligne!

Programme complet.

— Erik le Outgolfer
source

3

Full program.Quand n'est-ce pas?

— totalement humain

@totallyhuman Parfois, cela fonctionne aussi comme une fonction.

— Erik the Outgolfer

0

Swift 3 , 51 octets

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

For some extremely bizarre reasons, [0] doesn't work online. Here is the online compiler-compatible version (that uses .first! instead):

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

Test Suite (online-compatible).

— Mr. Xcoder
source

0

C# (Mono), 39 bytes

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

Try it online!

— TheLethalCoder
source

0

Stax, 7 bytes

ç&╬▼⌐╔ñ

Run and debug it

— recursive
source

Autour de moi, aidez-moi

Exemple.

Cas de test

Règles

Python 3 , 48 38 octets

Japt , 6 octets

Explication:

MATL , 13 octets

Explication

Python 2 , 35 octets

JavaScript (ES6), 28 25 octets

Essaye-le

Proton , 33 octets

Pyth , 12 11 octets

Proton , 33 octets

Gelée , 11 octets

Comment?

Haskell , 33 32 octets

Dyalog APL, 23 22 octets

Pyth, 5 octets

Code machine x86, 17 octets

Java 8, 42 octets

Remerciements

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

Forth (gforth), 45 bytes

Code Explanation

05AB1E , 9 octets

Explication

Rockstar , 681 octets

Explication:

Gelée , 18 octets

Swift 3 , 51 octets

C# (Mono), 39 bytes

Stax, 7 bytes