চ্যালেঞ্জ

পূর্ণসংখ্যার একটি খালি খালি অ্যারে দেওয়া, যেমন:

[5, 2, 7, 6, 4, 1, 3]

প্রথমে এটি অ্যারেগুলিতে বিভক্ত করুন যেখানে কোনও আইটেম আগেরটির চেয়ে বড় নয় (যেমন অ-আরোহিত অ্যারে):

[5, 2] [7, 6, 4, 1] [3]

পরবর্তী, প্রতিটি অ্যারে বিপরীত:

[2, 5] [1, 4, 6, 7] [3]

অবশেষে, তাদের সবাইকে একত্রিত করুন:

[2, 5, 1, 4, 6, 7, 3]

আপনার প্রোগ্রাম আউটপুট / ফাংশনটি কী দেয় তা এটাই হওয়া উচিত। এই পদ্ধতিটি পর্যাপ্ত সময় পুনরাবৃত্তি করুন এবং অ্যারের সম্পূর্ণরূপে বাছাই করা হবে।

বিধি

ইনপুট এবং আউটপুট যে কোনও মানক পদ্ধতির মাধ্যমে দেওয়া যেতে পারে এবং কোনও যুক্তিসঙ্গত অ্যারে ফর্ম্যাটে হতে পারে।
ইনপুট অ্যারে কখনই খালি হবে না তবে এতে নেতিবাচক এবং / বা সদৃশগুলি থাকতে পারে।
প্রতিটি পূর্ণসংখ্যার পরম মান সর্বদা 2 ^{31 এর} চেয়ে কম হবে ।

পরীক্ষার মামলা

আশা করি এগুলি সমস্ত প্রান্তের কেসগুলি কভার করে:

[1] -> [1]
[1, 1] -> [1, 1]
[1, 2] -> [1, 2]
[2, 1] -> [1, 2]
[2, 3, 1] -> [2, 1, 3]
[2, 1, 3] -> [1, 2, 3]
[2, 1, 2] -> [1, 2, 2]
[2, 1, 1] -> [1, 1, 2]
[3, 1, 1, 2] -> [1, 1, 3, 2]
[3, 2, 1, 2] -> [1, 2, 3, 2]
[3, 1, 2, 2] -> [1, 3, 2, 2]
[1, 3, 2, 2] -> [1, 2, 2, 3]
[1, 0, 5, -234] -> [0, 1, -234, 5]
[1, 0, 1, 0, 1] -> [0, 1, 0, 1, 1]
[1, 2, 3, 4, 5] -> [1, 2, 3, 4, 5]
[5, 4, 3, 2, 1] -> [1, 2, 3, 4, 5]
[2, 1, 5, 4, 3] -> [1, 2, 3, 4, 5]
[2, 3, 1, 5, 4] -> [2, 1, 3, 4, 5]
[5, 1, 4, 2, 3] -> [1, 5, 2, 4, 3]
[5, 2, 7, 6, 4, 1, 3] -> [2, 5, 1, 4, 6, 7, 3]
[-5, -2, -7, -6, -4, -1, -3] -> [-5, -7, -2, -6, -4, -3, -1]
[14, 5, 3, 8, 15, 7, 4, 19, 12, 0, 2, 18, 6, 11, 13, 1, 17, 16, 10, 9] -> [3, 5, 14, 8, 4, 7, 15, 0, 12, 19, 2, 6, 18, 11, 1, 13, 9, 10, 16, 17]

স্কোরিং

এটি কোড-গল্ফ , তাই বাইটের মধ্যে সংক্ষিপ্ততম কোডটি জয়ী।

code-golf array-manipulation sorting

— ETHproductions
সূত্র

4

এই বাছাই পদ্ধতির বড়-ও কী?

— mbomb007

1

@ mbomb007 আমি বিগ-ও স্বরলিপিটি খুব ভালভাবে বুঝতে পারি না তবে আমি মনে করি একটি একক পুনরাবৃত্তি হ'ল হে (এন)। সবচেয়ে খারাপ ক্ষেত্রে n পুনরাবৃত্তির দ্বারা এটি গুণ করুন এবং আপনি O (n ^ 2) পান (সবচেয়ে খারাপ ক্ষেত্রে; সেরা-কেস হবে O (n), আমি মনে করি, একক পুনরাবৃত্তির জন্য)।

— ETH প্রোডাকশনগুলি

1

যে আমার অধিকার শব্দ, কিন্তু এটা যে ইশারা একটি অ্যারের reversing একটি খুব দক্ষ অপারেশন নয় তাই এটি একটি মন্থর এর মূল্যO(n^2)

— DJMcMayhem

2

@ ওয়েট উইজার্ড অ্যারেটিকে বিপরীত করতে অ্যারের অনুলিপিটির জন্য জায়গা প্রয়োজন নেই, কেবল একটি একক উপাদানের জন্য কক্ষের প্রয়োজন। এবং হয় O(n)। প্রথম এবং শেষ উপাদানগুলি অদলবদল করুন এবং তারপরে দ্বিতীয় এবং দ্বিতীয় শেষ উপাদানগুলি অদলবদল করুন, যখন আপনি মাঝের স্টপটিতে পৌঁছবেন।

— জেসেন

O(n)বিপরীত হয় , কিন্তু বিপরীত সরাসরি আলগোরিদিম মধ্যে নির্মিত যেতে পারে (আমার জেএস উত্তর এটি কি); যেহেতু প্রতিটি পুনরাবৃত্তি অ্যারেতে প্রতিটি আইটেমের উপরে একবার লুপ করে, তাই একক পুনরাবৃত্তি হয় O(n)। (আমি মনে করি ...)

— ইটিএইচ প্রোডাকশনগুলি

19

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

f=([n,...a],z=[],q=[n,...z])=>a+a?n<a[0]?[...q,...f(a)]:f(a,q):q

পুনরাবৃত্তি এফটিডাব্লু! এখানে ব্যবহৃত প্রাথমিক অ্যালগরিদম হ'ল একটি অ্যারে বর্তমান অ-আরোহী রানের ট্র্যাক রাখা, যখনই একটি আরোহী উপাদান পাওয়া যায় এটি "ফিরিয়ে দেওয়া"। আমরা আইটেমগুলি শেষ না হওয়া অবধি ধারাবাহিকভাবে ফলাফলগুলিকে সমালোচনা করে আসছি do বিপরীতে প্রতিটি রান তৈরি করে ( [n,...z]পরিবর্তে [...z,n]), আমরা .reverse()বিনা ব্যয়ে দীর্ঘ এড়াতে পারি ।

পরীক্ষার স্নিপেট

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

f=([n,...a],z=[],q=[n,...z])=>a+a?n<a[0]?[...q,...f(a)]:f(a,q):q

g=a=>console.log("Input:",`[${a}]`,"Output:",`[${f(a)}]`)

g([1])
g([1,1])
g([1,2])
g([2,1])
g([3,2,1])
g([3,1,2])
g([3,1,1,2])
g([5,2,7,6,4,1,3])

<input id=I value="5, 2, 7, 6, 4, 1, 3">
<button onclick="g((I.value.match(/\d+/g)||[]).map(Number))">Run</button>

Expand snippet

— ETHproductions
সূত্র

আপনার অ্যারে কীভাবে আপনার প্রথম প্যারামিটারে পার্স হয় তা আপনি ব্যাখ্যা করতে পারেন [n,...a]। কী n? এটি কি আপনার অ্যারের মধ্যে প্রথম আইটেম?

— অলিভার

1

@ ওবরকন সঠিক nঅ্যারের মধ্যে প্রথম আইটেম এবং অ্যারের aবাকী অংশ। আপনি এখানে আরও তথ্য পেতে পারেন ।

— ইটিএইচ প্রডাকশনগুলি

ধন্যবাদ. এটা খুব সহায়ক ছিল। যেহেতু আপনার প্রথম প্যারামিটারটি একটি অ্যারে, তাই আপনাকে কেন অন্তর্ভুক্ত করা দরকার ...a? এটি কি তাই আপনি সুবিধা নিতে পারেন n? আরও একটি জিনিস, আপনি কল যখন f(a,q), নেই qপ্যারামিটার সেট করুন z?

— অলিভার

1

@ ওবরকন ওয়েল, f=([n])=>...কেবলমাত্র প্রথম উপাদানটি f=([n,a])=>...ক্যাপচার করবে এবং কেবল প্রথমটি nএবং দ্বিতীয়টি ক্যাপচার করবে a। কী f=([n,...a])=>,,,করবে তা করার আরেকটি উপায় f=a=>(n=a.unshift(),...।

— ETH প্রোডাকশনগুলি

1

এবং যেহেতু zফাংশনটির দ্বিতীয় প্যারামিটারটি f(a,q)বলা হয় , যখন এটি ডাকা fহয় z। আশাকরি এটা সাহায্য করবে!

— ETH প্রোডাকশনগুলি

14

পাইথন 3 , 63 বাইট

f=lambda x,*p:x[:1]>p>()and p+f(x)or x and f(x[1:],x[0],*p)or p

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

— ডেনিস
সূত্র

11

জেলি , 8 বাইট

Ṁ;<œṗ³UF

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

ব্যাখ্যা:

Ṁ;         Prepend the list [a1, a2… an] with its maximum.
  <        Elementwise compare this with the original list:
           [max(a) < a1, a1 < a2, …, a(n-1) < an, an]
           The first element is always 0.
   œṗ³     Partition the original list (³) at the indices
           of the non-zero values in the working list.
           (The spurious `an` at the end of the left argument,
           resulting from comparing lists of different sizes,
           is ignored by this operation, thankfully.)
      U    Reverse each part.
       F   Flatten.

— লিন
সূত্র

1

আমি যখন আপনার উত্তরটি দেখেছি তখন সম্পাদনাগুলি সংরক্ষণ করুন ting

— ডেনিস

@ ডেনিস হে, তাই আপনি ডায়ালগকে পার্টিশনযুক্ত এনক্লো যুক্ত করেছেন, তবে এপিএল 2 পার্টিশনের কী হবে?

— অ্যাডম

11

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

অবশ্যই, এটি ইতিমধ্যে ইটিএইচ প্রডাকশনগুলির উত্তর দ্বারা পরাজিত হয়েছে , তবে এটি পুনরাবৃত্তি না ব্যবহার করে আমি এ পর্যন্ত সেরা আসতে পেরেছি।

a=>a.map((n,i)=>a[x=[...o,...r=[n,...r]],i+1]>n&&(o=x,r=[]),r=o=[])&&x

নোট: উভয় আরম্ভ করা rএবং oসঙ্গে সঠিক একই বস্তু r = o = []একটি বিপজ্জনক ধারণা মত হতে পারে। তবে এখানে এটি করা নিরাপদ কারণ সাথে সাথে প্রথম পুনরাবৃত্তির সাথে rঅবিলম্বে তার নিজস্ব উদাহরণ (প্রথম উপাদান যুক্ত a) অর্পণ করা হয়েছে r = [n, ...r]।

পরীক্ষার মামলা

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

let f =

a=>a.map((n,i)=>a[x=[...o,...r=[n,...r]],i+1]>n&&(o=x,r=[]),r=o=[])&&x

console.log(JSON.stringify(f([1])));
console.log(JSON.stringify(f([1, 1])));
console.log(JSON.stringify(f([1, 2])));
console.log(JSON.stringify(f([2, 1])));
console.log(JSON.stringify(f([2, 3, 1])));
console.log(JSON.stringify(f([2, 1, 3])));
console.log(JSON.stringify(f([2, 1, 2])));
console.log(JSON.stringify(f([2, 1, 1])));
console.log(JSON.stringify(f([3, 1, 1, 2])));
console.log(JSON.stringify(f([3, 2, 1, 2])));
console.log(JSON.stringify(f([3, 1, 2, 2])));
console.log(JSON.stringify(f([1, 3, 2, 2])));
console.log(JSON.stringify(f([1, 0, 5, -234])));
console.log(JSON.stringify(f([1, 0, 1, 0, 1])));
console.log(JSON.stringify(f([1, 2, 3, 4, 5])));
console.log(JSON.stringify(f([5, 4, 3, 2, 1])));
console.log(JSON.stringify(f([2, 1, 5, 4, 3])));
console.log(JSON.stringify(f([2, 3, 1, 5, 4])));
console.log(JSON.stringify(f([5, 1, 4, 2, 3])));
console.log(JSON.stringify(f([5, 2, 7, 6, 4, 1, 3])));
console.log(JSON.stringify(f([-5, -2, -7, -6, -4, -1, -3])));
console.log(JSON.stringify(f([14, 5, 3, 8, 15, 7, 4, 19, 12, 0, 2, 18, 6, 11, 13, 1, 17, 16, 10, 9])));

স্নিপেট প্রসারিত করুন

— Arnauld
সূত্র

2

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

— ইটিএইচ প্রোডাকশন

8

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

lidO>vYsGhXSOZ)

ইনপুটটি একটি কলাম ভেক্টর, ফর্ম্যাট সহ [5; 2; 7; 6; 4; 1; 3](সেমিকোলনটি সারি বিভাজক)।

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

[5; 2; 7; 6; 4; 1; 3]উদাহরণ হিসাবে ইনপুট নিন ।

ব্যাখ্যা

l     % Push 1
      % STACK: 1
i     % Push input
      % STACK: 1, [5; 2; 7; 6; 4; 1; 3]
d     % Consecutive differences
      % STACK: 1, [-3; 5; -1; -2; -3; 2]
O>    % Test if greater than 0, element-wise
      % STACK: 1, [0; 1; 0; 0; 0; 1]
v     % Concatenate vertically
      % STACK: [1; 0; 1; 0; 0; 0; 1]
Ys    % Cumulative sum
      % STACK: [1; 1; 2; 2; 2; 2; 3]
G     % Push input again
      % STACK: [1; 1; 2; 2; 2; 2; 3], [5; 2; 7; 6; 4; 1; 3]
h     % Concatenate horizontally
      % STACK: [1 5; 1 2; 2 7; 2 6; 2 4; 2 1; 3 3]
XS    % Sort rows in lexicographical order
      % STACK: [1 2; 1 5; 2 1; 2 4; 2 6; 2 7; 3 3]
OZ)   % Get last column. Implicitly display
      % STACK: [2; 5; 1; 4; 6; 7; 3]

— লুইস মেন্ডো
সূত্র

আমি আপনার উত্তরটি অষ্টাভে অনুবাদ করে আমাকে 31 বাইট বাঁচিয়েছি!

— rahnema1

7

গণিত, 30 27 বাইট

^{@ মার্টিন এেন্ডারের কারণে 3 বাইট সংরক্ষণ করা হয়েছে ।}

Join@@Sort/@Split[#,#>#2&]&

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

— LegionMammal978
সূত্র

আমাকে মার! :)

— গ্রেগ মার্টিন

5

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

সত্যিই ভয়ঙ্কর একটি গল্ফ, তবে আমি আমার সমাধানটি পোস্ট করতে চেয়েছিলাম (ডেনিস কেবল আউটগল্ফ হয় না) ...

d=input();L=[];x=0;d+=-~d[-1],
for i in range(1,len(d)):
 if d[i]>d[i-1]:L+=d[x:i][::-1];x=i
print L

Repl.it পরীক্ষা!

পাইথন তালিকার আক্ষরিক হিসাবে ইনপুট দেওয়া উচিত [5, 3, 4, 2, 6, 1]।

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

— FlipTack
সূত্র

আমি মনে করি প্রথম লাইন হতে পারে d,L,x=input(),[],0;d+=...।

— ড্যানিয়েল

@ ডপঅ্যাপ যা ঠিক একই বাইট গণনা

— ফ্লিপট্যাক

4

পাইক, 11 8 বাইট ( পুরানো সংস্করণ )

$0m<fm_s

এখানে চেষ্টা করুন! (সর্বশেষ সংস্করণে কাজ করে)

$        -     delta(input)
 0m<     -    map(i<0 for i in ^)
    f    -   split_at(input, ^)
     m_  -  map(reverse, ^)
       s - sum(^)

— নীল
সূত্র

4

রেটিনা , 163 বাইট

হ্যাঁ, আমি জানি এটি কতটা ভয়াবহ। সাপোর্টিং zeros এবং নেগেটিভ ছিল সুপার মজা। বাইট গণনাটি আইএসও 8859-1 এনকোডিং ধরেছে।

\d+
$*
(?<=-1*)1
x
-

x,1
x¶1
\b(1+),(1+\1)\b
$1¶$2
,,1
,¶1
x,(¶|$)
x¶¶
(?<=\b\1x+(?=,(x+))),\b
¶
O%$#`.(?=(.*))
$.1
+`¶
,
\bx
-x
(\w+)
$.1
^,
0,
,$
,0
,,
,0,
^$
0

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

ব্যাখ্যা:

\d+                         # Convert to unary
$*
(?<=-1*)1                   # Replace negatives with x's instead of 1's
x
-                           # Remove minus sign

x,1                         # Separate if negative before positive
x¶1
\b(1+),(1+\1)\b             # or greater positive follows a positive
$1¶$2
,,1                         # or positive follows a zero
,¶1
x,(¶|$)                     # or zero follows a negative
x¶¶
(?<=\b\1x+(?=,(x+))),\b     # or negative follows a negative of greater magnitude.
¶
O%$#`.(?=(.*))              # Swear at the input, then reverse each line
$.1
+`¶                         # Remove breaks, putting commas back
,
\bx                         # Put the minus signs back
-x
(\w+)                       # Replace unary with length of match (decimal)
$.1
^,                          # Do a bunch of replacements to resurrect lost zeros
0,
,$
,0
,,
,0,
^$
0

— mbomb007
সূত্র

4

05 এ বি 1 ই , 19 18 16 14 বাইট

লুই মেন্ডোর বাছাইয়ের কৌশলটি ব্যবহার করে 2 বাইট সংরক্ষণ করা হয়েছে

ü‹X¸ì.pO¹)ø{ø¤

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

ব্যাখ্যা

উদাহরণ ইনপুট [5, 2, 7, 6, 4, 1, 3]

ü‹               # pair-wise less-than
                 # STACK: [0, 1, 0, 0, 0, 1]
  X¸ì            # prepend a 1
                 # STACK: [1, 0, 1, 0, 0, 0, 1]
     .p          # prefixes
       O         # sum
                 # STACK: [1, 1, 2, 2, 2, 2, 3]
        ¹        # push input
                 # STACK: [1, 1, 2, 2, 2, 2, 3], [5, 2, 7, 6, 4, 1, 3]
         )       # wrap stack in list
                 # STACK: [[1, 1, 2, 2, 2, 2, 3], [5, 2, 7, 6, 4, 1, 3]]
          ø      # zip
                 # STACK: [[1, 5], [1, 2], [2, 7], [2, 6], [2, 4], [2, 1], [3, 3]]
           {     # sort
                 # STACK: [[1, 2], [1, 5], [2, 1], [2, 4], [2, 6], [2, 7], [3, 3]]
            ø    # zip
                 # STACK: [[1, 1, 2, 2, 2, 2, 3], [2, 5, 1, 4, 6, 7, 3]]
             ¤   # tail
                 # OUTPUT: [2, 5, 1, 4, 6, 7, 3]

পূর্ববর্তী 16 বাইট সমাধান

Dü‹X¸ì.pO.¡€g£í˜

— Emigna
সূত্র

এই লাইনব্রেকগুলি আশ্চর্যজনকভাবে এটি ব্যাখ্যা করেছে ... :

— স্টিভি গ্রিফিন

@ স্টিভি গ্রিফিন: হ্যাঁ, আমি কোডটি পরিবর্তন করেছি এবং আমার ব্যাখ্যাটি নতুন করে লেখার আগে পোস্ট করেছি: পি

— লেখার

4

জাভাস্ক্রিপ্ট (ইসিএমএ 6), 121 128 125 119 108 বাইট

f=a=>{p=a[0],c=[],b=[];for(e of a){e>p&&b.push(c.reverse(c=[]));c.push(p=e)}return[].concat.call([],...b,c)}

লাম্বদা এক্সপ্রেশন একটি একক Arrayপ্যারামিটার নেয় a,।

আমাকে আমার প্রথম ভুল দেখতে সাহায্য করার জন্য @ ইটিএইচ প্রডাকশনসকে ধন্যবাদ।

— XavCo7
সূত্র

নিস! আমি মনে করি আপনি return(b+","+c).split`,` শেষে কিছু বাইট সংরক্ষণ করতে পারেন ।

— ETH প্রোডাকশনগুলি

1

আরও ভাল, আপনি বিপরীতে প্রয়োজনীয়তা অপসারণের c.unshiftপরিবর্তে ব্যবহার করতে পারেন । এটি করার পরে, আমি 94 বাইট পেয়েছি । c.pushc

— ETH প্রোডাকশন

3

রুবি, 60 55 বাইট

s=->x{x.slice_when{|p,q|p<q}.map{|z|z.reverse}.flatten}

চ্যালেঞ্জটি যা চেয়েছিল তা অনেকটাই। আমি একটি ল্যামডা সংজ্ঞায়িত s, যে একটি অ্যারের লাগে x, এবং Sever ছোট টুকরা যেখানে নিম্নলিখিত উপাদান তার চেয়ে অনেক বেশী হবে মধ্যে (টুকরা) এটি। এটি একটি গণককে ফিরিয়ে দেয়, যা আমরা মানচিত্রে কল করতে এবং টুকরোটির ক্রমটি বিপরীত করতে পারি, অবশেষে সমস্ত একসাথে সমতল করার আগে, যা concatenates এক অ্যারের মধ্যে সংজ্ঞায়িত অনুক্রমে উপাদান।

টেস্ট

p s[[1]]===[1]
p s[[1, 1]]===[1, 1]
p s[[1, 2]]===[1, 2]
p s[[2, 1]]===[1, 2]
p s[[2, 3, 1]]===[2, 1, 3]
p s[[2, 1, 3]]===[1, 2, 3]
p s[[2, 1, 2]]===[1, 2, 2]
p s[[2, 1, 1]]===[1, 1, 2]
p s[[3, 1, 1, 2]]===[1, 1, 3, 2]
p s[[3, 2, 1, 2]]===[1, 2, 3, 2]
p s[[3, 1, 2, 2]]===[1, 3, 2, 2]
p s[[1, 3, 2, 2]]===[1, 2, 2, 3]
p s[[1, 0, 5, -234]]===[0, 1, -234, 5]
p s[[1, 0, 1, 0, 1]]===[0, 1, 0, 1, 1]
p s[[1, 2, 3, 4, 5]]===[1, 2, 3, 4, 5]
p s[[5, 4, 3, 2, 1]]===[1, 2, 3, 4, 5]
p s[[2, 1, 5, 4, 3]]===[1, 2, 3, 4, 5]
p s[[2, 3, 1, 5, 4]]===[2, 1, 3, 4, 5]
p s[[5, 1, 4, 2, 3]]===[1, 5, 2, 4, 3]
p s[[5, 2, 7, 6, 4, 1, 3]]===[2, 5, 1, 4, 6, 7, 3]
p s[[-5, -2, -7, -6, -4, -1, -3]]===[-5, -7, -2, -6, -4, -3, -1]
p s[[14, 5, 3, 8, 15, 7, 4, 19, 12, 0, 2, 18, 6, 11, 13, 1, 17, 16, 10, 9]]===[3, 5, 14, 8, 4, 7, 15, 0, 12, 19, 2, 6, 18, 11, 1, 13, 9, 10, 16, 17]

— manonthemat
সূত্র

1

স্বাগতম, চমৎকার <s> প্রথম </s> দ্বিতীয় উত্তর, এটি দেখুন: কোডগল্ফ.স্ট্যাকেক্সেঞ্জার

— জিবি

অনেক ধন্যবাদ. আপনার প্রদত্ত লিঙ্কে পরামর্শ হিসাবে এটি একটি ল্যাম্বডায় পরিণত হয়েছে এবং সেভাবে 5 বাইট সংরক্ষণ করেছেন।

— মানোথমেট

2

ব্র্যাচল্যাগ , 10 বাইট

~c:{>=r}ac

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

ব্যাখ্যা

~c            Deconcatenate the Input
  :{>=r}a     Each resulting sublist must be non-increasing, and then reverse it
         c    Concatenate

— Fatalize
সূত্র

cবিপর্যয় চলাকালীন ব্র্যাচল্যাগগুলি কি প্রথমে কম তালিকায় বিভক্ত হওয়ার চেষ্টা করে?

@ ais523 হ্যাঁ, এটি হয়।

— 13

1

ডায়ালগ এপিএল , 7 15 বাইট

প্রয়োজনীয় ⎕ML←3, যা অনেক সিস্টেমে ডিফল্ট *

{∊⌽¨⍵⊂⍨1+⍵-⌊/⍵}

∊ তালিকাভুক্ত (সমতল)

⌽¨ প্রতিটি-বিপরীত

⍵⊂⍨ প্রতিটি সম্পর্কিত উপাদান এর পূর্বসূরীর চেয়ে বড় যেখানে কাটা দ্বারা আর্গুমেন্ট বিভাজন করা হয়েছে

1+ এক প্লাস

⍵- যুক্তি বিয়োগ

⌊/⍵ যুক্তির ক্ষুদ্রতম উপাদান

পুরাতন 7 বাইট সমাধানটি ইতিবাচক পূর্ণসংখ্যার সাথে ব্যর্থ হয়:

প্রয়োজনীয় ⎕ML←3, যা অনেক সিস্টেমে ডিফল্ট *

∊⌽¨⊆⍨⎕

∊ তালিকাভুক্ত (সমতল)

⌽¨ প্রতিটি-বিপরীত

⊂⍨ স্ব-বিভক্ত *

পার্টিশন ( ⊂) এমন একটি ফাংশন যা তার ডান আর্গুমেন্টটিকে কেটে দেয় যেখানে সম্পর্কিত বাম যুক্তি পূর্ববর্তীটির চেয়ে বড়। (দুর্ভাগ্যক্রমে এটি কেবল অ-নেতিবাচক পূর্ণসংখ্যাকে গ্রহণ করে এবং শূন্যের বিশেষ অর্থ রয়েছে)) সংস্করণ ১ 16 থেকে , গ্লিফটি ব্যবহার করে এই ⊂সিস্টেমে সমস্ত সিস্টেমে (এমনকি যেখানে তারা থাকে ⎕ML≠3) উপলব্ধ ⊆।

— আদম
সূত্র

1

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

(a:b)%l|any(<a)l=l++b%[a]|1<2=b%(a:l)
_%l=l
(%[])

ব্যবহারের উদাহরণ: (%[]) [5,2,7,6,4,1,3]-> [2,5,1,4,6,7,3]।

পুনরাবৃত্তি পদ্ধতির। ফাংশনটি %ইনপুট তালিকাটিকে তার প্রথম প্যারামিটার হিসাবে এবং একটি সংযোজক হিসাবে গ্রহণ করে lযা অব্যাহত অংশটিকে এতদূর ধরে রাখে (বিপরীত ক্রমে)। ইনপুট তালিকাটি খালি হলে বেস কেসটি পৌঁছে যায় এবং তারপরে ফলাফলটি সংগ্রহকারী হয় is যদি ইনপুট তালিকাটি খালি না থাকে এবং প্রথম উপাদানটি aবর্তমান খণ্ডে ( any(<a)l) এ ফিট না করে তবে সঞ্চালকটিকে ফিরিয়ে নিন এবং তালিকার বাকী অংশে এবং aনতুন সংযোজক হিসাবে পুনরাবৃত্ত কল যুক্ত করুন l++b%[a]। অন্যথায়, তালিকার বাকী aঅংশগুলিতে একটি পুনরাবৃত্ত কল করুন এবং থা সঞ্চয়ীকরণের ( b%(a:l)) তে চাপ দেওয়া। মূল ফাংশনটি খালি সঞ্চয়কারী সহ (%[])কল করে %।

— nimi
সূত্র

1

রেটিনা , 98 বাইট

বাইট গণনাটি আইএসও 8859-1 এনকোডিং ধরেছে।

$

-(\d+)
$1$*-/
\d+
$*
S-`(?<=(-+)/ )(?!\1)|(?=\b(1+))(?<!\2 )
O%`\S* 
¶

((-)|1)*/? 
$2$#1 
 $

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

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

1

আর, 64 বাইট

cat(unlist(lapply(split(x<-scan(),cumsum(c(F,diff(x)>0))),rev)))

স্টিডিনের কাছ থেকে ইনপুট পড়ে। আমরা ইনপুটটিকে ভেক্টরগুলির একটি তালিকায় বিভক্ত করে ব্যবহার করি split()যার জন্য একটি ফ্যাক্টর ভেরিয়েবলের দরকার হয় যা ইনপুটকে ভাগ করে দেয়। যৌক্তিক ভেক্টরটির সংযোজক যোগফলটি তৈরি করে ফ্যাক্টরটি তৈরি করা হয় যার জন্য পার্থক্যটি ইতিবাচক।

ভেক্টর বিবেচনা করুন:

x=c(5, 2, 7, 6, 4, 1, 3)

এখন পার্থক্যটি গ্রহণ এবং Fচালনা দ্বারা প্রিপেন্ডিং y=c(F,diff(x)>0)নিম্নলিখিত যৌক্তিক ভেক্টর উত্পাদন করতে পারে:

[1] FALSE FALSE  TRUE FALSE FALSE FALSE  TRUE

সংশ্লেষক সমষ্টি গ্রহণের cumsum(y)ফলে একটি ভেক্টর তৈরি হয় যেখানে প্রতিটি গোষ্ঠী একটি অনন্য উপাদান দ্বারা প্রতিনিধিত্ব করে যার উপর আমরা splitফাংশনটির সাথে একত্রিত করতে পারি :

[1] 0 0 1 1 1 1 2

— Billywob
সূত্র

এরdiffinv চেয়ে 60 বাইট ব্যবহার করছে cumsum।

— জিউসেপ

1

অক্টাভা, 75 44 বাইট

উপর ভিত্তি করে MATL উত্তর @LuisMendo এর

@(a)sortrows([cumsum([1;diff(a)>0]),a])(:,2)

অনলাইনে চেষ্টা করে দেখুন!

পূর্ববর্তী উত্তর

@(a)[fliplr(mat2cell(f=fliplr(a),1,diff(find([1,diff(f)<0,numel(a)])))){:}]

অনলাইনে চেষ্টা করে দেখুন!

অ্যারে বিপরীত

f=fliplr(a)

প্রথম পার্থক্য নিতে f

d = diff(f);

পূর্ববর্তী উপাদানগুলির তুলনায় পরবর্তী উপাদানটি কম যেখানে অবস্থান সন্ধান করুন

p=find([1,diff(f)<0,numel(a)])

পজিশনের প্রথম পার্থক্য প্রতিটি উপ অ্যারের দৈর্ঘ্য দেয়

len=diff(p)

mat2cellঅ্যারে নেস্টেড তালিকায় অ্যারে বিভক্ত করতে প্রতিটি উপ অ্যারের দৈর্ঘ্য ব্যবহার করুন

nest = mat2cell(f,1,len);

নেস্টেড তালিকার বিপরীত করুন

rev_nest = fliplr(nest)

নেস্টেড তালিকা সমতল করুন

[rev_nest{:}]

— rahnema1
সূত্র

0

পাইথ - 15 বাইট

s_McQf<@QtT@QTU

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

— Maltysen
সূত্র

0

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

{map |+«*.[0].reverse,m/:s([(\-?\d+)<?{[>=] $0}>] +)+/[0]}

রেজেক্স-ভিত্তিক সমাধান।
কারণ এটি ~~স্পার্টা~~ পার্ল !!

m/ /: ইনপুট অ্যারে স্ট্রিংফাই করুন এবং এর বিরুদ্ধে একটি রেগেক্স মেলে।
(\-? \d+): একটি সংখ্যা মেলে এবং এটি ক্যাপচার করুন $0।
<?{ [>=] $0 }>: জিরো-প্রস্থের দৃser় বক্তব্যটি কেবলমাত্র $0বর্তমান সাব-ম্যাচটিতে এখন পর্যন্ত সমস্ত ক্যাপচার করা হলেই মেলে তবে এটি অ-আসন্ন ক্রমে রয়েছে।
([ ] +)+: যতক্ষণ সম্ভব শেষ দুটি ধাপ পুনরাবৃত্তি করুন, অন্যথায় একটি নতুন উপ-ম্যাচ শুরু করুন।
map , [0]: সাব-ম্যাচগুলি নিয়ে আইট্রেট করুন।
|+«*.[0].reverse: প্রত্যেকের জন্য, মিলে যাওয়া মানগুলির তালিকাটি নিন $0, এটিকে বিপরীত করুন, মানগুলিকে সংখ্যায় ( +«) চাপিয়ে দিন এবং সেগুলি বাইরের তালিকার ( |) এ স্লিপ করুন ।

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

sub f(\a){flat $_,f a[+$_..*]with first {[<=] $_},:end,[\R,] a}

পুনরাবৃত্তি তালিকা প্রক্রিয়াকরণ সমাধান।
আমার চেয়ে বেশি শ্রমসাধ্য
যদিও ভাষাটিতে অনেক সুবিধাজনক বিল্ট-ইন রয়েছে তবে তালিকা বিভাজনের জন্য কিছুই নেই বলে মনে হয় (যেমন রুবির slice_whenবা হাস্কেলের মতো takeWhile)।

— smls
সূত্র

0

স্ট্যাকড , নন-কেপটিং, 34 বাইট

এখনও ক্রমাগত এই ভাষা বিকাশ।

{e.b:e b last<}chunkby$revmap flat

টিওএস-এ যুক্তি রয়েছে। এখানে চেষ্টা করুন!

chunkbyএকটি ফাংশন গ্রহণ করে এবং ফাংশনটি সন্তুষ্ট করে এমন সামঞ্জস্যপূর্ণ ডেটার অ্যারে সংগ্রহ করে। ফাংশনটি হ'ল:

{e.b:e b last<}
{e.b:         }  function with arguments [e, <unused>, b]--the element, <the index>, and the
                 chunk being built
     e       <   check if e is less than
       b last    the last element of b

এটি একটি কঠোরভাবে হ্রাস অ্যারে দেয়।

$revmapমূলত [rev]mapএবং প্রতিটি আইটেম বিপরীত।

flat অবশেষে অ্যারের সমতল।

অ্যারে বাছাই করার জন্য কিছু মজা:

[{e.b:e b last<}chunkby$revmap flat] @:sortstep
[$sortstep periodloop] @:sort

10:> @arr
arr out
arr shuf @arr
arr out
arr sort out

এই ফলাফলগুলি (উদাহরণস্বরূপ):

(0 1 2 3 4 5 6 7 8 9)
(4 5 1 0 6 7 2 8 9 3)
(0 1 2 3 4 5 6 7 8 9)

— কনর ও ব্রায়ান
সূত্র

0

পাইথন, 151 139 বাইট

সংরক্ষিত 12 বাইট @ Flp.Tkc ধন্যবাদ!

@ Flp.Tkc এর কাছাকাছি কোথাও নেই, একা থাকুন ...

def s(l):
 r=[];i=j=0
 while j<len(l)-1:
  if l[j+1]>l[j]:r+=l[i:j+1][::-1],;i=j+1
  j+=1
 r+=l[i:j+1][::-1],;return[i for s in r for i in s]

— Noodle9
সূত্র

সংযোজন ব্যবহারের পরিবর্তে, += data,অনুসরণযোগ্য কমা ব্যবহার করে সুস্পষ্টভাবে একটি টিউপল তৈরি করা হয়, যা তালিকার সাথে মিলিত হয় এবং তালিকায় সর্বশেষ উপাদান হিসাবে ডেটা যুক্ত করে। এই প্রসঙ্গে, করুনr+=l[i:j+1][::-1],

— ফ্লিপট্যাক

0

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

b=[];c=[];a+=9e9,
for i in a[:-1]:
 b=[a.pop(0)]+b
 if b[0]<a[0]:c+=b;b=[]

ইনপুট ইন a, আউটপুট ইনc

— সের্গেই পটিয়াকিন
সূত্র

0

পাইথন 3, 191 বাইট

a=[int(i)for i in input().split()]
while a!=sorted(a):
 b=[[]]
 for i,j in enumerate(a):
  if a[i-1]<j:b+=[[j]]
  else:b[-1]+=[j]
 a=[]
 for l in[k[::-1]for k in b]:a+=[k for k in l]
print(a)

আমি নিশ্চিত না যে এখানে sortedফাংশনটি চেক করার জন্য ব্যবহার করার অনুমতি দেওয়া হয়েছে কিনা তবে আমি এর বিরুদ্ধে কোনও ভাল কারণ ভাবতে পারি না এবং এটি আমার বাইট গণনাটি 30 ডলার বাইতে নামিয়ে আনল।

— sonrad10
সূত্র

0

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

#(filter number?(mapcat reverse(partition-by not(mapcat(fn[[a b]][a(< b a)])(partition 2 1(conj % 1))))))

পরপর সংখ্যা, রাখে উপর জোড়া মধ্যে পার্টিশন trueবা falseতাদের মধ্যে, উপর পার্টিশন notকরতে trueএবং সংখ্যার পরিণত falseএবং false true, উল্টিয়ে এর পার্টিশান ও সংখ্যাসূচক মান রাখে।

— NikoNyrh
সূত্র

একটি অ্যারে Sever- বাছাই করুন

চ্যালেঞ্জ

বিধি

পরীক্ষার মামলা

স্কোরিং

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

পরীক্ষার স্নিপেট

পাইথন 3 , 63 বাইট

জেলি , 8 বাইট

ব্যাখ্যা:

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

পরীক্ষার মামলা

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

ব্যাখ্যা

গণিত, 30 27 বাইট

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

পাইক, 11 8 বাইট ( পুরানো সংস্করণ )

রেটিনা , 163 বাইট

05 এ বি 1 ই , 19 18 16 14 বাইট

জাভাস্ক্রিপ্ট (ইসিএমএ 6), 121 128 125 119 108 বাইট

রুবি, 60 55 বাইট

ব্র্যাচল্যাগ , 10 বাইট

ব্যাখ্যা

ডায়ালগ এপিএল , 7 15 বাইট

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

রেটিনা , 98 বাইট

আর, 64 বাইট

অক্টাভা, 75 44 বাইট

পাইথ - 15 বাইট

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

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

স্ট্যাকড , নন-কেপটিং, 34 বাইট

পাইথন, 151 139 বাইট

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

পাইথন 3, 191 বাইট

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