Dato un elenco di numeri interi positivi, scrivere il codice che trova la lunghezza della sotto-lista contigua più lunga che sta aumentando (non rigorosamente). Questa è la lista più lunga in modo tale che ogni elemento sia maggiore o uguale all'ultimo.

Ad esempio se l'input era:

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

L'elenco secondario crescente più lungo sarebbe , quindi si otterrebbe .$[1,1,4,5]$$4$

La tua risposta verrà valutata prendendo la sua fonte come un elenco di byte e quindi trovando la lunghezza del sotto-elenco crescente più lungo di tale elenco. Un punteggio più basso è l'obiettivo. I legami vengono interrotti a favore di programmi con meno byte complessivi.

Pyth , punteggio 2 (8 byte)

lefSIT.:

Provalo qui!

Punti di codice [108, 101, 102, 83, 73, 84, 46, 58]. Un'altra soluzione più breve, leSI#.:segna 3, ma i suoi punti di codice sono [108, 101, 83, 73, 35, 46, 58], che sono molto vicini a un punteggio di 1, in realtà. Riorganizzare un po 'può aiutare Nevermind, le sottostringhe integrate .:non possono essere riorganizzate, quindi il punteggio più basso deve essere 2 se il programma lo utilizza.

Come?

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 , punteggio 2, 66 64 61 60 65 byte

• -2 byte grazie a Max Yekhlakov
• -1 byte grazie a nimi
• +5 byte per gestire l'elenco vuoto

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

Provalo online! (si verifica).

Non avrei mai pensato di ottenere un punteggio di 2 con Haskell, eppure eccomi qui!

La funzione gcalcola ricorsivamente le lunghezze di tutte le sottostringhe in aumento. foldr1 max.gprende il massimo di quelle lunghezze ( foldr1 maxequivale a maximum, ma con un punteggio più basso).

JavaScript (Node.js) , punteggio 3, 53 46 byte punteggio 2, 51 50 byte

-7 byte grazie @Arnauld

+5 +4 spazi in cambio di -1 punteggio

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

Provalo online!

Presuppone input non vuoti. 61 byte se è necessario gestire un elenco vuoto. Punteggio 2 ancora.

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

Provalo online!

... o 58 se il reso falseè consentito. Punteggio 2 ancora.

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

Buccia , 5 byte , punteggio = 2

00000000: bc6d 4cdc 14                   ▲mLġ≥

Provalo online!

È improbabile che ottenga un punteggio inferiore a 2 con Husk perché ġ¹ ha un punto di codice molto alto e deve esserci qualcosa prima che ottenga il massimo e la lunghezza. Si potrebbe fare un tentativo con il tentativo di utilizzare più funzioni ma \nsarebbe prima di qualsiasi funzione di supporto che abbia un punto di codice molto basso, quindi qualsiasi cosa dopo creerebbe una sequenza di byte crescente di almeno la lunghezza 2.

_{1: Questo sembra il modo migliore da usare per gli operatori di confronto dovrebbe seguire le varie funzioni di divisione come ↕( span).}

Spiegazione

▲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 byte, punteggio 3

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

Provalo online! Il collegamento si include come codici byte come input. Spiegazione:

\d+
$*

Converti in unario.

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

Dividi su coppie decrescenti.

T`1`_

Elimina le cifre.

^O`

Ordinare le virgole in ordine inverso. (Normalmente scrivo questo come O^ma non posso farlo qui per ovvi motivi.)

\G,?

Contare la sequenza di virgole più lunga e aggiungerne una per includere il numero finale.

Japt -h, 6 byte, punteggio 2

Non pensare che sia possibile un punteggio di 1. Dovrebbe funzionare anche con stringhe e array di caratteri.

ò>¹mÊn

Provalo - il test case incluso è il charcodes della soluzione.

Spiegazione

ò          :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 , punteggio 2, 13 byte

d0< ~Y'w)X>sQ

L'input può essere:

• Una matrice di numeri.
• Una stringa racchiusa tra virgolette singole. Le virgolette singole all'interno della stringa vengono salvate duplicando.

MATL utilizza la codifica ASCII. I punti di codice del codice sopra sono

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

Provalo online!

Spiegazione

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) , punteggio 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.

Provalo online!

Presuppone input non vuoti. I numeri sono presi dallo standard input separato da spazi.

Gelatina , 8 byte , punteggio 2

^{C'è probabilmente una soluzione punteggio 1 in qualche modo ...}

IṠµṣ-ZL‘

Provalo online!

Codice sorgente come un elenco di valori byte:

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

Come?

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 , punteggio 2, 46 byte

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

Provalo online!

Gestisce l'elenco vuoto. Il codice originale era:

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

Quindi solo 5 byte extra per ridurre il punteggio a 2.

Modifica: Ah, ho capito come rimuovere il compito , ma poi non riesco a ottenere quel punteggio inferiore a 3 a causa del )]]...

Spiegazione:

{                                  }  # 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 , punteggio 3 (9 byte )

Œʒ¥dP}éθg

Molto probabilmente può essere un punteggio di 2 in qualche modo.

Punti di codice dei byte di programma: [140,1,90,100,80,125,233,9,103](due elenchi di lunghezza 3: [1,90,100]e [80,125,233])

Provalo online.

Spiegazione:

Π           # 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) , punteggio 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;}

Provalo online!

Porta della mia risposta JS (con suggerimenti di Arnauld). etuin returne hilin whilerendono impossibile giocare a golf segnando 2.

for non può essere utilizzato qui perché:

• ;for sta salendo
• fornon può essere utilizzato all'inizio del corpo lambda (restrizioni dell'ambito). È possibile avvolgerlo {}ma apparentemente usando i whilebyte di salvataggio.

Powershell, punteggio 3, 44 byte

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

Script di prova:

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

Produzione:

True: 4

Spiegazione:

• Lo script accetta numeri interi come elenco di argomenti ( spaltting ).
• Ogni numero intero viene mappato da una funzione a legnth of contiguous sub-list that is increasing (not strictly). Quindi lo script ordina le lunghezze e ne prende un ultimo (massimo) (...|sort)[-1].

Powershell 6, punteggio 3, 43 byte

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

Come sopra. Una differenza: sort -b 1è una scorciatoia per sort -Bottom 1e significa 1 elemento dalla fine della matrice ordinata . Quindi non abbiamo bisogno di un indice [-1].

Stax , punteggio 3 (15 byte)

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

Esegui ed esegui il debug

Python 2 , punteggio 5, 87 byte punteggio 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>[ ])

Provalo online!

Ops! Ho pensato che questo fosse il code-golf per la prima volta ...

Dyalog APL , punteggio 2, 20 byte

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

Provalo online!

Wolfram Language (Mathematica) , punteggio 3, 45 byte

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

Provalo online!

SequenceCasese OrderedQda soli danno un punteggio di 3, quindi il punteggio non può essere migliorato senza cambiare l'approccio in modo significativo.

Java (JDK), 126 byte, punteggio 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;
}

Ingresso

[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, punteggio 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)}

Prova online

Spiegazione

1. Passaggio 1: controllare il valore precedente al valore successivo
2. Passaggio 2: se il valore precedente è inferiore o uguale, quindi aggiungere più 1 continuare mentre la condizione è vera
3. Passaggio 3: controllare il conteggio precedente con il conteggio successivo, mantenere il conteggio più alto nella variabile d.

Kotlin, punteggio 4, 67 byte

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

L'idea principale è: trasformare ogni numero intero in lunghezza di sottosequenze contigue che sta aumentando (non rigorosamente). Restituisci massimo.

• a.map{...} - per ogni numero intero nell'array do
• if(it<p){i=0} - se il numero intero corrente è inferiore a un numero intero precedente, quindi azzera il contatore
• p=it - memorizza il numero intero corrente nel precedente
• (++i) - incrementa il contatore e restituisce il valore dell'espressione
• .max() - Ottieni il massimo di tutta la lunghezza

Rubino , 64 byte

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

Provalo online!