कम से कम सबसे लंबे समय तक बढ़ते परिणाम कोड

Question

चुनौती सबसे लंबे समय तक बढ़ने के बाद सबसे कम कार्यान्वयन को लिखना है ।

उदाहरण : आज्ञा दें S अनुक्रम 1 5 7 1 8 4 3 5 [S = 8 की लंबाई]

• हमारे पास लंबाई का 1 उप-अनुक्रम है [इसे बढ़ाने पर विचार करेंगे]
  
• लंबाई 1 के 6 उप-क्रम 1 {1,5,7,8,4,3} [उन सभी को बढ़ता हुआ माना जाता है]
  
• ((* 2) / २ लंबाई के २ उप-क्रम [लेकिन हम डुप्लिकेट हटा देंगे], बढ़ते हुए उप-सेक् स मजबूत काले रंग में हैं।
  { 15,17 , 11, 18,14,13,57 , 51, 58 , 54,53,55,71, 78 , 74,73,75,84,83,85,43, 45,35 }
  

[ध्यान दें कि हम केवल उप-अनुक्रमों को सख्ती से बढ़ाने में रुचि रखते हैं]

[आप अनुक्रम के अंदर तत्वों के क्रम को नहीं बदल सकते हैं , इसलिए उदाहरण अनुक्रम में कोई उप-अनुक्रम [37] नहीं है]

• हमारे पास लंबाई 4 के उप-अनुक्रम हैं जो 1578 है, लेकिन लंबाई 5 का कोई उप-अनुक्रम नहीं है, इसलिए हम सबसे लंबे समय तक बढ़ते उप-अनुक्रम = 4 की लंबाई पर विचार करते हैं।
  

इनपुट :

ए ₁ ए ₂ ... _एन (अनुक्रम)

सभी संख्याएँ सकारात्मक पूर्णांक 10 ³
N <= 1000 से कम हैं

आउटपुट :

एक पूर्णांक इनपुट अनुक्रम के सबसे लंबे समय तक बढ़ते उप-अनुक्रम की लंबाई को दर्शाता है।

sample input(1)
1 2 4 2 5
sample output(1)
4

sample input(2)
1 5 7 1 8 4 3 5
sample output(2)
4

आपका कोड समयबद्ध तरीके से चलना चाहिए, कृपया इस कोड पर अपने कोड को यहां जमा करने से पहले परीक्षण करें (लिंक में मेरा 290-बाइट c + 11 समाधान भी है)

आप या तो फ़ाइल / स्टड से इनपुट ले सकते हैं या फ़ंक्शन पैरामीटर के रूप में और आप आउटपुट को फाइल / स्टडआउट में प्रिंट कर सकते हैं या यदि आप फ़ंक्शन लिखते हैं तो केवल मान लौटा सकते हैं

स्कोर बोर्ड

1. डेनिस सीजाम - 22
2. isaacg Pyth - 26
3. हॉवर्ड गोल्फस्क्रिप्ट - 35
4. गर्व हैस्केलर हास्केल - 56
5. रे पायथन 3 - 66
6. हिस्टोक्रेट रूबी - 67
7. DLeh C # - 92
8. योसेमाइटमार्क क्लॉजुर - 94
9. faubiguy पायथन 3 - 113

Comments

"हमारे पास लंबाई के 1 उप-अनुक्रम 0 है [इसे बढ़ाने पर विचार करेंगे]", तकनीकी रूप से आपके पास 0-लंबाई उप-अनुक्रमों की अनंत संख्या है :)

— Cruncher

वास्तव में, मुझे बयान बदलना होगा ताकि सभी "सेट" डुप्लिकेट को हटा दें, उदाहरण के लिए {1,5,7,1,8,4,3,5} {1,5,7,8,4 होना चाहिए , 3} और फिर हम यह कह सकते हैं कि "सेट" में 1 0-लंबाई की समानता है। धन्यवाद

— मुस्तफा 36a2

कार्यों के लिए, क्या हमें बाहरी फ़ंक्शन ( function f(){...}) या आंतरिक फ़ंक्शन (बस ...) के बाइट्स को गिनना चाहिए ? यदि हम बाहरी कार्यों को गिनते हैं, तो क्या अनाम कार्यों की अनुमति है?

— डेनिस

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

— मोस्टफा 36a2

Answer 1

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

1e3,q~{_2$<$0=(t}/$0=z

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

उदाहरण

$ cjam subsequence.cjam <<< '[2 1]'; echo
1
$ cjam subsequence.cjam <<< '[1 9 2 4 3 5]'; echo
4

कार्यक्रम प्रिंट 57के लिए इस परीक्षण का मामला 0.25 सेकंड के बाद।

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

मैंने @ रे के उत्तर से सामान्य विचार लिया ।

1e3,    " Push the array [ 0 ... 999 ] (J).        ";
q~      " Read from STDIN and evaluate.            ";
{       " For each integer (I) of the input array: ";
  _2$<  " Push [ J[0] ... J[I - 1] ] (A).          ";
  $0=(  " Compute min(A) - 1.                      ";
  t     " Update J[I] with the value on the stack. ";
}/      "                                          ";
$0=     " Compute abs(min(J)).                     ";

Answer 2

पायथन 3, 66

ध्यान दें कि सभी संख्याएँ रेंज [1, 999] में हैं, हम bप्रत्येक संख्या के साथ सबसे लंबे समय तक चलने की लंबाई को बनाए रखने के लिए एक सरणी का उपयोग कर सकते हैं । b[x] = dइसका मतलब है कि सबसे लंबे समय तक चलने वाली अंत xकी लंबाई है d। इनपुट से प्रत्येक संख्या के लिए, हम उपयोग करके ऐरे को अपडेट करते हैं b[x] = max(b[:x]) + 1और फिर max(b)अंत में ले जाकर हमें काम मिल जाता है ।

समय जटिलता है पर) ओ (एमएन) , जहां mहमेशा 1000 है और nइनपुट तत्वों की संख्या है।

def f(a):
 b=[0]*1000
 for x in a:b[x]=max(b[:x])+1
 return max(b)

वाह, पहले से ही अपुष्ट लग रहा है :) आप एक लाइन जोड़कर स्टड / स्टडआउट का उपयोग करके इसका परीक्षण कर सकते हैं:

print(f(map(int,input().split())))

Comments

for x in a: max(b)बहुत ज्यादा लग रहा है O (n ^ 2)।

— हॉवर्ड

@ हॉवर्ड यह O(1000 n)और 1000 एक स्थिर है। आप भी इसे सोच सकते हैं O(m n)।

— रे

इस तरह के तर्क के साथ पूरी चर्चा बेकार जटिलता हमेशा सीमित इनपुट पर क्योंकि है O(1);-)

— हावर्ड

@ हावर्ड मैं ACM-ICPC दुनिया से आता हूं और यह कुछ हद तक एक सम्मेलन है। आप इसे O (mn) के रूप में सोच सकते हैं। यह अभी भी O (n ^ 2) से अलग है। वैसे भी, यह लागत इंटरप्रेटर स्टार्ट-अप समय से कम होगी इसलिए मुझे लगता है कि यह काफी तेज है।

— रे

प्रभावशाली कम एल्गोरिदम! मैं केवल एक चरित्र (कम से कम पायथन 2 पर स्विच करते समय) स्पॉट कर सकता हूं: आप परिणाम प्रिंट कर सकते हैं। printसे छोटा है return।

— फाल्को

Answer 3

अजगर - 113

a=[]
for i in map(int,input().split()):
 if not a or i>a[-1]:a+=[i]
 z=0
 while a[z]<i:z+=1
 a[z]=i
print(len(a))

Comments

स्वीकृत समाधान। आपके कोड का परीक्षण यहां और यहां किया गया है ।

— मुस्तफा 36a2

@ Mostafa36a2 शब्द "स्वीकृत" का इस साइट पर एक और अर्थ है। मुझे लगता है कि आपका मतलब "स्वीकार्य" है।

— रे

क्षमा करें, हां मेरा मतलब स्वीकार्य था, स्वीकृत को चुनने के लिए बहुत जल्दी।

— मुस्तफा 36a2

लाइन a+=[i]*(a==[]or i>a[-1]);z=0और प्रिंटिंग के साथ len(a)(कोष्ठक के बिना) आप 4 वर्णों को बचा सकते हैं।

— फाल्को

Answer 4

पायथ , २६ २ ९ ३३ ३ ९

J*]0^T3Fkyw=@JkheS:J0k)eSJ

@ रे के समाधान का पोर्ट। आधिकारिक परीक्षण पास करता है। अब स्पेस-अलग-अलग STDIN इनपुट का उपयोग करता है, फ़ंक्शन कॉल नहीं।

निम्नानुसार चलाएं:

./pyth.py -c "J*]0^T3Fkyw=@JkheS:J0k)eSJ" <<< "1 5 7 2 8 4 3 5"
4

स्पष्टीकरण:

J*]0^T3                 J = [0]*10^3
Fkyw                    For k in space_sep(input()):
=@Jk                    J[k]=
heS:J0k                 max(J[0:k])+1
)                       end for
eSJ                     max(J)

---

समय असीमित:

अजगर , १,

L?eS,ytbhyf>Thbbb0

---

तकनीकी नोट: मैंने इस गोल्फ को लिखते समय अपने पाइथ में एक बग को देखा। Lकाम नहीं कर रहा था। यही कारण है कि उपरोक्त गिट रिपॉजिटरी के लिए हाल ही में एक प्रतिबद्ध है।

Comments

आपका कोड बड़ी सूची वाले किसी मामले के लिए समयबद्ध तरीके से नहीं चलता है (100 तत्व

— कहिए

@ Mostafa36a2 यदि आप रनटाइम की आवश्यकता बनाना चाहते हैं, तो कृपया प्रश्न में ऐसा कहें, और एक परीक्षण मामला या दो जोड़ दें। अगर यह सिर्फ एक टिप्पणी है, तो मैं सहमत हूं, यह बहुत धीमी है।

— isaacg

क्षमा करें, लेकिन मैंने उल्लेख किया है कि रनटाइम नहीं है, लेकिन कम से कम [समय पर ढंग], कोई समस्या नहीं अगर कोड में 10-20 मिनट या एक घंटे लगते हैं, लेकिन O (2 ^ n) समाधान कभी भी परिणाम नहीं देगा हमारा लंबा जीवन।

— मुस्तफा 36a2

@ Mostafa36a2 समझ गया, मैंने बस उस लाइन पर ध्यान दिया। मैं एक सुधार पर काम करेंगे।

— isaacg

क्षमा करें, मैं अब अपडेट देख रहा हूं, कृपया इस मामले को आजमाएं और मुझे बताएं कि क्या यह काम करता है।

— मुस्तफा 36a2

Answer 5

क्लोजर, 94 अक्षर

1000-आइटम वेक्टर में अपडेट के परिणामों के लिए @ रे के दृष्टिकोण का उपयोग करना:

(defn g[s](apply max(reduce #(assoc % %2(inc(apply max(take %2 %))))(into[](repeat 1e3 0))s)))

प्रति अनुरोध, प्रिंट स्टेटमेंट के साथ (उत्तर प्रिंट करेगा और शून्य लौटाएगा)। इनपुट एक वेक्टर होना चाहिए (g [1 2 3]) या एक सूची (g '(1 2 3)):

(defn g[s](prn(apply max(reduce #(assoc % %2(inc(apply max(take %2 %))))(into[](repeat 1e3 0))s))))

Comments

क्या आप इसे परीक्षण योग्य बनाने के लिए प्रिंट स्टेटमेंट जोड़ सकते हैं? इसे अंक में नहीं गिना जाएगा।

— मुस्तफा 36a2

अपडेट किया गया। मैंने इसे आपके दोनों बड़े उदाहरणों पर चलाया है, और उम्मीद के मुताबिक 58 और 57 मिले हैं।

— योसेमाइटार्क

मुझे लगता है कि आपको अभी भी फ़ंक्शन को कॉल करने की आवश्यकता है: पी, लेकिन अगर आपने इसे परीक्षण किया है तो यह पर्याप्त है।

— मुस्तफा 36a2

Answer 6

हास्केल, 58 57 56 वर्ण

(x:s)%v|v>x=x:s%v|0<1=v:s
_%v=[v]
l s=length$foldl(%)[]s

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

Comments

आपके द्वारा उल्लिखित एल्गोरिथ्म वही है जो @faubiguy द्वारा उपयोग किया जाता है।

— रे

@ आप सही कह रहे हैं

— गर्वित हेकेलर

Answer 7

GolfScript, 35 वर्ण

~]]){1${~2$<*)}%1+$-1>[\+]+}/$-1=0=

STDIN पर इनपुट के साथ एक पूर्ण कार्यक्रम के रूप में कार्य करने वाला कार्यान्वयन (दिए गए लंबाई की संख्या के बिना)। कार्यान्वयन लंबे समय तक इनपुट के लिए उचित है, यहां तक ​​कि ( यहां प्रयास करें )।

उदाहरण:

> 1 5 7 1 8 4 3 5
4

> 5 1 9 9 1 5
2

Comments

@ मार्टिनबटनर मेरे कंप्यूटर पर 1000 नंबर के लिए लगभग 5 सेकंड लगते हैं। मान लिया $जाता है कि O (n log n) एल्गोरिथ्म O (n ^ 2 log n) है।

— हावर्ड

कृपया इस लिंक

— Mostafa 36a2

@ Mostafa36a2 मैंने पहले ही किया था (टिप्पणी पहले देखें)। 5 सेकंड के बाद यह 58 पर लौटता है

— हॉवर्ड

यह एक और एक है, यह 57 को वापस आ जाना चाहिए, इसलिए यदि आपका कोड 57 लौटा है तो इसे स्वीकार कर लिया गया है :) बधाई हो

— Mostafa 36a2

@ Mostafa36a2 आह, अब मैं देख रहा हूं कि वे दो अलग-अलग परीक्षण मामले हैं। हां, आपका दूसरा लिंक 57 देता है क्योंकि इस इनपुट पर मेरा समाधान है।

— हावर्ड

Answer 8

रूबी, 67

s=Hash.new{|s,a|f,*r=a
s[a]=f ?[1+s[r.select{|x|x>f}],s[r]].max: 0}

बड़े इनपुट पर यह 30 सेकंड में चलता है, क्या यह समय पर गणना करता है? : p

यह क्रूर पुनरावृत्ति है, लेकिन कुछ संस्मरण के साथ।

Comments

हां, यह समयबद्ध तरीके से है :)

— मुस्तफा 36a2

Answer 9

सी #, 172 92 वर्ण

कुछ खास नहीं, लेकिन मैंने ऐसा किया तो मुझे लगा कि मैं इसे जमा कर सकता हूं।

int a(int[] j){int c=2,m=2,i=1;for(;++i<j.Length;){c=j[i]>j[i-1]?c+1:2;m=c>m?c:m;}return m;}

धन्यवाद Armin और बॉब उनके सुधार के लिए!

Comments

आप अपने पैरामीटर को int [] में बदल सकते हैं और फिर आपके पास कम वर्ण होंगे क्योंकि आपको int को स्ट्रिंग करने की आवश्यकता नहीं होगी

— Armin

आसपास के स्थान =>अनावश्यक हैं। आप i=0घोषणा को forलूप के बाहर भी ले जा सकते हैं int c=2,m=2,i=0;for(;। आप forशरीर के चारों ओर ब्रेसिज़ भी गिरा सकते हैं , क्योंकि आपके पास केवल एक ही बयान है।

— बॉब

और c++;if(c>m)m=c;हो सकता है m=c++>m?m:c;, और आप फिर से उसके चारों ओर ब्रेस उतार सकते हैं।

— बॉब

वास्तव में, आप 1. लूप शुरू if(i>0)करके चेक को भी छोड़ सकते हैं for। आप int c=2,m=2,i=0;for(;i<j.Length;i++)if(i>0)पहले दिए गए सुझाव को और छोटा कर सकते हैं int c=2,m=2,i=0;for(;i++<j.Length;)। उस पूरे खंड को परिवर्तित किया जा सकता है int c=2,m=2,i=0;for(;i++<j.Length;){c=j[i]>j[i-1]?c+1:2;m=c>m?m:c;}(अंतिम शेष को बदलने के लिए एक और टर्नरी का उपयोग करना if- अंगूठे का नियम कम है यदि आपका ifशरीर बस एक असाइनमेंट है।

— बॉब

क्षमा करें - मेरी पिछली टिप्पणी में टाइपो, m=c>m?m:cहोना चाहिए m=c>m?c:m। और अगर आप @ अर्मिन के सुझाव में जोड़ते हैं, तो आपको 92 बाइट्स मिलते हैं, जो आकार को लगभग आधा कर देते हैं! int a(int[] j){int c=2,m=2,i=0;for(;i++<j.Length;){c=j[i]>j[i-1]?c+1:2;m=c>m?c:m;}return m;}

— बॉब

Answer 10

जे , 19 बाइट्स

[:#]`I.`[} ::,~/@|.

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

O (n log n) में रन करता है , केवल लंबाई के बाद से संशोधित धैर्य प्रकार का उपयोग करते हुए, वास्तविक बाद की आवश्यकता नहीं है।

व्याख्या

[:#]`I.`[} ::,~/@|.  Input: array
                 |.  Reverse
               /     Reduce right-to-left
     I.                Find the index to insert while keeping it sorted
                       (uses binary search)
         }             Amend the current search array at that index with the next value
           ::          If error (when the index is not found)
             ,           Append the value at the end
 #                   Length of that array

Answer 11

बैश + कोरुटिल्स, 131 बाइट्स

यह समाधान समय पर आवश्यकता के अनुसार बुरी तरह से विफल हो जाता है, और विशेष रूप से कम भी नहीं है, लेकिन मुझे यह पसंद आया कि शेल स्क्रिप्ट में इस तरह की चीज कम से कम सैद्धांतिक रूप से संभव है, इसलिए मैं वैसे भी पोस्ट कर रहा हूं। यह O (2 ^ n) की अनंत काल-उत्प्रेरण समय जटिलता के साथ चलता है।

s=${1//,/,:\},\{}
a=`eval echo "{$s,:}"`
for s in $a;{
b="$(tr , \\n<<<$s|grep -v :)"
sort -nC<<<"$b"&&wc -w<<<$b
}|sort -nr|sed 1q

इनपुट एक अल्पविराम से अलग की गई सूची है जिसे एक कमांड-लाइन तर्क के रूप में पारित किया गया है:

$ time ./slisc.sh 1,5,7,1,8,4,3,5
4

real    0m1.240s
user    0m0.518s
sys 0m0.689s
$ 

ब्रेस विस्तार का उपयोग सभी संभव बाद की सूची बनाने के लिए किया जाता है।

• पहली पंक्ति के साथ अल्पविराम बदलता है ,:},{ करता है, जो एक स्ट्रिंग की तरह पैदा करता है1,:},{5,:},{7,:},{1,:},{8,:},{4,:},{3,:},{5
• दूसरी पंक्ति इस स्ट्रिंग को ब्रेसिज़, अल्पविराम और अर्धविराम के साथ पूरा करती है {1,:},{5,:},{7,:},{1,:},{8,:},{4,:},{3,:},{5,:}। यह एक मान्य बैश ब्रेस विस्तार है, जो कि evalएड के साथ echoइस स्पेस-सेपरेटेड लिस्ट को तैयार करता है1,5,7,1,8,4,3,5 1,5,7,1,8,4,3,: 1,5,7,1,8,4,:,5 1,5,7,1,8,4,:,: ...
• डिफ़ॉल्ट रूप से, व्हाट्सएप के साथ स्ट्रिंग्स को बैश करते हैं, इसलिए हम इस सूची के प्रत्येक तत्व पर लूप करते हैं:
  • अल्पविराम को नई सुर्खियों के साथ बदल दिया जाता है, फिर कॉलन वाली रेखाओं को हटा दिया जाता है, जिससे प्रत्येक संभावित परिणाम के लिए नई-अलग-अलग सूचियाँ दी जाती हैं
  • फिर हम sort -Cबढ़ते क्रम के लिए परीक्षण करते हैं, और यदि हां, तो wc -wसूची की लंबाई को प्रिंट करने के लिए उपयोग करें
• परिणामी सूची की लंबाई को उल्टा क्रमबद्ध किया जाता है और सबसे लंबे समय तक बढ़ने के बाद की लंबाई देने के लिए पहले मूल्य को मुद्रित किया जाता है।

Answer 12

स्टैक्स , 21 बाइट्स

ë/NS7Γ╥╚┌{1╤╒¬è¶²╢╦┌☼

इसे चलाएं और डीबग करें

इसके दो परीक्षण मामले हैं, जिनमें से एक 1000-तत्व मामला है। यह मेरी मशीन पर 24 सेकंड में एक चलता है। इस प्रकार की समस्या के लिए यह क्लासिक डायनेमिक प्रोग्रामिंग दृष्टिकोण का उपयोग करता है।

Answer 13

जे 34

ध्यान दें कि मैं मानक इनपुट भी पढ़ता हूं।

>./;+/@:*&.>(<*>.)/\&.><\.".1!:1]3

मानक इनपुट पढ़ने के बिना, मांस 26 वर्ण है।

>./;+/@:*&.>(<*>.)/\&.><\.

बस ध्यान दिया मेरा इनपुट बड़े इनपुट के लिए धीमा है, ओह अच्छी तरह से।

Answer 14

C ++ (gcc) , 129 बाइट्स

int f(int*a,int n){int l[n]{},i=n,j,m=0;for(;i--;m=l[i]>m?l[i]:m)for(j=n;--j>i;)if(a[i]<a[j]&&l[i]<l[j]+1)l[i]=l[j]+1;return++m;}

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

Answer 15

सी # (.NET कोर) , 155 बाइट्स

इनपुट सरणी (डायनेमिक प्रोग्रामिंग) में प्रत्येक स्थान पर सबसे लंबे समय तक बढ़ने वाली बाद की गणना करने के लिए एक सरणी का उपयोग किया, फिर सबसे बड़ा मान लौटाया। उदाहरण के लिए, इनपुट के लिए गणना की गई सरणी [1,5,7,1,8,4,3,5]होगी [1,2,3,1,4,2,2,3], और सबसे बड़ा मान 4लौटाया जाएगा।

int b(int[]x){int l=x.Length,r=1,i=0,j,c;var a=new int[l];a[0]=1;while(++i<l)for(j=0;j<i;j++){c=x[j]<x[i]?a[j]+1:1;a[i]=a[i]<c?c:a[i];r=r<c?c:r;}return r;}

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

Answer 16

वोल्फ्राम लैंग्वेज (गणितज्ञ) , 38 बाइट्स

Length@LongestOrderedSequence[#,Less]&

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

निश्चित रूप से सबसे लंबे समय तक क्रमबद्ध दृश्यों को खोजने के लिए एक गणितज्ञ द्वारा बनाया गया है। इसका नाम बहुत लंबा है: यह आधे से अधिक समाधान बनाता है, और अगर कोई व्यक्ति इस समाधान को निकालता है तो मुझे आश्चर्य नहीं होगा।