আংশিক যোগফল পরিমার্জন করা


23

পূর্ণসংখ্যার তালিকার আংশিক অঙ্কগুলি [একটি 1 , একটি 2 , একটি 3 , ..., একটি এন ]

s 1 = a 1
s 2 = a 1 + a 2
s 3 = a 1 + a 2 + a 3
...
s n = a 1 + a 2 + ... + a n

তারপরে আমরা আংশিক অঙ্কের [s 1 , s 2 , s 3 , ..., s n ] এর তালিকা নিতে পারি এবং নতুন তালিকা তৈরির জন্য এর আংশিক অঙ্কগুলি আবার গুনতে পারি এবং এই জাতীয় আরও কিছু।

সম্পর্কিত: আগাম পার্থক্যগুলি চিহ্নিত করা

ইনপুট:

  • পূর্ণসংখ্যার একটি খালি খালি তালিকা
  • একটি ইতিবাচক সংখ্যা পুনরাবৃত্তি,

আউটপুট: সংখ্যার যোগফলগুলি বহুবার নেওয়ার ফলে প্রাপ্ত পূর্ণসংখ্যার তালিকা মুদ্রণ করুন বা প্রত্যাবর্তন করুন।

সবচেয়ে কম বাইট জেতা বিল্ট-ইনগুলি সমস্যা সমাধান করার পরেও ঠিক আছে।

পরীক্ষার কেস:

f([-3, 4, 7, -1, 15], 1) == [-3, 1, 8, 7, 22]
f([-3, 4, 7, -1, 15], 3) == [-3, -5, 1, 14, 49]

লিডারবোর্ড:


যুক্তিগুলি কি একই ক্রমে থাকা দরকার, বা সংখ্যাগুলির তালিকার আগে পুনরাবৃত্তির সংখ্যা আসতে পারে ?
kirbyfan64sos

@ kirbyfan64sos হয় আদেশ করুন।
xnor

উত্তর:


14

জে, 5 বাইট

+/\^:

এটি জেজেজে অনলাইনে চেষ্টা করে দেখুন ।

কিভাবে এটা কাজ করে

  • /\ এটি একটি ক্রিয়াবিশেষ (ক্রিয়া যা বাম যুক্তি গ্রহণ করে) যা তার যুক্তি দ্বারা ক্রমশ হ্রাস পায়।

  • এভাবে +/\হয় ক্রমযোজিত সমষ্টি ক্রিয়া।

  • ^:হয় ক্ষমতা একত্রে ; মোট বার (f ^: n) yপ্রযোজ্য ।fny

  • ক্রিয়া-সংমিশ্রণ ট্রেনটি +/\^:একটি ক্রিয়াপদ তৈরি করে যা +/\তার (বাম) আর্গুমেন্টে বর্ণিত যতবার পুনরাবৃত্তি করে ।

    x (+/\^:) yপার্স হয়ে যায় (x (+/\^:)) yযা নির্বাহের সমতুল্য (+/\^:x) y

ব্যাখ্যায় তাঁর সহায়তার জন্য @ জগারবকে ধন্যবাদ জানাই।


13

গণিত, 19 বাইট

আচ্ছা, যদি বিল্ট-ইনগুলি ঠিক থাকে ...

Accumulate~Nest~##&

চ্যালেঞ্জের উদাহরণগুলির মতো একই স্বাক্ষর সহ একটি ফাংশন সংজ্ঞা দেয়। আমি বেশ নিশ্চিত, দীর্ঘ নামটির জন্য ধন্যবাদ Accumulateযে যদিও এটি গল্ফ ভাষা এবং এপিএল-পরিবার সহজেই পরাজিত হবে। :)

যারা গাণিতিক করেন না তাদের জন্য লেজিমনম্মল ৯78৮ এর মন্তব্যে বিস্তারিত জানাতে:

##ফাংশনটির প্যারামিটারগুলির একটি ক্রম উপস্থাপন করে (এটি এমন একটি তালিকার মতো যা এটি যেখানে'sোকানো হয় সেখানে স্বয়ংক্রিয়ভাবে "স্প্লেটস" হয়, যদি আপনি নিজের ভাষার পছন্দ থেকে সেই শব্দটির সাথে আরও পরিচিত হন)। ~পোতা ফাংশন আবাহন জন্য অন্বিত চিনি, তাই যদি আমরা পরামিতি সঙ্গে ফাংশন কল listএবং nএবং সবকিছু প্রসারিত করবে, আমরা পাই:

Accumulate~Nest~##
Nest[Accumulate, ##]
Nest[Accumulate, list, n]

যা হুবহু আর্গুমেন্ট অর্ডার দ্বারা প্রত্যাশিত হিসাবে ঘটবে Nest


এটি আকর্ষণীয়, 3 টি যুক্তি ব্যবহার করে ইনফিক্স নোটেশন ব্যবহার করে SlotSequence...
LegionMammal978

9

হাস্কেল, 26 23 বাইট

(!!).iterate(scanl1(+))

এটি একটি বেনামি ফাংশন সংজ্ঞায়িত করে, যা নিম্নলিখিত হিসাবে আহবান করা হয়েছিল:

> let f = (!!).iterate(scanl1(+)) in f [-3,4,7,-1,15] 3
[-3,-5,1,14,49]

3 বাইট বাঁচানোর জন্য @ নিমিকে ধন্যবাদ জানাই।

ব্যাখ্যা

(!!).                    -- Index by second argument from
     iterate(         )  -- the infinite list obtained by iterating
             scanl1(+)   -- the partial sums function (left scan by +) to first argument

খুব সুন্দর! এবং ব্যাখ্যা জন্য আপনাকে ধন্যবাদ!
জেক

2
যান pointfree, তাহলে আপনি এমনকি নাম ফাংশন জন্য বর্জন করতে পারেন: (!!).iterate(scanl1(+))
নিমি

@ নিমি ধন্যবাদ! কোনওরকম আমি যুক্তি দিয়েছিলাম যে রচনাটি এখানে আমার উপকারে আসবে না ...
Zgarb

9

এপিএল, 9 8 বাইট

{+\⍣⍺⊢⍵}

এটি একটি ডায়াডিক ফাংশন সংজ্ঞায়িত করে যা পুনরাবৃত্তিকে গ্রহণ করে এবং বাম এবং ডান আর্গুমেন্ট হিসাবে তালিকাবদ্ধ করে।

1 বাইট বন্ধ করে গল্ফ করার জন্য @ এনবিজেডকে ধন্যবাদ!

অনলাইনে ট্রাইএপএল চেষ্টা করে দেখুন ।

কিভাবে এটা কাজ করে

  • এবং ফাংশনে বাম এবং ডান যুক্তি রয়েছে।

  • +\ যোগফল যোগফল হ্রাস।

  • ⍣⍺পূর্ববর্তী অপারেটর বার পুনরাবৃত্তি ।

  • ⊢⍵এতে পরিচয় ফাংশন প্রয়োগ করে

    এটি কোডের (+\⍣⍺)⍵পরিবর্তে পরিবর্তিত করার একটি ছোট উপায় +\⍣(⍺⍵)

একযোগে, আমরা এতে +\মোট বার প্রয়োগ করি


@ অ্যালেক্সা: তাহলে কি +\⍣⎕⊢⎕গ্রহণযোগ্য হবে না ? ( পাইথনের মতো input())।
মেরিনাস

1
@মারিনাস আসলেই কি কোনও আরএপিএল এর বাইরে ছাপায়? আমার কাছে কেবলমাত্র ডেস্কটপ ইন্টারপ্রেটারকেই পরে নিয়োগের প্রয়োজন হবে ।
ডেনিস

5

মতলব, 41 বাইট

function f(l,n);for i=1:n;l=cumsum(l);end

বেশ সোজা। আমি এখনও মনে করি পিসওয়াস নির্ধারিত বেনাম ফাংশনগুলি বা পুনরাবৃত্তিতে অ্যাঙ্করগুলি তৈরির পথে কোনও বিলম্ব না করাই বেশ বিরক্তিকর।

Ungolfed:

function f(l,n);
for i=1:n;
    l=cumsum(l);
end

5

জাভাস্ক্রিপ্ট (ES6) 38

আশ্চর্যজনকভাবে ছোট। ম্যাপ পুনরাবৃত্তভাবে ব্যবহার করে

f=(l,n,t=0)=>n?f(l.map(x=>t+=x),n-1):l

function test()
{
  var n, v, i = I.value
  v = i.match(/\-?\d+/g).map(x=>+x)
  n = v.pop()
  console.log(v,n)
  O.innerHTML = I.value + ' -> ' + f(v,n) + '\n' + O.innerHTML;
}

test()
<input id=I value='[-3, 4, 7, -1, 15], 3'><button onclick="test()">-></button>
<pre id=O></pre>


5

কে, 7 3 বাইট

{y+\/x}

জে সলিউশনের সাথে খুব মিল। +\আক্ষরিকভাবে একটি আংশিক যোগফল সম্পাদন করে, এবং যখন /একটি monadic ক্রিয়া এবং একটি পূর্ণসংখ্যা বাম আর্গুমেন্ট সরবরাহ করা হয় এটি একটি নির্দিষ্ট সংখ্যার পুনরাবৃত্তি করে, যেমন "ফর" লুপের মতো। বাকীগুলি কেবল আর্গুমেন্টের ক্রম অনুসারে ঝরঝরে করে তা গুটিয়ে রাখছে।

  {y+\/x}[-3 4 7 -1 15;1]
-3 1 8 7 22
  {y+\/x}[-3 4 7 -1 15;3]
-3 -5 1 14 49

কোনা এবং ওকে পরীক্ষিত ।

সম্পাদনা:

@ কিরবিফ্যান 64৪৪ নির্ধারিত অনুসারে যদি আমাকে আর্গুমেন্টগুলি উল্টে দেওয়ার অনুমতি দেওয়া হয় তবে আমি পুরোপুরি ফাংশনটি মোড়ানো নিয়েই বিতরণ করতে পারি:

+\/

অনুরোধ করা হয়েছে:

+\/[3;-3 4 7 -1 15]

এটি কে 2.8 এবং কে 5 উভয় ক্ষেত্রেই সঠিকভাবে কাজ করে। এটি ওকে তে কাজ করে না কারণ সেই অনুবাদক এখনও তরকারী (ওরফে "প্রজেক্টযুক্ত") অ্যাডওয়্যারটি সমর্থন করে না এবং কম স্পষ্ট কারণে কোনাতে এটি সঠিকভাবে কাজ করছে বলে মনে হয় না।

সম্পাদনা : কিছু দিন আগে, +\/সূত্রটি ওকেতেও কাজ করে।


1
যুক্তিগুলি বিপরীত করা যেতে পারে , তাই আমি মনে করি আপনি কয়েকটি বাইট শেভ করতে সক্ষম হতে পারেন।
kirbyfan64sos

3 +\/ -3 4 7 -1 15কোনায় ঠিকঠাক কাজ করে তবে আপনি এটি কোনও ফাংশনে নির্ধারণ করতে পারবেন না। অদ্ভুত ...
ডেনিস

হ্যাঁ, কোনা স্পষ্টভাবে 3+\/-3 4 7 -1 15সেভাবে আচরণ করছে না +\/[3;-3 4 7 -1 15]- তারা যদি প্রাক্তনটিকে একটি বিশেষ সিনট্যাকটিক কেস হিসাবে পরিচালনা করে তবে আমাকে অবাক করে তোলে।
18


4

জুলিয়া, 29 বাইট

f(x,y)=y>0?f(cumsum(x),y-1):x

এটি আসলে খুব বেশি ব্যাখ্যা প্রয়োজন হয় না। এটি একটি পুনরাবৃত্ত ফাংশন, যদি y==0কেবলমাত্র আউটপুট এক্স। অন্যথায় হ্রাস Y, একটি cumsum সঞ্চালন, এবং পুনরাবৃত্তি। সম্ভবত সবচেয়ে গল্ফযুক্ত জুলিয়া সমাধান না, আমি এখনও এটি নিয়ে কাজ করছি।


4

ল্যাবরেথ , 73 বাইট

;?
,"
;
#
#;}=
;  #
"#;(
_  ;={()"
#;; ( { "
  ; { !\(@
+=( =
" " "
":{:"

কিছুক্ষণ হয়ে গেছে যখন আমি লাইব্রের্থে কিছু উত্তর দিয়েছি এবং এটি করণীয় মনে হয়েছিল। :)

ইনপুট ফর্ম্যাটটি একটি সমান্তরাল তালিকা যা প্রথমে পুনরাবৃত্তির সংখ্যা সহ (এবং তারপরে আংশিক অঙ্কগুলি প্রয়োগ করার জন্য তালিকা)। ডিলিমিটারগুলি যতক্ষণ না শেষ পূর্ণসংখ্যার পরে কোনও চরিত্র না থাকে ততক্ষণ এগুলি গুরুত্বপূর্ণ নয়, তাই আপনি পঠনযোগ্য কিছু ব্যবহার করতে পারেন:

3 | -3, 4, 7, -1, 15

আউটপুটটি নতুন লাইন দ্বারা পৃথক:

-3
-5
1
14
49

4

আর, 75 বাইট

এটি দীর্ঘ তবে ভিন্ন গ্রহণ ... ক্রমযুক্ত অঙ্কের পরিবর্তে কাঙ্ক্ষিত ক্রমটি সরাসরি গণনা করা:

function(x,n)sapply(1:length(x),function(i)sum(x[1:i]*choose(i:1+n-2,n-1)))

উল্লেখ করে যে cumsum x n (x) এর জন্য xi পদগুলির সহগের গুণকগুলি প্যাস্কেলের ত্রিভুজের কোণগুলি। অর্থাত

cumsum^3(x) = choose(2,2) * x1, choose(3,2) * x1 + choose(2,2) *x2, choose(4,2) * x1 + choose(3,2) * x2 + choose(2,2) * x3, ....

সম্পাদনা: একটি ফাংশন করতে


4

পাইথন 2, 67

এটি অ্যান্টনি রইটম্যানের সমান সংমিশ্রণ এবং মরগান থ্র্যাপের মতো একই পুনরাবৃত্তি ব্যবহার করে

f=lambda l,n:f([sum(l[:i+1])for i in range(len(l))],n-1)if n else l

আমি তাদের সমাধান দেখার আগেই আমি এই সমাধানটি বিকাশ করেছি এবং তারপরে এগুলির উভয় বা উভয়েরই মন্তব্য না করে উত্তর হিসাবে পোস্ট করা সহজ মনে হয়েছিল।


4

পাইথন, 113 93 89 76 বাইট

def f(l,n):
 for i in[0]*n:l=[sum(l[:j+1])for j in range(len(l))];
 print(l)

এটি উভয় পরীক্ষার ক্ষেত্রে কাজ করে। স্ট্যাটাস, মরগান থ্র্যাপ এবং রূথ ফ্র্যাঙ্কলিনকে যথাক্রমে 93, 89 এবং 76 বাইটে প্রোগ্রামটি গল্ফ করতে সাহায্য করার জন্য আপনাকে ধন্যবাদ।


1
দ্বিতীয় লুপটিকে একটি তালিকা বোধে পরিবর্তন করে আপনি বেশ কয়েকটি বাইট আউট করতে পারেন। যে k=[sum(l[:j+1])for j in range(len(l))],। তারপরে ;k=lটেকড দিয়ে আপনি এটিকে for iলুপের সাহায্যে একটি লাইনে ফেলে দিতে পারেন ।
স্থিতি

1
k=[sum(l[:j+1])for j in range(len(l))];l=k2 বাইট সংরক্ষণের জন্য লুপের মতো একই লাইনে আপনি সরতে পারেন এবং অন্য বাইট সংরক্ষণের জন্য এফ এর যুক্তিগুলির মধ্যে স্থানটি সরিয়ে ফেলতে পারেন।
মরগান থ্রাপ

আপনি মান ব্যবহার করবেন না হিসাবে i, আপনি প্রতিস্থাপন করতে পারেন for i in range(n)সঙ্গে for i in[0]*n(কারণ সব আপনার পছন্দের দৈর্ঘ্য তালিকায় উপাদান যায়)। এবং আমার মনে হয় অক্জিলিয়ারী তালিকা ব্যবহার না করেই এটা করতে পারেন k, শুধু যুক্তি পরিবর্তন l
রুথ ফ্র্যাংকলিন

4

গোল> <> 0.3.10 , 22 বাইট

SI
C>rFlMF:}+
NRl<C}<;

প্রথম পূর্ণসংখ্যাটি পুনরাবৃত্তির সংখ্যা হিসাবে নেওয়া হয় এবং বাকিগুলি তালিকা তৈরি করে। চূড়ান্ত তালিকা আউটপুট করা হয় নিউলাইন-পৃথক।

ভাষাটি এখনও বেশ অল্প বয়স্ক এবং অস্থির, তবে যেহেতু আমি এই অপারেটরগুলির উপর বেশ সেট করছি আমি ভেবেছিলাম এটি ঠিক আছে।

ব্যাখ্যা

SI            Read integer, moving down on EOF (first line runs as loop)
r             Reverse stack, putting iteration number on top

[outer loop]
F             Do #(iterations) times

[inner loop]
lMF           Do #(length of stack - 1) times
:             Duplicate top of stack
}             Rotate stack rightward (top goes to bottom)
+             Add the top two elements of the stack
C             Continue inner loop, moving down from F when loop is over

}             Rotate once more
C             Continue outer loop, moving down from F when loop is over

lRN           Print stack as (num + newline)
;             Halt

এটি কেন কাজ করে তা দেখতে, আসুন একটি ছোট উদাহরণ চেষ্টা করুন [5 2 1]:

[5 2 1] -- : --> [5 2 1 1] -- } -->  [1 5 2 1]  -- + --> [1 5 3]
[1 5 3] -- : --> [1 5 3 3] -- } -->  [3 1 5 3]  -- + --> [3 1 8]

-- } --> [8 3 1]

3

পাইথন, 52 বাইট

f=lambda l,n:n*l and f(f(l[:-1],1)+[sum(l)],n-1)or l

তালিকা lএবং পুনরাবৃত্তির সংখ্যা উভয়ই পুনরাবৃত্তি করে এমন একটি পুনরাবৃত্তি ফাংশন n। আসুন এটি ভেঙে দিন।

প্রথমে আসুন একটি পুনরাবৃত্ত ফাংশন বিবেচনা করি gযা কেবল একবার আংশিক যোগটি পুনরাবৃত্তি করে।

g=lambda l:l and g(l[:-1])+[sum(l)]

একটি খালি তালিকা দেখার জন্য l, এই ফেরৎ lনিজেই, খালি তালিকা। অন্যথায়, আংশিক lযোগফলের lশেষ প্রবেশটি সামগ্রিক যোগফল হয় , যা সর্বশেষের উপাদান ব্যতীত সকলের জন্য পুনরাবৃত্তির ফলাফলের সাথে যুক্ত হয় l

এখন, আসুন পুনরাবৃত্তি জন্য fপ্রযোজ্য একটি ফাংশন তাকান ।gn

f=lambda l,n:n and f(g(l),n-1)or l

যখন nহয় 0, তখন এই তালিকার ফেরৎ lঅপরিবর্তিত, এবং অন্যথায় প্রযোজ্য gএকবার, তারপর কল fএক কম পুনরাবৃত্তির অবশিষ্ট সঙ্গে যাও recursively।

এখন আসুন, আসল কোডটি আবার দেখি যা দুটি পুনরাবৃত্তিকে একক ফাংশনে একত্রিত করে। ধারণাটি হ'ল g(l)বিশেষ কেস হিসাবে বিবেচনা করা f(l,1)

f=lambda l,n:n*l and f(f(l[:-1],1)+[sum(l)],n-1)or l

আমরা গ্রহণ f(g(l),n-1)পূর্ববর্তী সংজ্ঞা, প্রসারিত থেকে g(l)মধ্যে g(l[:-1])+[sum(l)], এবং তারপর প্রতিস্থাপিত g(_)সঙ্গে f(_,1)থেকে recursive কল সীমাবদ্ধ করতে f

বেস কেসের ক্ষেত্রে আমরা lযখনই n==0বা ফিরে যেতে চাই l==[]। আমরা এগুলি উল্লেখ করে একত্রিত করি যে কোনও একটি n*lখালি তালিকা তৈরি করে, যা ফালসি। সুতরাং, যখনই n*lশূন্য নয় তখন আমরা পুনরাবৃত্তি করি এবং lঅন্যথায় ফিরে আসি।

যদিও এখানে দুটি পুনরাবৃত্তি কল রয়েছে f, এটি ফিবোনাকির সংখ্যাগুলির পুনরাবৃত্ত সংজ্ঞাটিকে তাত্ক্ষণিকভাবে ধাক্কা দিবে না, তবে এটি চতুর্ভুজ হিসাবে রয়ে গেছে।


3

সি ++ (61 + 17 = 78 বাইট)

#include<numeric>
void f(int*a,int*e,int n){for(;n--;)std::partial_sum(a,e,a);}

পরীক্ষা ক্ষেত্রে:

#include <iostream>
#include <iterator>

int main() {
    int a[] { -3, 4, 7, -1, 15 };
    f(a, std::end(a), 3);
    for (auto i : a)
        std::cout << i << " ";
}

স্পেসিফিকেশনটির সাথে এটি একটি সামান্য স্বাধীনতা লাগে: এটি সি-স্টাইল অ্যারে ব্যবহার করে, অ্যারের শুরু এবং শেষের দিকে পয়েন্টারগুলি অতিক্রম করে। অভ্যন্তরীণভাবে, আপনি দেখতে পাচ্ছেন, এটি কেবল একটি যে std::partial_sumএটি স্ট্যান্ডার্ড লাইব্রেরির আশেপাশে অত্যন্ত পাতলা মোড়ক । ফলস্বরূপ ফলস্বরূপ মানটি ফিরিয়ে দেওয়ার পরিবর্তে এটি কেবল পাস করা অ্যারেটিকে পরিবর্তন করে।

যদি আমরা জিনিসগুলির সংজ্ঞাটিকে সীমাতে ঠেলে দিতে কিছু মনে করি না (এবং, সম্ভবত কিছুটা ছাড়িয়ে) আমরা ল্যাম্বডা এক্সপ্রেশনটিতে একটি "ফাংশন" সংজ্ঞায়িত করতে পারি:

#include<numeric>
#include <iostream>
#include <iterator>

int main() {
    int a[] { -3, 4, 7, -1, 15 };
    int *e = std::end(a);
    int n=3;

    auto f=[&]{for(;n--;)std::partial_sum(a,e,a);};

    f();
    for (auto i : a)
        std::cout << i << " ";
}

এটি এই টুকরোটিতে ফাংশনের সংজ্ঞা (-র মতো বস্তু) হ্রাস করে:

[&]{for(;n--;)std::partial_sum(a,e,a);};

... 40 বাইটের জন্য (+17 এর জন্য #include)।


ওয়াও, আমি আশা করিনি যে এসটিএল আংশিক পরিমাণ গণনা করার জন্য অ্যালগ রাখবে।
জেরেজেস

1
@ জেরেজেস: কেউ স্প্যানিশ জিজ্ঞাসাবাদ প্রত্যাশা করে না .... ওহ, অপেক্ষা করুন, আমরা পাইথন নয়, সি ++ করছি। আমার ক্ষমা।
জেরি কফিন


2

Haskell,, 52 47 বাইট

প্রথমবারের মতো কোড গল্ফের 'প্রচেষ্টা', এবং আমি হাসকলের প্রথমদিকে খুব প্রচুর, তাই মন্তব্যগুলি আনন্দের সাথে স্বাগত! এটি ফাংশন কলটির কোনও প্রয়োজনীয় ফর্ম্যাট, বা এটি কোনও প্রোগ্রামের পক্ষে কোনও যুক্তি দ্বারা নেওয়া হয়েছিল কিনা তা নিয়ে প্রশ্নে স্পষ্ট ছিল না, তাই আমি কয়েকটি স্পেস সংরক্ষণ করতে ফাংশন আইডেন্টিফায়ার হিসাবে বিস্ময়বোধক চিহ্নটি ব্যবহার করেছি।

0!a=a
i!a=(i-1)![sum$take j a|j<-[1..length a]]

ব্যবহার (জিএইচসিআই):

$ ghci partialsums.hs
GHCi, version 7.6.3: http://www.haskell.org/ghc/  :? for help
Loading package ghc-prim ... linking ... done.
Loading package integer-gmp ... linking ... done.
Loading package base ... linking ... done.
[1 of 1] Compiling Main             ( partialsums.hs, interpreted )
Ok, modules loaded: Main.
*Main> 1![-3, 4 ,7 ,-1 ,15]
[-3,1,8,7,22]
*Main> 3![-3, 4 ,7 ,-1 ,15]
[-3,-5,1,14,49]

কোড গল্ফ স্বাগতম! এটি সাধারণত গার্ড ব্যবহার করার চেয়ে প্যাটার্ন ম্যাচের চেয়ে কম হয় 0!a=a i!a=...
xnor

ধন্যবাদ @ এক্সনোর - প্রাথমিক কোডটি তৈরি করার সময় আমি আগে 'এক্স' ব্যবহার করেছি এবং পোস্টে কোডটি সংশোধন করার সময় অবশ্যই এটি মিস করেছি missed সম্পাদনা করা হয়েছে।
জ্যাক

জন্য sum(take j a), আপনি ডান বন্ধনী করে এড়াতে পারেন sum$take j a, উচ্চ প্রাধান্য ব্যবহার $
xnor

আপনার সাহায্যের জন্য ধন্যবাদ! আমি কোনও কারণে, এমন ছাপে ছিলাম যে $সিনট্যাক্সের চেয়ে অগ্রাধিকার নেবে (এবং বাকী রেখাটি যেমন দাঁড়িয়েছে তেমন মূল্যায়ন করার চেষ্টা করবে)। অবশ্যই, এটি এমনকি বোঝা হবে না।
জেক


2

সি #, 52 + 85 = 148 137 বাইট

using E=System.Collections.Generic.IEnumerable<int>;

এবং

E I(E s,int i){int t=0;return i<1?s:I(System.Linq.Enumerable.Select(s,v=>t+=v),i-1);}

এটি অপ্রচলিত অনুশীলনগুলি ( v=>t+=v) ব্যবহার করে তবে এটি পিপিসিজি। স্ট্যাকের গভীরতার সীমাবদ্ধতাটিও নোট করুন।


2

পাইথন 3, 73

সম্ভবত আরও কিছুটা নিচে গল্ফ করা যেতে পারে।

def f(n,i):
 p=0;c=[]
 for m in n:p+=m;c+=[p]
 f(c,i-1)if i else print(n)

এই সংস্করণটি অল্প ব্যবহার করে, যা কিছুটা প্রতারণার মতো অনুভব করে তবে এখানে তা:

পাইথন 3 (নপি সহ), 72

from numpy import*
def f(n,i):
 if i:c=cumsum(n);f(c,i-1)
 else:print(n)

2

সি ++ 14, 102 103 94 + 17 (অন্তর্ভুক্ত) = 111 বাইট

#include<vector>
auto f(std::vector<int>a,int n){for(;n--;)for(int i=0;i<a.size()-1;++i)a[i+1]+=a[i];return a;}

অসম্পূর্ণ, পরীক্ষার ক্ষেত্রে

#include <vector>
#include <iostream>

auto f(std::vector<int> a, int n)
{
    for (; n--;)
        for (int i = 0; i < a.size() - 1; ++i)
            a[i + 1] += a[i];
    return a;
}


int main()
{
    auto t = f({-3, 4, 7, -1, 15}, 3);
    for (int i : t)
        std::cout << i << " ";
}

মূল্যায়নের আদেশ উপর নির্ভর করে। এটি ইউবি কিনা তা নিশ্চিত নয়, তবে এটি সংস্থাপক নির্ভর করে তাই এটি পরিবর্তন করেছি।


j0 থেকে এন পর্যন্ত গণনা করার পরিবর্তে 0 এ nগণনা করুন আমার গণনা অনুসারে 97 বাইট দেয়।
জেরি কফিন 3

@ জেরি কফিন ধন্যবাদ ..
জেরেজেস


1

বার্লেস্ক, 10 বাইট

{q++pa}jE!

এটি সাধারণভাবে খুব দক্ষ নয় তবে এটি কৌশলটি করে।

blsq ) {-3 4 7 -1 15} 1 {q++pa}jE!
{-3 1 8 7 22}
blsq ) {-3 4 7 -1 15} 3 {q++pa}jE!
{-3 -5 1 14 49}

1

সি ++ 14, 67 বাইট

যেমন নামহীন ল্যাম্বদা এর ইনপুটটি সংশোধন করে, cএলোমেলো-অ্যাক্সেস-ধারক হিসাবে প্রয়োজনীয় vector<int>

[](auto&c,int n){while(n--)for(int i=0;i++<c.size();c[i]+=c[i-1]);}


1

জেলি , 3 বাইট

SƤ¡

এটি অনলাইন চেষ্টা করুন!

এটি আমার ( মিস্টার এক্সকোডার এর) পদ্ধতি।

জেলি , 3 বাইট

+\¡

এটি অনলাইন চেষ্টা করুন!

এটি caird coinheringaahing এর সমাধান।

পদ্ধতি # 1

SƤ¡ - সম্পূর্ণ প্রোগ্রাম, dyadic।

  ¡- বারবার প্রয়োগ করুন, N বার।
 Ƥ - তালিকার উপসর্গের উপরের পূর্ববর্তী লিঙ্কটি মানচিত্র করুন।
এস - সম
     - স্পষ্টভাবে আউটপুট

পদ্ধতি # 2

+ \ ¡- সম্পূর্ণ প্রোগ্রাম, ডায়াডিক।

  ¡- বারবার প্রয়োগ করুন, N বার।
 \ - সংযোজক দ্বারা হ্রাস:
+ - সংযোজন

0

অ্যাক্সিয়োম 213 47 বাইট

m(a,b)==(for i in 1..b repeat a:=scan(+,a,0);a)

ungolf এবং কিছু উদাহরণ

 (3) -> [m([-3,4,7,-1,15],1), m([-3,4,7,-1,15],3)]
    Compiling function l with type List Integer -> List Integer
    Compiling function m with type (List Integer,Integer) -> List
       Integer

    (3)  [[- 3,1,8,7,22],[- 3,- 5,1,14,49]]
                                                       Type: List List Integer
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.