Учитывая список натуральных чисел, напишите код, который находит длину самого длинного непрерывного подсписка, который увеличивается (не строго). Это самый длинный подсписок, так что каждый элемент больше или равен последнему.

Например, если вход был:

$[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 байта благодаря Максу Ехлакову
• -1 байт благодаря Ними
• +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

Попробуйте онлайн! (проверяет себя).

Я никогда не думал, что смогу получить счет 2 с Haskell, и все же я здесь!

Функция 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;}

Попробуйте онлайн!

Порт моего (с предложениями от Арнаулда) JS ответа. etuв returnи hilв whileделают невозможным гольф забить 2.

for не может быть использован здесь, потому что:

• ;for восходящий
• forнельзя использовать в начале лямбда-тела (ограничения объема). Можно обернуть его, {}но, видимо, с помощью 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 92 101 байт

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 Language (Mathematica) , оценка 3, 45 байт

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

Попробуйте онлайн!

SequenceCasesи OrderedQсами по себе дают оценку 3, поэтому оценка не может быть улучшена без существенного изменения подхода.

Java (JDK), 126 байт, оценка 6

Golfed

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

Ungolfed

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]

Котлин, оценка 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: Если предыдущее значение меньше или равно, тогда добавьте плюс 1, продолжайте, пока условие выполнено
3. Шаг 3: проверить предыдущий счет со следующим счетом, сохранить наибольшее количество в переменной d.

Котлин, оценка 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}}}

Попробуйте онлайн!