Thách thức là viết ra triển khai ngắn nhất để tìm ra sự gia tăng dài nhất .

Ví dụ : Gọi S là dãy 1 5 7 1 8 4 3 5 [độ dài của S = 8]

• Chúng tôi có 1 chuỗi con có độ dài 0 [sẽ xem xét nó tăng]
  
• 6 chuỗi con có độ dài 1 {1,5,7,8,4,3} [tất cả chúng được coi là tăng]
  
• (7 * 8) / 2 chuỗi con có độ dài 2 [nhưng chúng tôi sẽ loại bỏ các bản sao], các tiểu mục tăng dần có màu đen mạnh.
  { 15,17 , 11, 18,14,13,57 , 51, 58 , 54,53,55,71, 78 , 74,73,75,84,83,85,43, 45,35 }
  

[lưu ý rằng chúng tôi chỉ quan tâm đến các chuỗi con tăng nghiêm ngặt]

[bạn không thể thay đổi thứ tự của các thành phần bên trong chuỗi, do đó không có chuỗi con [37] trong chuỗi ví dụ]

• Chúng tôi đã tăng các chuỗi con có độ dài 4 là 1578, nhưng không có chuỗi con có độ dài 5, vì vậy chúng tôi xem xét độ dài của chuỗi con tăng dài nhất = 4.
  

Đầu vào :

a ₁ a ₂ ... a _N (Trình tự)

tất cả các số là số nguyên dương nhỏ hơn 10 ³
N <= 1000

Đầu ra :

Một số nguyên biểu thị độ dài của chuỗi con tăng dài nhất của chuỗi đầu vào.

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

Mã của bạn phải chạy kịp thời, vui lòng kiểm tra mã của bạn trong trường hợp này trước khi gửi nó ở đây (cũng là liên kết chứa giải pháp c ++ 11 290 byte của tôi)

Bạn có thể lấy đầu vào từ tệp / stdin hoặc làm tham số hàm và bạn có thể in đầu ra thành tệp / thiết bị xuất chuẩn hoặc chỉ trả về giá trị nếu bạn viết hàm

Bảng điểm

1. Dennis CJam - 22
2. isaacg Pyth - 26
3. Howard GolfScript - 35
4. người bán hàng tự hào Haskell - 56
5. Ray Python 3 - 66
6. histocrat Ruby - 67
7. DLeh C # - 92
8. Áo choàng YosemiteMark - 94
9. faubiguy Python 3 - 113

CJam, 22 byte

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

Hãy thử trực tuyến.

Thí dụ

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

Chương trình in 57cho trường hợp thử nghiệm này sau 0,25 giây.

Làm thế nào nó hoạt động

Tôi lấy ý tưởng chung từ câu trả lời của @ Ray .

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)).                     ";

Con trăn 3, 66

Lưu ý rằng tất cả các số nằm trong phạm vi [1, 999], chúng ta có thể sử dụng một mảng bđể duy trì độ dài chuỗi dài nhất kết thúc với mỗi số. b[x] = dcó nghĩa là chuỗi dài nhất kết thúc bằng xcó độ dài d. Đối với mỗi số từ đầu vào, chúng tôi cập nhật mảng bằng cách sử dụng b[x] = max(b[:x]) + 1và sau đó chúng tôi đã hoàn thành công việc bằng cách thực hiện max(b)cuối cùng.

Độ phức tạp thời gian là Trên) O (mn) , trong đó mluôn là 1000 và nlà số phần tử đầu vào.

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

Wow, có vẻ như đã vô dụng :) Bạn có thể kiểm tra nó bằng cách sử dụng stdin / stdout bằng cách thêm một dòng:

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

Con trăn - 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))

Bình thường , 26 29 33 39

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

Giải pháp của cảng @ ray. Vượt qua các bài kiểm tra chính thức. Bây giờ sử dụng đầu vào STDIN được phân tách bằng dấu cách, không phải chức năng gọi.

Chạy như sau:

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

Giải trình:

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)

Thời gian không giới hạn:

Bình thường , 18

L?eS,ytbhyf>Thbbb0

Lưu ý kỹ thuật: Tôi nhận thấy một lỗi trong trình biên dịch Pyth của tôi khi viết golf này. Lđã không làm việc. Đó là lý do tại sao có một cam kết gần đây với kho git ở trên.

Clojure, 94 ký tự

Sử dụng phương pháp cập nhật kết quả của @ Ray trong một vectơ 1000 mục:

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

Mỗi yêu cầu, với câu lệnh in (sẽ in câu trả lời và trả về nil). Đầu vào phải là một vectơ (g [1 2 3]) hoặc danh sách (g '(1 2 3)):

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

Haskell, 58 57 56 ký tự

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

Điều này sử dụng một thuật toán tôi đã thấy một lần trên internet, nhưng tôi không thể tìm thấy nó. Phải mất một lượng thời gian không thể nhận thấy trên trường hợp thử nghiệm đã cho trên máy tính của tôi với GHCi (có thể sẽ còn nhanh hơn nếu được biên dịch).

GolfScript, 35 ký tự

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

Một triển khai hoạt động như một chương trình hoàn chỉnh với đầu vào trên STDIN (không có số độ dài cho trước). Việc thực hiện là hợp lý nhanh chóng, ngay cả đối với đầu vào dài hơn (thử ở đây ).

Ví dụ:

> 1 5 7 1 8 4 3 5
4

> 5 1 9 9 1 5
2

Ruby, 67

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

Điều này chạy trong 30 giây trên đầu vào lớn, điều đó có được tính là một cách kịp thời không? : p

Đó là đệ quy vũ phu, nhưng với một số ghi nhớ.

C #, 172 92 ký tự

Không có gì đặc biệt, nhưng tôi đã làm điều đó vì vậy tôi nghĩ rằng tôi cũng có thể gửi nó.

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;}

Cảm ơn Armin và Bob vì những cải tiến của họ!

J , 19 byte

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

Hãy thử trực tuyến!

Chạy trong O (n log n) , sử dụng một loại kiên nhẫn được sửa đổi vì chỉ cần độ dài, không phải là thứ tự thực tế, là cần thiết.

Giải trình

[:#]`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

Bash + coreutils, 131 byte

Giải pháp này thất bại khủng khiếp về yêu cầu cách thức kịp thời và thậm chí không đặc biệt ngắn, nhưng tôi thích rằng loại điều này ít nhất là về mặt lý thuyết có thể có trong kịch bản shell, vì vậy dù sao tôi cũng sẽ đăng. Điều này chạy với độ phức tạp thời gian gây ra vĩnh cửu của 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

Đầu vào là một danh sách được phân tách bằng dấu phẩy được truyền dưới dạng một đối số dòng lệnh:

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

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

Mở rộng cú đúp được sử dụng để xây dựng danh sách tất cả các chuỗi con có thể.

• Dòng đầu tiên thay thế dấu phẩy bằng ,:},{, tạo ra một chuỗi như1,:},{5,:},{7,:},{1,:},{8,:},{4,:},{3,:},{5
• Dòng thứ hai hoàn thành chuỗi này với dấu ngoặc nhọn, dấu phẩy và dấu chấm phẩy để cung cấp cho chuỗi này {1,:},{5,:},{7,:},{1,:},{8,:},{4,:},{3,:},{5,:}. Đây là một bản mở rộng bash brace hợp lệ, khi evaled với một echodanh sách phân tách không gian này1,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,:,: ...
• theo mặc định, bash chia tách các chuỗi với khoảng trắng, vì vậy chúng tôi lặp qua từng phần tử của danh sách này:
  • dấu phẩy được thay thế bằng dòng mới, sau đó các dòng chứa dấu hai chấm được loại bỏ, đưa ra danh sách phân tách dòng mới cho mỗi lần tiếp theo có thể
  • sau đó chúng tôi sort -Csẽ kiểm tra thứ tự tăng dần và nếu có, hãy sử dụng wc -wđể in độ dài của danh sách
• danh sách kết quả của độ dài danh sách được sắp xếp theo chiều ngược lại và giá trị đầu tiên được in để đưa ra độ dài tiếp theo tăng dài nhất.

Stax , 21 byte

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

Chạy và gỡ lỗi nó

Điều này có hai trường hợp thử nghiệm, một trong số đó là trường hợp 1000 phần tử. Nó chạy một trong 24 giây trên máy của tôi. Nó sử dụng phương pháp lập trình động cổ điển cho loại vấn đề này.

J 34

Lưu ý rằng tôi đọc đầu vào tiêu chuẩn là tốt.

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

Không đọc đầu vào tiêu chuẩn, thịt là 26 ký tự.

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

Chỉ cần nhận thấy tôi chạy chậm cho đầu vào lớn, oh tốt.

C ++ (gcc) , 129 byte

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;}

Hãy thử trực tuyến!

C # (.NET Core) , 155 byte

Đã sử dụng một mảng để tính toán chuỗi tăng dài nhất kết thúc tại mỗi vị trí trong mảng đầu vào (lập trình động), sau đó trả về giá trị lớn nhất. Ví dụ, mảng được tính toán cho đầu vào [1,5,7,1,8,4,3,5]sẽ là [1,2,3,1,4,2,2,3]và giá trị lớn nhất 4được trả về.

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;}

Hãy thử trực tuyến!

Ngôn ngữ Wolfram (Mathicala) , 38 byte

Length@LongestOrderedSequence[#,Less]&

Hãy thử trực tuyến!

Tất nhiên có một Mathicala tích hợp sẵn để tìm các chuỗi được đặt hàng dài nhất. Tên của nó rất dài: nó chiếm hơn một nửa giải pháp và tôi sẽ không ngạc nhiên nếu có ai đó chơi golf giải pháp này.