ভূমিকা

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

কাজটি

আপনার ইনপুটটি পূর্ণসংখ্যার L এর তালিকা , যা খালি থাকতে পারে। আপনার আউটপুটটি তালিকাভুক্ত হবে এল যেখানে ঠিক এক নম্বর এল _আমি অন্য এল _জে দ্বারা প্রতিস্থাপিত হয়েছে , যেখানে এল _আই <এল _জে এবং আই <জে ।

অন্য কথায়, আপনি একটি সংখ্যাকে তার পরে সংখ্যায় উচ্চ সংখ্যার সাথে প্রতিস্থাপন করবেন।

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

যদি আমি এবং জে এর অস্তিত্ব না রাখেন (যেমন এল বাড়ছে না), আপনার আউটপুট এল অপরিবর্তিত হবে।

উদাহরণ

এল = [3, 1, 4, -1, 2] ইনপুটটি বিবেচনা করুন । সম্ভাব্য ক্রিয়াকলাপগুলি হ'ল 3 দ্বারা 4 প্রতিস্থাপন, 1 দ্বারা 4 প্রতিস্থাপন, 1 দ্বারা 2 প্রতিস্থাপন, বা -1 দ্বারা 2 প্রতিস্থাপন । সুতরাং সম্ভাব্য ফলাফলগুলি হ'ল:

 [  3 ,   1 ,   4 ,  -1 ,   2 ]
 ------------------------------
 [( 4),   1 ,(  4),  -1 ,   2 ]
 [  3 ,(  4),(  4),  -1 ,   2 ]
 [  3 ,(  2),   4 ,  -1 ,(  2)]
 [  3 ,   1 ,   4 ,(  2),(  2)]

আপনি যদি পর্যাপ্ত সময় অপারেশনটি পুনরাবৃত্তি করেন তবে শেষ ফলাফলটি [4,4,4,2,2] হবে যা অবিকল এল এর লেজ ম্যাক্সিমার তালিকা ।

বিধি এবং স্কোরিং

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

সর্বনিম্ন বাইট গণনা জিতেছে।

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

সমস্ত সম্ভাব্য আউটপুট দেখানো হয়।

[] -> []
[1] -> [1]
[1,2] -> [2,2]
[2,1] -> [2,1]
[4,4,4,4] -> [4,4,4,4]
[-1,-3,-10] -> [-1,-3,-10]
[1,3,10] -> [3,3,10] [10,3,10] [1,10,10]
[1,1,2,1] -> [2,1,2,1] [1,2,2,1]
[998,64,2,-94,-789] -> [998,64,2,-94,-789]
[998,2,64,-94,-789] -> [998,64,64,-94,-789]
[3,1,4,-1,2] -> [4,1,4,-1,2] [3,4,4,-1,2] [3,2,4,-1,2] [3,1,4,2,2]
[-1,4,0,4,7,2,3] -> [4,4,0,4,7,2,3] [0,4,0,4,7,2,3] [-1,4,4,4,7,2,3] [7,4,0,4,7,2,3] [-1,7,0,4,7,2,3] [-1,4,7,4,7,2,3] [-1,4,0,7,7,2,3] [2,4,0,4,7,2,3] [-1,4,2,4,7,2,3] [3,4,0,4,7,2,3] [-1,4,3,4,7,2,3] [-1,4,0,4,7,3,3]
[3542,-12311,7662,1672,6081] -> [7662,-12311,7662,1672,6081] [3542,7662,7662,1672,6081] [3542,1672,7662,1672,6081] [6081,-12311,7662,1672,6081] [3542,6081,7662,1672,6081] [3542,-12311,7662,6081,6081]

code-golf array-manipulation

— Zgarb
সূত্র

9

জাভাস্ক্রিপ্ট (ES6), 41 40 39 38 বাইট

@ নীলকে একটি বাইট ধন্যবাদ সংরক্ষণ করা হয়েছে, @ ব্যবহারকারী81655- এ আরও একটি ধন্যবাদ

x=>x.map(c=>c<x[++i]>d?x[d=i]:c,d=i=0)

ঠিক যখন মনে হয় reduceRightঅবশেষে কোনও সুযোগ আছে, .mapআবার প্রদর্শিত হবে ...

— ETHproductions
সূত্র

x=>x.map(c=>c<x[++i]&!d?x[d=i]:c,d=i=0)?

— নীল

শর্তাবলী বাম থেকে ডান মূল্যায়ন করা হয় যার অর্থ x=>x.map(c=>c<x[++i]>d?x[d=i]:c,d=i=0)(38 বাইট) কাজ করা উচিত।

— ব্যবহারকারী 81655

@ ব্যবহারকারী81655 এটি আশ্চর্যজনক :-)

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

7

গণিত, 37 বাইট

#/.{a___,b_,c_,d___}/;b<c:>{a,c,c,d}&

খাঁটি ফাংশন এমনকি আসল সংখ্যার একটি তালিকা গ্রহণ করে এবং আসল সংখ্যার একটি তালিকা ফেরত দেয়। "ভুল" ক্রমে টানা প্রথম জোড়ের প্রবেশের সন্ধান করে এবং সেই জোড়ের প্রথমটি দ্বিতীয়টির সাথে প্রতিস্থাপন করে। দুর্দান্ত ডিফল্ট আচরণের /.অর্থ এটি উপযুক্ত হলে ইনপুটটি আনলটার্ট ফেরত দেয়।

মজাদার সাইড নোট: যদি আমরা প্রতিস্থাপন b<cসঙ্গে !OrderedQ[{c,b}], তারপর ফাংশন স্ট্রিং উপর কাজ করে (এবং সত্যিই কোন ডাটা টাইপ একবার উপযুক্ত ক্রম বর্ণনা করা হয়েছে)। উদাহরণস্বরূপ, #/.{a___,b_,c_,d___}/;!OrderedQ[{c,b}]:>{a,c,c,d}&ইনপুট {"programming", "puzzles", "code", "golf"}রিটার্নে {"puzzles", "puzzles", "code", "golf"}।

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

পার্শ্ব নোটের জন্য একটি সতর্কতামূলক: স্ট্রিংগুলির গাণিতিকের ক্যানোনিকাল ক্রমটি অদ্ভুত।

— মার্টিন এেন্ডার

কীভাবে, মার্টিন ইন্ডার?

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

শুধু চেষ্টা করুন Sort[FromCharacterCode /@ Range[32, 127]]। একবারে একাধিক শব্দের সাথে স্ট্রিং হয়ে গেলে এটি অদ্ভুত হয়ে যায়, কারণ এরপরে এটি স্পেস এবং স্টাফ উপেক্ষা করে।

— মার্টিন এেন্ডার

6

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

a=>a[a.some(e=>e<a[++i],i=0)*i-1]=a[i]

স্থানটিতে অ্যারে পরিবর্তন করে আউটপুট। সম্পাদনা: @ বুদ্ধিমানের জন্য 4 টি বাইট সংরক্ষণ করা হয়েছে @ ব্যবহারকারী 81655 এর জন্য 1 বাইট সংরক্ষণ করা হয়েছে।

— নিল
সূত্র

আমি মনে করি আপনি a=>a[i=0,a.findIndex(e=>e<a[++i])]=a[i]39

— র

40B জন্য আরেকটি দৃষ্টীকোণ:a=>a.map((_,b)=>Math.max(...a.slice(b)))

— লুক

@ লুক আমি মনে করি আপনি চ্যালেঞ্জকে ভুল বুঝছেন; বিন্দুটি হ'ল অ্যারেতে কেবল একটি পূর্ণসংখ্যাকেই বৃহত্তর করা।

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

@ ইথ প্রডাকশনগুলি অনুগ্রহ ফিরিয়ে দেওয়ার জন্য ধন্যবাদ, এখন সম্মানীরা সমান!

— নীল

আমি মনে করি আপনি (38 বাইট) findIndexদিয়ে প্রতিস্থাপন করতে পারবেন some:a=>a[i=0,a.some(e=>e<a[++i])*i-1]=a[i]

— ব্যবহারকারী 81655

5

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

f(a:r@(b:_))|a<b=b:r|1>0=a:f r
f e=e

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

পরপর উপাদানের জন্য তালিকা মাধ্যমে সন্ধান a,bসঙ্গে a<bএবং তাদের পরিবর্তন b,b।

37 বাইট থেকে উন্নত:

f(a:b:t)|a<b=b:b:t
f(a:t)=a:f t
f e=e

— xnor
সূত্র

আমি মনে করি f(a:r@(b:_))=max(b:r)(a:f r)কাজ করে এবং দুটি বাইট কম হয়।

— janrjan জোহানসেন

@ আরজান জোহেনসেন এটি একটি সুন্দর পদ্ধতি! আমার মনে হয় আপনার নিজের উত্তর হিসাবে এটি পোস্ট করা উচিত। আমি প্রথমে নিশ্চিত ছিলাম না যে এটি বন্ধনগুলি সঠিকভাবে পরিচালনা করবে, তবে আমি এখন দেখছি কারণ এটি কাজ করে f r >= r।

— xnor

ধন্যবাদ, আমি তাই করেছি !

— janrjan জোহানসেন

4

জেলি , 13 11 বাইট

ṫJṀ€ż¹ŒpQ-ị

সমস্ত সম্ভাব্য সংখ্যার মধ্যে সর্বমোট প্রতিস্থাপন করে।

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

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

ṫJṀ€ż¹ŒpQ-ị  Main link. Argument: A (array)

 J           Yield all indices of A, i.e., the array [1, ..., len(A)].
ṫ            Dyadic tail; for index k, take all elements starting with the k-th.
             This constructs the array of suffixes.
  Ṁ€         Maximum each; map the monadic maximum atom over the suffixes.
     ¹       Identity; yield A.
    ż        Zip; construct all pairs of elements of the result to the left and the
             corresponding elements of the result to the right.
      Œp     Cartesian product. Construct all arrays that, for each index, take
             either the left or the right element.
        Q    Unique; deduplicate the resulting arrays.
         -ị  At-index -1; select the second to last result.
             The last result is A itself, the first maxima of suffixes.

— ডেনিস
সূত্র

3

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

tdt0>0whY>d*0h+

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

আমি এই সমাধানের বিশাল ফ্যান নই। এটি আমার কাছে মারাত্মকভাবে অদক্ষ বলে মনে হচ্ছে। বিশেষত whY>d*এবং 0h+বিভাগগুলি।

— ডিজেএমসিএমহেম
সূত্র

3

পাইথন 2, 139 134 93 বাইট

a=input()
for i in range(len(a)):
 for j in a[i+1:]:
    if a[i]<j:a[i]=j;print a;exit()
print a

মারাত্মকভাবে দীর্ঘ, তবে এটি প্রথম প্রচেষ্টা।

টেম্পোরাল
ওল্ফ -১৪ (!!) বাইটকে ভ্যালু ইনিকে ধন্যবাদ জানায় 5

— HyperNeutrino
সূত্র

[1,2]এর [2,1]পরিবর্তে দেয়[2,2]

— টেম্পোরাল

1

@ টেম্পোরাল ওল্ফ হ্যাঁ, আমি চ্যালেঞ্জটি ভুলভাবে পড়েছি। কোনও বাইট সংরক্ষণ বা হারিয়েছে না, এটি ঠিক করবে।

— হাইপারনিউটারিনো

আপনি নিজের অভ্যন্তরের পূর্বে রিটার্নটি সরিয়ে ফেলতে পারেন এবং অভ্যন্তরীণ লুপের জন্য অতিরিক্ত স্থানের পরিবর্তে printএকটি \tট্যাব ব্যবহার করতে পারেন । এছাড়াও, আপনি exit()অতিরিক্ত একটির জন্য 0 এড়াতে পারেন । আপনাকে 132 এ নামিয়ে আনতে হবে

— টেম্পোরাল

@ টেম্পোরাল ওল্ফ ঠিক আছে, ধন্যবাদ!

— হাইপারনিউটারিনো

1

if a[i]<a[j]:a[i]=a[j];print a;exit()এমনকি আরও খাটো। হেক, এটি করা ভালfor j in a[i+1:]:\n\tif a[i]<j:a[i]=j;print a;exit()

— মান কালি

3

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

ttd0>fX>Q)2M(

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

ব্যাখ্যা

নিম্নলিখিত দুটি শর্ত সমতুল্য:

এমন একটি সংখ্যা রয়েছে যার ডানদিকে উচ্চতর সংখ্যা রয়েছে
এমন একটি সংখ্যা রয়েছে যার ডানদিকে অবিলম্বে একটি উচ্চতর সংখ্যা রয়েছে

কোডটি শর্ত 2 ব্যবহার করে, যা সহজ। এটি ক্রমাগত বৃদ্ধি গণনা করে এবং যদি ইতিবাচক হয় তবে এটি ইতিবাচক সন্ধান করে। দুটি জড়িত এন্ট্রি জন্য, এটি প্রথম দ্বিতীয় প্রবেশের মান লিখুন।

এই কৌশলটি হ্যান্ডেল করার জন্য ব্যবহৃত হয় যখন কোনও বিকল্প প্রতিস্থাপন করা যায় না। আরও লক্ষ করুন যে এমএটিএল সূচী- 1ভিত্তিক।

[3,1,4,-1,2]উদাহরণ হিসাবে ইনপুট ব্যবহার করা যাক ।

tt    % Get input implicitly and duplicate it twice
      % STACK: [3,1,4,-1,2], [3,1,4,-1,2], [3,1,4,-1,2]
d     % Consecutive differences
      % STACK: [3,1,4,-1,2], [3,1,4,-1,2], [-2  3 -5  3]
0>    % Are they positive?
      % STACK: [3,1,4,-1,2], [3,1,4,-1,2], [0 1 0 1]
f     % Find indices of all positive differences. Result may be empty
      % STACK: [3,1,4,-1,2], [3,1,4,-1,2], [2 4]
X>    % Maximum index with a positive difference. Empty input remains as empty
      % STACK: [3,1,4,-1,2], [3,1,4,-1,2], 4
Q     % Add 1. Since the addition is elementwise, empty input remains as empty
      % STACK: [3,1,4,-1,2], [3,1,4,-1,2], 5
)     % Get the entry of the input at that position
      % STACK: [3,1,4,-1,2], 2
2M    % Push maximum index with a positive difference, again
      % STACK: [3,1,4,-1,2], 2, 4
(     % Assign to that position. Implicitly display
      % STACK: [3,1,4,2,2]

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

3

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

এটি এক্সনোরের উত্তরের ভিত্তিতে তৈরি , যিনি পরামর্শ দিয়েছিলেন যে আমি নিজে এটি পোস্ট করব।

সম্পাদনা: xnor সংরক্ষণ করতে একটি বাইট খুঁজে পেয়েছে।

f(a:r@(b:_))=max(b:r)$a:f r
f e=e

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

মূলত, আমি পর্যবেক্ষণ করেছি যে xnor এর পদ্ধতির শাখাটি সর্বদা শাখার এক্সপ্রেশনগুলির মধ্যে যেটি সবচেয়ে বড় তা চয়ন করে শেষ হয়, যেহেতু হাস্কেল তালিকাগুলির জন্য অভিধান সংক্রান্ত ক্রম ব্যবহার করে। (কেসটি যখন a==bকাজ করে কেননা f r>=r, যা প্রবর্তনের মাধ্যমে পৃথকভাবে প্রমাণ করা যায়))

অন্যভাবে রাখুন, যখনই b:r > a:f r, তখন b:rএকটি সঠিক উত্তর এবং অন্যথায় আমরা পুনরাবৃত্তি করতে পারি a:f r।

সুতরাং আগে থেকে যাচাই করার পরিবর্তে a<b, আমি কেবলমাত্র দুটি এক্সপ্রেশন গণনা করে সর্বোচ্চ গ্রহণ করি। এটি একটি ক্ষতিকারক ধাক্কা দিতে পারে, যদিও হাস্কেলের অলসতা এড়ানো aএবং bসমান না হলে এড়ানো যায় ।

— আরজান জোহানসেন
সূত্র

1

দেখে মনে হচ্ছে max(b:r)$a:f rএকটি বাইট সংরক্ষণ করে।

— xnor

2

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

def f(x):
 for i,a in enumerate(x):
  m=max(x[i+1:])
  if m>a:x[i]=m;break

এটি দেওয়া মূল অ্যারে (তালিকা) কে রূপান্তর করে। আমি অসন্তুষ্ট যে এটি ল্যাম্বডা নয় এবং আমি নিশ্চিত যে আরও ভাল অপ্টিমাইজেশন রয়েছে; আমি আশা করি পরে এগুলিকে সম্বোধন করব।

সংক্ষিপ্ত বর্ণনা

এটি বর্তমান উপাদানের (জিরোথ দিয়ে শুরু) অতীতে অ্যারের সর্বাধিক সময় নেয়। এরপরে এটি এটিকে উপাদানটির সাথেই তুলনা করে: যদি সর্বাধিক হয় তবে এটির সাথে বর্তমান উপাদানটি প্রতিস্থাপন করুন এবং থামান, অন্যথায়, একের সাথে বৃদ্ধি এবং চেষ্টা চালিয়ে যান।

— কপি
সূত্র

2

রুবি, 66 61 বাইট

->a{i=r=-1;a.map{|e|m=a[i+=1,a.size].max;r&&m>e ?(r=!r;m):e}}

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

— মান কালি
সূত্র

2

সি, 47 বাইট

f(p,n)int*p;{n>1?*p<p[1]?*p=p[1]:f(p+1,n-1):0;}

পুনরাবৃত্তিমূলক বাস্তবায়ন এটির ইনপুট হিসাবে একটি অ্যারের প্রথম উপাদানটির নির্দেশক এবং অ্যারের দৈর্ঘ্য হিসাবে গ্রহণ করে। জায়গায় অ্যারে পরিবর্তন করে।

— hvd
সূত্র

আপনার কোড রিটার্নটি

— খালেদ.কে

@ খালেদ.কে এটি আউটপুট "3 4 4 -1 2" দেখায়, যা প্রশ্নে দেওয়া অনুমোদিত আউটপুটগুলির মধ্যে একটি। এর সাথে আপনার কী ভুল মনে হচ্ছে?

— এইচডিভি

আমি দেখছি, প্রশ্নটি যদিও এটি সম্পর্কে যথেষ্ট অস্পষ্ট

— খালেদ.কে

2

এসডাব্লুআই-প্রোলগ, 70 বাইট

f([H|T],[S|T]):-max_list(T,S),S>H,!.
f([H|T],[H|R]):-f(T,R),!.
f(I,I).

প্রথম ধারাটি তালিকার প্রথম উপাদানটিকে বাকী তালিকার সর্বাধিক মান সহ প্রতিস্থাপন করে, তবে কেবলমাত্র এই সর্বোচ্চটি বড় হয়। দ্বিতীয় ধারাটি পুনরাবৃত্তভাবে তালিকার লেজের জন্য শিকারটিকে কল করে। যদি এই ধারাগুলির কোনওটিই সফল না হয় তবে তৃতীয় ধারাটি কেবল ইনপুটটি দেয়।

এই সম্ভাব্য সমাধানগুলির মধ্যে একটি মাত্র প্রত্যাবর্তন। এগুলির মধ্যে একটি খুব অনুরূপ কোড সহ এটি সন্ধান করা তুচ্ছ, তবে তারপরে কোনও পরিবর্তন সম্ভব না হলে হ্যান্ডেল করতে আরও অনেক বেশি বাইট লাগে।

উদাহরণ:

?- f([-1,4,0,4,7,2,3], O).
O = [7, 4, 0, 4, 7, 2, 3]

— স্টিভেন
সূত্র

1

আর, 71 বাইট

a=scan()
l=length(a) 
lapply(1:l,function(x){
  a[x]=max(a[x:l])
  a
})

— ক্রিস
সূত্র

1

সি, 80 বাইট

i,j;f(l,n)int*l;{for(i=0;i<n;++i)for(j=i;++j<n;)if(l[i]<l[j]){l[i]=l[j];j=i=n;}}

সাথে কল করুন:

int main()
{
    int a[5]={3,1,4,-1,2};
    f(a,5);
    for(int k=0;k<5;++k)
        printf("%d ", a[k]);
}

— Steadybox
সূত্র

1

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

অনলাইনে এটি চেষ্টা করুন -২
বাইট ধন্যবাদ @ টেম্পোরাল ওল্ফ -২২
বাইটকে @ ভ্যালুআইঙ্ক-- বাইট ধন্যবাদ @ কোলকে ধন্যবাদ

ফাংশন যা ইনপুট অ্যারেটিকে রূপান্তর করে

def F(A):
 for i in range(len(A)):
    r=[y for y in A[i+1:]if y>A[i]]
    if r:A[i]=r[0];break

প্রথম পুনরাবৃত্তির পরে যদি থামার দরকার না হয় তবে এটি কিছুটা প্রাকটিয়ার হবে

— ডেড পসুম
সূত্র

এটি কাজ করে না বলে মনে হচ্ছে। চেষ্টা করুন [1, 3, 5, 7]; এটি ফিরে আসে [3, 3, 5, 7]।

— হাইপারনিউটারিনো

1

A[i]<y and=> y>A[i]and1 সংরক্ষণ করে

— টেম্পোরাল

@HyperNeutrino যদি আমি inderstand টাস্ক ঠিক আছে, বৈধ outut যে

— ডেড পসাম্

1

r=[y for y in A[i+1:]if y>A[i]]\n if r:A[i]=r[0];breakআপনার স্কোরটি 96 এ নামা বিবেচনা করুন !

— মান কালি

1

আমি পাইথন উত্তরগুলির মধ্যে একটির জন্য আমি যা পরামর্শ দিয়েছি তা প্রস্তাব দিতে পারে: আপনার যা আছে তা এমন কোনও ফাংশনে রূপান্তর করুন যা মূল অ্যারেটিকে রূপান্তর করে যাতে আপনি মুদ্রণ এড়াতে পারেন এবং input()।

— কোল

1

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

f=lambda x:x and[x[:1]+f(x[1:]),[max(x)]+x[1:]][x[0]<max(x)]

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

ব্যাখ্যা: প্রদত্ত উপাদানটি maxতালিকার বাকী অংশের উপাদানের চেয়ে কম কিনা তা পুনরাবৃত্তভাবে পরীক্ষা করে। যদি তা হয় maxতবে প্রথম উপাদানটি প্রতিস্থাপন করে তালিকাটি ফিরিয়ে দেয় ।

— গণিত জাঙ্কি
সূত্র

1

টিআই-বেসিক, 72 বাইট

Prompt L₁
If 2≤dim(L₁
Then
For(A,1,dim(L₁)-1
For(B,A,dim(L₁
If L₁(A)<L₁(B
Then
L₁(B→L₁(A
Goto E
End
End
End
End
Lbl E
L₁

ব্যাখ্যা:

Prompt L₁          # 4 bytes, input list
If 2≤dim(L₁        # 7 bytes, if the list has 2 or 1 element(s), skip this part and return it
Then               # 2 bytes
For(A,1,dim(L₁)-1  # 12 bytes, for each element in the list other than the last
For(B,A,dim(L₁     # 9 bytes, for each element after that one
If L₁(A)<L₁(B      # 12 bytes, if the second is larger than the first
Then               # 2 bytes
L₁(B→L₁(A          # 10 bytes, replace the first with the second
Goto E             # 3 bytes, and exit
End                # 2 bytes
End                # 2 bytes
End                # 2 bytes
End                # 2 bytes
Lbl E              # 3 bytes
L₁                 # 2 bytes, implicitly return L₁

— pizzapants184
সূত্র

1

sh, 118 বাইট

ইনপুট পূর্ণসংখ্যা স্ক্রিপ্টের আর্গুমেন্ট হিসাবে পাস করা হয়।

l=("$@");for i in "$@";{ for j in "$@";{(($i<$j))&&{ l[$x]=$j;echo ${l[@]};exit;};};shift;x=`expr $x+1`;};echo ${l[@]}

ভাঙ্গন:

l=("$@");                      #copy original list
for i in "$@";{ for j in "$@"; #check all elements j that follow element i in list
{(($i<$j))&&{ l[$x]=$j;echo ${l[@]};exit;};};   #if i<j, make i=j; print list, done
shift;                         #makes sure that i is compared only to j that occur after it
x=`expr $x+1`;};               #keeps track of i'th position in the list
echo ${l[@]}                   #prints list if it was unchanged

— ম্যাক্সিম মিখায়লভ
সূত্র

0

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

<?for(;$i+1<$c=count($a=$_GET)&&$a[+$i]>=$a[++$i];);$i>=$c?:$a[$i-1]=$a[$i];print_r($a);

ভাঙ্গন

for(;
$i+1<($c=count($a=$_GET))  # first condition end loop if the item before the last is reach 
&&$a[+$i]>=$a[++$i] # second condition end loop if item is greater then before 
;);
$i>=$c?:$a[$i-1]=$a[$i]; # replace if a greater item is found
print_r($a); #Output

— জার্গ হালসারম্যান
সূত্র

0

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

f(b:l)|l>[],m<-maximum l,b<m=m:l|1<2=b:f l
f x=x

ব্যবহারের উদাহরণ: f [1,1,2,1]-> [2,1,2,1]। এটি অনলাইন চেষ্টা করুন! ।

যদি ইনপুট তালিকার কমপক্ষে একটি উপাদান bথাকে তবে প্রথম উপাদানটি এবং lবাকী তালিকায় বাঁধুন । যদি lখালি না bথাকে এবং সর্বাধিকের চেয়ে কম না lহয় l, তারপরে সর্বাধিক অনুসরণ করুন , অন্যথায় ফিরে আসার bপরে পুনরাবৃত্তি করুন f l। যদি ইনপুট তালিকাটি খালি থাকে তবে তা ফিরিয়ে দিন।

— nimi
সূত্র

0

র‌্যাকেট 202 বাইট

(let((g(λ(L i n)(for/list((c(in-naturals))(l L))(if(= c i)n l))))(ol'()))
(for((c(in-naturals))(i L))(for((d(in-range c(length L)))#:when(>(list-ref L d)i))
(set! ol(cons(g L c(list-ref L d))ol))))ol)

Ungolfed:

(define (f L)
  (let ((replace (λ (L i n)   ; sub-function to replace i-th item in list L with n;
                   (for/list ((c (in-naturals))
                              (l L))
                     (if (= c i) n l))))
        (ol '()))             ; outlist initially empty; 
    (for ((c (in-naturals))               ; for each item in list
          (i L))
      (for ((d (in-range c (length L)))   ; check each subsequent item in list
            #:when (> (list-ref L d) i))  ; if greater, replace it in list
        (set! ol (cons (replace L c (list-ref L d)) ol)))) ; and add to outlist.
    ol))          ; return outlist.

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

(f '(3 1 4 -1 2))

আউটপুট:

'((3 1 4 2 2) (3 2 4 -1 2) (3 4 4 -1 2) (4 1 4 -1 2))

— rnso
সূত্র

0

সি, 67 বাইট

একক রান, 67 বাইট লাইভ

j;f(l,i)int*l;{j=i-1;while(i-->0)while(j-->0)l[j]=fmax(l[i],l[j]);}

একক পদক্ষেপ, 78 বাইট লাইভ

j;f(l,i)int*l;{j=i-1;while(i-->0)while(j-->0)if(l[j]<l[i]){l[j]=l[i];return;}}

টেইল ম্যাক্সিমা, 96 বাইট লাইভ

x;i;j;f(l,n)int*l;{do{x=0;for(i=0;i<n;i++)for(j=0;j<i;j++)if(l[j]<l[i])l[j]=l[i],x=1;}while(x);}

— Khaled.K
সূত্র

0

পাইথন 3 , 103 102 বাইট

lambda a:([a[:i]+[max(a[i:])]+a[i+1:]for i in range(len(a))if-~i==len(a)or max(a[i+1:])>a[i]]+[[]])[0]

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

— ovs
সূত্র

একক সংখ্যা বাড়ান

ভূমিকা

কাজটি

উদাহরণ

বিধি এবং স্কোরিং

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

জাভাস্ক্রিপ্ট (ES6), 41 40 39 38 বাইট

গণিত, 37 বাইট

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

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

জেলি , 13 11 বাইট

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

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

পাইথন 2, 139 134 93 বাইট

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

ব্যাখ্যা

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

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

সংক্ষিপ্ত বর্ণনা

রুবি, 66 61 বাইট

সি, 47 বাইট

এসডাব্লুআই-প্রোলগ, 70 বাইট

আর, 71 বাইট

সি, 80 বাইট

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

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

টিআই-বেসিক, 72 বাইট

sh, 118 বাইট

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

ভাঙ্গন

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

র‌্যাকেট 202 বাইট

সি, 67 বাইট

পাইথন 3 , 103 102 বাইট