给定一个正整数列表，编写代码以找到不断增加的最长连续子列表的长度（并非严格如此）。那是最长的子列表，因此每个元素都大于或等于最后一个。

例如，如果输入是：

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

增长子列表将是，因此您将输出。$[1,1,4,5]$$4$

通过将其来源作为字节列表，然后找到该列表中最长的递增子列表的长度，可以对您的答案进行评分。得分较低是目标。为了减少总字节数较少的程序，打破了联系。

Pyth，得分2（8个字节）

lefSIT.:

在这里尝试！

代码点[108, 101, 102, 83, 73, 84, 46, 58]。另一个较短的解决方案leSI#.:得分为3，但其代码点为[108, 101, 83, 73, 35, 46, 58]，实际上非常接近得分1。重新排列一点可能会对 Nevermind 有所帮助，内置的子字符串.:无法重新排列，因此，如果程序使用了它，最低分必须为2。

怎么样？

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，得分2，66 64 61 60 65字节

• -2个字节，感谢Max Yekhlakov
• -1字节感谢nimi
• +5个字节来处理空列表

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

在线尝试！（验证自己）。

我从没想过与Haskell可以得到2分，但是我来了！

函数g以递归方式计算所有递增子串的长度。 foldr1 max.g占用这些长度的最大值（foldr1 max等于maximum，但得分较低）。

的JavaScript（Node.js的），3分，53 46个字节 2分，51 50个字节

-7个字节，谢谢@Arnauld

+5 +4个空格以-1得分交换

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

在线尝试！

假定非空输入。如果必须处理空列表，则为61个字节。仍然得分2。

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

在线尝试！

...或58（如果false允许返回）。仍然得分2。

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

外壳，5 个字节，分数= 2

00000000: bc6d 4cdc 14                   ▲mLġ≥

在线尝试！

使用Husk不太可能获得低于2的分数，因为ġ¹具有非常高的代码点，并且需要一些东西才能获得最大值和长度。可以尝试使用多个功能，但是\n要在任何辅助功能（其代码点非常低）之前进行，因此之后的任何操作都会产生至少长度为2的递增字节序列。

_{1：这似乎是比较运算符的最佳使用方式，它需要遵循各种拆分函数↕（例如span）。}

说明

▲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

视网膜0.8.2，40字节，得分3

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

在线尝试！链接将自身包括为字节码作为输入。说明：

\d+
$*

转换为一元。

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

分割成对减少。

T`1`_

删除数字。

^O`

以相反的顺序对逗号进行排序。（我通常会这样写，O^但出于明显的原因不能在这里这样做。）

\G,?

计算最长的逗号，然后加一个以包含最终的数字。

Japt -h，6个字节，得分2

不要认为得分为1是不可能的。也应该与字符串和字符数组一起使用。

ò>¹mÊn

试试看 -包含的测试用例是解决方案的字符。

说明

ò          :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，得分2，13字节

d0< ~Y'w)X>sQ

输入可以是：

• 数字数组。
• 用单引号引起来的字符串。字符串中的单引号通过重复进行转义。

MATL使用ASCII编码。上面代码的代码点是

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

在线尝试！

说明

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

帕斯卡（FPC），得分2

111字节

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.

在线尝试！

假定非空输入。数字取自标准输入，并以空格分隔。

果冻，8 字节，得分2

^{以某种方式可能有一个1分解决方案...}

IṠµṣ-ZL‘

在线尝试！

源代码为字节值列表：

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

怎么样？

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，得分2，46个字节

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

在线尝试！

处理空列表。原始代码为：

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

所以只有5个额外的字节才能将分数降低到2。

编辑：啊，我想出了如何删除作业，但是由于)]]... ，我无法使该分数低于3 。

说明：

{                                  }  # 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，得分3（9 个字节）

Œʒ¥dP}éθg

以某种方式最有可能获得2分。

程序字节的代码点：（[140,1,90,100,80,125,233,9,103]长度为3 [1,90,100]和的两个子列表[80,125,233]）

在线尝试。

说明：

Π           # 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），得分3，94个字节

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

在线尝试！

我的端口（来自Arnauld的建议）JS答案。etu进入return和hil进入while都不可能打出2分。

for 在这里不能使用，因为：

• ;for 正在上升
• for不能在lambda主体的开头使用（范围限制）。可以使用{}但显然使用while保存字节来包装它。

Powershell，得分3，44个字节

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

测试脚本：

$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"
}

输出：

True: 4

说明：

• 该脚本将整数作为参数列表（spaltting）。
• 每个整数通过函数映射到的整数contiguous sub-list that is increasing (not strictly)。然后，脚本对长度进行排序并取最后一个（最大）(...|sort)[-1]。

Powershell 6，得分3，43字节

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

同上。区别之一sort -b 1是的快捷方式sort -Bottom 1，表示从排序数组末尾开始的1个元素。因此，我们不需要索引[-1]。

Stax，3分（15字节）

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

运行并调试

Python 2，得分5，87字节得分2，101 93 92101字节

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>[ ])

在线尝试！

哎呀！认为这是第一次通过代码高尔夫...

Dyalog APL，得分2，20字节

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

在线尝试！

Wolfram语言（Mathematica），得分3，45字节

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

在线尝试！

SequenceCases并OrderedQ单独给出3分，因此如果不大幅度改变方法，就无法提高得分。

Java（JDK），126个字节，得分6

打高尔夫球

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

不打高尔夫球

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

输入值

[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，得分6，119字节

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

在线尝试

说明

1. 步骤1：检查上一个值到下一个值
2. 步骤2：如果先前的值小于或等于，则在条件为true时加加1继续执行
3. 步骤3：检查前一个计数与下一个计数，将最高计数保留在变量d中。

Kotlin，得分4，67字节

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

主要思想是：将每个整数转换为不断增加的连续子序列的长度（不严格）。返回最大值。

• a.map{...} -对于数组中的每个整数
• if(it<p){i=0} -如果当前整数小于前一个整数，则重置计数器
• p=it -将当前整数存储在前一个
• (++i) -递增计数器和表达式的返回值
• .max() -获得所有长度的最大值

红宝石，64字节

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

在线尝试！