¿Cuántos días mínimos tardará en completar N unidades de trabajo?

10

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 . La solución más corta gana.

HarshGiri
fuente
1
Sugerencia: esta lista entera podría ser útil.
Leaky Nun
1
Entonces, ¿la entrada está restringida a enteros positivos, ya que Kenny demostró que es posible lograr un conteo de trabajo negativo? ¿O el trabajo por día está restringido a un mínimo de cero?
mbomb007
1
¿Por qué aceptaste la respuesta de Pyth? Mi respuesta de Jelly es 3 bytes más corta ...
Dennis
Hola, @ Dennis, necesito entender el enfoque y @Kenny Lau me ayuda a entenderlo.
HarshGiri
Soy nuevo en CodeGolf, por lo que me tomará un tiempo entender todas las cosas aquí completamente.
HarshGiri

Respuestas:

3

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).
Dennis
fuente
1
Uno no simplemente ...
Leaky Nun
1
"Afortunada coincidencia"
Arcturus
4

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!

Monja permeable
fuente
3

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>

George Reith
fuente
Incluso más corto en ES2016 (26 caracteres):f=n=>(n-1)**.5+(n+1)**.5|0
Florent
@Florent Wow gracias, no estaba al tanto del próximo operador de exponenciación.
George Reith
2

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
Florent
fuente
Incluso usa los mismos nombres de variables que los míos :)
Leaky Nun
Puede guardar un byte >=al <: D
Leaky Nun
@KennyLau ¡Gracias! Ha pasado mucho tiempo desde que no he jugado al golf. Estoy un poco oxidado x)
Florent
for(t=1;;)if(t*t++/4>=q)return t-1;es solo 36 bytes :)
Leaky Nun
1
@KennyLau He agregado una solución de 23 bytes :)
Florent
2

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.

xnor
fuente
2

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)
Monja permeable
fuente
1

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.
Suever
fuente
@LuisMendo Gracias por señalar eso. ¡Actualizado!
Suever
0

Python, 43 bytes

f=lambda n,i=1:i-1if i*i>=n*4 else f(n,i+1)
orlp
fuente
1
puede guardar un byte usando <en lugar de> =
Leaky Nun
0

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.

Kevin Cruijssen
fuente
0

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:).

benj2240
fuente