हानिपूर्ण छँटाई (कार्यान्वयन ड्रॉप्सर्ट)

Question

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

इस कार्य में, आपको पूर्णांकों की सूची इनपुट (STDIN या फ़ंक्शन तर्क) के रूप में दी जाएगी, आपको कम से कम 8-बिट हस्ताक्षरित पूर्णांकों की सीमा का समर्थन करना आवश्यक है।) आपका कार्य उन्हें ड्रॉप-डाउन करना और फिर शेष तत्वों को आउटपुट करना है। गण।

आप मान सकते हैं कि सूची गैर-रिक्त है।

यह कोड गोल्फ है, इसलिए सबसे छोटा कार्यक्रम जीतता है।

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

Input             Output
1 2 5 4 3 7       1 2 5 7
10 -1 12          10 12
-7 -8 -5 0 -1 1   -7 -5 0 1
9 8 7 6 5         9
10 13 17 21       10 13 17 21
10 10 10 9 10     10 10 10 10

लीडरबोर्ड

var QUESTION_ID=61808,OVERRIDE_USER=39022;function answersUrl(e){return"https://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(e,s){return"https://api.stackexchange.com/2.2/answers/"+s.join(";")+"/comments?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){answers.push.apply(answers,e.items),answers_hash=[],answer_ids=[],e.items.forEach(function(e){e.comments=[];var s=+e.share_link.match(/\d+/);answer_ids.push(s),answers_hash[s]=e}),e.has_more||(more_answers=!1),comment_page=1,getComments()}})}function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){e.items.forEach(function(e){e.owner.user_id===OVERRIDE_USER&&answers_hash[e.post_id].comments.push(e)}),e.has_more?getComments():more_answers?getAnswers():process()}})}function getAuthorName(e){return e.owner.display_name}function process(){var e=[];answers.forEach(function(s){var r=s.body;s.comments.forEach(function(e){OVERRIDE_REG.test(e.body)&&(r="<h1>"+e.body.replace(OVERRIDE_REG,"")+"</h1>")});var a=r.match(SCORE_REG);a&&e.push({user:getAuthorName(s),size:+a[2],language:a[1],link:s.share_link})}),e.sort(function(e,s){var r=e.size,a=s.size;return r-a});var s={},r=1,a=null,n=1;e.forEach(function(e){e.size!=a&&(n=r),a=e.size,++r;var t=jQuery("#answer-template").html();t=t.replace("{{PLACE}}",n+".").replace("{{NAME}}",e.user).replace("{{LANGUAGE}}",e.language).replace("{{SIZE}}",e.size).replace("{{LINK}}",e.link),t=jQuery(t),jQuery("#answers").append(t);var o=e.language;/<a/.test(o)&&(o=jQuery(o).text()),s[o]=s[o]||{lang:e.language,user:e.user,size:e.size,link:e.link}});var t=[];for(var o in s)s.hasOwnProperty(o)&&t.push(s[o]);t.sort(function(e,s){return e.lang>s.lang?1:e.lang<s.lang?-1:0});for(var c=0;c<t.length;++c){var i=jQuery("#language-template").html(),o=t[c];i=i.replace("{{LANGUAGE}}",o.lang).replace("{{NAME}}",o.user).replace("{{SIZE}}",o.size).replace("{{LINK}}",o.link),i=jQuery(i),jQuery("#languages").append(i)}}var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk",answers=[],answers_hash,answer_ids,answer_page=1,more_answers=!0,comment_page;getAnswers();var SCORE_REG=/<h\d>\s*([^\n,]*[^\s,]),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/,OVERRIDE_REG=/^Override\s*header:\s*/i;

body{text-align:left!important}#answer-list,#language-list{padding:10px;width:290px;float:left}table thead{font-weight:700}table td{padding:5px}

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script> <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"> <div id="answer-list"> <h2>Leaderboard</h2> <table class="answer-list"> <thead> <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr></thead> <tbody id="answers"> </tbody> </table> </div><div id="language-list"> <h2>Winners by Language</h2> <table class="language-list"> <thead> <tr><td>Language</td><td>User</td><td>Score</td></tr></thead> <tbody id="languages"> </tbody> </table> </div><table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table> <table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table>

Comments

जाँच है highest < current? या highest <= current?

— मॉर्गन थ्रैप

वर्तमान तत्व रखें यदि highest (so far)<=current।

— SuperJedi224

क्या हम मान सकते हैं कि सूची में कम से कम एक तत्व होगा?

— lirtosiast

@ThomasKwa: हाँ।

— SuperJedi224

ड्रॉपअर्स सुधारने की दक्षता पेरोल प्रणाली में उपयोग किए जाने पर कंपनी को बहुत पैसा बचा सकती है।

— 21

Answer 1

एपीएल, 9 बाइट्स

⊢(/⍨)⊢=⌈\

यह आरेख के साथ एक मोनोएड फ़ंक्शन ट्रेन है:

┌─┼───┐  
⊢ ⍨ ┌─┼─┐
┌─┘ ⊢ = \
/     ┌─┘
      ⌈  

गैर-ट्रेन संस्करण है

{⍵/⍨⍵=⌈\⍵}

यह मूल रूप से जांचता है कि क्या प्रत्येक तत्व चल रहे अधिकतम के बराबर है।

ध्यान दें कि मार्टिन बट्टनर का जे सॉल्यूशन इस लंबाई के समान है और इसे पहले पोस्ट किया गया था।

Comments

बोनस अंक क्योंकि यह प्यारा लग रहा है।

— सैमिच

कोड एक बिल्ली के प्रालंब पर एक असंतुष्ट दोस्त की शूटिंग की तरह दिखता है

— स्लीपबेटमैन

मुझे बाइट काउंटिंग के बारे में ज्यादा जानकारी नहीं है और एन्कोडिंग का उपयोग करने का इरादा है, लेकिन mothereff.in/byte-counter और meta.codegolf.stackexchange.com/questions/4944/… के अनुसार यह 17 बाइट्स है, और बाइट्सइज़मैटर्स । com यह 13.

— DLeh

@DLeh यह UTF-8 में है। एपीएल की अपनी विरासत एन्कोडिंग है जो कि एपीएल चरित्र से 1 बाइट है, यूनिकोड के अस्तित्व में आने से पहले।

— इसहाक

@DLeh bytesizematters बाइट्स की गणना करने के लिए एक निर्मित एल्गोरिथ्म का उपयोग करता है, जो एक वास्तविक एन्कोडिंग के अनुरूप नहीं है (और नहीं कर सकता है )।

— डेनिस

Answer 2

जे, 10 9 बाइट्स

#~(=>./\)

मेरे CJam विचार का कार्य संस्करण (कम बाइट में)। उदाहरण के लिए:

   f =: #~(=>./\)
   f 10 10 10 9 10
10 10 10 10
   f 1 2 5 4 3 7
1 2 5 7

व्याख्या

सबसे पहले, हमें प्रत्येक उपसर्ग का अधिकतम लाभ मिलता है:

    >./\

(यहां, >.अधिकतम ऑपरेटर है, /उस ऑपरेटर को एक सूची में गुना करता है, और \इनपुट के सभी उपसर्ग प्राप्त करता है।)

तब हम समानता के लिए उन मैक्सिमा के साथ प्रारंभिक सूची की तुलना करते हैं:

  (=>./\)

और अंत में, हम उन सभी तत्वों का चयन करते हैं जहाँ बूलियन परिणामों की इस सूची ने एक 1:

#~(=>./\)

Answer 3

हास्केल, 28

foldr(\x l->x:filter(x<)l)[] 

एक अनाम फ़ंक्शन। जैसे बुलाओ

foldr(\x l->x:filter(x<)l)[] [-7, -8, -5, 0, -1, 1] 
[-7,-5,0,1]

पुनरावृत्ति के बराबर

f[]=[]
f(x:l)=x:filter(x<)(f l)

पुनरावृत्त रूप से अनुवादित, हम तत्वों पर पुनरावृति करते हैं, और हम जो भी देखते हैं, उनमें से प्रत्येक के लिए, हम इसे उस सूची के शेष भाग से छोटा निकालते हैं जिसे हम पुनरावृत्त कर रहे हैं। एंटिसिथेनस के लिए धन्यवाद एक बाइट के साथ बचाया (x<)।

Comments

मेमने की करी क्यों नहीं? कुछ वर्ण को बचाने चाहिए ...

— MathematicalOrchid

@MathematicalOrchid यदि आप का मतलब है foldr(\x->(x:).filter(>=x))[], कि एक ही लंबाई हो जाता है।

— xnor

आह। मैंने अंत में फ़िल्टर देखा और सोचा "अरे, आप करी कर सकते हैं!" मेरे साथ ऐसा नहीं हुआ कि x:आप डॉट ऑपरेटर को जोड़ने के लिए बाध्य करते हैं। ओह अच्छा ...

— MathematicalOrchid

O(n^2)हालांकि यह है । बहुत सी अनावश्यक तुलनाएँ। ;

— has पर गर्व हैकेलर २ '

क्यों नहीं बदला (> = x) to (x <)? यह 1 बाइट बचाएगी

— एंटिस्थनीज

Answer 4

पायथन 2, 49

f=lambda a:a and f(a[:-1])+a[-1:]*(a[-1]==max(a))

Comments

ये अद्भुत है।

— मॉर्गन थ्रैप

@ThomasKwa समस्या यह है कि आप पुनरावर्ती कॉल को कैसे रोकते हैं। आपको खाली मामले की आवश्यकता है भले ही इनपुट उस मामले को बाहर कर दे।

— बकुरीउ

उस के साथ समस्या यह है कि यह कारण नहीं हैmax(a)

— njzk2

@ njzk2 चुनौती को रैखिक समय में कार्यान्वित करने की आवश्यकता नहीं है।

— feersum

@ njzk2 अच्छा कोड पिछले खत्म!

— फेर्सुम

Answer 5

जावास्क्रिप्ट (ईएस 6), 29

जावास्क्रिप्ट में मानक प्रकार के रूपांतरण का दुरुपयोग, संख्या से सरणी:

• सिर्फ 1 नंबर की सरणी => वह संख्या
• किसी अन्य सरणी => NaN

d=l=>l.filter(v=>l>v?0:[l=v])

// TEST
console.log=x=>O.innerHTML+=x+'\n'

;[
  [[1,2,5,4,3,7], [1,2,5,7]]
, [[10,-1,12], [10,12]]
, [[-7,-8,-5,0,-1,1], [-7,-5,0,1]]
, [[9,8,7,6,5], [9]]
, [[10,13,17,21], [10,13,17,21]]
, [[10,10,10,9,10], [10,10,10,10]]
].forEach(t=>( i=t[0],r=d(i),x=t[1],              
  console.log('Test '+i+' -> '+r+(r+''==x+''?' OK':' Fail (expected '+x+')')))
)

<pre id=O></pre>

Comments

वाह। मुझे लगा कि 38 बाइट्स लगभग संभव है; जाहिर है मैं बहुत गलत था। +1

— ETHproductions

टेबल संचालित परीक्षण। अच्छा!

— स्लीपबेटमैन

Answer 6

ऑक्टेव, 27 19 बाइट्स

@(a)a(cummax(a)==a)

Answer 7

पायथ, 12 बाइट्स

eMfqeTeST._Q

एक बार में सभी परीक्षण मामलों की जाँच करें।

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

         ._Q  Compute all prefixes of the input.
  f           Filter; for each T in the prefixes:
    eT          Retrieve the last element of T.
      eST       Sort T and retrieve its last element.
   q            Check for equality.
              Keep T if q returned True.
eM            Select the last element of each kept T.

Answer 8

ब्रेकीलॉग , 5 बाइट्स

⊇ᶠ↔ᵒt

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

जेली , 5 बाइट्स

ŒPUÞṪ

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

व्याख्या

⊇ᶠ↔ᵒt    ŒPUÞṪ
⊇ᶠ       ŒP       On all subsequences of {the input}
   ᵒ        Þ     sort by
  ↔        U      their reverse
    t        Ṫ    then take the last element (i.e. the maximum as given by the sort)

यह एक दुर्लभ स्थिति है: मुझे एक एल्गोरिथ्म का उपयोग करने के लिए मिलता है जो (जहां तक ​​मैं एक त्वरित स्किम के साथ बता सकता था) अब तक कोई भी उपयोग नहीं कर रहा है, और यह किसी भी तरह से दो अलग-अलग गोल्फिंग भाषाओं में बहुत अलग सिंटैक्स के साथ समाप्त होता है और बिलिन सेट, कार्यक्रमों के बीच 1 से 1 पत्राचार के साथ (आदेश एक ही क्रम में हैं!)। इसलिए उन्हें संयोजित करने के लिए यह अधिक समझ में आता था - एक तरह से, ये एक ही कार्यक्रम हैं, और मैंने इसे दोनों भाषाओं में लिखा था, जो देखने के लिए छोटा था - उन्हें अलग से प्रस्तुत करने की तुलना में।

यहां मूल विचार यह है कि किसी सूची की ड्रॉप्स इसकी लेक्सिकोग्राफिक रूप से अधिकतम रिवर्स के साथ है। अजीब तरह से, न तो ब्रेकीलॉग और न ही जेली के पास किसी विशेष फ़ंक्शन द्वारा अधिकतम खोजने के लिए एक बिलिन है (जेली के पास एक विशेष फ़ंक्शन द्वारा सभी मैक्सिमा को वापस करने के लिए एक बिलिन है , लेकिन वह एक सिंगलटन सूची लौटाएगा जिसमें परिणाम स्वयं के बजाय परिणाम होगा, और यह भी इस तरह से कम से कम नहीं है)। तो इसके बजाय, हम सभी संभावित बाद उत्पन्न करते हैं, रिवर्स द्वारा क्रमबद्ध करते हैं, अंतिम लेते हैं।

"लेक्सिकोग्राफ़िक रूप से अधिकतम रिवर्स" कार्यों का कारण यह है कि चुने हुए आउटपुट को समाप्त होना चाहिए (इस प्रकार इसका रिवर्स शुरू होना चाहिए) इनपुट सूची में उच्चतम संख्या के साथ (यह देखना आसान है कि ड्रापोर्ट आउटपुट हमेशा उस के साथ समाप्त हो जाएगा), और इस तरह से कर सकते हैं उसके बाद कुछ भी नहीं होता है (क्योंकि बाद में लेने से ऑर्डर सुरक्षित रहता है)। प्रेरणात्मक रूप से दोहराएं और हम ड्रापोर्ट की परिभाषा के साथ समाप्त होते हैं।

Answer 9

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

DeleteDuplicates[#,#>#2&]&

Comments

मैं गणितज्ञ को नहीं जानता, लेकिन कुछ ऐसा है जो कॉल DeleteDuplicatesनहीं लगता है कि यह {10, 10, 10, 10}इनपुट के लिए वापस आ जाएगा{10, 10, 10, 9, 10}

— डेनिस

@ डेनिस: यह करता है, मैंने इसका परीक्षण किया। चाल यह है कि मैं "पास" "तुल्यता" परीक्षण से अधिक है। हां, यह उस फ़ंक्शन का दुरुपयोग है, लेकिन यह काम करता है, और कोड गोल्फ वैसे भी सर्वोत्तम प्रोग्रामिंग प्रथाओं के बारे में बिल्कुल नहीं है।

— celtschk 19

ठीक है, इसके बावजूद कि नाम क्या सुझाता है, DeleteDuplicatesदो तर्कों के साथ एक साधारण फ़िल्टर लगता है।

— डेनिस

Answer 10

आर, 29 26 बाइट्स

function(x)x[x>=cummax(x)]

यह एक फ़ंक्शन ऑब्जेक्ट बनाता है जो एक वेक्टर को स्वीकार करता है xऔर xसभी तत्वों को हटाने के बाद लौटता है , कम से कम उतना बड़ा नहीं जितना कि संचयी अधिकतम x।

3 बाइट्स flodel के लिए धन्यवाद बचा लिया!

Comments

फ़ंक्शन का स्वरूप छोटा होगा।

— फ्लोडेल

@flodel आप बिल्कुल सही कह रहे हैं। धन्यवाद!

— एलेक्स ए।

Answer 11

के, 11 बाइट्स

{x@&~x<|\x}

कार्रवाई में:

  f: {x@&~x<|\x}
  f'(1 2 5 4 3 7
     10 -1 12
     -7 -8 -5 0 -1 1
     9 8 7 6 5
     10 13 17 21
     10 10 10 9 10)

(1 2 5 7
 10 12
 -7 -5 0 1
 ,9
 10 13 17 21
 10 10 10 10)

Comments

{x@&~<':x}एक बाइट कम है।

— kirbyfan64sos

@ kirbyfan64sos: प्रत्येक व्यक्ति का उपयोग सही परिणाम नहीं देता है। इनपुट मामले पर विचार करें 3 4 2 2 5।

— जॉनी

ओह समझा। एक फिक्स होगा {x@&~<':x}/, लेकिन यह एक ही लंबाई है।

— kirbyfan64sos

Answer 12

जावा, 82 बाइट्स

void f(int[]a){int m=a[0];for(int n:a){System.out.print(m>n?"":n+" ");m=n>m?n:m;}}

यहाँ एक सरल आउटपुट लूप है। यह बस अधिकतम को बनाए रखता है mऔर प्रत्येक तत्व की तुलना करता है।

Comments

एक मेमने का उपयोग करके आप इसे छोटा कर सकते हैं:a->{int m=a[0]...

— डैनियल एम।

हाँ, आप आमतौर पर कर सकते हैं। हालांकि मैं लैम्ब्डा-इज़ जावा गोल्फ नहीं करता हूं।

— 17

Answer 13

पर्ल, 33 बाइट्स

32 बाइट्स कोड + -p

$p=$_;s/\S+ ?/$&>=$p&&($p=$&)/ge

अतिरिक्त रिक्त स्थान उत्पादन में स्वीकार्य हैं, को हटाने के द्वारा 31 बाइट्स हो सकता है और ?। एक स्ट्रिंग (या अलग की गई नई लाइन की संख्या) को स्वीकार करता है STDIN:

perl -pe'$p=$_;s/\S+ ?/$&>=$p&&($p=$&)/ge' <<< '-7 -8 -5 0 -1 1'
-7 -5 0 1

perl -pe'$p=$_;s/\S+ ?/$&>=$p&&($p=$&)/ge' <<< '10 10 10 9 10'
10 10 10 10

Answer 14

पायथन 3, 67

सुंदर पाशविक बल। इसे एक समारोह में बदल दिया, क्योंकि मैंने याद किया कि यह एक वैध उत्तर था।

def f(i):
 s=[i[0]]
 for n in i[1:]:
  if s[-1]<=n:s+=[n]
 return s

Ungolfed संस्करण:

input_numbers = input().split()
sorted_numbers = []
previous_number = int(input_numbers[0])
for number in map(int, input_numbers):
    if previous_number <= number:
        sorted_numbers.append(number)
        previous_number = number
print(sorted_numbers)

Comments

६२ बाइट्स

— गतिज

Answer 15

हास्केल, 38 37 बाइट्स

JArkinstall को 1 बाइट धन्यवाद दिया ।

f(x:y:s)|x>y=f$x:s|1>0=x:f(y:s)
f s=s

Comments

आप कोष्ठक के अपने सेट को एक के साथ $एक पूरे बाइट में कटौती करने के लिए बदल सकते हैं ! f(x:y:s)|x>y=f$x:s|1>0=x:f(y:s);f s=s (अर्ध-

— उपनिवेश का

Answer 16

सी# - 6864 या 132127 वर्ण

int[]f(int[]b){return b.Where((v,i)=>i<1||b[i-1]<=v).ToArray();}

Whereइस मामले में सूची के माध्यम से पुनरावृत्ति हो रही है, और सूची vमें सूचकांक iमें प्रत्येक तत्व के लिए, बूलियन अभिव्यक्ति का मूल्यांकन करता है। यदि अभिव्यक्ति सच का मूल्यांकन करती है, तो आइटम को परिणाम में जोड़ा जाता है। बूलियन अभिव्यक्ति के लिए एकमात्र वास्तविक चाल यह है कि सी # शॉर्ट सर्किट या मूल्यांकन जैसे ही एक शर्त सच का मूल्यांकन करती है। यह IndexOutOfRangeExceptionअपवाद को रोकता है, और सूची में पहला तत्व रखता है।

यदि इनपुट और आउटपुट को स्ट्रिंग्स होना चाहिए (मैं निश्चित रूप से नहीं बता सकता, तो मैं इसे ओपी और बाकी आप को तय करने के लिए छोड़ दूँगा।)

string t(string b){var c=b.Split(' ').Select(d=>int.Parse(d)).ToList();return String.Join(" ",c.Where((v,i)=>i<1||c[i-1]<=v));}

एक छोटा सा देता है:

string t(string b) 
{
    var c=b.Split(' ').Select(d=>int.Parse(d)).ToList();
    return String.Join(" ",c.Where((v, i)=>i<1||c[i-1]<=v));
}

इस मामले में फ़ंक्शन की दूसरी पंक्ति ऊपर के समान सटीक तर्क का उपयोग कर रही है। Selectपकड़ लेता सूची के तत्वों और उन्हें करने के लिए धर्मान्तरित int। करने के लिए कॉल ToList¹ चयन का मूल्यांकन होने के लिए बाध्य है, और बदल जाता है varएक में List<int>तो यह है कि, संकलन समय पर Whereपूर्णांकों का एक संग्रह पर काम कर रहा है।

इसे सी # पैड पर आज़माएं

क्रमशः ट्रिम 4 बाइट्स और 5 बाइट्स की मदद करने के लिए विजुअलमेलन को धन्यवाद । :)

_{1 टूटू सूची?}

Comments

अगर मैं दुखी हूं, या यदि मेरे स्पष्टीकरण में कुछ स्पष्टीकरण की आवश्यकता है, तो कृपया मुझे बताएं। :)

— बीबी

अच्छा काम - आप कुछ सामान्य ट्रिक्स का उपयोग करके कुछ बाइट्स बचा सकते हैं - सरणी घोषणाओं int[]f(int[]b)के ठीक होने के बाद आपको रिक्त स्थान की आवश्यकता नहीं होती है, और आप इसका उपयोग कर सकते हैं i<1बजाय इसके i==0कि थोड़ा जाँच करें। स्ट्रिंग संस्करण के लिए, आप एक एकल-तर्क के चारों ओर ब्रैकेट को लंबोदर में भी छोड़ सकते हैं (उदाहरण के (d)=>int.Parse(d)लिए d=>int.Parse(d)। मैं भी केवल 67 बाइट्स गिन सकता हूं, 68 नहीं, आपके

— ओरिगनल में

@VisualMelon - धन्यवाद! मुझे लगा कि कोई भी उपद्रव कुल को बड़ा बना देगा। ;)

— बी

Answer 17

सीजेएम, 15 बाइट्स

q~{_2$<{;}&}*]p

CJam दुभाषिया में इसे ऑनलाइन आज़माएं ।

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

q~               Read an evaluate all input.
  {        }*    Reduce; push the first element; or each remaining element:
   _2$           Copy the topmost and second topmost element from the stack.
      <          Check if the topmost is smaller than the second topmost.
       {;}&      If it is, remove it from the stack.
             ]   Wrap the stack i an array.
              p  Print.

Answer 18

पॉवरशेल , 32 बाइट्स

$args|?{$e-eq$p-or$_-ge$p;$p=$_}

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

कम गोल्फ वाला:

$args|?{
    $empty -eq $previous -or $_ -ge $previous
    $previous = $_
}

Answer 19

सी: 73 बाइट्स

int i,j;i=j=INT_MIN;while(scanf("%d",&j)!=EOF)if(j>=i)printf("%d",j),i=j;

या

C: 49 बाइट्स

(यदि कोडगुल्ल प्रतियोगिताओं के लिए बनाए गए सीमा शुल्क हेडर की अनुमति है)

I z,y;z=y=INT_MIN;w(s(D,&y)!=E)i(y>z)p(D,y),z=y;}

फिर भी सीजेएम को हरा नहीं सकते, लेकिन कम से कम यह कुछ अन्य भाषाओं को हरा सकता है।

Comments

क्षमा करें, कस्टम हेडर की अनुमति नहीं है; यह एक अलग भाषा के रूप में गिना जाएगा।

— lirtosiast

आपके कस्टम हेडर के साथ प्राथमिक समस्या यह है कि आपने उन्हें इस प्रतियोगिता के शुरू होने के बाद प्रकाशित किया है।

— डेनिस

निश्चित रूप से मैं समझता हूं, लेकिन फिर मैं इसे न तो भविष्य की प्रतियोगिताओं में उपयोग कर सकता हूं?

— GameDeveloper

@DarioOO आप कर सकते हैं, लेकिन आपको अपने बाइट काउंट की ओर आयात स्टेटमेंट को शामिल करना होगा।

— SuperJedi224

या बस इसे एक नई भाषा कहते हैं।

— कैलक्यूलेटरफ्रिनलाइन

Answer 20

बर्लेस्क, 13 बाइट्स

परीक्षण मामलों से गुजरने वाले 11 बाइट समाधान:

-.2CO:so)[~

यहाँ ऑनलाइन कोशिश करें ।

व्याख्या:

-. -- prepend head of list to list
2CO -- n-grams (sliding window) of size 2
:so -- filter sorted lists
)[~ -- map last

हालांकि, यह संस्करण केवल इस तथ्य का उपयोग करके काम करता है, कि कोई दो छोटी संख्याएं दो संख्याओं के बीच में नहीं हैं। अन्यथा नीचे दिए गए संस्करण का उपयोग करें (जो 13B है):

पुराने संस्करण:

J-]{cm-1.>}LO

यहाँ ऑनलाइन कोशिश करें। स्पष्टीकरण:

J -- duplicate
-] -- head
{
  cm -- compare (returning -1,0 or 1)
  -1.> -- greater than -1
}LO -- Loop

यदि आप समान संख्याओं को छोड़ देते हैं तो आप .>उपयोग करने के बजाय बस साथ जा सकते हैं cm। इसके अलावा, यदि सूचियों में केवल सकारात्मक संख्याएँ हैं, जिनका आप उपयोग कर सकते हैं 0या -1इसके बजाय J-]।

Comments

हाँ, लेकिन तब मैं इसे हाइपरलिंक नहीं कर सकता :)।

— मरमं।

तय की। मैं सिर्फ एक "यहाँ ऑनलाइन कोशिश" लाइन जोड़ूंगा।

— मरमं।

Answer 21

मिंकोलंग 0.9 , 18 बाइट्स

ndN(nd1R`2&dN$I$).

इसे यहाँ आज़माएँ।

व्याख्या

ndN                Take first integer from input
(         $I$).    Repeat until the input is empty and then stop.
 nd1R`             Is the next integer less than the previous one?
      2&dN         If not (i.e., it's greater than or equal to), print it.

Answer 22

रूबी, ४१ ३y अक्षर

->a{m=a[0];a.map{|n|m>n ?p: m=n}-[p]}

नमूना रन:

2.1.5 :001 > [
2.1.5 :002 >     [1, 2, 5, 4, 3, 7],
2.1.5 :003 >     [10, -1, 12],
2.1.5 :004 >     [-7, -8, -5, 0, -1, 1],
2.1.5 :005 >     [9, 8, 7, 6, 5],
2.1.5 :006 >     [10, 13, 17, 21],
2.1.5 :007 >     [10, 10, 10, 9, 10],
2.1.5 :008 > ].each{ |test| p ->a{m=a[0];a.map{|n|m>n ?p: m=n}-[p]}[test] }
[1, 2, 5, 7]
[10, 12]
[-7, -5, 0, 1]
[9]
[10, 13, 17, 21]
[10, 10, 10, 10]

Comments

-[p]से कम है.compact

— नहीं है कि चार्ल्स

उफ़। बेशक। धन्यवाद। (खुद पर ध्यान दें: रूबी [/ लिंक] में गोल्फिंग के लिए [लिंक codegolf.stackexchange.com/questions/363/… को अपवोट करने के लिए पर्याप्त नहीं है , मुझे उन्हें भी याद रखना चाहिए।)

— मैनीक्योर

Answer 23

NARS2000 APL, 13 बाइट्स

NARS2000 विंडोज के लिए एक मुफ्त एपीएल दुभाषिया है; इसमें ऑपरेटर के साथ एक्सेस की जाने वाली मल्टीसेट सुविधाएं शामिल हैं ⍦।

(+⍦∩⌈\)

यह एक मोनोडिक कांटा है जो ⍦∩इनपुट के बहुस्तरीय चौराहे ( +) * और चलने वाले मैक्सिमम ( ⌈\) की सूची लेता है ।

चूंकि ⍦एक-बाइट एपीएल विरासत एन्कोडिंग में एक मानक एपीएल चरित्र नहीं है, इसलिए हमें यूटीएफ -8 का उपयोग करना चाहिए, जिससे ⍦∩⌈पात्रों को प्रत्येक तीन बाइट्स मिलेंगे। मैंने दो बाइट बचाने के +बजाय चुना ⊢।

NARS2000 कांटे का समर्थन करता है, जो कोष्ठक के बिना ट्रेनों में बनाया जा सकता है, लेकिन Dyalog के विपरीत यह कोष्ठक में फ़ंक्शन को लपेटे बिना फ़ंक्शन को असाइन करने की अनुमति नहीं देता है।

* +तकनीकी रूप से जटिल संयुग्म है, लेकिन इनपुट वास्तविक है।

Comments

तो, क्यों codegolf.stackexchange.com/questions/61808/… यहाँ भी लागू नहीं होता है?

— कैट

NARS2000 विरासत एपीएल एनकोडिंग का उपयोग नहीं कर सकता है - और नियम से पहले भी कि एनकोडिंग वास्तव में दुभाषियों द्वारा उपयोग किया जाना चाहिए, यह 7 बाइट्स नहीं हो सकता है क्योंकि साई किसी भी विरासत एपीएल एन्कोडिंग का हिस्सा नहीं है।

— lirtosiast

Answer 24

> <> -v ध्वज के साथ, 36 31 + 2 = 33 बाइट्स

:&\o " "&n:~& <
~ >l?!;:&:&(?!^

-V के साथ स्टैक पर सूची इनपुट करें ताकि सूची का पहला तत्व स्टैक के शीर्ष पर हो। यह एक अनुगामी स्थान के साथ ड्रॉपडाउन सूची को प्रिंट करेगा।

परीक्षण चालन :

$ for input in "1 2 5 4 3 7" "10 -1 12" "-7 -8 -5 0 -1 1" "9 8 7 6 5" "10 13 17 21" "10 10 10 9 10"; do echo $input '-> ' $(python fish.py dropsort.fsh -v $(echo $input | tac -s ' ')); done

1 2 5 4 3 7 ->  1 2 5 7

10 -1 12 ->  10 12

-7 -8 -5 0 -1 1 ->  -7 -5 0 1

9 8 7 6 5 ->  9

10 13 17 21 ->  10 13 17 21

10 10 10 9 10 ->  10 10 10 10

संपादित करें: फोंगॉइड के लिए 5 बाइट्स सहेजे गए

Comments

आप 5 बाइट्स को 1 के रूप में लाइन 1 :&\o" "&n:~& <और लाइन 2 को फिर से शुरू करके बचा सकते हैं~ >l?!;:&:&(?!^

— फोन्गॉइड

@Fongoid धन्यवाद, अद्यतन!

— हारून

Answer 25

पायथन, 102 99 94 + 5 6 नॉन-फाइल-फाइनल न्यूलाइन्स = 107 105 100 बाइट्स

(मैंने इंडेंटेशन के लिए टैब का इस्तेमाल किया)

def d(l):
    j=b=0;m=l[j];r=[]
    for i in l:
        (m,b)=[(m,0),(i,1)][i>=m]
        if b>0:r+=[i]
        j+=1
    l[:]=r

वहाँ सबसे अच्छा नहीं है, लेकिन यह कोड गोल्फ में मेरा पहला शॉट है। निष्कासन से संबंधित बगों में सूची इनलाइन को सॉर्ट करने का तरीका समझ नहीं सका, इसलिए मैंने आदेशित तत्वों को एक अस्थायी सूची में स्थानांतरित कर दिया।

EDIT: list.append () यह बदसूरत तरीका करने से छोटा है

r + = [i] list.append () से कम था; धन्यवाद njzk2 !

Comments

r + = [i] r.append से छोटा है

— njzk2

मैंने पहले भी ऐसा करने की कोशिश की थी, लेकिन मुझे एक त्रुटि मिली क्योंकि मुझे एहसास नहीं था कि आपको इसे कोष्ठक के साथ करना है। धन्यवाद!

— जेम्स मर्फी

Answer 26

स्काला: 232 126 120 बाइट्स

def f(x:Int*)=(Seq[Int]()/:x)((r,y)=>r.headOption.filter(y>=).map(_=>y+:r).getOrElse(if(r.isEmpty) y+:r else r)).reverse

Comments

List[Int]आवश्यकताओं को पूरा नहीं करने के लिए एक "विस्तार विधि" जोड़ना , आपको इनपुट STDIN के माध्यम से या एक तर्क के रूप में मिलना चाहिए। इसके अलावा, यह आपके उत्तर को धुंधला कर देता है ... बस क्यों नहीं def dropSort(s:Seq[Int]):Seq[Int]?

— जैकब

मुझे लगा कि यह फैंसी होगा, लेकिन आप सही कह रहे हैं, वैसे भी बहुत ज्यादा बाइट्स ...

— मार्टिन सेलेर

गुना का उपयोग करके बहुत अच्छा सुधार! आप अभी भी कुछ स्थानों को शेव कर सकते हैं और साथ ही आप y> = का उपयोग कर सकते हैं बजाय _ <= y जो एक उचित आयात के बिना एक संकलन की चेतावनी देता है, लेकिन यह भी दर्शाता है कि स्काला कितना भयानक है (ओह, और किसी अन्य चरित्र को बंद कर देता है)।

— जैकब २

Tipp के लिए Thx!

— मार्टिन सीलर

Answer 27

स्काला, 54 बाइट्स

def f(x:Int*)=(x:\Seq[Int]())((y,r)=>y+:r.filter(y<=))

Ungolfed:

def dropSort(xs: Seq[Int]): Seq[Int] =
  xs.foldRight(Seq.empty[Int]) { (x, result) =>
    x +: result.filter(r => r >= x)
  }

Answer 28

टाइनी लिस्प, 107 बाइट्स

( इस भाषा केवल प्रकाशित किया गया था इस सवाल के बाद, तो यह जवाब प्रतियोगिता से बाहर चलाता है। ऐसा नहीं है कि इसे जीतने के लिए कोई मौका नहीं था। भाषा बाद में आगे विकसित लोगों को मैं यहां इस्तेमाल किया और अधिक से अधिक buildins के लिए है, लेकिन मैं के साथ रह रहा हूँ संस्करण I मूल रूप से 2015 में लागू किया गया था। यह उत्तर अभी भी नए आधिकारिक दुभाषिया के साथ काम करता है , हालांकि यह कुछ चेतावनी देता है क्योंकि मैं एक पैरामीटर को परिभाषित करता हूं जो नए _{बिल्डिन} (जोड़ने के लिए) _{को छाया देता है। TIO लिंक के लिए DLosc का धन्यवाद।} )aa

(d r(q((m a)(i a(i(l(h a)m)(r m(t a))(c(h a)(r(h a)(t a))))()))))(d ds(q((b)(i b(c(h b)(r(h b)(t b)))()))))

यह एक फ़ंक्शन ds(और इसके पुनरावर्ती सहायक फ़ंक्शन r) को परिभाषित करता है जो इसके तर्क को सॉर्ट करता है, जो पूर्णांकों की एक सूची होनी चाहिए।

r एक पूंछ-पुनरावर्ती कार्य नहीं है, इसलिए बहुत लंबी सूचियों के लिए यह स्टैक ओवरफ्लो में चल सकता है।

Ungolfed:

(d r
   (q((m a)
      (i a
         (i (l (h a) m)
            (r m (t a))
            (c (h a)
               (r (h a) (t a))
             )
          )
         ()
       )
   ) )
 )
(d ds
  (q(
      (b)
      (i b
        (c (h b)
           (r (h b) (t b))
         )
        ()
       )
   ) )
 )

इसका उपयोग करने के कुछ उदाहरण यहां दिए गए हैं (प्रश्न से परीक्षण मामलों के साथ):

(d list (q (args args)))
(d -
   (q( (n)
       (s 0 n)
    ) )
 ) 

(ds (list 1 2 5 4 3 7))
(ds (list 10 (- 1) 12))
(ds (list (- 7) (- 8) (- 5) 0 (- 1) 1))
(ds (list 9 8 7 6 5))
(ds (list 10 13 17 21))
(ds (list 10 10 10 9 10))

(हाँ, -7पूर्णांक शाब्दिक नहीं है, इसलिए हमें उनका प्रतिनिधित्व करने के लिए एक फ़ंक्शन को परिभाषित करना होगा।) आउटपुट

list
-
(1 2 5 7)
(10 12)
(-7 -5 0 1)
(9)
(10 13 17 21)
(10 10 10 10)

Comments

"-7 एक पूर्णांक शाब्दिक नहीं है" मैं अभी भी हँस रहा हूँ, +1

— बिल्ली

क्या आपने वास्तव में बिल्डरों के लिए हर एक चरित्र का उपयोग किया है? (सिवाय r, मुझे लगता है ..)

— कैलकुलेटर

@CatsAreFluffy क्षमा करें, मुझे आपकी टिप्पणी को समझने में समस्याएं हैं। टाइनी लिस्प में 7 बिल्ड-इन फ़ंक्शन और तीन बिल्ड-इन मैक्रोज़ हैं, जिनमें से सभी में एकल चरित्र-नाम हैं (मुझे लगता है कि गोल्फ के लिए भाषा को आसान बनाना आसान है), जिसमें कोष्ठक और स्थान विशेष वाक्यविन्यास हैं। ध्यान दें कि टिनी लिस्प मेरा आविष्कार नहीं है।

— पाओलो एबरमन

आह, मुझे लगता है कि मैं इसे अभी प्राप्त करता हूं ... आप इसके बजाय एकल-वर्ण नाम का उपयोग करने का प्रस्ताव कर रहे हैं ds? मुझे लगता है कि यह किया जा सकता है, एक और बाइट को बचाएगा। मुझे लगता है कि मैंने dsड्रॉप सॉर्ट के लिए एक संक्षिप्त नाम के रूप में चयन किया है।

— पाओलो एबरमन

अरे, मैंने अभी इस पर ध्यान दिया। अच्छी नौकरी! मेटा सर्वसम्मति के अनुसार, अनाम लैम्बडा फ़ंक्शंस प्रस्तुत करने का एक मान्य रूप है, इसलिए आप छुटकारा पाने (d dsऔर )अंत में मिलान से 6 बाइट्स बचा सकते हैं । अन्य गोल्फ संभव है यदि आप मेरे वर्तमान दुभाषिया का उपयोग करना चाहते हैं , लेकिन यदि आप मूल प्रश्न में अटकल से चिपके रहना चाहते हैं, तो यह ठीक है। :)

— DLosc

Answer 29

जेली, 5 बाइट्स

=»\Tị

ध्यान दें कि चुनौती जेली के निर्माण से पहले की है।

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

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

=»\Tị  Main link. Argument: A (list)

 »\    Yield the cumulative maxima of A.
=      Perform element-by-element comparison.
       Yields 1 iff A[n] = max(A[1], ..., A[n]).
   T   Get all indices of truthy elements.
    ị  Retrieve the items of A at those indices.

Answer 30

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

Pick[#,#-Max~FoldList~#,0]&