34

आपको एक प्रोग्राम या फ़ंक्शन लिखना चाहिए, जिसने सकारात्मक पूर्णांक की एक सूची दी हो, एक सख्ती से बढ़ती सूची बनाने के लिए प्रत्येक तत्व को सबसे छोटे सकारात्मक पूर्णांक के साथ गुणा करता है।

उदाहरण के लिए यदि इनपुट है

5 4 12 1 3

गुणा होगा

5*1=5 4*2=8 12*1=12 1*13=13 3*5=15

और आउटपुट बढ़ती हुई सूची होगी

5 8 12 13 15

इनपुट

कम से कम 1 तत्व वाले सकारात्मक पूर्णांक की एक सूची

उत्पादन

सकारात्मक पूर्णांक की एक सूची

उदाहरण

9 => 9
1 2 => 1 2
2 1 => 2 3
7 3 => 7 9
1 1 1 1 => 1 2 3 4
5 4 12 1 3 => 5 8 12 13 15
3 3 3 8 16 => 3 6 9 16 32
6 5 4 3 2 1 => 6 10 12 15 16 17
9 4 6 6 5 78 12 88 => 9 12 18 24 25 78 84 88
8 9 41 5 12 3 5 6 => 8 9 41 45 48 51 55 60
15 8 12 47 22 15 4 66 72 15 3 4 => 15 16 24 47 66 75 76 132 144 150 153 156

यह कोड गोल्फ है इसलिए सबसे छोटा कार्यक्रम या फ़ंक्शन जीतता है।

मज़ेदार तथ्य: इनपुट के लिए उत्पादन के अंतिम तत्व N, N-1, ... ,1हो रहा है (N+1)thअनुक्रम का तत्व A007952 । यदि आपको कोई प्रमाण मिलता है, तो आप इसे अपने गोल्फ उत्तर में शामिल करने या टिप्पणी के रूप में पोस्ट करने के लिए स्वागत करते हैं।

— randomra
स्रोत

क्या किसी ने उस प्रमाण पर अभी तक जमीन बनाई है?

— कॉनर क्लार्क

20

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

:‘×µ\

~~@ डेनिस के उठने से पहले~~ पहले जेली जवाब ~~देती है और मुझे पीटती है।~~ इसे ऑनलाइन आज़माएं!

व्याख्या

:          Integer division, m//n
 ‘         Increment, (m//n+1)
  ×        Multiply, (m//n+1)*n
   µ       Turn the previous links into a new monadic chain
    \      Accumulate on the array

@ बाइट के लिए शुक्रिया -1 बाइट।

— Sp3000
स्रोत

4

:‘×µ\एक बाइट बचाता है।

— डेनिस

20

@

— डेनिस

9

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

@Patrick रॉबर्ट्स द्वारा सुझाए गए अनुसार संपादित करें , pएक असंगठित पैरामीटर हो सकता है। एक ही बाइट गिनती लेकिन एक वैश्विक चर का उपयोग करने से बचें

(a,p)=>a.map(n=>p=n*-~(p/n))

परीक्षा

f=(a,p)=>a.map(n=>p=n*-~(p/n))

console.log=x=>O.textContent+=x+'\n'

;[
[[9], [ 9]],
[[1, 2], [ 1, 2]],
[[2, 1], [ 2, 3]],
[[7, 3], [ 7, 9]],
[[1, 1, 1, 1], [ 1, 2, 3, 4]],
[[5, 4, 12, 1, 3], [ 5, 8, 12, 13, 15]],
[[3, 3, 3, 8, 16], [ 3, 6, 9, 16, 32]],
[[6, 5, 4, 3, 2, 1], [ 6, 10, 12, 15, 16, 17]],
[[9, 4, 6, 6, 5, 78, 12, 88], [ 9, 12, 18, 24, 25, 78, 84, 88]],
[[8, 9, 41, 5, 12, 3, 5, 6], [ 8, 9, 41, 45, 48, 51, 55, 60]],
[[15, 8, 12, 47, 22, 15, 4, 66, 72, 15, 3, 4], [ 15, 16, 24, 47, 66, 75, 76, 132, 144, 150, 153, 156]]
].forEach(t=>{
  var i=t[0],k=t[1],r=f(i),ok=(k+'')==(r+'')
  console.log(i + ' => ' + r + (ok?' OK':'FAIL expecting '+x))
})

<pre id=O></pre>

स्निपेट का विस्तार करें

— edc65
स्रोत

मुझे लगता है कि आप मॉडुलो का उपयोग करके कुछ बाइट्स बचा सकते हैं, जैसे मैंने अपने उत्तर में किया था ।

— aross

क्या आप p = 0 को छोड़ नहीं सकते? आपको इसे कई सूचियों पर चलाने की आवश्यकता है, लेकिन सवाल सिर्फ एक सूची के लिए है

— चार्ली व्यान

1

@CharlieWynn यदि आप किसी वैरिएबल को इनिशियलाइज़ नहीं करते हैं तो आपको अपरिभाषित वैरिएबल के लिए त्रुटि मिलती है। यदि संयोग से चर पहले से मौजूद है (जो वेब पेज के वातावरण में आसानी से हो सकता है), तो इसका कोई भी गलत मूल्य हो सकता है।

— edc65

@ edc65 पर्याप्त है, इस पृष्ठ पर पहले से ही p परिभाषित है!

— चार्ली व्यान

1

@ पैट्रिक रॉबर्ट्स फिर से सोच, मैं अभी भी ग्लोबल्स से बच सकता था f=a=>a.map(n=>a+=n-a%n,a=0):। लेकिन यह मेरा एल्गोरिथ्म नहीं है (मुझे मूर्खतापूर्ण) इसलिए मैं अपने को वैसा ही रखूंगा और जैसा कि ऊपर को बढ़ाऊंगा

— edc65

6

पायथन 2, 67 64 बाइट्स

पहले कोड-गोल्फिंग पर प्रयास करें, ताकि सुझावों की सराहना की जाए।

def m(l):
 for x in range(1,len(l)):l[x]*=l[x-1]/l[x]+1
 print l

— Taronyu
स्रोत

नमस्ते, मुझे लगता है कि आप प्रत्येक (विंडोज का उपयोग करके) 2 बाइट्स के रूप में लाइन रिटर्न की गिनती कर रहे हैं, लेकिन इस साइट पर आप प्रत्येक लाइन रिटर्न को एकल बाइट के रूप में गिनते हैं। तो आपका स्कोर वास्तव में 65 बाइट्स है। (आप अपने कोड को mothereff.in/byte-counter में कॉपी और पेस्ट कर सकते हैं यदि आप सुनिश्चित नहीं हैं।) इसके अलावा, आप एक और बाइट को बचाने के print lबजाय कर सकते हैं return l। अच्छी नौकरी!

— मैथमैडैन

धन्यवाद, मैं लाइन रिटर्न के बारे में नहीं जानता था। यह बताता है कि मुझे हमेशा अलग-अलग बाइट काउंट क्यों मिले हैं। और मैंने यह भी विचार नहीं किया, कि छपाई पर्याप्त है और उसे सूची वापस नहीं करनी है।

— तरन्नु

कोई बात नहीं! BTW, जब से आपने बताया कि "टिप्स की सराहना की जाती है", तो आपको codegolf.stackexchange.com/questions/54/… के माध्यम से ब्राउज़ करने में रुचि हो सकती है । का आनंद लें!

— मैथमैनंदन

5

PHP, 55 46 42 41 बाइट्स

आईएसओ 8859-1 एन्कोडिंग का उपयोग करता है।

for(;$a=$argv[++$i];)echo$l+=$a-$l%$a,~ß;

इस तरह से चलाएं ( -dकेवल सौंदर्यशास्त्र के लिए जोड़ा गया):

php -d error_reporting=30709 -r 'for(;$a=$argv[++$i];)echo$l+=$a-$l%$a,~ß;' 10 10 8

इस्माईल मिगुएल को 1 बाइट thx बचाया।
मंजिल के बजाय मोडुलो का उपयोग करके 8 बाइट्स को बचाया
सहेजे गए 4 बाइट्स इस्माइल मिगुएल (foreach के बदले)
~ßएक जगह का उत्पादन करने के लिए उपयोग करके एक बाइट को बचाया ।

— aross
स्रोत

मुझे लगता है कि आप के $a+0साथ बदल सकते हैं +$a। इसके अलावा, आप यह मान सकते हैं कि इनपुट में कभी भी ए नहीं होगा 0, इसलिए, आप अपनी जगह $a+0&&printबस ले सकते हैं +$a&print। वास्तव में, आप भी कर सकते हैं $a&print, क्योंकि PHP में "0" == 0 == 0.0 == false। लेकिन इसकी जरूरत नहीं है अगर आप सिर्फ एक का उपयोग करें echo, मुझे लगता है।

— इस्माइल मिगुएल

बाइनरी andकाम नहीं करेगा (तार्किक के विपरीत), और न ही इस तरह से काम करेगा। चूंकि मैं सीएलआई से इनपुट ले रहा हूं, पहला तर्क यह है -, जिसे मैं शून्य को प्रिंट करने के बजाय पकड़ना चाहता हूं। कोशिश करो php -r 'print_r($argv);' foo। अपने पहले सुझाव के साथ 1 बाइट बचाए, हालांकि, thx

— 16

1

कैसे के बारे में for(;$a=$argv[++$i];)echo$l+=$a-$l%$a,' ';? यह 42 बाइट लंबा है और पहले तत्व को छोड़ देता है।

— इस्माईल मिगुएल

अच्छा एक, THX @IsmaelMiguel

— aross

आपका स्वागत है। यदि आप वास्तव में गांठदार होना चाहते हैं, तो आप अंतरिक्ष को बदल सकते हैं a^A, लेकिन यह बहुत सारी चेतावनियां (चेतावनी आग्नेय) हैं। यह किसी भी तरह से बायटेकाउंट को नहीं बदलेगा, लेकिन निश्चित रूप से अलग दिखता है।

— इस्माईल मिगुएल

4

हास्केल (30 28 25 बाइट्स)

scanl1(\x y->y*div x y+y)

विस्तारित संस्करण

f :: Integral n => [n] -> [n]
f xs = scanl1 increaseOnDemand xs
 where
   increaseOnDemand :: Integral n => n -> n -> n
   increaseOnDemand acc next = next * (1 + acc `div` next)

व्याख्या

scanl1आपको एक सूची को मोड़ने और सभी मध्यवर्ती मूल्यों को दूसरी सूची में संचित करने में सक्षम बनाता है। यह एक विशेषज्ञता है scanl, जिसमें निम्न प्रकार हैं:

scanl  :: (acc  -> elem -> acc)  -> acc -> [elem] -> [acc]
scanl1 :: (elem -> elem -> elem) ->        [elem] -> [elem]

scanl1 f (x:xs) = scanl f x xs

इसलिए, हमें केवल एक उपयुक्त फ़ंक्शन है जो हमारी सूची के दो अंतिम तत्व ( accविस्तारित संस्करण में) लेता है और एक जिसे हम संसाधित करना चाहते हैं ( nextविस्तारित संस्करण में) और एक उपयुक्त संख्या लौटाते हैं।

हम अगले एक के माध्यम से संचायक को विभाजित करके और परिणाम को फर्श करके आसानी से इस संख्या को प्राप्त कर सकते हैं। divउसका ख्याल रखता है। बाद में, हमें बस 1यह सुनिश्चित करने के लिए जोड़ना होगा कि सूची वास्तव में बढ़ रही है (और हम साथ समाप्त नहीं होते हैं 0)।

— जीटा
स्रोत

अपने फ़ंक्शन को कोई नाम देने की आवश्यकता नहीं है। आप के ( ... )साथ भी बदल सकते हैं $ ...और मुझे लगता है कि आपने एक अंतिम नई पंक्ति को गिना है जिसे छोड़ा जा सकता है: scanl1$\x y->y*div x y+y24 बाइट्स।

— nimi

@ निम्मी: सच में? भाव गिनते हैं? कहा जा रहा है, मैं किसी भी बाइट्स को (...)बनाम के साथ नहीं बचाता $, क्योंकि $\ ऑपरेटर के रूप में पार्स किया जाता है और मुझे इसके बाद एकल स्थान की आवश्यकता होगी $।

— ज़ीटा

अनाम फ़ंक्शन को डिफ़ॉल्ट रूप से अनुमति दी जाती scanl1(...)है एक अनाम फ़ंक्शन है। $बनाम के बारे में (): आप सही हैं, मेरी गलती है।

— nimi

4

सी ++, 63 60 57 बाइट्स

void s(int*f,int*e){for(int c=*f;++f!=e;c=*f+=c/ *f**f);}

कार्यस्थल में एक सीमा दी गई है [first, last)। मूल रूप से टेम्प्लेट संस्करण के रूप में लिखा गया था, लेकिन यह लंबा था:

template<class T>void s(T f,T e){for(auto c=*f;++f!=e;c=*f+=c/ *f**f);}

विस्तारित संस्करण

template <class ForwardIterator>
void sort(ForwardIterator first, ForwardIterator last){
    auto previous = *first;

    for(++first; first != last; ++first){
        auto & current = *first;
        current += current * (current / previous);
        previous = current;
    }
}

— जीटा
स्रोत

3

सीजेएम, 13 बाइट्स

q~{\_p1$/)*}*

CJam- शैली सूची के रूप में इनपुट। आउटपुट को अलग किया गया है।

इसका परीक्षण यहां करें।

व्याख्या

q~    e# Read and evaluate input.
{     e# Fold this block over the list (i.e. "foreach except first")...
  \   e#   Swap with previous value.
  _p  e#   Duplicate and print previous value.
  1$  e#   Copy current value.
  /   e#   Integer division.
  )*  e#   Increment and multiply current value by the result.
}*

अंतिम मूल्य स्टैक पर छोड़ दिया जाता है और अंत में स्वचालित रूप से मुद्रित होता है।

— मार्टिन एंडर
स्रोत

3

मेथेमेटिका, 36 32 बाइट्स

 #2(Floor[#1/#2]+1)&~FoldList~#&

परीक्षा

#2(Floor[#1/#2]+1)&~FoldList~#& /@ {{5, 4, 12, 1, 3}, 
   {15, 8, 12, 47, 22, 15, 4, 66, 72, 15, 3, 4}}
(* {{5, 8, 12, 13, 15}, {15, 16, 24, 47, 66, 75, 76, 132, 144, 
  150, 153, 156}} *)

— जेसन बी।
स्रोत

3

पर्ल, 17 + 3 = 20 बाइट्स

$p=$_*=$==1+$p/$_

आवश्यकताएं -pऔर -lझंडे:

$ perl -ple'$p=$_*=$==1+$p/$_' <<< $'15\n8\n12\n47\n22\n15\n4\n66\n72\n15\n3\n4'
15
16
24
47
66
75
76
132
144
150
153
156

स्पष्टीकरण:

# '-p' reads each line into $_ and auto print
# '-l' chomp off newline on input and also inserts a new line when printing
# When assigning a number to `$=` it will automatic be truncated to an integer
# * Added newlines for each assignment 
$p=
  $_*=
    $==
      1+$p/$_

— andlrc
स्रोत

3

पायथन (3.5), 63 62 बाइट्स

def f(a):
 r=[0]
 for i in a:r+=i*(r[-1]//i+1),
 return r[1:]

परीक्षा

>>> print('\n'.join([str(i)+' => '+str(f(i)) for i in [[9],[1,2],[2,1],[7,3],[1,1,1,1],[5,4,12,1,3],[3,3,3,8,16],[6,5,4,3,2,1],[9,4,6,6,5,78,12,88],[8,9,41,5,12,3,5,6],[15,8,12,47,22,15,4,66,72,15,3,4]]]))
[9] => [9]
[1, 2] => [1, 2]
[2, 1] => [2, 3]
[7, 3] => [7, 9]
[1, 1, 1, 1] => [1, 2, 3, 4]
[5, 4, 12, 1, 3] => [5, 8, 12, 13, 15]
[3, 3, 3, 8, 16] => [3, 6, 9, 16, 32]
[6, 5, 4, 3, 2, 1] => [6, 10, 12, 15, 16, 17]
[9, 4, 6, 6, 5, 78, 12, 88] => [9, 12, 18, 24, 25, 78, 84, 88]
[8, 9, 41, 5, 12, 3, 5, 6] => [8, 9, 41, 45, 48, 51, 55, 60]
[15, 8, 12, 47, 22, 15, 4, 66, 72, 15, 3, 4] => [15, 16, 24, 47, 66, 75, 76, 132, 144, 150, 153, 156]

पिछला समाधान

कुछ पुनरावर्ती समाधान लेकिन बड़े

(68 bytes) f=lambda a,i=0:[i,*f(a[1:],a[0]*(i//a[0]+1))][i==0:]if a!=[]else[i]
(64 bytes) f=lambda a,i=0:a>[]and[i,*f(a[1:],a[0]*(i//a[0]+1))][i<1:]or[i]

— एर्वान
स्रोत

इसके बजाय r+=[…], आप का उपयोग कर सकते हैंr+=…,

— 22

@Cyoce मैं बदलाव करता हूं लेकिन जब मैं r=[0]डिफॉल्ट पैरामीटर में परिभाषित किया जाता है तो rवह गैर- फोकल हो जाता है

— Erwan

आप ठीक कह रहे हैं, मैं भूल गया कि पायथन ने डिफ़ॉल्ट पैरामल को कैसे संभाला। अन्य टिप को हालांकि काम करना चाहिए

— Cycece

@Cyoce हाँ यह सुझाव के लिए धन्यवाद काम करता है

— एर्वान

3

ब्रेकीलॉग , 12 बाइट्स

{≤.;?%0∧}ᵐ<₁

अजीब पर्याप्त रूप से प्रत्येक चर को एक संख्या से गुणा करने की कोशिश करना शुरू हो जाएगा 2 से गुणा करने की कोशिश कर रहा है और 0 या 1 नहीं है। हालांकि यह काम करने लगता है और दोनों अन्य Brachylog कार्यान्वयन धड़कता है

व्याख्या

{       }ᵐ          --  Map each number
 ≤.                 --      to a number greater or equal to the original
  .;?%0             --      and a multiple of the original
       ∧            --      no more constraints
          <₁        --  so that the list is strictly increasing

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

— Kroppeb
स्रोत

2

ब्रेकीलॉग , 54 बाइट्स

:_{h_.|[L:T],LhH,(T_,IH;0:$Ie*H=:T>I),Lb:I:1&:[I]rc.}.

व्याख्या

:_{...}.                § Call sub-predicate 1 with [Input, []] as input. Unify its output
                        § with the output of the main predicate


§ Sub-predicate 1

h_.                     § If the first element of the input is an empty list, unify the
                        § output with the empty list
|                       § Else
[L:T],LhH,              § Input = [L,T], first element of L is H
    (T_,IH              §     If T is the empty list, I = H
    ;                   §     Else
    0:$Ie*H=:T>I),      §     Enumerate integers between 0 and +inf, stop and unify the
                        §     enumerated integer with I only if I*H > T
Lb:I:1&                 § Call sub-predicate 1 with input [L minus its first element, I]
:[I]rc.                 § Unify the output of the sub-predicate with
                        § [I|Output of the recursive call]

— Fatalize
स्रोत

2

अजगर, ११

t.u*Yh/NYQ0

परीक्षण सूट

क्या एक संचयी घटता है, एक कमी जो सभी मध्यवर्ती मूल्यों को लौटाता है, जिसके साथ शुरू होता है 0। चूंकि इनपुट में केवल धनात्मक पूर्णांक समाहित करने की गारंटी है, यह ठीक है। प्रत्येक चरण में, हम पुराने मूल्य लेते हैं, इसे नए मूल्य से विभाजित करते हैं और जोड़ते हैं 1, फिर हम नए मूल्य से गुणा करते हैं।

— FryAmTheEggman
स्रोत

2

सी, 79 बाइट्स

p;main(x,v)char**v;{for(;*++v;printf("%d ",p=((x+p-1)/x+!(p%x))*x))x=atoi(*v);}

Ungolfed

p; /* previous value */

main(x,v) char**v;
{
    /* While arguments, print out x such that x[i] > x[i-1] */
    for(;*++v; printf("%d ", p = ((x+p-1)/x + !(p%x)) * x))
        x = atoi(*v);
}

— कोल कैमरून
स्रोत

p=p/x*x+xकाम नहीं करेगा ?

— नील

@ नील हाँ, यह काम करेगा। निश्चित रूप से इस एक को उखाड़ फेंका :)

— कोल कैमरन

2

पॉवरशेल, 26 बाइट्स

$args[0]|%{($l+=$_-$l%$_)}

एक स्पष्ट सरणी के रूप में इनपुट लेता है, उदाहरण के लिए, के > .\sort-by-multiplying.ps1 @(6,5,4,3,2,1)माध्यम से $args[0]।

हम फिर उस पर |%{...}और प्रत्येक पुनरावृत्ति जादू प्रदर्शन के लिए पाश । नहीं, सिर्फ मजाक कर रहा है, हम एक ही सापेक्ष चाल अन्य उत्तर (क्योंकि मैं इसे देखा रंगमंच की सामग्री @aross के रूप में उपयोग वहाँ पहले)।

एन्कैप्सुलेटिंग परेंस (...)यह सुनिश्चित करते हैं कि गणित ऑपरेशन का परिणाम पाइपलाइन पर रखा गया है, और इस प्रकार आउटपुट। यदि हम उन बंदों को छोड़ देते हैं, तो कुछ भी आउटपुट नहीं होगा क्योंकि $lनिष्पादन समाप्त होने के बाद चर कचरा इकट्ठा होता है।

उदाहरण

PS C:\Tools\Scripts\golfing> .\sort-by-multiplying.ps1 @(8,9,1,5,4)
8
9
10
15
16

— AdmBorkBork
स्रोत

1

जाप, 11 बाइट्स

Uå@Y*-~(X/Y

इसे ऑनलाइन टेस्ट करें!

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

          // Implicit: U = input array of integers
Uå@       // Cumulative reduce: map each previous value X and current value Y to:
-~(X/Y    //  floor(X/Y+1).
          // Implicit: output last expression

— ETHproductions
स्रोत

1

05AB1E , 11 बाइट्स

कोड:

R`[=sŽDŠ/ò*

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

स्पष्टीकरण:

R            # Reverse input
 `           # Flatten the list
  [          # While loop
   =         # Print the last item
    s        # Swap the last two items
     Ž       # If the stack is empty, break
      D      # Duplicate top of the stack
       Š     # Pop a,b,c and push c,a,b
        /    # Divide a / b
         ò   # Inclusive round up
          *  # Multiply the last two items

CP-1252 एन्कोडिंग का उपयोग करता है।

— अदनान
स्रोत

1

मिन्कोलांग 0.15 , 17 बाइट्स

nd1+?.z0c:1+*d$zN

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

व्याख्या

nd                   Take number from input and duplicate it
  1+                 Add 1
    ?.               Stop if top of stack is 0 (i.e., when n => -1 because input is empty).
      z              Push value from register
       0c            Copy first item on stack
         :           Pop b,a and push a//b
          1+         Add 1
            *        Multiply
             d$z     Duplicate and store in register
                N    Output as number

अनिवार्य रूप से, रजिस्टर आरोही सूची के नवीनतम सदस्य को रखता है और इसे इनपुट द्वारा विभाजित किया जाता है और अगले सदस्य के लिए गुणक प्राप्त करने के लिए बढ़ा दिया जाता है। मिंकोलंग के कोड फ़ील्ड की टोरॉइडल विशेषता का मतलब है कि यह क्षैतिज रूप से बिना छोरों ()या []छोरों की आवश्यकता के बिना लूप करता है।

— एलेंडिया स्ट्राटन
स्रोत

1

ब्रेकीलॉग , 21 बाइट्स

l~lCℕ₁ᵐ≤ᵛ~+?&;Cz≜×ᵐ<₁

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

ऊपरी मान के रूप में इनपुट मानों के योग का उपयोग करता हैगुणांक C के लिए । बहुत धीमी गति से, 5 या 6 से परे इनपुट सूची की लंबाई के लिए TIO पर समय (मूल्यों के योग पर भी निर्भर करता है)। लेकिन मेरे मूल संस्करण की तरह धीमा नहीं है, जिसमें 3 तत्वों तक की छोटी सूचियों की आवश्यकता होती है, छोटे मूल्यों के साथ, समय न निकालने के लिए:

21 बाइट्स

l~l.&+^₂⟦₁⊇.;?z/ᵐℕ₁ᵐ∧

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

— sundar - मोनिका को बहाल करना
स्रोत

1

सी (जीसीसी) , 37 बाइट्स

o(int*_){for(;*++_;)*_*=_[~0]/ *_+1;}

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

— जोनाथन फ्रेच
स्रोत

38 बाइट्स, पुनरावर्ती दृष्टिकोण ।

— जोनाथन फ्रेच

1

पायथन 2 , 53 बाइट्स

lambda a:reduce(lambda b,v:b+[b[-1]/v*v+v],a,[0])[1:]

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

k*x>yतात्पर्य है k>y/x; तो सबसे छोटा kहो सकता है k=floor(y/x)+1। चूंकि पायथन 2.7 में, पूर्णांक विभाजन पहले से ही लिया गया है floor, जैसा हम चाहते हैं k=y/x+1, और k*x = (y/x+1)*x = y/x*x+x।

— चास ब्राउन
स्रोत

0

Oracle SQL 11.2, 210 बाइट्स

WITH v AS(SELECT TO_NUMBER(COLUMN_VALUE)a,rownum i FROM XMLTABLE(('"'||REPLACE(:1,' ','","')||'"'))),c(p,n)AS(SELECT a,2 FROM v WHERE i=1UNION ALL SELECT a*CEIL((p+.1)/a),n+1 FROM c,v WHERE i=n)SELECT p FROM c;

संयुक्त राष्ट्र के golfed

WITH v AS                                           
(
  SELECT TO_NUMBER(COLUMN_VALUE)a, rownum i            -- Convert the input string into rows 
  FROM   XMLTABLE(('"'||REPLACE(:1,' ','","')||'"'))   -- using space as the separator between elements
)
, c(p,n) AS                        
(
  SELECT a, 2 FROM v WHERE i=1                         -- Initialize the recursive view
  UNION ALL 
  SELECT a*CEIL((p+.1)/a),n+1 FROM c,v WHERE i=n       -- Compute the value for the nth element
)
SELECT p FROM c;

— Jeto
स्रोत

0

Chez योजना (140 बाइट्स)

गोल्फ संस्करण:

(define(f l)(define(g l p m)(cond((null? l)l)((<(*(car l)m)(+ p 1))(g l p(+ m 1)))(else(cons(*(car l)m)(g(cdr l)(* m(car l))1)))))(g l 0 1))

Ungolfed संस्करण:

(define(f l)
  (define(g l p m)
    (cond
      ((null? l) l)
      ((< (* (car l) m) (+ p 1)) (g l p (+ m 1)))
      (else (cons (* (car l) m) (g (cdr l) (* m (car l)) 1)))
    )
  )
  (g l 0 1)
)

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

— जाचरी कपास
स्रोत

* m(car l)हो सकता है *(car l)m।

— जोनाथन फ्रेच

0

के (ओके) , 11 बाइट्स

{y*1+_x%y}\

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

— जे। सल्ल
स्रोत

गुणा करके क्रमबद्ध करें

इनपुट

उत्पादन

उदाहरण

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

व्याख्या

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

पायथन 2, 67 64 बाइट्स

PHP, 55 46 42 41 बाइट्स

हास्केल (30 28 25 बाइट्स)

विस्तारित संस्करण

व्याख्या

सी ++, 63 60 57 बाइट्स

विस्तारित संस्करण

सीजेएम, 13 बाइट्स

व्याख्या

मेथेमेटिका, 36 32 बाइट्स

परीक्षा

पर्ल, 17 + 3 = 20 बाइट्स

पायथन (3.5), 63 62 बाइट्स

परीक्षा

पिछला समाधान

ब्रेकीलॉग , 12 बाइट्स

व्याख्या

ब्रेकीलॉग , 54 बाइट्स

व्याख्या

अजगर, ११

सी, 79 बाइट्स

Ungolfed

पॉवरशेल, 26 बाइट्स

उदाहरण

जाप, 11 बाइट्स

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

05AB1E , 11 बाइट्स

मिन्कोलांग 0.15 , 17 बाइट्स

व्याख्या

ब्रेकीलॉग , 21 बाइट्स

21 बाइट्स

सी (जीसीसी) , 37 बाइट्स

पायथन 2 , 53 बाइट्स

Oracle SQL 11.2, 210 बाइट्स

Chez योजना (140 बाइट्स)

के (ओके) , 11 बाइट्स