অর্ধেকের মধ্যে একটি তালিকা ভাঁজ করুন

24

আমরা পূর্ণসংখ্যার একটি তালিকা ভাঁজ করতে যাচ্ছি। এটি করার পদ্ধতিটি নিম্নরূপ: তালিকাটি যদি দৈর্ঘ্যের দৈর্ঘ্যের হয় তবে তার দৈর্ঘ্যের অর্ধেকের একটি তালিকা তৈরি করুন যেখানে নতুন তালিকার নবম আইটেমটি পুরানো তালিকার নবম আইটেমের যোগফল এবং নবম থেকে টু- পুরানো তালিকার শেষ আইটেম। উদাহরণস্বরূপ যদি আমরা তালিকা ছিল

[1 2 3 4 5 6 7 8]

আমরা এটি যেমন ভাঁজ হবে

 [8 7 6 5]
+[1 2 3 4]
__________
 [9 9 9 9]

যদি তালিকাটি বিজোড় দৈর্ঘ্যের হয়, এটিকে ভাঁজ করার জন্য আমরা প্রথমে মাঝারি আইটেমটি সরিয়ে ফেলব, এটিকে ভাঁজ করব যেন এটি সমান এবং ফলাফলটি মধ্যবর্তী আইটেমটি সংযোজন করে।

উদাহরণস্বরূপ যদি আমরা তালিকা ছিল

[1 2 3 4 5 6 7]

আমরা এটি যেমন ভাঁজ হবে

 [7 6 5]
+[1 2 3]
__________
 [8 8 8]
++     [4]
__________
 [8 8 8 4]

কার্য

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

এটি একটি কোড-গল্ফ প্রশ্ন তাই উত্তরগুলি বাইটে স্কোর করা হবে, কম বাইট আরও ভাল।

নমুনা বাস্তবায়ন

এখানে হাসকেলে একটি প্রয়োগ রয়েছে যা একটি ফাংশন সংজ্ঞা দেয় fযা একটি ভাঁজ সম্পাদন করে।

f(a:b@(_:_))=a+last b:f(init b)
f x=x

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

code-golf  array-manipulation 
— গম উইজার্ড
সূত্র
আপনি যখন পূর্ণসংখ্যা বলবেন, এর মধ্যে শূন্য বা নেতিবাচক পূর্ণসংখ্যার অন্তর্ভুক্ত?
— নীল
1
@ নীল হ্যাঁ এটি করে।
— গম উইজার্ড
2
@ গ্রজেগোর্জপুয়াউস্কি আপনার তালিকাটি বাছাই করা উচিত নয়। যে কোনও অর্ডার করা সংগ্রহ অনুমোদিত, যেমন ভেক্টর বা অ্যারে।
— গম উইজার্ড
1
@ ডেভিডস্টারকি সর্বাধিক যুক্তিসঙ্গত তালিকা যুক্তিসঙ্গত পরিমাণে মেমরির সাথে উপচে পড়বে না। ভাঁজটি প্রকৃতপক্ষে যোগফল বাড়ায় না তাই তালিকাগুলি মূল তালিকার যোগের একক সিলেটে রূপান্তর করবে।
— গম উইজার্ড
2
@ ওয়েট উইজার্ড আমি সে সম্পর্কে জানি না, আমি শুনেছি যে কোনও তালিকা 7 বারের চেয়ে অর্ধেকেরও বেশি ভাঁজ করা অসম্ভব।
— Carmeister 4

উত্তর:

9

পাইথন , 46 বাইট

f=lambda l:l[1:]and[l[0]+l[-1]]+f(l[1:-1])or l

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

একই দৈর্ঘ্য:

f=lambda l:l[1:]and[l.pop(0)+l.pop()]+f(l)or l

একটি আরও সংক্ষিপ্ত সমাধান সম-দৈর্ঘ্যের তালিকার জন্য কাজ করে (30 বাইট)

lambda l:[x+l.pop()for x in l]

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

আমি এখনও বিজোড় দৈর্ঘ্যের জন্য এটি সংশোধন করার জন্য একটি ছোট উপায় সন্ধান করার চেষ্টা করছি।

— xnor
সূত্র
ওহ, আমি মারাত্মকভাবে ছড়িয়ে পড়েছি ÷ _ ÷
— মিঃ এক্সকোডার
"মাঝের স্থল" সমাধানটিও f=lambda l:l[1:]and[l[0]+l.pop()]+f(l[1:])or lএকই দৈর্ঘ্য ...
— ETH প্রোডাকশনগুলি
8

ইমোজিকোড , 203 বাইট

🐋🍨🍇🐖🔢🍇🔂i⏩0➗🐔🐕2🍇😀🔡➕🍺🔲🐽🐕i🚂🍺🔲🐽🐕➖🐔🐕➕1i🚂10🍉🍊😛1🚮🐔🐕2🍇😀🔡🍺🔲🐽🐕➗🐔🐕2🚂10🍉🍉🍉

এটি ছিল আমার জন্য কোডের সবচেয়ে বেদনাদায়ক ইমোজিকোড উত্তর। অপ্রয়োজনীয় দৈর্ঘ্য: /

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

— betseg
সূত্র
4

জাপট , 21 18 16 বাইট


l
íUj°V/2V w)mx

এটি অনলাইন পরীক্ষা!

সম্পূর্ণরূপে ভয়ঙ্কর @ অলিভারকে সামান্য কম ভয়ঙ্কর ধন্যবাদ । আমি আরও বিল্ট-ইনগুলি প্রয়োগ করার পরে এবং কিছু বাগগুলি ঠিক করার পরে বিআরবি ...

— ETHproductions
সূত্র
2

গণিত, 88 বাইট

(d=Array[s[[#]]+s[[-#]]&,x=⌊t=Length[s=#]/2⌋];If[IntegerQ@t,d,d~AppendTo~s[[x+1]]])&
— J42161217
সূত্র
2

গণিত 57 বাইট

(#+Reverse@#)[[;;d-1]]&@Insert[#,0,d=⌈Length@#/2⌉+1]&

মিডপয়েন্টে একটি শূন্য প্রবেশ করান, তালিকাটিকে তার বিপরীতে যুক্ত করে এবং উপযুক্ত দৈর্ঘ্য নেয় takes

— কেলি লোদার
সূত্র
2

জেলি , 7 বাইট

œs2U2¦S

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

-২ ইটিএইচ প্রডাকশনগুলিকে ... এবং আমাকে আগে উপলব্ধি করে ধন্যবাদ ।

— এরিক দ্য আউটগল্ফার
সূত্র
ETH ঠিক ছিল, 7 বাইট
— মিস্টার এক্সকোডার
@ ইথ প্রডাকশনস ধন্যবাদ, যদিও আমি আমার কম্পিউটারটি বন্ধ করার পরে ইতিমধ্যে আবিষ্কার করেছি।
— এরিক আউটগল্ফার
1

এমএটিএল , 9 বাইট

`6L&)swtn

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

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

একটি অ্যারে দেওয়া [a b c ... x y z], আসুন [a z]"ক্রাস্ট" সুবরে এবং [b c ... y z]"কোর" সুব্রেরি বলা যাক।

কোডটি একটি লুপের মধ্যে থাকে যা ভূত্বককে সরিয়ে দেয়, এর যোগফলকে গণনা করে এবং মূলটিকে স্ট্যাকের শীর্ষে নিয়ে যায়, পরবর্তী পুনরাবৃত্তির জন্য প্রস্তুত। লুপ শর্তটি মূল সুবরেতে উপাদানগুলির সংখ্যা

`       % Do...while
  6L    %   Push [2 -1+1j]. As an index, this is interpreted as 2:end-1
  &)    %   2-output reference indexing: pushes a subarray with the indexed 
        %   elements (core) and another with the ramaining elements (crust)
  s     %   Sum of (crust) subarray
  w     %   Swap. Moves the core subarray to the top
  t     %   Duplicate
  n     %   Number of elements.
        % End (implicit). Procced with next iteration if top of the stack is
        % nonzero; else exit
        % Display stack (implicit)
— লুইস মেন্ডো
সূত্র
1

সি # (.নেট কোর) , 118 111 বাইট

a=>a.Reverse().Zip(a,(c,d)=>c+d).Take(a.Length/2).Concat(a.Skip(a.Length/2).Take(a.Length%2))

বাইট গণনা অন্তর্ভুক্ত

using System.Linq;

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

ইনপুট হিসাবে দয়া করে কমা ( ,) বা স্পেস দিয়ে পৃথক করা নম্বরগুলি ব্যবহার করুন । ব্যাখ্যা:

a =>                                  // Take one input parameter (array)
a.Reverse()                           // Reverse it
.Zip(a, (c, d) => c + d)              // Take every corresponding member of reversed
                                      //    and original, and add them together
.Take(a.Length / 2)                   // Get first half of the collection
.Concat(                              // Add another collection
    a.Skip(a.Length / 2)              // Take input and leave out first half of it
    .Take(a.Length % 2)               // If length is odd, take first element (so the middle)
                                      //    otherwise create an empty collection
);
— গ্রেজগোর্জ পুয়াওস্কি
সূত্র
আপনি একটি পরিবর্তনশীল দৈর্ঘ্য সেট করে এবং একটি সুস্পষ্ট রিটার্নে স্যুইচ করে বাইটস সংরক্ষণ করতে পারেন?
— TheLethalCoder
@TheLethalCoder দুর্ভাগ্যবশত এটা দীর্ঘ হওয়ার
— Grzegorz Puławski
1

পার্ল, 42 38 টি অক্ষর

সাব এফ {@ এ = ম্যাপ {$ + পপ} স্প্লাইস @ , 0, @ / 2; @ এ, @ } 

sub f{(map{$_+pop}splice@_,0,@_/2),@_}

উদাহরণস্বরূপ যেমন চেষ্টা করুন:

perl -e 'my @input=(1..9); sub f{(map{$_+pop}splice@_,0,@_/2),@_}  print join(",",f(@input));
— bytepusher
সূত্র
1
ভেরিয়েবলের সাথে আমার সংবেদনশীল এবং পেশাদার সংযুক্তির কারণে কমে যাওয়া একটি ত্রুটি স্থির করে। জেএস দ্বারা আউটগল্ফড হতে অস্বীকার করুন: পি
— বাইটপুশার
1

পাইথ, 18 17 13 বাইট

V.Tc2Q aYsN;Y

আমার আসল পন্থা ছিল

WtQ aY+.)Q.(Q0;+Y

-১ বাইট মিঃ এক্সকোডারকে ধন্যবাদ

-4 বাইট ধন্যবাদ FryAmTheEggman ধন্যবাদ

— ডেভ
সূত্র
c2<list>অর্ধেকের মধ্যে একটি তালিকা বিভক্ত করার চেষ্টা করুন । আর একটি কমান্ড যা কার্যকর হতে পারে .T।
— FryAmTheEggman
17 বাইট:WtQ aY+.)Q.(Q0;+Y
— মিঃ এক্সকডার
1

সি ++ 17, 75 73 71 বাইট

নামবিহীন ল্যাম্বদা হিসাবে, একটি ধারক গ্রহণ vectorবা এর মতো গ্রহণ listকরে ইনপুটটি সংশোধন করে ফেরত দেয়:

[](auto&L){for(auto a=L.begin(),b=L.end();a<--b;L.pop_back())*a+++=*b;}

সুপরিচিত 'Go-to' অপারেটর <--এবং ট্রিপল প্লাস ব্যবহার করে+++

অসম্পূর্ণ এবং উদাহরণ:

#include<iostream>
#include<vector>

using namespace std;

auto f=
[](auto&L){
 for(
  auto a=L.begin(),b=L.end();
  a<--b;
  L.pop_back()
 )
 *a+++=*b;
}
;

void test(auto L) {
 for(auto x:L)cout << x << ", ";
 cout << endl;
 f(L);
 for(auto x:L)cout << x << ", ";
 cout << endl << endl;
}

int main() { 
 vector<int> A = {1,2,3,4,5,6,7,8}, B = {1,2,3,4,5,6,7};
 test(A);
 test(B);
}
— কার্ল ন্যাপ
সূত্র
1

এপিএল (ডায়ালগ ইউনিকোড) , 21 বাইট এসবিসিএস

-3 বাইটস @ অ্যাডমকে ধন্যবাদ

(⌊2÷⍨≢)(↑{+⌿↑⍺⍵}∘⌽↓)⊢

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

ব্যাখ্যা:

(⌊2÷⍨≢)(↑{+⌿↑⍺⍵}∘⌽↓)⊢  ⍝ Monadic function train
(⌊2÷⍨≢)                  ⍝ Left portion:
     ≢                   ⍝ Take the length of the input...
  2÷⍨                    ⍝ Divide it by two...
 ⌊                       ⍝ And floor it. This gives our midpoint index. Call it "X"
                      ⊢  ⍝ Right portion: return the original input. Call it "Y"
       (↑{+⌿↑⍺⍵}∘⌽↓)   ⍝ Midddle portion: takes X and Y as arguments
        ↑           ↓    ⍝ Take and drop Y by X. Essentially splits Y in half
                         ⍝ Presents the two halves to the next function
                 ∘⌽     ⍝ Reverse the second half
         {+⌿↑⍺⍵}       ⍝ Final function, takes first half and reversed second half
              ⍺⍵        ⍝ Construct a nested list of first and second halves...
             ↑          ⍝ ...and "mix" them into a matrix. Has the nice property that
                        ⍝ it will pad the first half with a zero if needed.
          +⌿           ⍝ Sum the matrix along the columns, return resulting vector
— voidhawk
সূত্র
ডায়ালগ বর্ধিত, 18 বাইট:+⌿(⌊2÷⍨≢)(↑↑⍮⌽⍤↓)⊢
— এডম
প্রশিক্ষণ, 21 বাইট: (⌊2÷⍨≢)(↑{+⌿↑⍺⍵}∘⌽↓)⊢`
— অ্যাডাম
0

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

f=(a,[b,...c]=a)=>c+c?[b+c.pop(),...f(c)]:a

কোড স্নিপেট দেখান

আসফের অনুপ্রেরণায় 3 বাইট সংরক্ষণ করা হয়েছে ।

— নিল
সূত্র
খুশী হলাম। আপনি 2 বাইট সংরক্ষণ করতে '1 / c [0]' থেকে '[] + সি' এ পরিবর্তন করতে পারেন।
— আসফ
@ আসফ আসলে আমার মনে c+cহয় তৃতীয় বাইটের জন্য কাজ করে।
— নীল
0

জাভা 8, 93 বাইট

দ্বিগুণ! এটি একটি ল্যাম্বদা যা একটি নেয় int[]এবং একটি প্রদান করে int[]।

l->{int n=l.length,i=0;for(;i<n/2;)l[i]+=l[n-++i];return java.util.Arrays.copyOf(l,n/2+n%2);}

অবহেলিত ল্যাম্বদা

l -> {
    int n = l.length, i = 0;
    for (; i < n / 2; )
        l[i] += l[n - ++i];
    return java.util.Arrays.copyOf(l, n / 2 + n % 2);
}

বেশ সোজা। এটি দ্বিতীয়ার্ধটিকে ইনপুটটির প্রথমার্ধে ভাঁজ করে এবং ঠিক প্রথম অর্ধের একটি অনুলিপি দেয়।

আশ্চর্যজনকভাবে, রিটার্নের বিবৃতিতে অ্যারের অনুলিপিটি বিজোড়-দৈর্ঘ্যের ইনপুটগুলির জন্য চূড়ান্ত উপাদানটির চিকিত্সাটি পরিচালনা করার সবচেয়ে সহজ উপায় বলে মনে হয়।

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