একটি অ্যারের ডেল্টাস বাছাই করুন এবং পুনরায় প্রয়োগ করুন

11

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

শ্রেণীবিভাজন.

আপনার কাজটি হল পূর্ণসংখ্যার একটি অ্যারে নেওয়া, তাদের ডেল্টাগুলি বাছাই করা এবং পুনরায় সংকলন করা যাতে পূর্ণসংখ্যার নতুন অ্যারে দেওয়া হয়।

যেমন।

ইনপুট জন্য:

1  5 -3  2  9

নিম্নলিখিত ডেল্টাস পান:

  4 -8  5  7

তারপরে, ফলন হিসাবে এই ডেল্টাস বাছাই করুন:

 -8  4  5  7

এবং তাদের পুনরায় প্রয়োগ করুন, যা দেয়:

1 -7 -3  2  9

ইনপুট আউটপুট

আপনাকে একটি তালিকা / অ্যারে / টেবিল / টিপল / স্ট্যাক / ইত্যাদি দেওয়া হবে। কোনও মানক ইনপুট পদ্ধতির মাধ্যমে ইনপুট হিসাবে স্বাক্ষরিত পূর্ণসংখ্যাগুলির of

উপরের ডেল্টা বাছাই পদ্ধতি অনুসরণ করে আপনাকে অবশ্যই কোনও গ্রহণযোগ্য আকারে আবারও পরিবর্তিত তথ্য আউটপুট করতে হবে।

আপনি এন ইনপুট পাবেন 0 < N < 10যেখানে প্রতিটি সংখ্যা সীমার মধ্যে চলে-1000 < X < 1000

পরীক্ষার কেস

1 5 -3 2 9   -> 1 -7 -3 2 9
-5 -1 -6 5 8 -> -5 -10 -7 -3 8
-8 1 -7 1 1  -> -8 -16 -16 -8 1
8 -9 3 0 -2  -> 8 -9 -12 -14 -2
-5 -2 -5 5 0 -> -5 -10 -13 -10 0
-1 9 -1 -7 9 -> -1 -11 -17 -7 9

মন্তব্য

code-golf  array-manipulation  sorting  integer 
— ATaco
সূত্র
2
আইএমও আপনার দ্বিতীয় শিরোলেখটি সরিয়ে ফেলতে হবে (পোস্টের শিরোনামে একটি)। এটি কুরুচিপূর্ণ এবং কেবল স্থান গ্রহণ করে এবং এটি শিরোনামের একটি অনুলিপি (যা এটির উপরে 20 পিক্সেলের মতো)।
— আর

উত্তর:

3

গণিত, 40 বাইট

FoldList[Plus,#&@@#,Sort@Differences@#]&

খাঁটি ফাংশন ইনপুট হিসাবে (যে কোনও স্থানে) একটি তালিকা নেওয়া এবং একটি তালিকা ফেরত। FoldList[Plusএকটি সংখ্যা দিয়ে শুরু হয় (এই ক্ষেত্রে, #&@@#ইনপুটটির প্রথম উপাদান) এবং বার বার স্ব-বর্ণনামূলক তালিকার উপাদান যুক্ত করে Sort@Differences@#। এটি অন্তর্নির্মিতের আচরণের অনুকরণ করে Accumulate, তবে প্রথম সংখ্যাটি হাত দ্বারা পার্থক্যের তালিকায় প্রেনড করা দরকার যা বাইট-কাউন্টকে আরও উচ্চতর করে তোলে (যতদূর আমি বলতে পারি)।

— গ্রেগ মার্টিন
সূত্র
2

পাইথন 2, 92 বাইট

l=input();p=0;d=[]
r=l[0],
for e in l:d+=e-p,;p=e
for e in sorted(d[1:]):r+=r[-1]+e,
print r
— orlp
সূত্র
2

হাস্কেল, 59 বাইট

import Data.List
f l@(a:b)=scanl1(+)$a:(sort$zipWith(-)b l)

ভাঙ্গন:

f l@(a:b) =           --we create a function f that takes as input a list l with head a and tail b
zipWith(-)b l        --we make a new list with the deltas
sort$                    --sort it
a:                          --prepend a to the list
scanl1(+)$          --create a new list starting with a and adding the deltas to it cumulatively
— জেনেরিক প্রদর্শনের নাম
সূত্র
2
scanl(+)a$sort...
— নিমি
2

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

([p,...a])=>[s=p,...a.map(e=>p-(p=e)).sort((a,b)=>b-a).map(e=>s-=e)]

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

— নিল
সূত্র
2

পাইথন 2 ,

90 বাইট

x=input()
print[sum(sorted(map(int.__sub__,x[1:],x[:-1]))[:i])+x[0]for i in range(len(x))]

84 বাইট

ল্যাম্বডা ব্যবহারে 6 বাইট সংরক্ষণ করা হয়েছে। ওভসকে ধন্যবাদ!

lambda x:[sum(sorted(map(int.__sub__,x[1:],x[:-1]))[:i])+x[0]for i in range(len(x))]

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

কোডটি ভেঙে দেওয়া,

>>> x
[1, 5, -3, 2, 9]
>>> map(int.__sub__,x[1:],x[:-1]) #delta
[4, -8, 5, 7]
>>> sorted(map(int.__sub__,x[1:],x[:-1])) #sorted result
[-8, 4, 5, 7]
>>> [sorted(map(int.__sub__,x[1:],x[:-1]))[:i]for i in range(len(x))]
[[], [-8], [-8, 4], [-8, 4, 5], [-8, 4, 5, 7]]
>>> [sum(sorted(map(int.__sub__,x[1:],x[:-1]))[:i])+x[0]for i in range(len(x))]
[1, -7, -3, 2, 9]

শুভ কোডিং!

— কীর্তন প্রভাকরণ
সূত্র
আমি এটির মতো উপায় করার চেষ্টা করছিলাম!
— কুইন্টোপিয়া
1
এটিকে একটি ফাংশনে রূপান্তর করে আপনি কিছু বাইট সংরক্ষণ করতে পারেন:lambda x:[sum(sorted(map(int.__sub__,x[1:],x[:-1]))[:i])+x[0]for i in range(len(x))]
— ওভস
1

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

(p,M=[p[0]])=>p.map((a,b)=>p[b+1]-a).sort((a,b)=>a-b).map((a,b)=>M=[...M,M[b]+a])[p.length-2]
— আর কাপ
সূত্র
1

পাইথ, 11 বাইট

.u+NYS.+QhQ

এটি কেবল বিবৃতিতে বর্ণিত সুস্পষ্ট জিনিসটি করে।

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

      .+Q    Take the deltas of the input
     S       sort it
.u           Cumulative reduce
  +NY        using addition
         hQ  starting with the first element of the input

আরও গল্ফ স্বাগত জন্য পরামর্শ।

— quintopia
সূত্র
1

পিএইচপি, 89 বাইট

for($a=$argv;n|$i=$a[++$x+1];)$d[]=$i-$a[$x];for(sort($d);$x-$y++;)echo$a[1]+=$d[$y-2],_;

এভাবে চালান:

php -nr 'for($a=$argv;n|$i=$a[++$x+1];)$d[]=$i-$a[$x];for(sort($d);$x-$y++;)echo$a[1]+=$d[$y-2],",";' 1  5 -3  2  9;echo
> 1_-7_-3_2_9_

ব্যাখ্যা

for(
  $a=$argv;          # Set input to $a.
  n | $i=$a[++$x+1]; # Iterate over input.
)
  $d[] = $i-$a[$x];  # Add an item to array $d, with the difference between
                       the current and previous item.

for(
  sort($d);          # Sort the delta array.
  $x-$y++;           # Loop as many times as the previous loop.
)
  echo
    $a[1]+=$d[$y-2], # Print the first input item with the delta applied
                     # cumulatively. First iteration takes $d[-1], which
                     # is unset, so results in 0.
    _;               # Print underscore as separator.
— aross
সূত্র
1

পাইপথন 2 সাথে নাম্পি, 67 56 বাইট

from numpy import*
lambda l:cumsum(l[:1]+sorted(diff(l)))

নিম্পি ডেল্টাসগুলি গণনা করুন, সেগুলি বাছাই করুন, প্রথম উপাদানটি পুনরায় পরিবেশন করুন, এবং আঙ্গুলের সংখ্যার অঙ্কগুলি গণনা করুন। বেশ সস্তা?

— quintopia
সূত্র
1
করতে ইম্পোর্ট পরিবর্তন করে 3 বাইট সংরক্ষণ from numpy import*এবং n.cumsumকরতে cumsumএবং n.diffকরতেdiff
— ovs
ধন্যবাদ। আমি স্ট্যান্ডার্ড সমস্ত কৌশলগুলি ভুলে অজগরটি গল্ফ করেছিলাম এর পরে আপনি বলতে পারেন।
— কুইন্টোপিয়া
0

পার্ল 6 , 31 বাইট

{[\+] @_[0],|sort @_[1..*]Z-@_}

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

সম্প্রসারিত:

{
  [\+]            # triangle produce values using &infix<+>
    @_[0],        # starting with the first argument
    |             # slip the following into this list
      sort        # sort the following

         # generate the list of deltas

         @_[1..*] # the arguments starting with the second one
         Z[-]     # zipped using &infix:<->
         @_       # the arguments
}
— ব্র্যাড গিলবার্ট বি 2 গিলস
সূত্র
0

ব্যাচ, 197 বাইট

@set n=%1
@set s=
:l
@set/ad=5000+%2-%1
@set s=%s% %d%
@shift
@if not "%2"=="" goto l
@echo %n%
@for /f %%a in ('"(for %%b in (%s%)do @echo %%b)|sort"') do @set/an+=%%a-5000&call echo %%n%%

sort সংখ্যা অনুসারে বাছাই করে না, তাই আমি 5000 এর দ্বারা সমস্ত পার্থক্যকে পক্ষপাত করি।

— নিল
সূত্র
0

বাশ + সাজান, ১০২ বাইট

echo $1
n=$1
shift
for e in $*
do
echo $((e-n))
n=$e
done|sort -n|while read e
do
echo $((n+=e))
done

sh + সাজানো + এক্সপ্রেস, 106 বাইট

echo $1
n=$1
shift
for e in $*
do
expr $e - $n
n=$e
done|sort -n|while read e
do
n="$n + $e"
expr $n
done
— নিল
সূত্র
0

Clojure, 46 বাইট

#(reductions +(first %)(sort(map -(rest %)%)))

একদিন আমি ক্লজর ভাষা তৈরি করতে যাচ্ছি যার ক্লোজারের চেয়ে কম ফাংশন নাম রয়েছে।

— NikoNyrh
সূত্র
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.