23

পূর্ণসংখ্যার একটি তালিকা প্রদত্ত একটি নির্দিষ্ট অর্ডার / গভীরতায় ফরোয়ার্ড পার্থক্য তৈরি করে ।

পূর্ণসংখ্যার তালিকার জন্য:

(10, 18, -12, 4, 8, -3, -5, 67, 9, 14)

বিভিন্ন আদেশ / গভীরতায় ফরোয়ার্ড পার্থক্যগুলি হ'ল:

0   10,   18,  -12,    4,    8,   -3,   -5,  67,  9,  14
1      8,  -30,   16,    4,  -11,   -2,   72, -58,  5
2       -38,   46,  -12,  -15,    9,   74, -130, 63
3           84,  -58,   -3,   24,   65, -204, 193
4            -142,   55,   27,   41, -269, 397
5               197,  -28,   14, -310, 666
6                 -225,   42, -324, 976
7                    267, -366, 1300
8                      -633, 1666
9                         2299

ইনপুট সঙ্গে তাই

4, (10, 18, -12, 4, 8, -3, -5, 67, 9, 14)

আপনি তালিকা ফিরে হবে

(-142,   55,   27,   41, -269, 397)

ইনপুট

ইনপুটটি STDIN বা ফাংশন পরামিতিগুলির মাধ্যমে হতে পারে।

একটি পূর্ণসংখ্যা ফেরতের গভীরতা উল্লেখ করে। এটি তালিকা বিয়োগ 1 দৈর্ঘ্য হতে হবে

এর জন্য সামনের পার্থক্য গণনা করার জন্য পূর্ণসংখ্যার একটি তালিকা

আউটপুট

আউটপুট STDOUT এর মাধ্যমে বা ফাংশন দ্বারা ফিরে আসতে পারে।

পূর্ণসংখ্যার একটি তালিকা হিসাবে নির্দিষ্ট গভীরতার জন্য সামনের পার্থক্য

বিধি

অন্তর্নির্মিত এবং তৃতীয় পক্ষের ফাংশনগুলি যা সরাসরি এটি করে তা অনুমোদিত নয়।

স্ট্যান্ডার্ড লুফোলের বিধিনিষেধগুলি প্রযোজ্য।

সংক্ষিপ্ততম কোড জিতেছে

— MickyT
সূত্র

19

জে, 15 9 7 বাইট

খুব সহজ. বাম এবং ডান আর্গুমেন্ট হিসাবে গভীরতা এবং তালিকা নেয়।

-~/\~&2

সমস্ত adverbial কৌতুক ছাড়া সুস্পষ্ট সংজ্ঞা হিসাবে, এটি হ্রাস পায়

4 : '(2 -~/\ ])^:x y'

-~/\~&2 y- এর ফরোয়ার্ড পার্থক্য y।
x -~/\~&2 y- এর - xঅগ্রিম পার্থক্য y।

যদি আমি এই ফাংশনটির একটি গুরুতর (উদাহরণস্বরূপ, অ-গল্ফযুক্ত) সংজ্ঞা দিই, তবে আমি সম্ভবত এটির মতো কিছু করব:

(}. - }:) : ($:@[&0)

মোনাডিক কেস ফরোয়ার্ড পার্থক্যের গণনা করে যেখানে ডায়াডিক কেস -২০ xতম ফরোয়ার্ড পার্থক্য গণনা করে ।

এমনকি সহজ, কিন্তু ঠিক সমান নয়:

+/\inv

+/\আর্গুমেন্টের উপসর্গের পরিমাণগুলির একটি ভেক্টর সরবরাহ করে। inv(হিসাবে সংজ্ঞায়িত ^:_1) একটি সংমিশ্রণ যা একটি ক্রিয়াটি বিপরীত করে। এটি জে যেখানেই কোনও ক্রিয়াটি বিপরীত করতে এবং যেখানে ক্ষেত্রে +/\জে জানেন কীভাবে তা কাজ করে।

— FUZxxl
সূত্র

3

এটি ক্রিয়াকলাপ হিসাবে -এই ক্রিয়াকলাপ হিসাবে অ্যাডওয়্যারস এবং সংযোগগুলির শক্তি দেখায় ।

— এলোমেলো

14

পাইথন, 61 59 বাইট

f=lambda n,L:n and f(n-1,[x-y for x,y in zip(L[1:],L)])or L

এখানে আমরা তালিকার প্রথমটি ছাড়াও সমস্তটির সাথে তালিকার শেষটি ব্যতীত অন্য সমস্তকে জিপ করে বিয়োগফলকে সম্পাদন করি। দুটি তালিকার সর্বনিম্ন দৈর্ঘ্য নেওয়ার প্রকৃতির কারণে zip(L[1:],L)এটি সমতুল্য :zip(L[1:],L[:-1])zip

>>> zip([1,2,3],[4,5])
[(1, 4), (2, 5)]

একটি বিকল্প যা কেবল দীর্ঘ (একমাত্র পাইথন 2):

f=lambda n,L:n and f(n-1,map(int.__sub__,L[1:],L[:-1]))or L

দুর্ভাগ্যক্রমে পাইথন 2 তালিকার শেষটি কাটাচ্ছে না, তাই আমি করতে পারি না map(int.__sub__,L,L[1:])। বিরক্তিকরভাবে, পাইথন 3 টি করে , তবে mapআর কোনও তালিকা ফিরে আসে না যাতে এটি আরও বাইট (60 বাইট) হয়ে শেষ করে:

f=lambda n,L:n and f(n-1,list(map(int.__sub__,L[1:],L)))or L

তবে, যদি আমরা ইনপুটটিকে তালিকার f(3, 2, 5, 6, 7, 5, 10, 25)(যেমন গভীরতা 3 এবং তালিকা [2, 5, 6, 7, 5, 10, 25]) এর পরে গভীরতা হতে দেয় তবে এটি 56 বাইট :

f=lambda n,*T:n and f(n-1,*map(int.__sub__,T[1:],T))or T

এখানে আরেকটি বিকল্প রয়েছে যা উত্পাদনের কোডে এটি দেখে যে কেউ সত্যিই বিরক্ত হবে (এটি মূল তালিকাটি ধ্বংস করে দেয়):

f=lambda n,L:n and f(n-1,[L[1]-L.pop(0)for _ in L[1:]])or L

— Sp3000
সূত্র

আপনার শেষ কোডটি ভুল। L[1]-L.pop(0)পরিবর্তে আপনার প্রয়োজন হবে।

— mbomb007

@ mbomb007 ধরার জন্য ধন্যবাদ এটি ছিল বিশ্রী - পুরোটা সময় আমার ভুল উপায়ে চারদিকে যুক্তি ছিল।

— Sp3000

এটি কাছাকাছি ছিল, তবে প্রতিটি গভীরতার মতো কিছুতে লক্ষণগুলি বিপরীত হয়েছিল।

— mbomb007

9

গণিত 23 57 23 বাইট

বিয়োগফলের তালিকাটি কাজে লাগিয়ে মার্টিন বাটনারের পরামর্শ।

 Rest@#-Most@#&~Nest~##&

যেমন

Rest@# - Most@# &~Nest~## & @@ {{10, 18, -12, 4, 8, -3, -5, 67, 9, 14}, 4}

{-142, 55, 27, 41, -269, 397}

Rest@#-Most@# বিয়োগফল বিয়োগ করে এমন বিয়োগফল পরিচালনা করে।

নেস্ট পারফরম্যান্সে উল্লেখ করেছেন যে নির্ধারিত সংখ্যক সময়, সর্বদা সাম্প্রতিক তালিকায় সর্বদা অপারেটিং থাকে।

— DavidC
সূত্র

7

হাস্কেল, 40 34 বাইট

n#l=iterate(zipWith(-)=<<tail)l!!n

ব্যবহারের উদাহরণ: 4 # [10,18,-12,4,8,-3,-5,67,9,14]যা আউটপুট দেয় [-142,55,27,41,-269,397]।

এটি কীভাবে কাজ করে: প্রতিবেশী উপাদানগুলির মধ্যে পার্থক্য বারবার গণনা করুন এবং মধ্যবর্তী ফলাফলগুলিকে একটি তালিকায় সংরক্ষণ করুন। nএই তালিকা থেকে তম উপাদান নিন ।

সম্পাদনা করুন: @ জগারব সংরক্ষণ করতে 6 বাইট খুঁজে পেয়েছে। অসাধারণ!

— nimi
সূত্র

আপনি ফাংশন মোনাড ব্যবহার করতে এবং ল্যাম্বডাকে সংক্ষিপ্ত করতে পারেন (zipWith(-)=<<tail)।

— জাগারব

7

জাভাস্ক্রিপ্ট (ES6), 52 49 বাইট

mapঅ্যারে স্ক্যান করতে এবং sliceপ্রতিটি পুনরাবৃত্তির কলটিতে প্রথম উপাদানটি ড্রপ করে সাধারণ পুনরাবৃত্তির কাজ ।

3 বাইট সম্পাদনা করুন সংরক্ষিত, ধন্যবাদ @ ডকম্যাক্স, সত্যিই স্মার্ট পরামর্শ

F=(n,l)=>n?F(n-1,l.slice(1).map((a,k)=>a-l[k])):l

টেস্ট সালে ফায়ারফক্স / ফায়ারবাগ কনসোলটি

for(i=0;i<10;i++)console.log(F(i,[10, 18, -12, 4, 8, -3, -5, 67, 9, 14]))

[10, 18, -12, 4, 8, -3, -5, 67, 9, 14]
[8, -30, 16, 4, -11, -2, 72, -58, 5]
[-38 , 46, -12, -15, 9, 74, -130, 63]
[84, -58, -3, 24, 65, -204, 193]
[-142, 55, 27, 41, -269, 397 ]
[197, -28, 14, -310, 666]
[-225, 42, -324, 976]
[267, -366, 1300]
[-633, 1666]
[2299]

— edc65
সূত্র

1

মানচিত্র সামনে স্লাইস দক্ষতার প্রয়োজনীয়তার এড়াতে pএবং 3 টি অক্ষর সংরক্ষণ করুন: H=(n,l)=>n?H(n-1,l.slice(1).map((a,k)=>a-l[k])):l।

— ডকম্যাক্স

6

সিজেম, 15 বাইট

l~{{_@-\}*;]}*p

সিজ্যাম-স্টাইলের অ্যারে এবং তারপরে গভীরতা হিসাবে ইনপুট নেয়:

[10 18 -12 4 8 -3 -5 67 9 14] 4

এবং ফলাফলটি সিজেম-স্টাইলের অ্যারে হিসাবে মুদ্রণ করে।

এটি এখানে পরীক্ষা করুন।

ব্যাখ্যা

l~              "Read and eval input.";
  {         }*  "Repeat this block N times, which computes the forward differences.";
   {    }*      "Fold this block onto the list - this is quite an abuse of folding semantics.";
    _           "Duplicate the current element (for the use in the next difference).";
     @          "Pull up the other copy of the last element.";
      -         "Subtract.";
       \        "Swap the difference and the other copy of the current element.";
          ;     "Discard the last element.";
           ]    "Wrap everything in an array again.";

— মার্টিন ইন্ডার
সূত্র

5

জাভা, 122 119 বাইট

int[]a(int[]a,int b){if(b<1)return a;int e=a.length-1,c[]=new int[e],i=e;for(;i-->0;)c[i]=a[i+1]-a[i];return a(c,b-1);}

উদাহরণ ব্যবহার: http://ideone.com/ALgYez

জিওবিটসকে তিনটি বাইট ধন্যবাদ: v)>

— এক নম্বর
সূত্র

আপনার দ্বিতীয়টি থেকে মুক্তি পাওয়া উচিত int এবং কেবল i=eঅন্যের সাথে নিযুক্ত করা উচিত ।

— Geobits

5

> <> 53 50 বাইট

l:[2-&\~~]r1-:?!vr
&}-@:$/!?&:-1
:;!? &&  lo*84n~<

ব্যবহার: প্রথমে গভীরতার সাথে স্ট্যাকটি (-v পাইথন ইন্টারপ্রেটারে) প্রস্তুত করুন এবং তারপরে পূর্ণসংখ্যাগুলি অনুসরণ করুন।

উদাহরণ স্বরূপ:

forward.fish -v 3 2 5 6 7 5 10 25

রিটার্নস

2 -3 10 3

সহায়তার জন্য Sp3000 ধন্যবাদ।

— cirpis
সূত্র

1

এর ?!চেয়েও 0=?কি কিছু উপাদান ব্যবহার এবং সরানো সম্ভব ?

— Sp3000

আমার স্নাতকের! এটি একটি

— গুচ্ছকে

5

উপস্থাপিকা , 95 92 79 78 বাইট

?    (1-vv- # ) v  !
  ?     #   ^   #
?(1-)   1  (#)  1)(#)
  1   #(# ) 1  (#

ইনপুট ফর্ম্যাট হয়

N
M
n_1
n_2
...
n_M

Nপার্থক্যগুলির গভীরতা কোথায় এবং Mইনপুটটিতে পূর্ণসংখ্যার সংখ্যা। যোগ Mকরা প্রয়োজনীয় ছিল, কারণ প্রিলিউডের ইনপুটটির 0শেষে থেকে আলাদা করার কোনও উপায় নেই । আউটপুটটি পূর্ণসংখ্যার একটি নিউলাইন দ্বারা পৃথক তালিকা হিসাবেও। আমাকে এই চ্যালেঞ্জের জন্য আমরা কিছুটা সামঞ্জস্য করা প্রিলোড স্পেক ধরে নিয়েছিলাম , কারণ স্ট্যান্ডার্ড প্রিলিওড বাইট মান হিসাবে পূর্ণসংখ্যার পাঠ করে, যা নেতিবাচক সংখ্যায় প্রবেশ করা অসম্ভব করে তোলে। মূলত, এটি অতিরিক্ত পতাকা সহ পাইথন দোভাষীNUMERIC_INPUT ।

অবগতির জন্য শুধুমাত্র আছে 48 38 37 অ-স্পেস অক্ষর - বাকি নিছক সঠিকভাবে কোড সারিবদ্ধ প্রয়োজন পড়তো।

ব্যাখ্যা

প্রিলিডে, প্রতিটি লাইন একটি পৃথক "ভয়েস" যা নিজস্ব স্ট্যাকের উপর পরিচালিত হয়। প্রোগ্রামটি কলাম দ্বারা কলাম কার্যকর করা হয়, যেখানে পৃথক ভয়েসগুলি "সমান্তরালে" অপারেট করার জন্য নেওয়া হয়। সমস্ত কমান্ডগুলি একক অক্ষর, এবং প্রথম বন্ধনী হ'ল ব্রেইনফাক-এর মতো লুপস (যা যখন স্ট্যাকের শীর্ষটি শূন্য হয় না তখন প্রবেশ করা হয় এবং পুনরাবৃত্তি করা হয়)। নোট করুন যে বন্ধ হওয়া বন্ধনীগুলির উল্লম্ব অবস্থানটি অপ্রাসঙ্গিক - এটিকে অন্য ভয়েসে রাখা এখনও সাম্প্রতিক খোলার প্রথম বন্ধনের সাথে মিল হিসাবে গণ্য হয় এবং লুপের শর্তের জন্য যা স্ট্যাক পরীক্ষা করা হয় তা সর্বদা ভয়েস যেখানে (উপস্থিত হয়েছিল appeared এখন এই প্রোগ্রামে ...

প্রোগ্রামটি মূলত দুটি ভাগে বিভক্ত হতে পারে। নীচের দুটি লাইনগুলি কেবলমাত্র প্রোগ্রামটির বেশিরভাগ লুপের জন্য ব্যবহৃত হয় (মূল লুপটি বাদে N) 1পিছনে এগিয়ে চলে passing শীর্ষ দুটি লাইনে মূল লুপ এবং প্রকৃত ভিন্নতা রয়েছে। নিম্নলিখিত টীকাতে কোড স্থানান্তরিত হয়েছে, তাই আমি স্বতন্ত্র কলামগুলি টিকা দিতে পারি:

? ?   # Read two integers. Read instructions are processed top to bottom, so the first voice 
      # reads N and the third voice reads M.
  (   # Start a loop on the third voice. This loop will execute M times, reading the input list
      # and pushing M 1s onto the fourth voice - i.e. a unary representation of M.
 ?11  # Read an integer onto the second voice, push 1s onto the third and fourth voice.
  -   # Subtract the 1 from the third voice, decrementing M down to 0.
  )   # End of loop, if the third voice is not 0 yet, to back two columns.
(     # Start a loop on the first voice. This is the main loop and will execute N times. Each
      # iteration will compute the forward differences once and thereby shorten the list by one
      # element and also reduce the stack of 1s on the bottom voice by one.
1  #  # Push a 1 onto the first voice and pop a 1 from the last. Together with the next column,
      # this decrements both N and (the unary) M.
-  (  # Subtract the 1 from the first voice (decrementing N), and start a loop on the fourth 
      # voice over whatever is left of M (the length of the resulting difference list). Note 
      # that this column is *not* part of the loop, so the - on the first voice will only be 
      # executed once. This loop builds the differences in reverse order on the first voice.
v#1#  # Pop a 1 from the fourth voice and push a 1 onto the third. This loops over M while
      # shifting its unary representation to the other stack. In addition, shift the top stack
      # element from the second to the first voice.
v     # Copy the next element from the second voice to the first, without popping.
-  )  # Subtract the two elements on the first voice and end the loop if the fourth voice is 
      # empty. Note that his column *is* part of the loop.
  (   # Start a loop on the third voice. This is another loop over M, shifting the stack of 1s 
      # back to the fourth voice, and reversing the differences by shifting them onto the 
      # second.
#^#1  # As stated above, shift an element from the first to the second voice, a 1 from the
      # third to the fourth.
  )   # End the loop. After this point, we're back to the original situation, except that the
      # second voice has been replaced by its differences. The bottom stack element the
      # previous list is also still on that stack, but the decreasing loop lengths on the third
      # and fourth voices ensures that this element is never touched again.
)     # End the main loop when N has been reduced to 0.
   (  # Start another loop over the remaining list length, shifting and reversing the result.
v#1#  # Shift a 1 back to the third voice and an element from the second to the first voice.
  )   # End the loop. Note that this parenthesis is not on the same voice as the corresponding
      # opening parenthesis, but its exact position is irrelevant. Moving it to this voice
      # saves a byte.
  (   # Start one last loop over the length of the result.
! #   # Pop a 1 from the third voice while printing (and popping) one element of the result.
  )   # End the loop.

— মার্টিন ইন্ডার
সূত্র

5

পাইথন, 70 68 67 59 বাইট

f=lambda x,n:n and f([x[1]-x.pop(0)for i in x[1:]],n-1)or x

আমি পুনরাবৃত্ত হওয়ার আগে নন-গল্ফ সংস্করণ:

def f(x,n):
    for j in range(n):
        for i in range(len(x)-1):
            x[i]=x[i+1]-x[i]
    return x[:-n]

— mbomb007
সূত্র

5

আর, 48 39 46 44 বাইট

Recursion!

function(x,y)if(x)Recall(x-1,diff(y)) else y

xসম্পাদন করার জন্য পুনরাবৃত্তির সংখ্যা এবং yপূর্ণসংখ্যার ভেক্টর।
if(x)যতক্ষণ সত্য x>0।
Recall বর্তমান ফাংশন কল কিন্তু নতুন যুক্তি সঙ্গে।
Diff পরপর তালিকা / ভেক্টর উপাদানগুলির মধ্যে পার্থক্য আউটপুট করে।

পূর্বের সংস্করণসমূহ:

#does not work for x=0:
function(x,y){for(i in 1:x)y=diff(y);y}

#does not use diff function:
function(x,y){for(i in 1:x)y=y[-1]-head(y,-1);y}

y[-1]       is a list minus its first element
head(y,-1)  is a list minus its last element

— freekvd
সূত্র

পার্থক্যটি ফাংশন x বার পুনরাবৃত্তি করার আরও ভাল উপায় আছে? লুপের জন্য ব্যবহার করা অতিরিক্ত অনুভূত হয়।

— freekvd

হ্রাস আছে, তবে এটির জন্য আমার মনে হয় আরও বেশি অক্ষর লাগবে।

— মিকিটি

একটি ছোট সমস্যা আছে। 0 গভীরতার সাথে ডাকলে এটি গভীরতা 2

— মিকটি

ভিন্ন পদ্ধতির জন্য গিয়েছিলেন, সমস্যার সমাধান হয়েছে তবে 7 টি অক্ষর যোগ করতে হয়েছিল।

— freekvd

2

ভাল ব্যবহার Recall()।

— অ্যালেক্স এ

3

পাইথন, 92 87 86 বাইট

def a(b,c):
 if c<1:return b
 d=[];e=b[0]
 for f in b[1:]:d+=f-e,;e=f
 return a(d,c-1)

এটি আমার প্রথম পাইথন গল্ফ। কোন পরামর্শ প্রশংসা করা হবে :)

5 6 বাইট Sp3000 ধন্যবাদ: ডি

— এক নম্বর
সূত্র

আমি একটি তালিকা বোঝার প্রস্তাব দিই।

— mbomb007

আপনি চালু করতে পারেন appendমধ্যে d+=f-e,। সাধারণভাবে, কোড-গল্ফের জন্য আপনাকে এর জন্য কখনও ব্যবহারের প্রয়োজন হবে না L.append।

— Sp3000

3

সি, 68 55 বাইট

f(int *l){for(--l[-1]?f(l):0;*l;l++)*l=l[1]-*l;*--l=0;}

এটি কিছুটা ইনপুট স্পিক দিয়ে স্বাধীনতা গ্রহণ করতে পারে। একটি int অ্যারে তৈরি করা হয় যেমন উপাদান 0 গভীরতা এবং উপাদান 1 থেকে (n + 1) ইনপুট তালিকা উপাদান 0 থেকে n হয়। তারপরে উপাদান 1 এর ঠিকানাটি ফাংশনে প্রেরণ করা হয়।

অ্যারে অবশ্যই শূন্য হতে হবে। অ্যারে জায়গায় সম্পাদিত হয়।

উদাহরণ:

#include <stdio.h>

f(int *l){for(--l[-1]?f(l):0;*l;l++)*l=l[1]-*l;*--l=0;}

int main (int argc, char **argv)
{
  int list[] = {4, 10, 18, -12, 4, 8, -3, -5, 67, 9, 14, 0};
  int *elem;

  f(list + 1);

  for (elem = list + 1; *elem; elem++) {
    printf("%d, ", *elem);
  }
}

http://ideone.com/m5PDgF

— ডিজিটাল ট্রমা
সূত্র

তুমি কেন একটা জায়গা রেখেছ int *l?

— জোনাথন ফ্রেচ

2

পাওয়ারশেল 115 111 বাইট

$p={param($a, $b)0..($a-1)|%{$b=@($l=$b.length;for($i=0;$i-lt$l;$i++){$b[$i+1]-$b[$i]})[0..($l-2)]};$b-join','}

এরূপ কার্যকর করুন:

.$p 4 @(10,18,-12,4,8,-3,-5,67,9,14)

আউটপুট:

-142,55,27,41,-269,397

একটি কোঁকড়া ধনুর্বন্ধকে অন্য স্থানে সরিয়ে নিয়ে যাওয়া উত্তরের প্রতিটি পদক্ষেপ প্রদর্শন করতে দেয়।

8,-30,16,4,-11,-2,72,-58,5
-38,46,-12,-15,9,74,-130,63
84,-58,-3,24,65,-204,193
-142,55,27,41,-269,397

— StephenP
সূত্র

2

স্টাটা, 126 বাইট

di _r(a)_r(b)
token $b
gl $c=wordcount($b)
forv x=1/$a{
gl $c--
forv y=1/$c{
loc `y'=``y'+1'-``y''
}
}
forv z=1/$c{
di ``z''
}

গভীরতার প্রতিনিধিত্ব করে এমন একটি পূর্ণসংখ্যা হিসাবে ইনপুট প্রত্যাশা করে, তারপরে একটি পৃথক পূর্ণসংখ্যার তালিকা পৃথক করে, উভয়ই স্ট্যান্ডার্ড প্রম্পটের মাধ্যমে দেওয়া হয়। আউটপুট হ'ল নতুন লাইনের দ্বারা পৃথক পূর্ণসংখ্যার তালিকা।

প্রথমে এটি পূর্ণসংখ্যার তালিকাটিকে (যেটিকে এটি 1 দীর্ঘ স্ট্রিং হিসাবে দেখায়) স্থানীয় ভেরিয়েবলের তালিকায় রূপান্তর করে যার নামগুলি 1,2,3, ... তারপর এটি y তম স্থানীয় ভেরিয়েবলের মান সেট করে এগিয়ে পার্থক্যগুলি গণনা করে y + 1 তম স্থানীয় ভেরিয়েবল বিয়োগের মান yth স্থানীয় পরিবর্তনশীল (যেমন 18-10 = 8) এর মান, যা কেবলমাত্র ব্যবহারের পরে বিদ্যমান মানগুলিকে ওভাররাইট করে। এটি এটি global a (গ্লোবাল ভেরিয়েবলের মান) বার করে। তারপরে এটি প্রতিটি স্থানীয় ভেরিয়েবলের মান একবারে 1 প্রদর্শন করে।

— bmarks
সূত্র

ব্যাখ্যার জন্য +1। এটি প্রক্রিয়াজাতকরণ তালিকার একটি দুর্দান্ত উপায় ol

— Zgarb

@ জগারব, আমি স্টাটাকে ফাইলের মাধ্যমে (অ্যারে / অন্য ইনপুটটির কারণে এখানে কাজ করবে না) বাদে অ্যারে / তালিকা হিসাবে ইনপুট নেওয়ার কোনও উপায় জানি না। এজন্য এটিকে এভাবে কাজ করতে হবে।

— 16:39

2

টি এসকিউএল, অনেক বেশি :)

আমি যখন প্রথম এই সমস্যাটি দেখেছি, তখন আমি ভাবছিলাম যে কোনও প্রশ্নের ক্ষেত্রে এটি করার কোনও উপায় আছে কিনা। বেশিরভাগ ভাষার জন্য তুচ্ছ, এসকিউএল কোয়েরির জন্য এটি এতটা নয়।

পূর্ণসংখ্যা তালিকার জন্য ইনপুটটি ভেরিয়েবল @ (গভীরতার জন্য) এবং @ এল এ চলে যায়। @ এল একটি ব্যবহারকারী সংজ্ঞায়িত টেবিল প্রকার

CREATE TYPE L AS TABLE(n INT IDENTITY(0,1),v INT)

ইনপুট সেটআপ

DECLARE @L L,@ INT=4
INSERT @L(v)values(10),(18),(-12),(4),(8),(-3),(-5),(67),(9),(14)

কিছু মন্তব্য সহ ক্যোয়ারী

WITH R AS( 
    -- Recursive query to calculate the level of a pascal triangle with alternating negatives
    -- For 4 this is 1 -4  6 -4  1  
    SELECT 1c,0g UNION ALL SELECT-c*(@-g)/(g+1),g+1FROM r WHERE g<@
    ),
    O AS( 
    --Multiple N values of list by reversed pascal triangle values
    --shifting the start for each iteration (list length) - N
    SELECT c*v v,F 
    FROM @L L 
        CROSS APPLY(
            SELECT TOP((SELECT COUNT(*)FROM @L)-@)ROW_NUMBER()OVER(ORDER BY(SELECT\))-1F FROM sys.all_views a,sys.all_views b)c 
        JOIN R ON N=F+@-G
    )
-- Sum the multiplied values
SELECT SUM(V)FROM o GROUP BY F ORDER BY F

ফল

— MickyT
সূত্র

2

জাপট `-h` , 17 5 বাইট

12 বাইট সংরক্ষিত @ শ্যাগিকে ধন্যবাদ thanks

VÆ=än

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

— লুইস ফিলিপে দে জেসুস মুনোজ
সূত্র

13 বাইট

— শেগি

বা কোনও আলাদা বাস্তবায়ন 12 বাইট

— শেজি

আপনি আরও দুটি বাইট সংরক্ষণ করতে উভয়ের äÏ-Xসাথে প্রতিস্থাপন করতে পারেন än।

— শেগি

এটি 5 বাইট নিচে পেয়েছেন !

— শেগি

@ শেগি ধিক্কার আপনি জ্যাপ্ট এক্সডি তে খুব ভাল আছেন আপনার 5 বাইট উত্তর পোস্ট করা উচিত

— লুইস

0

স্মাইলব্যাসিক, 76 বাইট

অবশেষে ব্যবহারের একটি কারণ ARYOP!

DEF F L,D
IF!D THEN@R
DIM B[0]COPY B,L
T=SHIFT(L)ARYOP 1,L,L,B
F L,D-1@R
END

— 12Me21
সূত্র

0

ক্লোজার, 47 বাইট

#(if(= 0 %)%2(recur(dec %)(map -(rest %2)%2))))

বেনামে ফাংশনে একটি সাধারণ পুনরাবৃত্তি। যদি আর্গুমেন্টের ক্রমটি এখন থেকে %2আরও ঘন ঘন ঘন ঘন ঘন ঘন ঘন হয়ে আসে তবে আপনি 1 বাইট সংরক্ষণ করুন %।

— NikoNyrh
সূত্র

0

জেলি , 2 বাইট

I¡

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

ব্যাখ্যা

I¡  Main Link
 ¡  Repeat `n` times; this repeats the previous link by <right argument> times
I   Get forward differences

খুব সোজা উত্তর: পি

— হাইপারনিউটারিনো
সূত্র

0

Japt , 7 বাইট

লুইসকে তার সমাধানের জন্য আমি কয়েকটি বিকল্প সরবরাহ করেছিলাম ।

_än}gNÅ

চেষ্টা করে দেখুন

10 বাইট

ÏÄ<V}f@=än

চেষ্টা করে দেখুন

— রোমশ
সূত্র

বিভিন্ন উপায় এগিয়ে

ইনপুট

আউটপুট

বিধি

জে, 15 9 7 বাইট

পাইথন, 61 59 বাইট

গণিত 23 57 23 বাইট

হাস্কেল, 40 34 বাইট

জাভাস্ক্রিপ্ট (ES6), 52 49 বাইট

সিজেম, 15 বাইট

ব্যাখ্যা

জাভা, 122 119 বাইট

> <> 53 50 বাইট

উপস্থাপিকা , 95 92 79 78 বাইট

ব্যাখ্যা

পাইথন, 70 68 67 59 বাইট

আর, 48 39 46 44 বাইট

পাইথন, 92 87 86 বাইট

সি, 68 55 বাইট

পাওয়ারশেল 115 111 বাইট

স্টাটা, 126 বাইট

টি এসকিউএল, অনেক বেশি :)

জাপট -h , 17 5 বাইট

স্মাইলব্যাসিক, 76 বাইট

ক্লোজার, 47 বাইট

জেলি , 2 বাইট

ব্যাখ্যা

Japt , 7 বাইট

10 বাইট

জাপট `-h` , 17 5 বাইট