Étant donné une liste d'entiers positifs, écrivez du code qui trouve la longueur de la sous-liste contiguë la plus longue qui augmente (pas strictement). Il s'agit de la sous-liste la plus longue de sorte que chaque élément soit supérieur ou égal au dernier.

Par exemple, si l'entrée était:

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

La sous-liste augmentant le plus longtemps serait , vous donc .$[1,1,4,5]$$4$

Votre réponse sera notée en prenant sa source sous la forme d'une liste d'octets, puis en trouvant la longueur de la sous-liste croissante la plus longue de cette liste. Un score inférieur est l'objectif. Les liens sont rompus en faveur de programmes avec moins d'octets globaux.

Pyth , score 2 (8 octets)

lefSIT.:

Essayez-le ici!

Points de code [108, 101, 102, 83, 73, 84, 46, 58]. Une autre solution plus courte, leSI#.:note 3, mais ses points de code sont [108, 101, 83, 73, 35, 46, 58], qui sont très proches d'un score de 1, en fait. Réorganiser un peu peut aider Nevermind, la sous-chaîne intégrée .:ne peut pas être réorganisée, donc le score le plus bas doit être de 2 si le programme s'en sert.

Comment?

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 , score 2, 66 64 61 60 65 octets

• -2 octets grâce à Max Yekhlakov
• -1 octet grâce à nimi
• +5 octets pour gérer la liste vide

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

Essayez-le en ligne! (se vérifie).

Je n'ai jamais pensé que je pourrais obtenir un score de 2 avec Haskell, et pourtant je suis là!

La fonction gcalcule récursivement les longueurs de toutes les sous-chaînes croissantes. foldr1 max.gprend le maximum de ces longueurs ( foldr1 maxest équivalent à maximum, mais avec un score inférieur).

JavaScript (Node.js) , score 3, 53 46 octets score 2, 51 50 octets

-7 octets merci @Arnauld

+5 +4 espaces en échange de -1 score

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

Essayez-le en ligne!

Suppose une entrée non vide. 61 octets si la liste vide doit être gérée. Marque encore 2.

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

Essayez-le en ligne!

... ou 58 si le retour falseest autorisé. Marque encore 2.

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

Husk , 5 octets , score = 2

00000000: bc6d 4cdc 14                   ▲mLġ≥

Essayez-le en ligne!

Il est peu probable d'obtenir un score inférieur à 2 avec Husk, car ġ¹ a un point de code très élevé et il doit y avoir quelque chose avant pour obtenir le maximum et la longueur. Une tentative pourrait être faite en essayant d'utiliser plusieurs fonctions, mais ce \nserait avant toutes les fonctions d'assistance qui ont un point de code très bas, donc tout ce qui après cela créerait une séquence d'octets croissante d'au moins la longueur 2.

_{1: Cela semble être la meilleure façon d'utiliser les opérateurs de comparaison pour suivre les différentes fonctions de partage comme ↕( span).}

Explication

▲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 octets, score 3

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

Essayez-le en ligne! Le lien se comprend sous forme de codes octets en entrée. Explication:

\d+
$*

Convertissez en unaire.

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

Séparer en paires décroissantes.

T`1`_

Supprimez les chiffres.

^O`

Triez les virgules dans l'ordre inverse. (J'écrirais normalement ceci comme O^mais je ne peux pas le faire ici pour des raisons évidentes.)

\G,?

Comptez la plus longue virgule et ajoutez-en une pour inclure le nombre final.

Japt -h, 6 octets, score 2

Ne pensez pas qu'un score de 1 soit possible. Devrait également fonctionner avec des chaînes et des tableaux de caractères.

ò>¹mÊn

Essayez-le - le cas de test inclus est le code de la solution.

Explication

ò          :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 , score 2, 13 octets

d0< ~Y'w)X>sQ

L'entrée peut être:

• Un tableau de nombres.
• Une chaîne entourée de guillemets simples. Les guillemets simples dans la chaîne sont échappés par la duplication.

MATL utilise le codage ASCII. Les points de code du code ci-dessus sont

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

Essayez-le en ligne!

Explication

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) , score 2

111 octets

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.

Essayez-le en ligne!

Suppose une entrée non vide. Les nombres sont tirés d'une entrée standard séparée par des espaces.

Gelée , 8 octets , score 2

^{Il y a probablement une solution de score 1 en quelque sorte ...}

IṠµṣ-ZL‘

Essayez-le en ligne!

Code source sous forme de liste de valeurs d'octets:

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

Comment?

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 , score 2, 46 octets

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

Essayez-le en ligne!

Gère la liste vide. Le code d'origine était:

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

Donc, seulement 5 octets supplémentaires pour réduire le score à 2.

Edit: Ah, j'ai compris comment supprimer l'affectation , mais je ne peux pas obtenir ce score en dessous de 3 en raison de la )]]...

Explication:

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

Œʒ¥dP}éθg

Peut très probablement être un score de 2 d'une manière ou d'une autre.

Points de code des octets de programme: [140,1,90,100,80,125,233,9,103](deux sous-listes de longueur 3: [1,90,100]et [80,125,233])

Essayez-le en ligne.

Explication:

Π           # 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) , score 3, 94 octets

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

Essayez-le en ligne!

Port de ma réponse JS (avec les suggestions d'Arnauld). etudans returnet hilen whilerendant impossible le golf pour marquer 2.

for ne peut pas être utilisé ici car:

• ;for est ascendant
• forne peut pas être utilisé au début du corps lambda (restrictions de portée). Il est possible de l'envelopper {}mais en utilisant apparemment des whileoctets de sauvegarde.

Powershell, score 3, 44 octets

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

Script de test:

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

Production:

True: 4

Explication:

• Le script prend des entiers comme liste d'arguments ( spaltting ).
• Chaque entier est mappé par une fonction à la longueur de contiguous sub-list that is increasing (not strictly). Ensuite, le script trie les longueurs et en prend une dernière (maximum) (...|sort)[-1].

Powershell 6, score 3, 43 octets

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

Comme ci-dessus. Une différence: sort -b 1est un raccourci pour sort -Bottom 1et signifie 1 élément de la fin du tableau trié . Nous n'avons donc pas besoin d'un index [-1].

Stax , score 3 (15 octets)

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

Exécuter et déboguer

Python 2 , Note 5, 87 octets score de 2, 101 93 92 101 octets

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

Essayez-le en ligne!

Oups! Je pensais que c'était du golf de code pour la première fois ...

Dyalog APL , score 2, 20 octets

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

Essayez-le en ligne!

Wolfram Language (Mathematica) , score 3, 45 octets

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

Essayez-le en ligne!

SequenceCaseset OrderedQpar eux-mêmes donnent un score de 3, donc le score ne peut pas être amélioré sans changer l'approche de manière significative.

Java (JDK), 126 octets, score 6

Golfé

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

Non golfé

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

Contribution

[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, Score 6, 119 octets

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

Essayez en ligne

Explication

1. Étape 1: vérifier la valeur précédente à la valeur suivante
2. Étape 2: Si la valeur précédente est inférieure ou égale, ajoutez plus 1 continuez à faire pendant que la condition est vraie
3. Étape 3: vérifier le décompte précédent avec le décompte suivant, conserver le décompte le plus élevé dans la variable d.

Kotlin, Score 4, 67 octets

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

L'idée principale est: Transformer chaque entier en longueur de sous-séquences contiguës qui augmente (pas strictement). Retour maximum.

• a.map{...} - pour chaque entier du tableau, faites
• if(it<p){i=0} - si l'entier actuel est inférieur à un entier précédent, réinitialiser le compteur
• p=it - stocker l'entier actuel dans le précédent
• (++i) - incrémenter le compteur et renvoyer la valeur de l'expression
• .max() - obtenez un maximum de toute la longueur

Ruby , 64 octets

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

Essayez-le en ligne!