शांत शीर्षकहीन अनुक्रम बात

19

चलिए f n n (k) को प्राकृतिक संख्याओं के पहले k पदों के योग के रूप में परिभाषित करते हैं [1, k ) जहां प्रत्येक संख्या को n बार दोहराया जाता है ।

k       | 0    1    2    3    4    5    6    7    8    9
--------+-------------------------------------------------
f_1(k)  | 0    1    3    6    10   15   21   28   36   45
deltas  |   +1   +2   +3   +4   +5   +6   +7   +8   +9
--------+-------------------------------------------------
f_2(k)  | 0    1    2    4    6    9    12   16   20   25
deltas  |   +1   +1   +2   +2   +3   +3   +4   +4   +5
--------+-------------------------------------------------
f_3(k)  | 0    1    2    3    5    7    9    12   15   18
deltas  |   +1   +1   +1   +2   +2   +2   +3   +3   +3

एक वर्ग सरणी के रूप में इसके विरोधी विकर्ण OEIS अनुक्रम A134546 के समान हैं ।

चुनौती

एक प्रोग्राम / फ़ंक्शन लिखें जो दो गैर-नकारात्मक पूर्णांक n और k लेता है और f n (k) आउटपुट करता है ।

विशेष विवरण

  • मानक I / O नियम लागू होते हैं ।
  • मानक खामियों को मना किया जाता है ।
  • आपका समाधान या तो 0-अनुक्रमित हो सकता है या n और / या k के लिए 1-अनुक्रमित हो सकता है, लेकिन कृपया निर्दिष्ट करें कि कौन सा।
  • यह चुनौती सभी भाषाओं में सबसे छोटा दृष्टिकोण खोजने के बारे में नहीं है, बल्कि, यह प्रत्येक भाषा में सबसे छोटा दृष्टिकोण खोजने के बारे में है ।
  • आपका कोड बाइट्स में स्कोर किया जाएगा , आमतौर पर एन्कोडिंग UTF-8 में, जब तक कि अन्यथा निर्दिष्ट न हो।
  • में निर्मित कार्यों कि इस अनुक्रम की गणना कर रहे हैं की अनुमति दी है, लेकिन एक समाधान है कि पर निर्भर नहीं करता सहित एक अंतर्निहित प्रोत्साहित किया जाता है।
  • स्पष्टीकरण, यहां तक ​​कि "व्यावहारिक" भाषाओं के लिए भी प्रोत्साहित किया जाता है ।

परीक्षण के मामलों

इन परीक्षण मामलों में, n 1-अनुक्रमित है और k 0-अनुक्रमित है।

n   k      fn(k)

1   2      3
2   11     36
11  14     17
14  21     28
21  24     27
24  31     38
31  0      0

कुछ बेहतर प्रारूपों में:

1 2
2 11
11 14
14 21
21 24
24 31
31 0

1, 2
2, 11
11, 14
14, 21
21, 24
24, 31
31, 0

संदर्भ कार्यान्वयन

यह हास्केल में लिखा गया है ।

f n k = sum $ take k $ replicate n =<< [1..]

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

इस चुनौती को सैंडबॉक्स किया गया था।

code-golf  math  number  sequence 
— totallyhuman
स्रोत
क्या आपको लगता है कि मेरा संपादन स्वरूपण में सुधार करता है, या यह सिर्फ मेरे ब्राउज़र पर है?
— user202729 10
@ user202729 हेह ... यह मेरे ब्राउज़र पर बंद दिखता है, लेकिन मुझे संदेह है कि मेरा स्वरूपण अधिकांश ब्राउज़रों पर अच्छा लग रहा था ... मैं इसे ऐसे ही रखूंगा, इसका कोई मतलब नहीं है। बस अजीब लग रहा है। : पी
— बिलकुल अमानवीय
हम मामले को संभालने की जरूरत है f_n(0) = 0के लिए k0 से इंडैक्स?
— Cinaski
9
" कूल अनटाइटल्ड सीक्वेंस बात " लोल, मैं केवल एक कठिन समय नहीं है, जो मेरे द्वारा देखे गए दृश्यों के नाम के साथ आ रहा है;)
— केविन क्रूज़सेन
3
@ फैबियन नहीं, आप केवल पहले kशब्दों को बार-बार आने वाले प्राकृतिक संख्याओं की सूची से जोड़ते हैं, पहले शब्दों को नहीं n*k।
— मार्टिन एंडर

जवाबों:

12

रूबी , 32 28 23 बाइट्स

->n,k{k.step(0,-n).sum}

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

व्याख्या

आइए एक त्रिकोण के क्षेत्र के रूप में योग की कल्पना करें, उदाहरण के लिए n = 3 और k = 10:

*
*
*
**
**
**
***
***
***
****

फिर हम पंक्ति के बजाय कॉलम द्वारा योग करते हैं: पहला कॉलम है k, फिर k-n, k-2nऔर इसी तरह।

— जीबी
स्रोत
8

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

lambda n,k:(k+k%n)*(k/n+1)/2

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

धन्यवाद मार्टिन एंडर, नील और श्री Xcoder मदद करने के लिए।

— जीबी
स्रोत
1
आप वास्तव में k/nवैसे भी जरूरत नहीं है - k-(k/n)*nबस है k%n। मेरा बैच जवाब देखें।
— नील
— श्री एक्सकोडर
धन्यवाद। मुझे नहीं लगा कि यह इतना आसान हो सकता है।
— जीबी
8

भूसी , 4 बाइट्स

Σ↑ṘN

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

व्याख्या

यह चुनौती में संदर्भ कार्यान्वयन का सीधा अनुवाद होने के कारण समाप्त होता है:

   N  Start from the infinite sequence of all natural numbers.
  Ṙ   Replicate each element n times.
 ↑    Take the first k values.
Σ     Sum them.
— मार्टिन एंडर
स्रोत
5

गणितज्ञ, 40 बाइट्स

Tr@Sort[Join@@Range@#2~Table~#][[;;#2]]&

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

Tr[Range@(s=⌊#2/#⌋)]#+#2~Mod~#(s+1)&

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

गणितज्ञ, 18 बाइट्स

मार्टिन एंडर द्वारा

Tr@Range[#2,0,-#]&

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

n~Sum~{n,#2,0,-#}&

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

— J42161217
स्रोत
2
Tr@Range[#2,0,-#]&या n~Sum~{n,#2,0,-#}&जीबी के रूबी जवाब से चाल का उपयोग कर।
— मार्टिन एंडर
5

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

Rxḣ³S

@ Mr.Xcoder के जेली समाधान की तुलना में एक और बाइट लेकिन यह जेली में मेरा पहला सबमिशन है और मैं अभी भी इस बात को लेकर उलझन में हूं कि जेली का टैकस ऑपरेंड कैसे चुनता है इसलिए मैं अभी भी संतुष्ट हूं। नोट इनपुट्स का क्रम kतब है n।

व्याख्या

Rxḣ³S
R           Range: [1,2,...,k]
 x          Times: repeat each element n times: [1,1,1,2,2,2,...,n,n,n]
  ḣ³        Head: take the first k elements. ³ returns the first argument.
    S       Sum

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

— dylnan
स्रोत
4

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

1 अनुक्रमित

Ḷ:‘S

इसे ऑनलाइन आज़माएं! या एक परीक्षण सूट देखें ।

— मिस्टर एक्सकोडर
स्रोत
आप 0 अनुक्रमण कर सकते हैं तो मुझे लगता है कि Ḷ:Sयह भी काम करता है
— dylnan
@dylnan वास्तव में मुझे नहीं लगता कि 0-अनुक्रमित का यहाँ क्या मतलब है। मैं वापस लुढ़का, और हम देखेंगे
— श्री एक्सकोडर
शून्य से @dylnan डिवीजन एक त्रुटि है।
— आउटगोल्फ
4

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

करी सिंटैक्स में इनपुट लेता है (n)(k)। के falseबदले0 देता है ।

n=>g=k=>k>0&&k+g(k-n)

परीक्षण के मामलों

कोड स्निपेट दिखाएं

कैसे?

n =>             // main unamed function taking n
  g = k =>       // g = recursive function taking k
    k > 0 &&     // if k is strictly positive:
      k +        //   add k to the final result
      g(k - n)   //   subtract n from k and do a recursive call

यह @ जीबी के रूबी जवाब के समान है ।

यह चुनौती बताती है कि 'सीढ़ी' का निर्माण बाएं से दाएं कैसे किया जाता है, जबकि यह पुनरावर्ती कार्य इसे नीचे से ऊपर तक बनाता है। साथ n = 2 और कश्मीर = 11 :

सीढ़ी

— Arnauld
स्रोत
3

बैच, 34 बाइट्स

@cmd/cset/a(%2+%2%%%1)*(%2/%1+1)/2

एक बंद फार्मूला जो मुझे मिला। पहला तर्क n1-अनुक्रमित है, दूसरा तर्क k0-अनुक्रमित है।

— नील
स्रोत
3

हास्केल , 28 बाइट्स

n#k|m<-k`mod`n=sum[m,m+n..k]

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

एक दृष्टिकोण जो मैंने कुछ रेंज मापदंडों के साथ चारों ओर पेंच करके पाया। सबसे निश्चित रूप से सबसे छोटा नहीं है, लेकिन यह बहुत अच्छा है कि इतने सारे अलग-अलग दृष्टिकोण कैसे हैं।

— totallyhuman
स्रोत
3

सी, 38 34 बाइट्स

पुनरावर्ती परिभाषा।

-4 बाइट्स स्टेडीबॉक्स की बदौलत ।

f(n,k){return k--?1+f(n,k)+k/n:0;}

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

मिस्टर एक्सकोडर द्वारा 32 बाइट्स , जी.बी.

f(n,k){return(k+k%n)*(k/n+1)/2;}

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

— कोलेरा सु
स्रोत
— मिस्टर
1
जीबी के दृष्टिकोण का उपयोग करना, 32 बाइट्स
— मिस्टर एक्सकोडर
tio.run/… -> 28 बाइट्स
— GB
1
34 बाइट्स (पुनरावर्ती संस्करण): f(n,k){return k--?1+f(n,k)+k/n:0;} इसे ऑनलाइन आज़माएं!
— 18
3

आर , 37 33 31 बाइट्स

-6 बाइट्स ग्यूसेप के लिए धन्यवाद

function(n,k)sum(rep(1:k,,k,n))

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

कुछ भी आकर्षक नहीं। हैंडल मामला है जब k = 0।[0:k]

— NofP
स्रोत
1
आप यहाँ ब्रेसिज़ से छुटकारा पा सकते हैं। यदि आप इन-ऑर्डर तर्कों का उपयोग करते हैं , तो आप उपयोग करके rep.defaultछुटकारा पा सकते हैं, लेकिन फिर आपका उत्तर मूल रूप से rturnbull है, लेकिन बेस R के बजाय[0:k]rep(1:k,,k,n)R + pryr
— Giuseppe
1
आप अभी भी ब्रेसिज़ से छुटकारा पा सकते हैं! {}
— ग्यूसेप
[0: k] प्रतिस्थापन मुझे मिला और मैं ब्रेसिज़ के बारे में भूल गया :)
— NofP
2

सी ++, 53 बाइट्स

बस सूत्र का उपयोग करें। n1-अनुक्रमित और हैk 0-अनुक्रमित है।

[](int n,int k){return k/n*(k/n+1)/2*n+k%n*(k/n+1);};

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

— कोलेरा सु
स्रोत
~ऑपरेटर को गाली देकर कुछ बाइट्स बचाएं । [](int n,int k){return-k/n*~(k/n)/2*n-k%n*~(k/n);};
— सीलिंगकैट
2

जे , 13 बाइट्स

1#.]{.(#1+i.)

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

बायां तर्क n है, दायां k है।

i. एक सूची बनाता है 0..k-1

1+ सूची की प्रत्येक संख्या में एक जोड़ता है, 1,2, yealding, ..., k

# ऊपर के साथ एक हुक बनाता है, इसलिए सूची के प्रत्येक तत्वों की एन प्रतियां कॉपी की जाती हैं।

]{. उनमें से पहला n लें

1#. आधार रूपांतरण द्वारा उनकी राशि ज्ञात कीजिए।

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

— गैलेन इवानोव
स्रोत
मुझे हुक पसंद है।
— कोल
2

रेटिना , 29 26 बाइट्स

\d+
$*
(?=.*?(1+)$)\1
$'
1

इसे ऑनलाइन आज़माएं! लिंक में उनके पसंदीदा इनपुट (0-अनुक्रमित kपहले, 1-अनुक्रमित nदूसरे) में सुधार के लिए परीक्षण के मामले और हेडर शामिल हैं । मैं @ जीबी के रूबी जवाब से प्रेरित था। स्पष्टीकरण:

\d+
$*

यूनीरी में बदलें।

(?=.*?(1+)$)\1
$'

के हर स्ट्रिंग के मिलान nके भीतर k, और मैच के बाद सब कुछ के साथ मैच की जगह। यह वह जगह है k-n, k-2n, k-3n, लेकिन nयह भी मैच के बाद, तो आप प्राप्त है k, k-n, k-2nआदि यह भी मेल खाता है n, जो केवल हटा दी जाती है (यह अब जरूरत है)।

1

परिणाम योग करें और वापस दशमलव में परिवर्तित करें।

— नील
स्रोत
2

पर्ल 6 , 39 बाइट्स

->\n,\k{(0,{|($_+1 xx n)}...*)[^k].sum}

झसे आज़माओ

एन और के दोनों 1 आधारित हैं

विस्तारित:

-> \n, \k { # pointy block lambda with two parameters ｢n｣ and ｢k｣

  ( # generate the sequence

    0,         # seed the sequence (this is why ｢k｣ is 1-based)

    {          # bare block lambda with implicit parameter ｢$_｣
      |(       # slip this into outer sequence
        $_ + 1 # the next number
        xx n   # repeated ｢n｣ times (this is why ｢n｣ is 1-based)
      )
    }

    ...        # keep doing that until

    *          # never stop

  )[ ^k ]      # get the first ｢k｣ values from the sequence
  .sum         # sum them
}
— ब्रैड गिल्बर्ट b2gills
स्रोत
1

क्लोजर, 54 बाइट्स

#(nth(reductions +(for[i(rest(range))j(range %)]i))%2)

2 तर्क k0-अनुक्रमित है, इसलिए (f 14 20)28 है।

— NikoNyrh
स्रोत
1

एपीएल + विन, 13 बाइट्स

+/⎕↑(⍳n)/⍳n←⎕

N और फिर k के लिए स्क्रीन इनपुट के लिए संकेत। सूचकांक उत्पत्ति = १।

— ग्राहम
स्रोत
1

जाप , 7 6 बाइट्स

मूल रूप से जीबी के समाधान से प्रेरित और एक बंदरगाह के लिए विकसित हुआ!

kपहले इनपुट के रूप में लेता है और nदूसरे के रूप में।

õ1Vn)x

कोशिश करो

व्याख्या

पूर्णांकों का निहित इनपुट U=kऔर V=n। (पूर्णांकों की एक सरणी उत्पन्न õ) से 1करने के लिए Uके एक कदम के साथ Vनकार दिया ( n) और इसके द्वारा इसे कम ( x)।

— झबरा
स्रोत
1

आर , 27 बाइट्स

अनाम फ़ंक्शन जो उस क्रम में लेता है kऔर nहोता है। लंबाई की एक सूची बनाता है k(तीसरा तर्क rep) जो प्रत्येक तत्व समय (चौथा तर्क ) को दोहराते हुए (पहले तर्क के 1माध्यम से ) से बना है । फिर उस सूची का योग लेता है।krepnrep

n1-अनुक्रमित है और k0-अनुक्रमित है। के लिए एक त्रुटि देता है n<1। 

pryr::f(sum(rep(1:k,,k,n)))

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

— rturnbull
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.