काम की एन इकाइयों को पूरा करने में उसे कितने न्यूनतम दिन लगेंगे?

Question

एक व्यक्ति को Nकाम की इकाइयों को पूरा करना होगा; काम की प्रकृति समान है।

काम को लटका पाने के लिए, वह पहले दिन में केवल एक यूनिट का काम पूरा करता है ।

वह काम पूरा होने का जश्न मनाना चाहता है, इसलिए वह अंतिम दिन में एक यूनिट काम पूरा करने का फैसला करता है ।

वह केवल पूरा करने के लिए अनुमति दी है x, x+1या x-1एक दिन में काम की इकाइयों , जहां xपिछले दिन पर पूरा काम की इकाइयों है।

आपका कार्य एक प्रोग्राम या फ़ंक्शन बनाना है जो काम की इकाइयों को पूरा करने के लिए न्यूनतम दिनों की गणना करेगा N।

नमूना इनपुट और 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]

इनपुट STDINको फ़ंक्शन तर्क के माध्यम से या किसी भी उपयुक्त तरीके से लिया जा सकता है ।

आउटपुट मुद्रित या फ़ंक्शन के परिणाम के रूप में, या किसी भी उपयुक्त तरीके से हो सकता है।

यह कोड-गोल्फ है । सबसे छोटा समाधान जीतता है।

Comments

संकेत: यह पूर्णांक सूची सहायक हो सकती है।

— लीक नून

तो, इनपुट पॉजिटिव पूर्णांकों तक ही सीमित है, क्योंकि केनी ने दिखाया कि नकारात्मक कार्य गणना को प्राप्त करना संभव है? या क्या कार्य प्रतिदिन शून्य की सीमा तक सीमित है?

— mbomb007

आपने पायथ उत्तर को क्यों स्वीकार किया? मेरी जेली का जवाब 3 बाइट्स छोटा है ...

— डेनिस

अरे, @ डेनिस मुझे दृष्टिकोण समझने की जरूरत है और @ केनी लाऊ मुझे इसे समझने में मदद करते हैं।

— हर्षगिरी

मैं कोडगॉल्फ में नया हूं, इसलिए यहां सभी सामानों को पूरी तरह से समझने में थोड़ा समय लगेगा।

— हर्षगिरी

Answer 1

जेली , 5 बाइट्स

×4’½Ḟ

यह @ LeakyNun के दृष्टिकोण के एक बंद रूप का उपयोग करता है ।

इसे ऑनलाइन आज़माएं!

एक भाग्यशाली संयोग के कारण, Ḟके रूप में ओवरलोड हो गया है floor/ realवास्तविक / जटिल संख्या के लिए। यह जेली में केवल तीन अतिभारित परमाणुओं में से एक है।

यह काम किस प्रकार करता है

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

Comments

एक बस नहीं है ...

— लीक नून

"भाग्यशाली संयोग"

— आर्कटुरस

Answer 2

पायथ , 8 बाइट्स

tfg/*TT4

यह काम किस प्रकार करता है:

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

इसे ऑनलाइन आज़माएं!

छद्म कोड में:

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

बोनस, 22 बाइट्स

"-1 के लिए 7 लौटाना चाहिए"

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

इसे ऑनलाइन आज़माएं!

Answer 3

जावास्क्रिप्ट (ES2016), 24 बाइट्स

ESF संस्करण के लघु संस्करण @Florent और प्रतिपादक संचालक (वर्तमान में केवल फ़ायरफ़ॉक्स रात में बनाता है या ट्रांसपैरर्स) के लिए धन्यवाद।

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

जावास्क्रिप्ट (ईएस 6), 30 बाइट्स

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

इस क्रम पर आधारित है ।

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>

Comments

ES2016 (26 वर्ण) में भी छोटा:f=n=>(n-1)**.5+(n+1)**.5|0

— फ्लोरेंट

@Florent वाह धन्यवाद, आगामी घातांक ऑपरेटर के बारे में पता नहीं था।

— जॉर्ज रीथ

Answer 4

जावास्क्रिप्ट, 32 31 बाइट्स

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

अघोषित कोड:

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

यह केनी लाऊ के awser के समान एल्गोरिथ्म का उपयोग करता है लेकिन इसे कुछ बाइट्स को बचाने के लिए पुनरावर्ती बंद के रूप में लागू किया जाता है।

उपयोग:

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

REPL समाधान, 23 बाइट्स

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

प्रारंभ में लगा q=टुकड़ा चलाने के लिए:

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

Comments

यह भी मेरा नाम के समान चर नाम का उपयोग करता है :)

— Leaky Nun

बदल कर एक बाइट बचा सकते हैं >=करने के लिए <डी:

— लीकी नून

@ केनीलाऊ धन्यवाद! यह एक लंबा समय हो गया है क्योंकि मैंने गोल्फ नहीं किया है। मैं थोड़ा सा जंग खा रहा हूँ)

— फ्लोरेंट

for(t=1;;)if(t*t++/4>=q)return t-1;केवल 36 बाइट्स है :)

— लीक नून

@ केनीलाऊ मैंने 23 बाइट्स समाधान जोड़ा है :)

— फ्लोरेंट

Answer 5

पायथन, 28 बाइट्स

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

एक फ्लोट आउटपुट करता है। maxवहाँ दे रहा है 0के लिए n<=0है, जबकि नकारात्मक का वर्गमूल के लिए एक त्रुटि से बचने।

Answer 6

यूजीएल , 30 25 बाइट्स

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

इसे ऑनलाइन आज़माएं!

नकारात्मक इनपुट के लिए काम नहीं करता है।

यह काम किस प्रकार करता है:

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)

पिछला 30-बाइट समाधान:

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

ऑनलाइन दुभाषिया यहाँ ।

नकारात्मक इनपुट के लिए काम नहीं करता है।

यह काम किस प्रकार करता है:

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)

Answer 7

MATL, 11 बाइट्स

E:t*4/G<f0)

इसी तरह के एल्गोरिथ्म @KennyLau को छोड़कर, अनिश्चित काल तक लूप करने के बजाय, मैं कुछ बाइट्स को बचाने के लिए 1 ... 2n से लूप करता हूं।

इसे ऑनलाइन आज़माएं!

व्याख्या

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

Comments

@LuisMendo कि बाहर इशारा करने के लिए धन्यवाद। अपडेट किया गया!

— स्वेवर

Answer 8

Pyke, 8 बाइट्स

#X4f)ltt

यहाँ कोशिश करो!

@KennyLau के समान एल्गोरिथ्म का उपयोग करता है

Answer 9

पायथन, 43 बाइट्स

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

Comments

एक बाइट को बचाने के लिए <=> के बजाय का उपयोग करके बचा सकता है

— लीक नून

Answer 10

जावा 8, 30 24 बाइट्स

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

इसे ऑनलाइन आज़माएं।

यह जाँचने की आवश्यकता नहीं है कि क्या n0 से बड़ा है, क्योंकि नकारात्मक इनपुट के लिए जावा का Math.sqrtरिटर्न NaN, जो 0कि intहम पहले से ही सकारात्मक इनपुट के लिए उपयोग करने वाले कलाकारों के साथ बन जाता है।

Answer 11

रूबी , 30 बाइट्स

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

इसे ऑनलाइन आज़माएं!

के .to_iबजाय यहाँ एक बाइट की बचत .floor।

गैर-सकारात्मक मात्रा में काम के लिए समर्थन 6 बाइट्स ( n<1?0:) की लागत पर आता है ।