Una persona tiene que completar Nunidades de trabajo; La naturaleza del trabajo es la misma.

Para acostumbrarse al trabajo, completa solo una unidad de trabajo en el primer día .

Él desea celebrar la finalización del trabajo, por lo que decide completar una unidad de trabajo en el último día .

Solo se le permite completar x, x+1o x-1unidades de trabajo en un día , donde xestán las unidades de trabajo completadas el día anterior.

Su tarea es crear un programa o función que calcule la cantidad mínima de días que tardará en completar las Nunidades de trabajo.

Entrada de muestra y salida:

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]

La entrada puede tomarse a través STDINo como argumento de función, o de cualquier manera apropiada.

La salida puede imprimirse o como resultado de una función, o de cualquier manera apropiada.

Este es el código de golf . La solución más corta gana.

Jalea , 5 bytes

×4’½Ḟ

Esto utiliza una forma cerrada del enfoque de @ LeakyNun .

Pruébalo en línea!

Debido a una coincidencia afortunada, Ḟse sobrecarga como floor/ realpara números reales / complejos. Este es uno de los únicos tres átomos sobrecargados en Jelly.

Cómo funciona

×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

Cómo funciona:

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

Pruébalo en línea!

En pseudocódigo:

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

bonificación, 22 bytes

"debería devolver 7 por -1"

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

Pruébalo en línea!

JavaScript (ES2016), 24 bytes

Versión acortada de la variante ES6 a continuación gracias a @Florent y al Operador de exponenciación (actualmente solo en las compilaciones o transpiladores nocturnos de Firefox).

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

JavaScript (ES6), 30 bytes

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

Basado en esta secuencia .

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

Código sin golf:

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

Utiliza el mismo algoritmo que la respuesta de Kenny Lau, pero se implementa como cierre recursivo para guardar algunos bytes.

Uso:

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

Solución REPL, 23 bytes

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

Prependa q=a ejecutar el fragmento:

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

Emite un flotador. El maxestá ahí para dar 0a n<=0evitando al mismo tiempo un error de raíz cuadrada de negativo.

UGL , 30 25 bytes

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

Pruébalo en línea!

No funciona para entradas negativas.

Cómo funciona:

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)

Solución anterior de 30 bytes:

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

Intérprete en línea aquí .

No funciona para entradas negativas.

Cómo funciona:

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)

Algoritmo similar a @KennyLau, excepto que en lugar de hacer un bucle indefinido, hago un bucle de 1 ... 2n para guardar algunos bytes.

Pruébalo en línea!

Explicación

    % 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

Pruébalo aquí!

Utiliza el mismo algoritmo que @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)

Pruébalo en línea.

No es necesario verificar si nes mayor que 0, ya que Java Math.sqrtdevuelve NaNlas entradas negativas, lo que se convierte 0en la conversión intque ya usamos para las entradas positivas.

Rubí , 30 bytes.

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

Pruébalo en línea!

Guardar un byte aquí con en .to_ilugar de .floor.

El soporte para cantidades de trabajo no positivas tiene un costo de 6 bytes ( n<1?0:).