परिचय

मान लीजिए कि आप संख्याओं की सूची की टेल मैक्सिमा की गणना करना चाहते हैं, यानी प्रत्येक गैर-रिक्त प्रत्यय की अधिकतम संख्या। ऐसा करने का एक तरीका यह है कि एक नंबर को बार-बार चुनना और उसके बाद होने वाली एक उच्च संख्या द्वारा प्रतिस्थापित करना, जब तक कि यह संभव नहीं हो। इस चुनौती में, आपका कार्य इस एल्गोरिथम का एक चरण करना है।

काम

आपका इनपुट पूर्णांक L की एक सूची है , जो खाली हो सकती है। आपका आउटपुट सूची होगी एल जहां ठीक एक नंबर एल _मैं एक और ने ले लिया है एल _जे , जहां एल _मैं <एल _जे और मैं <j ।

दूसरे शब्दों में, आप एक संख्या को उसके बाद होने वाली उच्च संख्या से बदल देंगे।

आप सभी वैध जोड़े में से स्वतंत्र रूप से i और j चुन सकते हैं , और पसंद nondeterministic हो सकती है।

अगर ऐसा i और j मौजूद नहीं है (यानी L गैर-बढ़ता है), तो आपका आउटपुट 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

जावास्क्रिप्ट (ईएस 6), 41 40 39 38 बाइट्स

@Neil को एक बाइट धन्यवाद, @ user81655 को एक और धन्यवाद दिया

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 बाइट) काम करना चाहिए।

— user81655

@ user81655 यह अद्भुत :-)

— ETHproductions

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

जावास्क्रिप्ट (ईएस 6), 43 39 38 बाइट्स

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

सरणी में जगह को संशोधित करके आउटपुट। संपादित करें: 4 बाइट्स @ETHproductions की बदौलत सहेजे गए। @ User81655 पर 1 बाइट का धन्यवाद सहेजा गया।

— नील
स्रोत

मुझे लगता है कि आप a=>a[i=0,a.findIndex(e=>e<a[++i])]=a[i]39 के लिए कर सकते हैं ।

— ETHproductions

40 बी के लिए एक और दृष्टिकोण:a=>a.map((_,b)=>Math.max(...a.slice(b)))

— ल्यूक

@ मुझे लगता है कि आप चुनौती को गलत समझ रहे हैं; बिंदु केवल सरणी में पूर्णांकों में से एक को बड़ा करना है।

— 23

@ETHproductions एहसान वापस करने के लिए धन्यवाद, अब सम्मान भी!

— नील

मुझे लगता है कि आप (38 बाइट्स) के findIndexसाथ बदलने में सक्षम हो सकते हैं some:a=>a[i=0,a.some(e=>e<a[++i])*i-1]=a[i]

— user81655

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)काम करता है और दो बाइट्स कम है।

— अर्जन जोहानसन

@ !RjanJohansen यह एक सुंदर विधि है! मुझे लगता है कि आपको इसे अपने उत्तर के रूप में पोस्ट करना चाहिए। मुझे यकीन नहीं था कि पहली बार यह संबंधों को सही ढंग से संभाल लेगा, लेकिन मुझे लगता है कि अब यह काम करता है f r >= r।

— xnor

धन्यवाद, मैंने ऐसा किया है !

— अर्जन जोहान्सन

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

MATL , 15 बाइट्स

tdt0>0whY>d*0h+

इसे ऑनलाइन आज़माएं!

मैं इस समाधान का बहुत बड़ा प्रशंसक नहीं हूं। यह मुझे बहुत ही अयोग्य लगता है। विशेष रूप से whY>d*और 0h+वर्गों।

— DJMcMayhem
स्रोत

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 बाइट्स टेम्पोरलवुल्फ
-41 (!!) के लिए धन्यवाद बाइट्स वैल्यू इंक के लिए धन्यवाद

— HyperNeutrino
स्रोत

[1,2]के [2,1]बजाय देता है[2,2]

— TemporalWolf

1

@TemporalWolf हाँ, मैंने चुनौती को गलत बताया। कोई बाइट नहीं बचा या खो गया, ठीक कर देगा।

— हाइपरन्यूट्रिनो

आप अपने आंतरिक से पहले रिटर्न को हटा सकते हैं printऔर \tआंतरिक लूप के लिए अतिरिक्त स्थान के बजाय एक टैब का उपयोग कर सकते हैं । इसके अलावा, आप exit()एक अतिरिक्त एक के लिए 0 ड्रॉप कर सकते हैं । आपको 132 तक नीचे लाना चाहिए।

— टेम्पोरलवुल्फ

@TemporalWolf ठीक है, धन्यवाद!

— हाइपरएन्यूट्रीनो

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

MATL , 13 बाइट्स

ttd0>fX>Q)2M(

इसे ऑनलाइन आज़माएं!

व्याख्या

निम्नलिखित दो स्थितियाँ समतुल्य हैं:

एक संख्या है जो इसके दाईं ओर एक उच्च संख्या है
एक संख्या है जिसके पास इसके दाईं ओर एक उच्च संख्या है

कोड शर्त 2 का उपयोग करता है, जो सरल है। यह लगातार वृद्धि की गणना करता है और यदि कोई हो, तो अंतिम सकारात्मक खोज करता है। दो शामिल प्रविष्टियों के लिए, यह पहली में दूसरी प्रविष्टि का मूल्य लिखता है।

इस चाल का उपयोग मामले को संभालने के लिए किया जाता है जब कोई प्रतिस्थापन नहीं किया जा सकता है। यह भी ध्यान दें कि MATL इंडेक्सिंग- 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 के उत्तर पर आधारित है , जिन्होंने सुझाव दिया कि मैं इसे स्वयं पोस्ट करता हूं।

संपादित करें: xnor को बचाने के लिए एक बाइट मिला।

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

इसे ऑनलाइन आज़माएं!

मूल रूप से, मैंने देखा कि एक्सनोर की विधि का ब्रांचिंग हमेशा समाप्त हो जाता है, जिसमें से कोई भी शाखा अभिव्यक्ति का चयन सबसे बड़ा है, क्योंकि हास्केल सूचियों के लिए लेक्सिकोग्राफिक ऑर्डरिंग का उपयोग करता है। (मामला जब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
स्रोत

आपका कोड रिटर्न अमान्य ideone.com/83HJqN

— Khaled.K

@ खालिद.के यह आउटपुट "3 4 4 -1 2" को दर्शाता है, जो प्रश्न में दिए गए आउटपुट में से एक है। आपको क्या लगता है कि इसमें क्या गलत है?

— hvd

मैं देख रहा हूं, इस बारे में सवाल काफी अस्पष्ट है

— खालिद। के।

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 बाइट्स

यह कोशिश करें -1 @ बाइट के लिए धन्यवाद @TemporalWolf
-25 बाइट्स @ValueInk के लिए धन्यवाद
-7 बाइट्स @Cole के लिए धन्यवाद

फ़ंक्शन जो इनपुट सरणी को बदल देता है

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 बचाता है

— टेम्पोरलवुल्फ़

@ हैपरनेट्रिनो अगर मैं सही काम करता हूं, तो यह वैध है

— डेड पॉसम

1

r=[y for y in A[i+1:]if y>A[i]]\n if r:A[i]=r[0];break96 तक अपना स्कोर छोड़ने के लिए विचार करें !

— वैल्यू इंक

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

श, 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

PHP, 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
स्रोत

एक ही नंबर उठाएं

परिचय

काम

उदाहरण

नियम और स्कोरिंग

परीक्षण के मामलों

जावास्क्रिप्ट (ईएस 6), 41 40 39 38 बाइट्स

गणितज्ञ, 37 बाइट्स

जावास्क्रिप्ट (ईएस 6), 43 39 38 बाइट्स

हास्केल , 36 बाइट्स

जेली , 13 11 बाइट्स

यह काम किस प्रकार करता है

MATL , 15 बाइट्स

पायथन 2, 139 134 93 बाइट्स

MATL , 13 बाइट्स

व्याख्या

हास्केल , 34 33 बाइट्स

पायथन 3, 79 बाइट्स

संक्षिप्त विवरण

रूबी, 66 61 बाइट्स

सी, 47 बाइट्स

एसडब्ल्यूआई-प्रोलॉग, 70 बाइट्स

आर, 71 बाइट्स

सी, 80 बाइट्स

पायथन 2, 89 बाइट्स

पायथन 2, 60 बाइट्स

टीआई-बेसिक, 72 बाइट्स

श, 118 बाइट्स

PHP, 88 बाइट्स

टूट - फूट

हास्केल, 48 बाइट्स

रैकेट 202 बाइट्स

सी, 67 बाइट्स

पायथन 3 , 103 102 बाइट्स