Wenn Sie eine Liste positiver Ganzzahlen haben, schreiben Sie Code, der die Länge der längsten zusammenhängenden Teilliste ermittelt, die ansteigt (nicht unbedingt). Dies ist die längste Unterliste, sodass jedes Element größer oder gleich dem letzten ist.

Zum Beispiel, wenn die Eingabe war:

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

Die am längsten aufsteigende Unterliste wäre $[1,1,4,5]$ , Sie würden also $4$ ausgeben .

Ihre Antwort wird bewertet, indem Sie die Quelle als eine Liste von Bytes nehmen und dann die Länge der am längsten wachsenden Unterliste dieser Liste ermitteln. Eine niedrigere Punktzahl ist das Ziel. Verbindungen werden zugunsten von Programmen mit weniger Gesamtbytes unterbrochen.

Pyth , Punktzahl 2 (8 Bytes)

lefSIT.:

Probieren Sie es hier aus!

Codepunkte [108, 101, 102, 83, 73, 84, 46, 58]. Eine andere kürzere Lösung hat die leSI#.:Punktzahl 3, aber die Codepunkte liegen [108, 101, 83, 73, 35, 46, 58]tatsächlich sehr nahe an der Punktzahl 1. Das Neuanordnen eines Bits kann Nevermind helfen . Die eingebauten Teilzeichenfolgen .:können nicht neu angeordnet werden. Daher muss die niedrigste Punktzahl 2 sein, wenn das Programm davon Gebrauch macht.

Wie?

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 Bytes

• -2 Bytes dank Max Yekhlakov
• -1 byte dank nimi
• +5 Bytes für die leere Liste

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

Probieren Sie es online! (überprüft sich selbst).

Ich hätte nie gedacht, dass ich mit Haskell eine Punktzahl von 2 erreichen könnte, und doch bin ich hier!

Die Funktion gberechnet die Länge aller aufsteigenden Teilzeichenfolgen rekursiv. foldr1 max.gNimmt das Maximum dieser Längen ( foldr1 maxentspricht maximum, aber mit einer niedrigeren Punktzahl).

JavaScript (Node.js) , Score 3, 53, 46 Bytes, Score 2, 51, 50 Bytes

-7 Bytes danke @Arnauld

+5 +4 Felder im Austausch mit -1 Punkten

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

Probieren Sie es online!

Nimmt eine nicht leere Eingabe an. 61 Bytes, wenn leere Liste behandelt werden muss. Noch 2 Punkte.

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

Probieren Sie es online!

... oder 58, wenn die Rückgabe falseerlaubt ist. Noch 2 Punkte.

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

Schale , 5 Bytes , Punktzahl = 2

00000000: bc6d 4cdc 14                   ▲mLġ≥

Probieren Sie es online!

Es ist unwahrscheinlich, dass Husk eine Punktzahl von weniger als 2 erreicht, da ġ¹ einen wirklich hohen Codepunkt hat und etwas vor sich liegen muss, um das Maximum und die Länge zu erreichen. Es könnte versucht werden, mehrere Funktionen zu verwenden, \njedoch vor allen Hilfsfunktionen, die einen wirklich niedrigen Codepunkt haben. Daher würde alles, was danach erfolgt, eine zunehmende Byte-Sequenz von mindestens Länge 2 erzeugen.

_{1: Dies scheint der beste Weg zu sein, den Vergleichsoperatoren verwenden müssten, um den verschiedenen Split-Funktionen wie ↕( span) zu folgen .}

Erläuterung

▲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, Punktzahl 3

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

Probieren Sie es online!Link schließt sich als Bytecode als Eingabe ein. Erläuterung:

\d+
$*

In Unary konvertieren.

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

Auf abnehmende Paare aufteilen.

T`1`_

Löschen Sie die Ziffern.

^O`

Sortieren Sie die Kommas in umgekehrter Reihenfolge. (Ich würde das normalerweise schreiben alsO^ aber aus offensichtlichen Gründen kann ich das hier nicht tun.)

\G,?

Zählen Sie den längsten Komma-Lauf und addieren Sie einen, um die endgültige Zahl einzuschließen.

Japt -h , 6 Bytes, Punktzahl 2

Denken Sie nicht, dass eine Punktzahl von 1 möglich ist. Sollte auch mit Strings & Character Arrays funktionieren.

ò>¹mÊn

Versuch es - inklusive Testfall ist der Charcode der Lösung.

Erläuterung

ò          :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 Bytes

d0< ~Y'w)X>sQ

Die Eingabe kann sein:

• Ein Array von Zahlen.
• Eine Zeichenfolge, die in einfache Anführungszeichen eingeschlossen ist. Einfache Anführungszeichen in der Zeichenfolge werden durch Duplizieren maskiert.

MATL verwendet ASCII-Codierung. Die Codepunkte des obigen Codes sind

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

Probieren Sie es online!

Erläuterung

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

Probieren Sie es online!

Nimmt eine nicht leere Eingabe an. Zahlen werden aus der Standardeingabe entnommen und durch Leerzeichen getrennt.

Gelee , 8 Bytes , Punktzahl 2

^{Es gibt wahrscheinlich irgendwie eine Lösung mit Punktzahl 1 ...}

IṠµṣ-ZL‘

Probieren Sie es online!

Quellcode als Liste von Bytewerten:

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

Wie?

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 Bytes

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

Probieren Sie es online!

Behandelt die leere Liste. Der ursprüngliche Code war:

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

Also nur 5 zusätzliche Bytes, um die Punktzahl auf 2 zu reduzieren.

Edit: Ah, ich habe herausgefunden, wie ich die Zuweisung entfernen kann , aber dann kann ich diese Punktzahl wegen der nicht unter 3 bringen)]] ...

Erläuterung:

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

Œʒ¥dP}éθg

Kann höchstwahrscheinlich eine Punktzahl von 2 sein.

Codepunkte der Programmbytes: [140,1,90,100,80,125,233,9,103](zwei Unterlisten der Länge 3: [1,90,100]und [80,125,233])

Probieren Sie es online aus.

Erläuterung:

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

Probieren Sie es online!

Port meiner (mit Vorschlägen von Arnauld) JS Antwort. etuin returnund hilin whilemachen es unmöglich, Golf zu spielen, um 2 zu erzielen.

for kann hier nicht verwendet werden, weil:

• ;for steigt auf
• forKann nicht am Anfang des Lambda-Körpers verwendet werden (Umfangseinschränkungen). Es ist möglich, es mit, {}aber anscheinend mit whilespart Bytes zu schließen.

Powershell, Punktzahl 3, 44 Bytes

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

Testskript:

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

Ausgabe:

True: 4

Erläuterung:

• Das Skript verwendet Ganzzahlen als Argumentliste ( spaltting ).
• Jede Ganzzahl wird durch eine Funktion auf die Länge von abgebildet contiguous sub-list that is increasing (not strictly). Dann sortiert das Skript die Längen und nimmt ein letztes (Maximum) (...|sort)[-1].

Powershell 6, Score 3, 43 Bytes

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

Das gleiche wie oben. Ein Unterschied:sort -b 1 Abkürzung für sort -Bottom 1und bedeutet 1 Element vom Ende des sortierten Arrays . Wir brauchen also keinen Index [-1].

Stax , 3 Punkte (15 Bytes)

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

Führen Sie es aus, und debuggen Sie es

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

Probieren Sie es online!

Hoppla! Dachte, dies war das erste Mal Code-Golf durch ...

Dyalog APL , Score 2, 20 Bytes

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

Probieren Sie es online!

Wolfram Language (Mathematica) , Punktzahl 3, 45 Bytes

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

Probieren Sie es online!

SequenceCasesund OrderedQfür sich allein eine Punktzahl von 3 ergeben, so dass die Punktzahl nicht verbessert werden kann, ohne den Ansatz signifikant zu ändern.

Java (JDK), 126 Bytes, Ergebnis 6

Golf gespielt

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

Eingang

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

Versuchen Sie es online

Erläuterung

1. Schritt 1: Überprüfen Sie den vorherigen Wert auf den nächsten Wert
2. Schritt 2: Wenn der vorherige Wert kleiner oder gleich ist, dann addiere plus 1 und mache weiter, solange die Bedingung wahr ist
3. Schritt 3: Vorherige Zählung mit nächster Zählung prüfen, höchste Zählung in Variable d beibehalten.

Kotlin, Score 4, 67 Bytes

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

Hauptidee ist: Transformiere jede ganze Zahl in die Länge zusammenhängender Teilsequenzen, die zunimmt (nicht streng). Maximum zurückgeben.

• a.map{...} - für jede ganze Zahl im Array tun
• if(it<p){i=0} - Wenn die aktuelle Ganzzahl kleiner als eine vorherige Ganzzahl ist, setzen Sie den Zähler zurück
• p=it - Aktuelle Ganzzahl in der vorherigen speichern
• (++i) - Inkrementzähler und Rückgabewert des Ausdrucks
• .max() - Maximale Länge erhalten

Ruby , 64 Bytes

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

Probieren Sie es online!