Eine Person muss NArbeitseinheiten absolvieren; Die Art der Arbeit ist die gleiche.

Um den Dreh raus zu bekommen, erledigt er am ersten Tag nur eine Arbeitseinheit .

Er möchte den Abschluss der Arbeiten feiern und beschließt, am letzten Tag eine Arbeitseinheit fertigzustellen .

Er ist nur zu vervollständigen erlaubt x, x+1oder x-1an einem Tag Arbeitseinheiten , wobei xdie Einheiten der Arbeit am Vortag abgeschlossen sind.

Ihre Aufgabe ist es, ein Programm oder eine Funktion zu erstellen, die die Mindestanzahl von Tagen berechnet, die er für die Fertigstellung Nvon Arbeitseinheiten benötigt.

Beispiel Eingabe und Ausgabe:

input -> output (corresponding work_per_day table)
-1    -> 0      []
0     -> 0      []
2     -> 2      [1,1]
3     -> 3      [1,1,1]
5     -> 4      [1,1,2,1] or [1,2,1,1]
9     -> 5      [1,2,3,2,1]
13    -> 7      [1,2,2,2,3,2,1]

Die Eingabe kann durch STDINoder als Funktionsargument oder auf geeignete Weise erfolgen.

Die Ausgabe kann gedruckt oder als Ergebnis einer Funktion oder auf geeignete Weise erfolgen.

Das ist Code-Golf . Die kürzeste Lösung gewinnt.

Gelee , 5 Bytes

×4’½Ḟ

Dies verwendet eine geschlossene Form des Ansatzes von @ LeakyNun .

Probieren Sie es online aus!

Aufgrund eines glücklichen Zufalls Ḟwird als floor/ realfür reelle / komplexe Zahlen überladen . Dies ist eines der wenigen überladenen Atome in Jelly.

Wie es funktioniert

×4’½Ḟ  Main link. Argument: n (integer)

×4     Compute 4n.
  ’    Decrement; yield 4n - 1.
   ½   Square root; yield sqrt(4n - 1).
       If n < 2, this produces an imaginary number.
    Ḟ  If sqrt(4n - 1) is real, round it down to the nearest integer.
       If sqrt(4n - 1) is complex, compute its real part (0).

Pyth , 8 Bytes

tfg/*TT4

Wie es funktioniert:

tfg/*TT4   Q is implicitly assigned to the input.
 f         test for T=1,2,3,... returning the first successful case
   /*TT4   whether T * T / 4
  g     Q  is greater than or equal to the input (second argument implied)
t          and subtract 1 from the first successful case

Probieren Sie es online aus!

Im Pseudocode:

for(int T=1;;T++)
    if(T*T/4 >= Q)
        return T-1;

Bonus, 22 Bytes

"sollte 7 für -1 zurückgeben"

+tfg/*TT4?>Q0Q-2Q1*4g1

Probieren Sie es online aus!

JavaScript (ES2016), 24 Byte

Verkürzte Version der folgenden ES6-Variante dank @Florent und dem Exponentiation Operator (derzeit nur in Firefox Nightly Builds oder Transpilern).

n=>(n-1)**.5+(n+1)**.5|0

JavaScript (ES6), 30 Byte

n=>(s=Math.sqrt)(n-1)+s(n+1)|0

Basierend auf dieser Sequenz .

f=n=>(s=Math.sqrt)(n-1)+s(n+1)|0

units.oninput = () => output.value = f(+units.value||0);

<label>Units: <input id="units" type="number" value="0" /></label>
<label>Days: <input id="output" type="number" value="0" disabled /></label>

JavaScript, 32 31 Bytes

f=(q,t=1)=>q>t*t/4?f(q,t+1):t-1

Ungolfed Code:

function f(q, t = 1) {
  return q > t * t / 4
    ? f(q, t + 1)
    : t - 1
}

Es verwendet den gleichen Algorithmus wie Kenny Laus Antwort, wird jedoch als rekursiver Abschluss implementiert, um einige Bytes zu sparen.

Verwendungszweck:

f(-1)  // 0
f(0)   // 0
f(2)   // 2
f(3)   // 3
f(5)   // 4
f(9)   // 5
f(13)  // 7

REPL-Lösung, 23 Bytes

for(t=1;t*t++/4<q;);t-2

Bereiten Sie vor q=, um das Snippet auszuführen:

q=-1;for(t=1;t*t++/4<q;);t-2 // 0
q=9;for(t=1;t*t++/4<q;);t-2  // 5
q=13;for(t=1;t*t++/4<q;);t-2 // 7

Python, 28 Bytes

lambda n:max(4*n-1,0)**.5//1

Gibt einen Float aus. Das maxist es zu geben , 0für die n<=0während eines Fehlers für Quadratwurzel von negativen zu vermeiden.

UGL , 30 25 Bytes

i$+$+dc^l_u^^$*%/%_c=:_do

Probieren Sie es online aus!

Funktioniert nicht für negative Eingänge.

Wie es funktioniert:

i$+$+dc^l_u^^$*%/%_c=:_do
i$+$+d                     #n = 4*input-1
      c                    #i=0
       ^l_     %/%_c=:_    #while      > n:
           ^^$*            #      i**2
          u                #                i = i+1
                       do  #print(i)

Vorherige 30-Byte-Lösung:

iuc^l_u^^$*cuuuu/%_u%/%_c=:_do

Online-Dolmetscher hier .

Funktioniert nicht für negative Eingänge.

Wie es funktioniert:

iuc^l_u^^$*cuuuu/%_u%/%_c=:_do
iuc                             #push input; inc; i=0;
   ^l_u             %/%_c=:_    #while        > input:
       ^^$*cuuuu/%_             #      i**2/4
                   u            #                      i = i+1
                            do  #print(i)

MATL, 11 Bytes

E:t*4/G<f0)

Ein ähnlicher Algorithmus wie bei @KennyLau, außer dass ich nicht auf unbestimmte Zeit eine Schleife durchführe, sondern eine Schleife von 1 ... 2n durchführe, um einige Bytes zu sparen.

Probieren Sie es online aus!

Erläuterung

    % Implicitly grab the input
E   % Double the input
:   % Create an array from 1...2n
t*  % Square each element
4/  % Divide each element by 4
G<  % Test if each element is less than G
f   % Get the indices of the TRUE elements in the array from the previous operation
0)  % Get the last index (the first index where T*T/4 >= n)
    % Implicitly display the result.

Pyke, 8 Bytes

#X4f)ltt

Probieren Sie es hier aus!

Verwendet den gleichen Algorithmus wie @KennyLau

Python, 43 Bytes

f=lambda n,i=1:i-1if i*i>=n*4 else f(n,i+1)

Java 8, 30 24 Bytes

n->(int)Math.sqrt(n*4-1)

Probieren Sie es online aus.

Es muss nicht überprüft werden, ob nes größer als 0 ist, da Java für negative Eingaben Math.sqrtzurückgibt NaN, was 0mit der Umwandlung zu wird, die intwir bereits für die positiven Eingaben verwenden.

Ruby , 30 Bytes

->n{n<1?0:((4*n-1)**0.5).to_i}

Probieren Sie es online aus!

Speichern eines Bytes hier mit .to_istatt .floor.

Die Unterstützung für nicht positive Arbeitsmengen kostet 6 Byte ( n<1?0:).