Đưa ra một danh sách các số nguyên dương, viết mã tìm độ dài của danh sách phụ liền kề dài nhất đang tăng (không nghiêm ngặt). Đó là danh sách con dài nhất sao cho mỗi phần tử lớn hơn hoặc bằng phần tử cuối cùng.

Ví dụ: nếu đầu vào là:

$[1,1,2,1,1,4,5,3,2,1,1]$

Danh sách phụ tăng dài nhất sẽ là $[1,1,4,5]$ , vì vậy bạn sẽ xuất $4$ .

Câu trả lời của bạn sẽ được ghi bằng cách lấy nguồn của nó làm danh sách các byte và sau đó tìm độ dài của danh sách phụ tăng dài nhất của danh sách đó. Một điểm thấp hơn là mục tiêu. Các mối quan hệ bị phá vỡ theo hướng có lợi cho các chương trình có ít byte tổng thể hơn.

Pyth , điểm 2 (8 byte)

lefSIT.:

Hãy thử nó ở đây!

Mã điểm [108, 101, 102, 83, 73, 84, 46, 58]. Một giải pháp ngắn hơn, leSI#.:điểm 3, nhưng điểm mã của nó [108, 101, 83, 73, 35, 46, 58], rất gần với điểm 1, thực sự. Sắp xếp lại một chút có thể giúp Nevermind, các chuỗi con tích hợp .:không thể được sắp xếp lại, vì vậy điểm thấp nhất phải là 2 nếu chương trình sử dụng nó.

Làm sao?

lefSIT.:     Full program. Accepts either a list or a string from STDIN.
      .:     Substrings.
  f  T       Only keep those that are...
   SI        Sorting-Invariant.
le           Length of the last item.

Haskell , điểm 2, 66 64 61 60 65 byte

• -2 byte nhờ Max Yekhlakov
• -1 byte nhờ nimi
• +5 byte để xử lý danh sách trống

foldr1 max.g
g[]=[0]
g(x:y:z)|x>y=1: g(y:z)
g(_:y)|a:b<-g y=1+a:b

Hãy thử trực tuyến! (tự kiểm chứng).

Tôi chưa bao giờ nghĩ rằng tôi có thể đạt được điểm 2 với Haskell, nhưng tôi vẫn ở đây!

Hàm gtính toán độ dài của tất cả các chuỗi con tăng dần theo cách đệ quy. foldr1 max.glấy tối đa các độ dài đó ( foldr1 maxtương đương với maximum, nhưng với số điểm thấp hơn).

JavaScript (Node.js) , điểm 3, 53 46 byte điểm 2, 51 50 byte

-7 byte cảm ơn @Arnauld

+5 +4 khoảng trống để đổi -1 điểm

a=> a.map($= p=n=>$=(p<=(p=n)?++ x:x=1)<$?$: x)&&$

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

Giả sử đầu vào không trống. 61 byte nếu danh sách trống phải được xử lý. Điểm 2 vẫn còn.

a=> a.map($= p=n=>$=(p<=(p=n)?++ x:x=1)<$?$: x)&& a.length&&$

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

... Hoặc 58 nếu trở lại falseđược cho phép. Điểm 2 vẫn còn.

a=> a.map($= p=n=>$=(p<=(p=n)?++ x:x=1)<$?$: x)&& a>[ ]&&$

Husk , 5 byte , điểm = 2

00000000: bc6d 4cdc 14                   ▲mLġ≥

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

Không thể có được điểm thấp hơn 2 với Husk vì ġ¹ có điểm mã thực sự cao và cần phải có một cái gì đó trước khi nó đạt được tối đa và độ dài. Một nỗ lực có thể được thực hiện với việc cố gắng sử dụng nhiều hàm nhưng \nsẽ có trước bất kỳ hàm trợ giúp nào có mã số thực sự thấp để mọi thứ sau đó sẽ tạo ra một chuỗi byte tăng ít nhất là độ dài 2.

_{1: Đây có vẻ như là cách tốt nhất để sử dụng cho các toán tử so sánh sẽ cần tuân theo các hàm phân tách khác nhau như ↕( span).}

Giải trình

▲mLġ≥  -- example input: [1,1,2,1,1,4,5,3,2,1,1]
   ġ≥  -- group elements by geq: [[1,1,2],[1,1,4,5],[3],[2],[1,1]]
 mL    -- map length: [3,4,1,1,2]
▲      -- maximum: 4

Võng mạc 0.8.2 , 40 byte, điểm 3

\d+
$*
(?<=(1+)),(?!\1)
¶
T`1`_
^O`
\G,?

Hãy thử trực tuyến! Liên kết bao gồm chính nó như mã byte làm đầu vào. Giải trình:

\d+
$*

Chuyển đổi sang unary.

(?<=(1+)),(?!\1)
¶

Chia theo cặp giảm.

T`1`_

Xóa các chữ số.

^O`

Sắp xếp dấu phẩy theo thứ tự ngược lại. (Tôi thường viết nó như là O^nhưng không thể làm điều đó ở đây vì lý do rõ ràng.)

\G,?

Đếm số lần chạy dấu phẩy dài nhất và thêm một để bao gồm số cuối cùng.

Japt -h, 6 byte, điểm 2

Đừng nghĩ điểm 1 là có thể. Nên làm việc với chuỗi & mảng ký tự quá.

ò>¹mÊn

Hãy thử nó - bao gồm trường hợp thử nghiệm là các mã của giải pháp.

Giải trình

ò          :Partition after each integer
 >         :  That's greater than the integer that follows it
  ¹        :End partition
   m       :Map
    Ê      :  Length
     n     :Sort
           :Implicitly output last element

MATL , điểm 2, 13 byte

d0< ~Y'w)X>sQ

Đầu vào có thể là:

• Một dãy số.
• Một chuỗi kèm theo dấu ngoặc đơn. Dấu ngoặc đơn trong chuỗi được thoát bằng cách nhân đôi.

MATL sử dụng mã hóa ASCII. Các điểm mã của đoạn mã trên là

100, 48, 60, 32, 126, 89, 39, 119, 41, 88, 62, 115, 81

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

Giải trình

d     % Implicit input. Consecutive differences (of code points) 
0<    % Less than 0? Element-wise. Gives true or false
      % Space. This does nothing; but it breaks an increasing substring
~     % Negate
Y'    % Run-length encoding. Gives array of true/false and array of lengths
w     % Swap
)     % Index. This keeps only lenghts of runs of true values
X>    % Maximum. Gives empty array if input is empty
s     % Sum. This turns empty array into 0
Q     % Add 1. Implicit display

Pascal (FPC) , điểm 2

111 byte

var a,b,c,t:bYte;bEgIn repeat read(a); iNc(c); if a<b then c:=1; if c>t then t:= c;b:= a;until eOf;write(t)eNd.

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

Giả sử đầu vào không trống. Các số được lấy từ đầu vào tiêu chuẩn cách nhau bởi khoảng trắng.

Jelly , 8 byte , điểm 2

^{Có lẽ có một giải pháp điểm 1 bằng cách nào đó ...}

IṠµṣ-ZL‘

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

Mã nguồn dưới dạng danh sách các giá trị byte:

[73, 205, 9, 223, 45, 90, 76, 252]

Làm sao?

IṠµṣ-ZL‘ - Link: list of integers  e.g. [ 1, 1, 2, 1, 1, 4, 5, 3, 2, 1, 1]
I        - increments                    [ 0, 1,-1, 0, 3, 1,-2,-1,-1, 0]
 Ṡ       - sign                          [ 0, 1,-1, 0, 1, 1,-1,-1,-1, 0]
  µ      - start a new monadic chain (a low byte to stop score being 3)
    -    - literal minus one             -1
   ṣ     - split at                      [[0, 1], [0, 1, 1], [], [], [0]]
     Z   - transpose                     [[0, 0, 0], [1, 1], 1]
      L  - length                        3
       ‘ - increment                     4

Perl 6 , điểm 2, 46 byte

{my&g=1+*×*;+max 0,|[\[&g]] [ |@_] Z>=0,|@_ }

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

Xử lý danh sách trống. Mã ban đầu là:

{my&g=1+*×*;+max 0,|[\[&g]] @_ Z>=0,|@_}

Vì vậy, chỉ có 5 byte thêm để giảm điểm xuống còn 2.

Chỉnh sửa: Ah, tôi đã tìm ra cách xóa bài tập , nhưng sau đó tôi không thể đạt được số điểm dưới 3 vì)]] ...

Giải trình:

{                                  }  # Anonymous code block
 my&g=     ;  # Assign to &g an anonymous Whatever lambda
      1+*×*   # That multiplies the two inputs together and adds 1
                            @_ Z  0,|@_   # Zip the list with itself off-set by one
                                >=        # And check if each is equal or larger than the previous
                                         # e.g. [5,7,7,1] => [1,1,1,0]
                    [\[&g]]  # Triangular reduce it by the function declared earlier
                          # This results in a list of the longest substring at each index
                          # e.g. [5,7,7,1] => [1,2,3,1]
            +max 0,|      # And return the max value from this list, returning 0 if empty

05AB1E , điểm 3 (9 byte )

Œʒ¥dP}éθg

Nhiều khả năng có thể là một điểm 2 bằng cách nào đó.

Điểm mã của byte chương trình: [140,1,90,100,80,125,233,9,103](hai danh sách con có độ dài 3: [1,90,100]và [80,125,233])

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

Giải trình:

Π           # Sublists
 ʒ   }       # Filter by:
  ¥          #  Take the deltas
   d         #  Check for each whether the number is >= 0
    P        #  And check if it was truthy for all deltas
      é      # Then sort by length
       θ     # Take the last element
        g    # And take its length as result

Java (JDK) , điểm 3, 94 byte

a->{int m=0,p=0,x=0,i=0,n;while(i<a.length){n=a[i++];m=(p<=(p=n)?++x:(x=1)) <m?m:x;}return m;}

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

Cổng của tôi (với các đề xuất từ ​​Arnauld) câu trả lời JS. etutrong returnvà hiltrong whileđó làm cho golf không thể đạt được điểm 2.

for không thể được sử dụng ở đây vì:

• ;for đang tăng dần
• forkhông thể được sử dụng ở đầu cơ thể lambda (giới hạn phạm vi). Có thể gói nó với {}nhưng dường như sử dụng whiletiết kiệm byte.

Powershell, điểm 3, 44 byte

($args|%{$i*=$_-ge$p;$p=$_;(++$i)}|sort)[-1]

Kịch bản thử nghiệm:

$f = {

(
    $args|%{        # for each integer from argument list
        $i*=$_-ge$p # -ge means >=.
                    # This statement multiplies the $i by the comparison result.
                    # A result of a logical operator is 0 or 1.
                    # So, we continue to count a current sequence or start to count a new sequence
        $p=$_       # let $p stores a 'previous integer'
        (++$i)      # increment and return incremented as length of a current sequence
    }|sort          # sort lengthes 
)[-1]               # take last one (maximum)

}

@(
    ,(4, 1,1,2,1,1,4,5,3,2,1,1)
) | % {
    $e,$a = $_
    $r = &$f @a
    "$($r-eq$e): $r"
}

Đầu ra:

True: 4

Giải trình:

• Kịch bản lấy số nguyên làm danh sách đối số ( spaltting ).
• Mỗi số nguyên ánh xạ bởi một hàm đến phần năm của contiguous sub-list that is increasing (not strictly). Sau đó, kịch bản sắp xếp độ dài và mất cuối cùng (tối đa) (...|sort)[-1].

Powershell 6, điểm 3, 43 byte

$args|%{$i*=$_-ge$p;$p=$_;(++$i)}|sort -b 1

Giống như trên. Một điểm khác biệt: sort -b 1là lối tắt cho sort -Bottom 1và có nghĩa là 1 phần tử từ cuối mảng được sắp xếp . Vì vậy, chúng tôi không cần một chỉ số [-1].

Stax , điểm 3 (15 byte)

Z|[F|]F:^!C_%|M

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

Python 2 , điểm 5, 87 byte điểm 2, 101 93 92 101 byte

lambda a,m=1,o=[1]:max(reduce(lambda B,c:[B[:-m]+[B[-m]+m],B+o][c[0]>c[m]],zip(a,a[m:]), o)) *(a>[ ])

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

Ôi trời! Nghĩ rằng đây là môn đánh gôn lần đầu tiên thông qua ...

APL Dyalog , điểm 2, 20 byte

{⍵≡⍬:0⋄⌈/≢¨⍵⊂⍨1,2>/⍵}

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

Ngôn ngữ Wolfram (Mathicala) , điểm 3, 45 byte

Max[Length/@SequenceCases[#,x_/;OrderedQ@x]]&

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

SequenceCasesvà OrderedQtự mình cho điểm 3, vì vậy điểm số không thể được cải thiện mà không thay đổi cách tiếp cận đáng kể.

Java (JDK), 126 byte, Điểm 6

Chơi gôn

private static int l(byte[] o){int m=0;int c=1;int p=0;for(byte i:o){if(m<c){m=c;}if(i>=p){p= i;c++;}else{c=1;p=0;}}return m;}

Ung dung

private static int longest(byte[] input) {
    int maxc = 0;
    int consec = 1;
    int prev = 0;
    for (byte i : input) {
        if (maxc < consec) {
            maxc = consec;
        }
        if (i >= prev) {
            prev = i;
            consec++;
        }
        else {
            consec = 1;
            prev = 0;
        }
    }
    return maxc;
}

Đầu vào

[112, 114, 105, 118, 97, 116, 101, 32, 115, 116, 97, 116, 105, 99, 32, 105, 110, 116, 32, 108, 40, 98, 121, 116, 101, 91, 93, 32, 111, 41, 123, 105, 110, 116, 32, 109, 61, 48, 59, 105, 110, 116, 32, 99, 61, 49, 59, 105, 110, 116, 32, 112, 61, 48, 59, 102, 111, 114, 40, 98, 121, 116, 101, 32, 105, 58, 111, 41, 123, 105, 102, 40, 109, 60, 99, 41, 123, 109, 61, 99, 59, 125, 105, 102, 40, 105, 62, 61, 112, 41, 123, 112, 61, 32, 105, 59, 99, 43, 43, 59, 125, 101, 108, 115, 101, 123, 99, 61, 49, 59, 112, 61, 48, 59, 125, 125, 114, 101, 116, 117, 114, 110, 32, 109, 59, 125]

Kotlin, Điểm 6, 119 byte

 fun x(a : IntArray){var m=1;var k=0;var d=1;while(k<a.size-1){if(a[k]<=a[k+1])m++;else{if(d<m)d=m;m=1};k++};println(d)}

Thử trực tuyến

Giải trình

1. Bước 1: Kiểm tra giá trị trước đó đến giá trị tiếp theo
2. Bước 2: Nếu giá trị trước nhỏ hơn hoặc bằng thì thêm cộng 1 tiếp tục làm trong khi điều kiện là đúng
3. Bước 3: kiểm tra số đếm trước với số đếm tiếp theo, giữ số đếm cao nhất trong biến d.

Kotlin, Điểm 4, 67 byte

{a:IntArray->var i=0;var p=0;a.map{if(it<p){i=0};p=it;(++i)}.max()}

Ý chính là: Chuyển đổi từng số nguyên thành độ dài của các chuỗi con liền kề đang tăng (không nghiêm ngặt). Trả lại tối đa.

• a.map{...} - cho mỗi số nguyên trong mảng làm
• if(it<p){i=0} - nếu số nguyên hiện tại nhỏ hơn số nguyên trước đó, thì đặt lại bộ đếm
• p=it - lưu trữ số nguyên hiện tại trước đó
• (++i) - bộ đếm tăng và giá trị trả về của biểu thức
• .max() - lấy maximun của tất cả các chiều dài

Ruby , 64 byte

->e{e.size.downto(1).find{|l|e.each_cons(l).find{|c|c==c.sort}}}

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