Bei einer Eingabe nmuss Ihr Programm oder Ihre Funktion die kleinste positive Ganzzahl ausgeben, ksodass nauf das nächste Vielfache von gerundet kgrößer als ist n.

Beispiel.

Bei einer Eingabe 20sollte der Ausgabewert wie folgt lauten 3:

Das nächste Vielfache von 1ist 20, das nicht größer als ist 20.
Das nächste Vielfache von 2ist 20, das nicht größer als ist 20.
Der nächste Vielfache von 3heißt 21, das ist als größer 20, so dass es ausgegeben wird.

Testfälle

#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

Die Ausgabe bei jeder ungeraden Eingabe sollte 2 sein.

Regeln

n ist eine positive ganze Zahl kleiner als 2^32
Das Runden wird so durchgeführt, dass, wenn zwei Vielfache von kgleich weit entfernt sind n, das größere gewählt wird ( "Runden halbiert" ). Auf diese Weise nergibt jede ungerade eine Ausgabe von 2.
Das ist Code-Golf , also gewinnt der kürzeste Code in jeder Sprache .

code-golf number

— fireflame241
quelle

Ich habe das Format Ihrer Testfälle bearbeitet, um das Lesen zu vereinfachen und präziser zu gestalten. Lassen Sie mich wissen, wenn Sie Probleme damit haben oder wenn eines der neuen Beispiele nicht funktioniert. :)

— DJMcMayhem

@ Shaggy Fertig! Ich habe 500 Gewinnchancen und 450 Gewinnchancen von der Liste gestrichen.

— fireflame241

Gibt es einen oeis Link für diese Sequenz?

— James K

@ JamesK Ich habe keinen gefunden, als ich vorher gesucht habe. Möglicherweise könnte jemand mit einem OEIS-Account einen erstellen?

— Fireflame241

12

Python 3 , 48 38 Bytes

Bearbeiten: -10 Bytes mithilfe von Rekursion

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

Probieren Sie es online!

— Halvard Hummel
quelle

9

Japt , 6 Bytes

@<rX}a

Probieren Sie es online!

Erläuterung:

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

2

rist ein Builtin? o_o

— Erik der Outgolfer

@EriktheOutgolfer: Japt hat auch integrierte Funktionen zum Auf- oder Abrunden :)

— Shaggy

5

Ich wusste, dass dieses Feature eines Tages nützlich sein würde: D

— ETHproductions 16.08.17

@ Shaggy das ist verrückt! o_o_o

— Erik der Outgolfer

@Oliver: Das hat mich jetzt mehr überzeugt, mich mit Funktionsmethoden auseinanderzusetzen - meine eigene Version davon war 7 Bytes:o æ@<rX

— Shaggy

7

MATL , 13 Bytes

tQ:yy/Yo*<fX<

Probieren Sie es online! Oder überprüfen Sie alle Eingaben von 1bis1000 .

Erläuterung

Betrachten Sie die Eingabe 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
quelle

5

Python 2 , 35 Bytes

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

Probieren Sie es online!

— xnor
quelle

5

JavaScript (ES6), 28 bis 25 Byte

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

3 Bytes gespart dank Arnauld.

Probier es aus

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>

Erweitern Sie das Snippet

Oder testen Sie alle Zahlen von 1-1000 (geben Sie ihm eine Minute, um zu rennen):

Code-Snippet anzeigen

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>

Erweitern Sie das Snippet

— Zottelig
quelle

5

Proton , 33 Bytes

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

Probieren Sie es online!

— Mr. Xcoder
quelle

Ich weiß nichts über Proton, aber es scheint, dass Sie 3 Bytes sparen können: Probieren Sie es online!

— jferard

Vielleicht ein Zufall, aber das ist genau das Gleiche wie die Lösung von totalhuman ...: p

— Erik the Outgolfer

@EriktheOutgolfer Wir haben es zur gleichen Zeit gepostet (tatsächlich habe ich ihn um ein paar Sekunden verwöhnt) mit 37-Byte, weil Hyper die Operatoren blockiert hat, und als er sie repariert hat, haben wir beide aktualisiert.

— Mr. Xcoder

Ähh, ich hab dich ninja IIRC. : P

— totalhuman

@totallyhuman Du hast mich mit einem 41-Byte ninja'd. Ich habe den 37-Byter zuerst gepostet und dich ein paar Sekunden damit fertig gemacht.

— Mr. Xcoder

4

Pyth , 12 11 Bytes

hfgy%QTTm+2

Probieren Sie es hier aus.

— Mr. Xcoder
quelle

4

Proton , 33 Bytes

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

Probieren Sie es online!

— total menschlich
quelle

FWIW, warum hast du entfernt ?

— Mr. Xcoder

3

Jelly , 11 Bytes

÷R%1<.¬;1TṂ

Eine monadische Verknüpfung, die positive ganze Zahlen aufnimmt und zurückgibt.

Probieren Sie es online! oder sehen Sie sich eine Testsuite an .

Wie?

÷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

Hinweis: Die Verkettung 1ist nur die Fälle zu behandeln , in denen neiner der ist 1, 2oder 4wenn das Ergebnis muss sein n+1( ‘R÷@%1<.¬TṂwürde auch funktionieren).

— Jonathan Allan
quelle

3

Haskell , 33 32 Bytes

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

Probieren Sie es online!

Dank w0lf ein Byte gespeichert

— jferard
quelle

Sie können !!0anstelle vonhead

— Cristian Lupascu

2

Dyalog APL, 23 22 Bytes

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

Probieren Sie es online!

— Uriel
quelle

2

Pyth, 5 Bytes

fgy%Q

Testsuite

Keine Rundung eingebaut, nur nach der ersten positiven Ganzzahl T suchen, wobei das Doppelte der Eingangsmodifikation T größer oder gleich T ist.

Erläuterung:

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
quelle

2

x86-Maschinencode, 17 Byte

Dieser Code implementiert eine grundlegende, iterative Lösung in Form einer wiederverwendbaren Funktion:

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

Die Funktion folgt der Fastcall-Aufrufkonvention , sodass der einzelne Parameter ( n) im ECXRegister übergeben wird. Der Rückgabewert ( k) wird wie gewohnt im zurückgegebenEAX Register zurückgegeben.

Probieren Sie es online!

— Cody Gray
quelle

2

Java 8, 42 Bytes

Lambda von Integerbis Integer.

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

Probieren Sie es online

Danksagung

-1 Byte dank Kevin Cruijssen

— Jakob
quelle

4

Sie können ein Byte speichern, indem Sie das erste wie f=1++ffn->{for(int f=1;;)if(n%++f*2>=f)return f;}

— folgt

1

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

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

Probieren Sie es online!

Versucht jede Ganzzahl $kab 1, bis ein Rest von mindestens der Hälfte gefunden wird $k.

— Xcali
quelle

1

Viertens (gviertens) , 45 Bytes

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

Probieren Sie es online!

Code-Erklärung

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

1

05AB1E , 9 Bytes

∞.ΔIs/Dò‹

Probieren Sie es online!

Erläuterung

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

— Schwarze Eule Kai
quelle

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

Sie können Rockstar online ausprobieren , aber Sie müssen den Code kopieren und einfügen. Sie werden aufgefordert, eine Eingabenummer einzugeben.

Ich habe nicht die niedrigste Byteanzahl gewählt, da Rockstar offensichtlich nicht zum Golfen geeignet ist. Stattdessen habe ich versucht, Rock'n'Roll-Texte zu wählen.

Erläuterung:

Dies basiert auf der gleichen Lösung wie andere (Python, Java):

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

Zuerst muss ich jedoch die Modul- und Deckenfunktionen definieren, die der Poesie halber Gedanken und Rock genannt werden.

Das Folgende ist eine weniger poetische Version mit unterschiedlichen Variablennamen und Erklärungen, bei denen die Syntax unklar ist. Klammern kennzeichnen Kommentare.

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
quelle

0

Jelly , 18 Bytes

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

Probieren Sie es online!

Volles Programm.

— Erik der Outgolfer
quelle

3

Full program.Wann ist es nicht

— Totalhuman

@totallyhuman Manchmal funktioniert es auch als Funktion.

— Erik der Outgolfer

0

Schnelle 3 , 51 Bytes

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

Funktioniert aus extrem bizarren Gründen [0]nicht online. Hier ist die Online-Compiler-kompatible Version (die .first!stattdessen verwendet):

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

Test Suite (online-kompatibel).

— Mr. Xcoder
quelle

0

C # (Mono) , 39 Bytes

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

Probieren Sie es online!

— TheLethalCoder
quelle

0

Stax , 7 Bytes

ç&╬▼⌐╔ñ

Führen Sie es aus und debuggen Sie es

— rekursiv
quelle

Um mich herum, hilf mir

Beispiel.

Testfälle

Regeln

Python 3 , 48 38 Bytes

Japt , 6 Bytes

Erläuterung:

MATL , 13 Bytes

Erläuterung

Python 2 , 35 Bytes

JavaScript (ES6), 28 bis 25 Byte

Probier es aus

Proton , 33 Bytes

Pyth , 12 11 Bytes

Proton , 33 Bytes

Jelly , 11 Bytes

Wie?

Haskell , 33 32 Bytes

Dyalog APL, 23 22 Bytes

Pyth, 5 Bytes

x86-Maschinencode, 17 Byte

Java 8, 42 Bytes

Danksagung

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

Viertens (gviertens) , 45 Bytes

Code-Erklärung

05AB1E , 9 Bytes

Erläuterung

Rockstar , 681 Bytes

Erläuterung:

Jelly , 18 Bytes

Schnelle 3 , 51 Bytes

C # (Mono) , 39 Bytes

Stax , 7 Bytes