Seseorang harus menyelesaikan Nunit kerja; sifat pekerjaannya sama.

Untuk menguasai pekerjaan, ia menyelesaikan hanya satu unit pekerjaan di hari pertama .

Dia ingin merayakan penyelesaian pekerjaan, jadi dia memutuskan untuk menyelesaikan satu unit pekerjaan di hari terakhir .

Ia hanya diizinkan menyelesaikan x, x+1atau x-1unit kerja dalam satu hari , di mana xunit kerja selesai pada hari sebelumnya.

Tugas Anda adalah membuat program atau fungsi yang akan menghitung jumlah hari minimum yang akan ia ambil untuk menyelesaikan Nunit kerja.

Input Sampel dan Ouput:

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]

Masukan dapat diambil melalui STDINatau sebagai argumen fungsi, atau dengan cara apa pun yang sesuai.

Keluaran dapat dicetak atau sebagai hasil dari suatu fungsi, atau dengan cara apa pun yang sesuai.

Ini adalah kode-golf . Solusi terpendek menang.

Jelly , 5 byte

×4’½Ḟ

Ini menggunakan bentuk tertutup dari pendekatan @ LeakyNun .

Cobalah online!

Karena kebetulan yang beruntung, Ḟkelebihan beban sebagai floor/ realuntuk bilangan real / kompleks. Ini adalah salah satu dari tiga atom kelebihan beban di Jelly.

Bagaimana itu bekerja

×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 byte

tfg/*TT4

Bagaimana itu bekerja:

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

Cobalah online!

Dalam pseudo-code:

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

bonus, 22 byte

"harus mengembalikan 7 untuk -1"

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

Cobalah online!

JavaScript (ES2016), 24 byte

Versi singkat dari varian ES6 di bawah ini berkat @Florent dan Operator Eksponensial (saat ini hanya di Firefox nightly builds atau transpiler).

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

JavaScript (ES6), 30 byte

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

Berdasarkan urutan ini .

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 byte

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

Kode tidak dikunci:

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

Ia menggunakan algoritma yang sama dengan anwser Kenny Lau tetapi diimplementasikan sebagai penutupan rekursif untuk menghemat beberapa byte.

Pemakaian:

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

Solusi REPL, 23 byte

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

Berlaku q=untuk menjalankan cuplikan:

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 byte

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

Output mengapung. The maxada untuk memberikan 0untuk n<=0sementara menghindari kesalahan untuk akar kuadrat negatif.

UGL , 30 25 byte

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

Cobalah online!

Tidak berfungsi untuk input negatif.

Bagaimana itu bekerja:

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)

Solusi 30 byte sebelumnya:

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

Penerjemah online di sini .

Tidak berfungsi untuk input negatif.

Bagaimana itu bekerja:

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 byte

E:t*4/G<f0)

Algoritma mirip dengan @ KennyLau kecuali bahwa alih-alih mengulang tanpa batas, saya mengulang dari 1 ... 2n untuk menyimpan beberapa byte.

Cobalah secara Online!

Penjelasan

    % 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 byte

#X4f)ltt

Coba di sini!

Menggunakan algoritma yang sama dengan @KennyLau

Python, 43 byte

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

Java 8, 30 24 byte

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

Cobalah online.

Tidak perlu memeriksa apakah nlebih besar dari 0, karena Math.sqrtpengembalian Java NaNuntuk input negatif, yang menjadi 0dengan para pemain yang inttelah kita gunakan untuk input positif.

Ruby , 30 byte

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

Cobalah online!

Menyimpan byte di sini dengan .to_ialih - alih .floor.

Dukungan untuk jumlah pekerjaan non-positif datang dengan biaya 6 byte ( n<1?0:).