Враховуючи список натуральних чисел, напишіть код, який знаходить довжину найдовшого суміжного підспису, що збільшується (не строго). Це найдовший підпис, такий, що кожен елемент більший за або останній.

Наприклад, якщо введення було:

$[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ġ≥

Спробуйте в Інтернеті!

Навряд чи вийде бал нижчий за 2 за допомогою Husk, оскільки ġ¹ має дійсно високу кодову точку, і перед цим потрібно щось зробити, щоб отримати максимум та довжину. Спроба може бути здійснена при спробі використання декількох функцій, але \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].

Стакс , оцінка 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>[ ])

Спробуйте в Інтернеті!

Оупс! Думав, що це кодовий гольф вперше через ...

Діалог APL , оцінка 2, 20 байт

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

Спробуйте в Інтернеті!

Мова Вольфрама (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]

Котлін, оцінка 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{...} - для кожного цілого числа в масиві do
• 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}}}

Спробуйте в Інтернеті!