Le défi est d'écrire l' implémentation la plus courte pour trouver la sous- séquence croissante la plus longue .

Exemple : Soit S la séquence 1 5 7 1 8 4 3 5 [longueur de S = 8]

• Nous avons 1 sous-séquence de longueur 0 [la considérera croissante]
  
• 6 sous-séquences de longueur 1 {1,5,7,8,4,3} [toutes sont considérées comme en augmentation]
  
• (7 * 8) / 2 sous-séquences de longueur 2 [mais nous allons supprimer les doublons], les sous-séquences croissantes sont en noir fort.
  { 15,17 , 11, 18,14,13,57 , 51, 58 , 54,53,55,71, 78 , 74,73,75,84,83,85,43, 45,35 }
  

[notez que nous ne nous intéressons qu'aux sous-séquences strictement croissantes]

[vous ne pouvez pas changer l'ordre des éléments à l'intérieur de la séquence, il n'y a donc pas de sous-séquence [37] dans l'exemple de séquence]

• Nous avons des sous-séquences croissantes de longueur 4 qui est 1578, mais il n'y a pas de sous-séquence de longueur 5, donc nous considérons la longueur de la sous-séquence croissante la plus longue = 4.
  

Entrée :

a ₁ a ₂ ... a _N (la séquence)

tous les nombres sont des entiers positifs inférieurs à 10 ³
N <= 1000

Sortie :

Un entier indiquant la longueur de la sous-séquence croissante la plus longue de la séquence d'entrée.

sample input(1)
1 2 4 2 5
sample output(1)
4

sample input(2)
1 5 7 1 8 4 3 5
sample output(2)
4

Votre code doit s'exécuter en temps opportun, veuillez tester votre code sur ce cas avant de le soumettre ici (également le lien contient ma solution c ++ 11 de 290 octets)

Vous pouvez soit prendre l'entrée d'un fichier / stdin ou en tant que paramètre de fonction et vous pouvez soit imprimer la sortie dans un fichier / stdout ou simplement retourner la valeur si vous écrivez une fonction

Tableau des scores

1. Dennis CJam - 22
2. isaacg Pyth - 26
3. Howard GolfScript - 35
4. fier haskeller Haskell - 56
5. Ray Python 3-66
6. rubis histocrate - 67
7. DLeh C # - 92
8. YosemiteMark Clojure - 94
9. faubiguy Python 3 - 113

CJam, 22 octets

1e3,q~{_2$<$0=(t}/$0=z

Essayez-le en ligne.

Exemple

$ cjam subsequence.cjam <<< '[2 1]'; echo
1
$ cjam subsequence.cjam <<< '[1 9 2 4 3 5]'; echo
4

Le programme imprime 57pour ce scénario de test après 0,25 seconde.

Comment ça fonctionne

J'ai pris l'idée générale de la réponse de @ Ray .

1e3,    " Push the array [ 0 ... 999 ] (J).        ";
q~      " Read from STDIN and evaluate.            ";
{       " For each integer (I) of the input array: ";
  _2$<  " Push [ J[0] ... J[I - 1] ] (A).          ";
  $0=(  " Compute min(A) - 1.                      ";
  t     " Update J[I] with the value on the stack. ";
}/      "                                          ";
$0=     " Compute abs(min(J)).                     ";

Python 3, 66

Notez que tous les nombres sont dans la plage [1, 999], nous pouvons utiliser un tableau bpour conserver la longueur de sous-séquence la plus longue se terminant par chaque numéro. b[x] = dsignifie que la sous-séquence la plus longue se terminant par xa une longueur d. Pour chaque numéro de l'entrée, nous mettons à jour le tableau à l'aide b[x] = max(b[:x]) + 1puis nous avons fait le travail en prenant max(b)finalement.

La complexité temporelle est Sur) O (mn) , où mest toujours 1000 et nest le nombre d'éléments d'entrée.

def f(a):
 b=[0]*1000
 for x in a:b[x]=max(b[:x])+1
 return max(b)

Wow, on dirait déjà non golfé :) Vous pouvez le tester en utilisant stdin / stdout en ajoutant une ligne:

print(f(map(int,input().split())))

Python - 113

a=[]
for i in map(int,input().split()):
 if not a or i>a[-1]:a+=[i]
 z=0
 while a[z]<i:z+=1
 a[z]=i
print(len(a))

Pyth , 26 29 33 39

J*]0^T3Fkyw=@JkheS:J0k)eSJ

Port de la solution de @ ray. Réussit les tests officiels. Utilise maintenant une entrée STDIN séparée par des espaces, pas un appel de fonction.

Exécutez comme suit:

./pyth.py -c "J*]0^T3Fkyw=@JkheS:J0k)eSJ" <<< "1 5 7 2 8 4 3 5"
4

Explication:

J*]0^T3                 J = [0]*10^3
Fkyw                    For k in space_sep(input()):
=@Jk                    J[k]=
heS:J0k                 max(J[0:k])+1
)                       end for
eSJ                     max(J)

Temps illimité:

Pyth , 18

L?eS,ytbhyf>Thbbb0

Note technique: J'ai remarqué un bug dans mon complieur Pyth lors de l'écriture de ce golf. Lne fonctionnait pas. C'est pourquoi il y a eu un commit récent dans le dépôt git ci-dessus.

Clojure, 94 caractères

En utilisant l'approche de @ Ray de mise à jour des résultats dans un vecteur de 1000 éléments:

(defn g[s](apply max(reduce #(assoc % %2(inc(apply max(take %2 %))))(into[](repeat 1e3 0))s)))

Par demande, avec instruction d'impression (imprime la réponse et renvoie zéro). L'entrée doit être un vecteur (g [1 2 3]) ou une liste (g '(1 2 3)):

(defn g[s](prn(apply max(reduce #(assoc % %2(inc(apply max(take %2 %))))(into[](repeat 1e3 0))s))))

Haskell, 58 57 56 caractères

(x:s)%v|v>x=x:s%v|0<1=v:s
_%v=[v]
l s=length$foldl(%)[]s

Cela utilise un algorithme que j'ai vu une fois sur Internet, mais je ne le trouve pas. Cela prend un temps imperceptible sur le cas de test donné sur mon ordinateur avec GHCi (ce serait probablement encore plus rapide s'il était compilé).

GolfScript, 35 caractères

~]]){1${~2$<*)}%1+$-1>[\+]+}/$-1=0=

Une implémentation fonctionnant comme un programme complet avec entrée sur STDIN (sans le numéro de longueur donné). L'implémentation est relativement rapide, même pour des entrées plus longues (essayez ici ).

Exemples:

> 1 5 7 1 8 4 3 5
4

> 5 1 9 9 1 5
2

Rubis, 67

s=Hash.new{|s,a|f,*r=a
s[a]=f ?[1+s[r.select{|x|x>f}],s[r]].max: 0}

Cela s'exécute en 30 secondes sur la grande entrée, cela compte-t-il en temps opportun? : p

C'est une récursivité brute, mais avec une certaine mémorisation.

C #, 172 92 caractères

Rien de spécial, mais je l'ai fait alors j'ai pensé que je pourrais aussi bien le soumettre.

int a(int[] j){int c=2,m=2,i=1;for(;++i<j.Length;){c=j[i]>j[i-1]?c+1:2;m=c>m?c:m;}return m;}

Merci Armin et Bob pour leurs améliorations!

J , 19 octets

[:#]`I.`[} ::,~/@|.

Essayez-le en ligne!

Fonctionne en O (n log n) , en utilisant un tri de patience modifié car seule la longueur, et non la sous-séquence réelle, est nécessaire.

Explication

[:#]`I.`[} ::,~/@|.  Input: array
                 |.  Reverse
               /     Reduce right-to-left
     I.                Find the index to insert while keeping it sorted
                       (uses binary search)
         }             Amend the current search array at that index with the next value
           ::          If error (when the index is not found)
             ,           Append the value at the end
 #                   Length of that array

Bash + coreutils, 131 octets

Cette solution échoue horriblement sur l' exigence de manière opportune , et n'est même pas particulièrement courte, mais j'ai aimé que ce genre de chose soit au moins théoriquement possible dans le script shell, donc je poste quand même. Cela fonctionne avec une complexité temporelle induisant l'éternité de O (2 ^ n).

s=${1//,/,:\},\{}
a=`eval echo "{$s,:}"`
for s in $a;{
b="$(tr , \\n<<<$s|grep -v :)"
sort -nC<<<"$b"&&wc -w<<<$b
}|sort -nr|sed 1q

L'entrée est une liste séparée par des virgules passée comme un seul argument de ligne de commande:

$ time ./slisc.sh 1,5,7,1,8,4,3,5
4

real    0m1.240s
user    0m0.518s
sys 0m0.689s
$ 

L'expansion d'accolade est utilisée pour construire la liste de toutes les sous-séquences possibles.

• La première ligne remplace les virgules par ,:},{, ce qui produit une chaîne comme1,:},{5,:},{7,:},{1,:},{8,:},{4,:},{3,:},{5
• La deuxième ligne complète cette chaîne avec des accolades, des virgules et des points-virgules pour donner ceci {1,:},{5,:},{7,:},{1,:},{8,:},{4,:},{3,:},{5,:}. Ceci est une extension d'accolade bash valide, qui lorsqu'elle est evaléditée avec un echoproduit cette liste séparée par des espaces1,5,7,1,8,4,3,5 1,5,7,1,8,4,3,: 1,5,7,1,8,4,:,5 1,5,7,1,8,4,:,: ...
• par défaut, bash sépare les chaînes avec des espaces, nous bouclons donc sur chaque élément de cette liste:
  • les virgules sont remplacées par des nouvelles lignes, puis les lignes contenant des deux-points sont supprimées, donnant des listes séparées par des nouvelles lignes pour chaque sous-séquence possible
  • nous sort -Ctestons ensuite l' ordre croissant, et si oui, utilisons wc -wpour imprimer la longueur de la liste
• la liste résultante des longueurs de liste est triée en sens inverse et la première valeur est imprimée pour donner la longueur de sous-séquence augmentant la plus longue.

Stax , 21 octets

ë/NS7Γ╥╚┌{1╤╒¬è¶²╢╦┌☼

Exécuter et déboguer

Celui-ci comporte deux cas de test, dont l'un est le cas à 1000 éléments. Il s'exécute en 24 secondes sur ma machine. Il utilise l'approche de programmation dynamique classique pour ce type de problème.

J 34

Notez que je lis également l'entrée standard.

>./;+/@:*&.>(<*>.)/\&.><\.".1!:1]3

Sans lire l'entrée standard, la viande est de 26 caractères.

>./;+/@:*&.>(<*>.)/\&.><\.

Je viens de remarquer que le mien tourne lentement pour une grande entrée, eh bien.

C ++ (gcc) , 129 octets

int f(int*a,int n){int l[n]{},i=n,j,m=0;for(;i--;m=l[i]>m?l[i]:m)for(j=n;--j>i;)if(a[i]<a[j]&&l[i]<l[j]+1)l[i]=l[j]+1;return++m;}

Essayez-le en ligne!

C # (.NET Core) , 155 octets

A utilisé un tableau pour calculer la sous-séquence croissante la plus longue se terminant à chaque position dans le tableau d'entrée (programmation dynamique), puis a renvoyé la plus grande valeur. Par exemple, le tableau calculé pour l'entrée [1,5,7,1,8,4,3,5]serait [1,2,3,1,4,2,2,3]et la plus grande valeur 4est renvoyée.

int b(int[]x){int l=x.Length,r=1,i=0,j,c;var a=new int[l];a[0]=1;while(++i<l)for(j=0;j<i;j++){c=x[j]<x[i]?a[j]+1:1;a[i]=a[i]<c?c:a[i];r=r<c?c:r;}return r;}

Essayez-le en ligne!

Wolfram Language (Mathematica) , 38 octets

Length@LongestOrderedSequence[#,Less]&

Essayez-le en ligne!

Il y a bien sûr un Mathematica intégré pour trouver les séquences ordonnées les plus longues. Son nom est très long: il représente plus de la moitié de la solution, et je ne serai pas surpris si quelqu'un sur-joue cette solution.