Biorąc pod uwagę wejście n, twój program lub funkcja musi wypisać najmniejszą dodatnią liczbę całkowitą, ktak aby nzaokrąglona do najbliższej wielokrotności kbyła większa niż n.

Przykład.

Przy danych wejściowych 20wartość wyjściowa powinna wynosić 3:

Najbliższa wielokrotność 1to 20, która nie jest większa niż 20.
Najbliższa wielokrotność 2to 20, która nie jest większa niż 20.
Najbliższa wielokrotność 3to 21, która jest większa niż 20, więc jest generowana.

Przypadki testowe

#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

Dane wyjściowe przy każdym nieparzystym wejściu powinny wynosić 2.

Zasady

n jest dodatnią liczbą całkowitą mniejszą niż 2^32
zaokrąglanie jest wykonywane w taki sposób, że jeśli dwa wielokrotności ksą jednakowo odległe n, wybierana jest większa ( „zaokrąglanie o połowę w górę” ). W ten sposób każdy kurs dziwny ndaje wynik 2.
To jest golf golfowy , więc wygrywa najkrótszy kod w każdym języku .

code-golf number

— fireflame241
źródło

Zmodyfikowałem format twoich przypadków testowych, aby ułatwić czytanie i bardziej zwięzły. Daj mi znać, jeśli masz z tym jakieś problemy lub jeśli któryś z nowych przykładów jest wyłączony. :)

— DJMcMayhem

@Shaggy Done! Usunąłem 500 kursów i 450 wyrównanych z listy.

— fireflame241

Czy istnieje link Oeis dla tej sekwencji?

— James K

@JamesK Nie znalazłem żadnego, gdy szukałem wcześniej. Być może ktoś z kontem OEIS mógłby to zrobić?

— fireflame241

12

Python 3 , 48 38 bajtów

Edycja: -10 bajtów za pomocą rekurencji

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

Wypróbuj online!

— Halvard Hummel
źródło

9

Japt , 6 bajtów

@<rX}a

Wypróbuj online!

Wyjaśnienie:

@    <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
źródło

2

rjest wbudowany? o_o

— Erik the Outgolfer

@EriktheOutgolfer: Japt ma również wbudowane funkcje zaokrąglania w górę lub w dół :)

— Kudłaty

5

I wiedział, funkcja ta będzie się przydać kiedyś: D

— ETHproductions

@ Kudłaty, to wariat! o_o_o

— Erik the Outgolfer

@Oliver: To mnie bardziej przekonało do opanowania metod działania, teraz - moja własna wersja miała 7 bajtów:o æ@<rX

— Shaggy

7

MATL , 13 bajtów

tQ:yy/Yo*<fX<

Wypróbuj online! Lub sprawdź wszystkie dane wejściowe od 1do1000 .

Wyjaśnienie

Rozważ wejście 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
źródło

5

Python 2 , 35 bajtów

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

Wypróbuj online!

— xnor
źródło

5

JavaScript (ES6), 28 25 bajtów

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

3 bajty zapisane dzięki Arnauldowi.

Sprawdź to

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>

Rozwiń fragment kodu

Lub przetestuj wszystkie liczby od 1-1000 (Daj mu minutę na uruchomienie):

Pokaż fragment kodu

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>

Rozwiń fragment kodu

— Kudłaty
źródło

5

Proton , 33 bajty

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

Wypróbuj online!

— Pan Xcoder
źródło

Nic nie wiem o Protonie, ale wygląda na to, że możesz zaoszczędzić 3 bajty: Wypróbuj online!

— jferard

Może zbieg okoliczności, ale jest to dokładnie to samo, co rozwiązanie całkowicie ludzkie ...: p

— Erik the Outgolfer

@EriktheOutgolfer Umieściliśmy to w tym samym czasie (w rzeczywistości go ninja o kilka sekund) z 37-bajtem, ponieważ Hyper przekreślił operatorów, a kiedy je naprawił, oboje zaktualizowaliśmy.

— Pan Xcoder,

Uhh, ja ninja'd you IIRC. : P

— totalnie ludzki,

@totallyhuman You ninja'd me with 41-byter. Najpierw umieściłem 37-bajtowego, a ninja cię o to kilka sekund.

— Pan Xcoder,

4

Pyth , 12 11 bajtów

hfgy%QTTm+2

Wypróbuj tutaj.

— Pan Xcoder
źródło

4

Proton , 33 bajty

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

Wypróbuj online!

— całkowicie ludzki
źródło

FWIW, dlaczego usunąłeś ?

— Pan Xcoder,

3

Galaretka , 11 bajtów

÷R%1<.¬;1TṂ

Monadyczny link przyjmujący i zwracający dodatnie liczby całkowite.

Wypróbuj online! lub zobacz a testowy .

W jaki sposób?

÷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

Uwaga: połączeniem 1jest tylko obsługiwać przypadki, w których njest jeden 1, 2lub 4gdy wynik musi być n+1( ‘R÷@%1<.¬TṂrównież dzieło).

— Jonathan Allan
źródło

3

Haskell , 33 32 bajty

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

Wypróbuj online!

Zaoszczędzono jeden bajt dzięki w0lf

— Jferard
źródło

Możesz użyć !!0zamiasthead

— Cristian Lupascu

2

Dyalog APL, 23 22 bajtów

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

Wypróbuj online!

— Uriel
źródło

2

Pyth, 5 bajtów

fgy%Q

Zestaw testowy

Brak wbudowanych funkcji zaokrąglania, po prostu sprawdzanie pierwszej dodatniej liczby całkowitej T, gdzie podwójny mod wejściowy T jest większy lub równy T.

Wyjaśnienie:

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
źródło

2

Kod maszynowy x86, 17 bajtów

Ten kod implementuje podstawowe, iteracyjne rozwiązanie w postaci funkcji wielokrotnego użytku:

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

Funkcja działa zgodnie z konwencją wywoływania fastcall , dzięki czemu pojedynczy parametr ( n) jest przekazywany do ECXrejestru. Zwracana wartość ( k) jest zwykle zwracana do EAXrejestru.

Wypróbuj online!

— Cody Gray
źródło

2

Java 8, 42 bajty

Lambda od Integerdo Integer.

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

Wypróbuj online

Podziękowanie

-1 bajt dzięki Kevin Cruijssen

— Jakob
źródło

4

Możesz zapisać bajt, zaczynając f=1i używając ++fpierwszego f, w ten sposób:n->{for(int f=1;;)if(n%++f*2>=f)return f;}

— Kevin Cruijssen

1

Perl 5 , 24 + 1 (-p) = 25 bajtów

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

Wypróbuj online!

Próbuje każdej liczby całkowitej, $kzaczynając od 1, aż znajdzie resztę, która jest co najmniej w połowie $k.

— Xcali
źródło

1

Dalej (gforth) , 45 bajtów

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

Wypróbuj online!

Wyjaśnienie kodu

: 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
źródło

1

05AB1E , 9 bajtów

∞.ΔIs/Dò‹

Wypróbuj online!

Wyjaśnienie

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

— Czarna sowa Kai
źródło

1

Rockstar , 681 bajtów

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

Możesz wypróbować Rockstar online , ale musisz skopiować i wkleić kod. Zostaniesz poproszony o podanie numeru wejściowego.

Nie zdecydowałem się na najmniejszą liczbę bajtów, ponieważ Rockstar oczywiście nie jest przeznaczony do gry w golfa, więc zamiast tego spróbowałem napisać tekst Rock 'n' Roll.

Wyjaśnienie:

Jest to oparte na tym samym rozwiązaniu co inne (python, java):

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

Najpierw jednak muszę zdefiniować funkcje modułu i sufitu, które dla poezji nazywane są Myślą i Kamieniem.

Poniżej jest mniej poetycka wersja z różnymi nazwami zmiennych i objaśnieniami, w których składnia jest niejasna. Nawiasy oznaczają komentarze.

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
źródło

0

Galaretka , 18 bajtów

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

Wypróbuj online!

Pełny program

— Erik the Outgolfer
źródło

3

Full program.Kiedy to nie jest

— całkowicie ludzki,

@totallyhuman Czasami działa również jako funkcja.

— Erik the Outgolfer,

0

Swift 3 , 51 bajtów

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

Z kilku bardzo dziwnych powodów [0]nie działa online. Oto wersja kompatybilna z kompilatorem online (która używa .first!zamiast tego):

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

Pakiet testowy (kompatybilny online).

— Pan Xcoder
źródło

0

C # (mono) , 39 bajtów

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

Wypróbuj online!

— TheLethalCoder
źródło

0

Stax , 7 bajtów

ç&╬▼⌐╔ñ

Uruchom i debuguj

— rekurencyjny
źródło

Round Me, Help Me

Przykład.

Przypadki testowe

Zasady

Python 3 , 48 38 bajtów

Japt , 6 bajtów

Wyjaśnienie:

MATL , 13 bajtów

Wyjaśnienie

Python 2 , 35 bajtów

JavaScript (ES6), 28 25 bajtów

Sprawdź to

Proton , 33 bajty

Pyth , 12 11 bajtów

Proton , 33 bajty

Galaretka , 11 bajtów

W jaki sposób?

Haskell , 33 32 bajty

Dyalog APL, 23 22 bajtów

Pyth, 5 bajtów

Kod maszynowy x86, 17 bajtów

Java 8, 42 bajty

Podziękowanie

Perl 5 , 24 + 1 (-p) = 25 bajtów

Dalej (gforth) , 45 bajtów

Wyjaśnienie kodu

05AB1E , 9 bajtów

Wyjaśnienie

Rockstar , 681 bajtów

Wyjaśnienie:

Galaretka , 18 bajtów

Swift 3 , 51 bajtów

C # (mono) , 39 bajtów

Stax , 7 bajtów