Dada uma lista de números inteiros positivos, escreva um código que encontre o comprimento da sub-lista contígua mais longa que está aumentando (não estritamente). Essa é a sublista mais longa, de modo que cada elemento seja maior ou igual ao último.

Por exemplo, se a entrada foi:

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

A sub-lista crescente mais longa seria , portanto você produziria .$[1,1,4,5]$$4$

Sua resposta será pontuada tomando sua origem como uma lista de bytes e, em seguida, localizando o comprimento da sub-lista crescente mais longa dessa lista. Uma pontuação mais baixa é o objetivo. Os laços são quebrados em favor de programas com menos bytes gerais.

Pitão , pontuação 2 (8 bytes)

lefSIT.:

Experimente aqui!

Pontos de código [108, 101, 102, 83, 73, 84, 46, 58]. Outra solução mais curta, tem leSI#.:3 pontos, mas seus pontos de código [108, 101, 83, 73, 35, 46, 58]são muito próximos a 1, na verdade. Reorganizar um pouco pode ajudar o Nevermind, as subseqüências internas são as .:que não podem ser reorganizadas; portanto, a pontuação mais baixa deve ser 2 se o programa fizer uso dela.

Quão?

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 , pontuação 2, 66 64 61 60 65 bytes

• -2 bytes graças a Max Yekhlakov
• -1 byte graças a nimi
• +5 bytes para lidar com a lista vazia

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

Experimente online! (se verifica).

Eu nunca pensei que poderia conseguir uma pontuação de 2 com Haskell, e ainda estou aqui!

A função gcalcula os comprimentos de todas as substrings crescentes recursivamente. foldr1 max.gleva o máximo desses comprimentos ( foldr1 maxé equivalente a maximum, mas com uma pontuação mais baixa).

JavaScript (Node.js) , pontuação 3, 53 46 bytes pontuação 2, 51 50 bytes

-7 bytes obrigado @Arnauld

+5 +4 espaços em troca de -1 de pontuação

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

Experimente online!

Pressupõe entrada não vazia. 61 bytes se a lista vazia precisar ser manipulada. Pontuação 2 ainda.

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

Experimente online!

... ou 58, se o retorno falsefor permitido. Pontuação 2 ainda.

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

Husk , 5 bytes , pontuação = 2

00000000: bc6d 4cdc 14                   ▲mLġ≥

Experimente online!

É improvável que você obtenha uma pontuação menor que 2 com Husk, porque ġ¹ tem um ponto de código realmente alto e precisa haver algo antes dele para obter o máximo e o comprimento. Uma tentativa poderia ser feita com a tentativa de usar várias funções, mas \nseria antes de qualquer função auxiliar que tenha um ponto de código muito baixo; portanto, qualquer coisa depois disso criaria uma sequência de bytes crescente de pelo menos o comprimento 2.

_{1: Parece que a melhor maneira de usar para os operadores de comparação precisaria seguir as várias funções de divisão como ↕( span).}

Explicação

▲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

Retina 0.8.2 , 40 bytes, pontuação 3

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

Experimente online! O link inclui-se como códigos de bytes como entrada. Explicação:

\d+
$*

Converta para unário.

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

Dividir em pares decrescentes.

T`1`_

Exclua os dígitos.

^O`

Classifique as vírgulas na ordem inversa. (Normalmente, eu escreveria isso como O^mas não posso fazer isso aqui por razões óbvias.)

\G,?

Conte a execução de vírgula mais longa e adicione uma para incluir o número final.

Japt -h, 6 bytes, pontuação 2

Não pense que uma pontuação de 1 é possível. Também deve funcionar com strings e matrizes de caracteres.

ò>¹mÊn

Experimente - o caso de teste incluído é o código da solução.

Explicação

ò          :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 , pontuação 2, 13 bytes

d0< ~Y'w)X>sQ

A entrada pode ser:

• Uma matriz de números.
• Uma cadeia de caracteres entre aspas simples. Aspas simples dentro da string são escapadas pela duplicação.

MATL usa codificação ASCII. Os pontos de código do código acima são

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

Experimente online!

Explicação

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) , pontuação 2

111 bytes

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.

Experimente online!

Pressupõe entrada não vazia. Os números são obtidos da entrada padrão separados por espaços.

Geléia , 8 bytes , pontuação 2

^{Provavelmente existe uma solução de pontuação 1 de alguma forma ...}

IṠµṣ-ZL‘

Experimente online!

Código fonte como uma lista de valores de bytes:

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

Quão?

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 , pontuação 2, 46 bytes

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

Experimente online!

Lida com a lista vazia. O código original era:

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

Portanto, apenas 5 bytes extras para reduzir a pontuação para 2.

Edit: Ah, eu descobri como remover a tarefa , mas não consigo obter essa pontuação abaixo de 3 por causa da )]]...

Explicação:

{                                  }  # 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 , pontuação 3 (9 bytes )

Œʒ¥dP}éθg

Provavelmente pode ser uma pontuação de 2 de alguma forma.

Pontos de código dos bytes de programa: [140,1,90,100,80,125,233,9,103](duas sublistas de comprimento 3: [1,90,100]e [80,125,233])

Experimente online.

Explicação:

Π           # 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) , pontuação 3, 94 bytes

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

Experimente online!

Porto da minha (com sugestões de Arnauld) resposta JS. etudentro returne hildentro whiletornam impossível jogar golfe para marcar 2.

for não pode ser usado aqui porque:

• ;for está subindo
• fornão pode ser usado no início do corpo lambda (restrições de escopo). É possível envolvê-lo, {}mas aparentemente usando whilesalva bytes.

Powershell, pontuação 3, 44 bytes

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

Script de teste:

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

Resultado:

True: 4

Explicação:

• O script usa números inteiros como lista de argumentos ( spaltting ).
• Cada número inteiro é mapeado por uma função para a extensão de contiguous sub-list that is increasing (not strictly). Em seguida, o script classifica os comprimentos e leva um último (máximo) (...|sort)[-1].

Powershell 6, pontuação 3, 43 bytes

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

O mesmo que acima. Uma diferença: sort -b 1é um atalho para sort -Bottom 1e significa 1 elemento do final da matriz classificada . Portanto, não precisamos de um índice [-1].

Stax , pontuação 3 (15 bytes)

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

Execute e depure

Python 2 , pontuação 5, 87 bytes pontuação 2, 101 93 92 101 bytes

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

Experimente online!

Opa! Pensei que era a primeira vez em code-golf ...

Dyalog APL , pontuação 2, 20 bytes

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

Experimente online!

Wolfram Language (Mathematica) , pontuação 3, 45 bytes

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

Experimente online!

SequenceCasese, OrderedQpor si só, dão uma pontuação de 3, para que a pontuação não possa ser melhorada sem alterar significativamente a abordagem.

Java (JDK), 126 bytes, Pontuação 6

Golfe

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

Entrada

[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, pontuação 6, 119 bytes

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

Experimente on-line

Explicação

1. Etapa 1: verifique o valor anterior para o próximo valor
2. Etapa 2: se o valor anterior for menor ou igual, adicione mais 1 continuando enquanto a condição for verdadeira
3. Etapa 3: verifique a contagem anterior com a próxima contagem, mantenha a contagem mais alta na variável d.

Kotlin, pontuação 4, 67 bytes

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

A idéia principal é: Transforme cada número inteiro no comprimento de sub sequências contíguas que estão aumentando (não estritamente). Retorno máximo.

• a.map{...} - para cada número inteiro na matriz, faça
• if(it<p){i=0} - se o número inteiro atual for menor que o número anterior, redefina o contador
• p=it - armazena inteiro inteiro no anterior
• (++i) - contador de incremento e valor de retorno da expressão
• .max() - obtenha o máximo de todo o comprimento

Ruby , 64 bytes

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

Experimente online!