Imprimer tous les nombres lexicographiquement croissants sous 10000

32

Un nombre croissant lexicographiquement est un nombre entier dont les chiffres sont en ordre strictement croissant. Imprimez tous les nombres lexicographiquement croissants sous 10000.

Voici les lignes de la sortie attendue:

0
1
2
3
4
5
6
7
8
9
12
13
14
15
16
17
18
19
23
24
25
26
27
28
29
34
35
36
37
38
39
45
46
47
48
49
56
57
58
59
67
68
69
78
79
89
123
124
125
126
127
128
129
134
135
136
137
138
139
145
146
147
148
149
156
157
158
159
167
168
169
178
179
189
234
235
236
237
238
239
245
246
247
248
249
256
257
258
259
267
268
269
278
279
289
345
346
347
348
349
356
357
358
359
367
368
369
378
379
389
456
457
458
459
467
468
469
478
479
489
567
568
569
578
579
589
678
679
689
789
1234
1235
1236
1237
1238
1239
1245
1246
1247
1248
1249
1256
1257
1258
1259
1267
1268
1269
1278
1279
1289
1345
1346
1347
1348
1349
1356
1357
1358
1359
1367
1368
1369
1378
1379
1389
1456
1457
1458
1459
1467
1468
1469
1478
1479
1489
1567
1568
1569
1578
1579
1589
1678
1679
1689
1789
2345
2346
2347
2348
2349
2356
2357
2358
2359
2367
2368
2369
2378
2379
2389
2456
2457
2458
2459
2467
2468
2469
2478
2479
2489
2567
2568
2569
2578
2579
2589
2678
2679
2689
2789
3456
3457
3458
3459
3467
3468
3469
3478
3479
3489
3567
3568
3569
3578
3579
3589
3678
3679
3689
3789
4567
4568
4569
4578
4579
4589
4678
4679
4689
4789
5678
5679
5689
5789
6789

Ceci est un défi de golf de code! La réponse la plus courte gagne!

(PS à la recherche d'une solution python)

code-golf  number  sequence  kolmogorov-complexity 
— Varun Patro
source
3
devons-nous les imprimer sur des lignes distinctes ou est-ce que l'espace est séparé?
— Giuseppe
3
Bienvenue chez PPCG! Beau premier défi. Pour les défis futurs, je peux recommander d'utiliser le Sandbox pour affiner un défi et obtenir des commentaires significatifs avant de le publier sur main.
— AdmBorkBork
4
Pour développer la question de @ Giuseppe, pouvons-nous sortir séparés par des virgules, des espaces, au format tableau [0,1,...], etc. ou devons-nous sortir chaque nombre sur une ligne séparée?
— ETHproductions
10
Les nombres doivent-ils être dans un ordre spécifique, ou doivent-ils simplement exister?
— Kamil Drakari
14
@VarunPatro, veuillez mettre à jour le défi pour indiquer explicitement que chaque numéro est sur une ligne distincte (bien que je le déconseille) et assurez-vous d'informer toutes les solutions existantes qui ne le font pas.
— Shaggy

Réponses:

30

Python 2 , 56 octets

for n in range(9999):
 if eval('<'.join(`n`))**n:print n

Essayez-le en ligne!

Convertit chaque nombre comme 124une expression 1<2<4et l'évalue pour vérifier si les chiffres sont triés,

Un hoquet se produit pour les nombres à un chiffre donnant une expression qui est juste le nombre lui-même. Cela entraîne 0une valeur Falsey même si elle doit être imprimée. Ce problème est résolu par une astuce suggérée par Erik le Outgolfer de faire **n, ce qui donne une valeur truthy 0**0pour n=0et n'affecte pas la valeur de la vérité autrement.

— Xnor
source
Que signifie le `faire dans `n`?
— BruceWayne
1
@BruceWayne Il prend la représentation de chaîne. Cela a été supprimé dans Python 3.
— xnor
5
@BruceWayne Notez que c'est la même chose que la repr()fonction, pas la str()fonction. Ce ne sont pas toujours les mêmes. Voici un exemple.
— mbomb007
1
@ mbomb007 merci pour ce commentaire! J'aurais pensé que c'était str()équivalent.
— BruceWayne
2
Nous pouvons gérer le cas 0 avec un peu de ruse .
— xsot
11

Haskell , 50 octets

unlines[s|s<-show<$>[0..6^5],s==scanl1(max.succ)s]

Essayez-le en ligne!

Génère une chaîne multiligne. Nous vérifions que le nombre saugmente en utilisant s==scanl1(max.succ)s, une variante du contrôle de tri habituel s==scanl1 max squi garantit un tri strict en incrémentant chaque caractère numérique avant d'en prendre le maximum et le chiffre suivant.

Ourous a enregistré un octet en utilisant 6^5comme limite supérieure à la place d'un nombre à 4 chiffres.

— Xnor
source
8

Gelée , 7 octets

9ŒPḌḣ⁹Y

Essayez-le en ligne!

Comment ça marche

9ŒPḌḣ⁹Y  Main link. No arguments.

9        Set the return value to 9.
 ŒP      Powerset; promote 9 to [1, ..., 9] and generate all subsets.
   Ḍ     Undecimal; map the subsets of digits to the integers they represent.
     ⁹   Yield 256.
    ḣ    Dyadic head; take the first 256 elements of the integer list.
      Y  Separate the result by linefeeds.
— Dennis
source
2
J'essaie de comprendre comment 0est inclus ici, mais je ne connais pas Jelly. Ai-je raison de dire que le jeu de puissance de Jelly comprend le tableau vide qui est ensuite converti en 0"non décimal"?
— Shaggy
1
Oui, c'est exactement ce qui se passe.
— Dennis
8

Japt -R, 12 11 8 octets

L²Ç¶ìüÃð

Essaye-le

L            :100
 ²           :Squared
  Ç          :Map the range [0,L²)
    ì        :  Split to a digit array
     ü       :  For the sake of simplicity*, let's say: Sort & deduplicate
             :  Implicitly rejoin to an integer
   ¶         :  Test for equality with original number
      Ã      :End map
       ð     :Get 0-based indices of truthy elements
             :Implicitly join with newlines and output

* Ou, pour offrir une meilleure explication: la üméthode trie un tableau et le divise en éléments égaux (par exemple, [8,4,8,4].ü() -> [[4,4],[8,8]]) puis, dans ce qui semble être une bizarrerie étrange et, espérons-le, pas un bogue, la ìméthode, lors de la reconversion du tableau en un nombre, prend le premier élément de chaque tableau imbriqué, plutôt que d'aplatir d'abord le tableau, ce à quoi je m'attendais lorsque j'ai essayé cette astuce (par exemple, [[4,4],[8,8]].ì() -> 48).

— Hirsute
source
1
Agréable. Similaire à ce que j'avais:L²Ç¥ì ü ¬Ãð
— Oliver
2
Je dois dire que cette üastuce que vous avez utilisée est géniale :-) @Oliver
— ETHproductions
1
@Oliver, vous devez l'avoir posté lors de la mise à jour; grands esprits ... :)
— Shaggy
@ETHproductions, comme la plupart des choses, je l'ai essayé sur un coup de tête - étonné que cela fonctionne.
— Shaggy
6

R , 62 49 octets

`[`=write;0[1];for(i in 1:4)combn(1:9,i)[1,i,,""]

Essayez-le en ligne!

Étant donné que l' combnitération s'effectue par son entrée dans l'ordre donné, il est facile de créer tous les entiers augmentant lexicographiquement, en les imprimant dans l'ordre. writeles imprime à chaque inombre de chiffres en lignes de largeur i, répondant ainsi parfaitement à l'exigence de nouvelle ligne.

— Giuseppe
source
bonne idée à exploiter combn!
— digEmAll
Aliasing extrêmement intelligent!
— J.Doe
6

Perl 6 , 25 octets

[<](.comb)&&.say for ^1e4

-1 octet grâce à nwellnhof

Essayez-le en ligne!

.combproduit une liste des chiffres de chaque numéro et [<]effectue une réduction inférieure à cette liste, équivalente à: digit1 < digit2 <... < digitN .

— Sean
source
2
[<](.comb)&&.sayenregistre un octet.
— nwellnhof
C'est étonnamment lisible. (Je connais déjà un peu Perl 6, mais quand même ...)
— JL
5

PowerShell , 42 40 octets

0..1e4|?{-join("$_"|% t*y|sort -u)-eq$_}

Essayez-le en ligne!

Boucle de 0à 1e4(c.- à -d 10000.). Retirez les objets dont |?{...}le nombre sous forme de chaîne $_est -eqégal au nombre cast toCharArra y, puis sortédité avec le -udrapeau nique. En d'autres termes, seuls les nombres sont identiques à leurs chaînes triées et dédupliquées. Chacun d'eux est laissé sur le pipeline et la sortie est implicite.

— AdmBorkBork
source
4

Pyth , 10 octets

jiRThc2yS9

Essayez-le en ligne!

Comment ça marche

jiRThc2yS9
        S9  Yield [1, 2, 3, 4, 5, 6, 7, 8, 9].
       y    Take all 512 subsets.
     c2     Split the array of subsets into 2 pieces (256 subsets each).
    h       Head; take the first piece.
 iRT        Convert each subset from base 10 to integer.
j           Separate by newlines.
— Dennis
source
3

J, 26 octets

,.(#~(-:/:~@~.)@":"0)i.1e4

Essayez-le en ligne!

explication

,. (#~ (-: /:~@~.)@":"0) i.1e4
                         i.1e4  NB. list 0 to 9999
                     "0         NB. for each number in the input list
                  @":"0         NB. convert it to a string and
   (#~ (         )              NB. remove any not passing this test:
        -:                      NB. the string of digits matches
              @~.               NB. the nub of the digits (dups removed)
           /:~                  NB. sorted
,.                              NB. ravel items: take the result of all that
                                NB. and turn it into a big column
— Jonas
source
3

05AB1E (hérité) , 8 octets

4°ÝD€êû

Essayez-le en ligne!

Fonctionne également dans la nouvelle version de 05AB1E mais est douloureusement lent pour une raison quelconque.

Comment?

4 ° ÝD € êà »- Programme complet.
4 ° Ý - Appuyez sur [0 ... 10000].
   D € ê - Poussez chaque entier dans [0 ... 10000] trié et dédupliqué en même temps.
      Ã »- Et rejoignez l'intersection des deux listes par des retours à la ligne.
— M. Xcoder
source
Bonne réponse. Mieux que le 9 octets que j'avais (qui ne fonctionne que dans l'héritage).
— Kevin Cruijssen
2

Python 2 , 64 61 octets

lambda:[x for x in range(9999)if sorted(set(`x`))==list(`x`)]

Essayez-le en ligne!

Obtient les caractères uniques de la représentation sous forme de chaîne de l'entier, les trie et compare le résultat au nombre d'origine.

— Triggernométrie
source
Vous pouvez enregistrer un octet en utilisant range(9999)ou tout autre nombre compris entre 6790 et 9999. Nos solutions sont presque identiques BTW :)
— DJMcMayhem
@DJMcMayhem Mais cela ne vérifierait pas TOUS les nombres inférieurs à 10 000 ....: P Merci! Parfois, je deviens trop littéral avec ces défis.
— Triggernométrie
2

V , 41 octets

7000ïÎaÛ
Îy$úúP
Ç^¨ä*©±$/d
ÎãlD
爱/d
HO0

Essayez-le en ligne!

Hexdump:

00000000: 3730 3030 efce 61db 0ace 7924 fafa 500a  7000..a...y$..P.
00000010: c75e a8e4 2aa9 b124 2f64 0ace e36c 440a  .^..*..$/d...lD.
00000020: e788 b12f 640a 484f 30                   .../d.HO0
— DJMcMayhem
source
2

Fusain , 19 octets

ΦＥＸχ⁴Ｉι¬Φι∧쬋§ι⊖μλ

Essayez-le en ligne! Le lien est vers la version verbeuse du code. Explication:

   χ                Predefined variable 10
  Ｘ                 To the power
    ⁴               Literal 4
 Ｅ                  Map over implicit range
      ι             Current value
     Ｉ              Cast to string
Φ                   Filter over strings where
         ι          Current string
        Φ           Filtered over characters
           μ        Character index (is nonzero)
          ∧         And
                 μ  Character index
                ⊖   Decremented
              §     Indexed into
               ι    Current string
            ¬       Is not
             ‹      Less than
                  λ Current character
       ¬            Results in an empty string
                    Implicitly print matches on separate lines
— Neil
source
2

Gelée , 13 9 8 octets

5 octets enregistrés grâce à @Dennis

9œcⱮ4ẎŻY

Essayez-le en ligne!

Explication

Génère tous les nombres lexicographiquement croissants en dessous de 10000 en prenant les chiffres [1 ... 9] et en trouvant toutes les combinaisons de longueur ≤ 4.

9œcⱮ4ẎŻY    Main link. Arguments: none
9           Yield 9.
   Ɱ4       For each n in [1...4]:
 œc           Yield the combinations of the range [1...9] of length n.
     Ẏ      Tighten; dump each of the 4 lists generated into the main list.
      Ż     Prepend a 0 to the list.
       Y    Join on newlines.

Gelée , 11 10 9 octets

Un octet enregistré grâce à @EriktheOutgolfer

ȷ4Ḷ<ƝẠ$ƇY

Essayez-le en ligne!

Explication

Filtre à travers la plage, en conservant les nombres qui augmentent lexicographiquement.

ȷ4Ḷ<ƝẠ$ƇY    Main link. Arguments: none
ȷ4           Yield 10^4 (10000).
  Ḷ          Generate the range [0...10000).
       Ƈ     Filter; yield only the numbers where this link return a truthy value.
      $        Run these two links and yield the result.
    Ɲ            For each pair of items (digits) in the number:
   <               Check whether the left digit is less than the right digit.
     Ạ           All; check that every comparison yielded true.
               This yields whether the digits are strictly increasing.
        Y    Join the filtered list on newlines.
— ETHproductions
source
2

C # (Visual C # Interactive Compiler) , 102 101 ... 73 octets

-12 et -4 merci @Dennis!

for(var i=0;i<7e3;i++)if((i+"").Aggregate((a,b)=>a<b?b:':')<':')Print(i);

Essayez-le en ligne!

Chaque entier de 0 à 7k est testé en le convertissant d'abord en chaîne. En exploitant le fait que C # traite les chaînes comme des énumérables de caractères et LINQ, un agrégat est calculé pour chaque caractère énumérable comme suit:

  • comparer la valeur cumulée avec le caractère courant
  • si le caractère courant est supérieur à l'accumulation, retourne le caractère courant
  • sinon retour :qui est supérieur à9

Si le résultat est inférieur à :, alors le nombre a des chiffres lexicographiquement croissants.

— Dana
source
Le défi ne stipule-t-il pas que tous les nombres de 0 à 1 000 doivent être imprimés? Je suis à peu près sûr que cela imprime les numéros 0-7000
— Incarnation de l'ignorance
Je crois que le plus grand nombre valide est 6789? C'est moins que cela 7000, vous n'avez donc pas besoin d'aller plus haut.
— dana
Oh je vois. Foolish me
— Incarnation of Ignorance
Pas idiot du tout :) Je suis presque sûr de l'avoir emprunté à la réponse de quelqu'un d'autre et je me grattais la tête pour savoir pourquoi ils l'ont fait.
— dana
2

Wolfram Language (Mathematica) , 36 octets

Après avoir écrit cela, il a été précisé que chaque numéro doit être sur une nouvelle ligne, donc +7 octets pour le Print/@.

Cette méthode tire parti du fait que la Subsetsfonction 1) ne reproduit aucun chiffre et 2) trie la sortie par taille et contenu définis.FromDigitsrassemble chaque liste de chiffres.

-1 octet grâce à @ Mr.Xcoder

Print/@FromDigits/@Range@9~Subsets~4

Essayez-le en ligne!

— Kelly Lowder
source
1
Print/@FromDigits/@Range@9~Subsets~4pour 36 octets.
— M. Xcoder
C'est drôle, j'y ai pensé et je ne l'ai pas fait parce que je pensais que ~ avait une priorité plus élevée que @
— Kelly Lowder
2

K (ngn / k) / K (oK) , 32 30 26 octets

Solution:

`0:$&&/'1_'>':'" ",'$!9999

Essayez-le en ligne!

Explication:

`0:$&&/'1_'>':'" ",'$!9999 / the solution
                     !9999 / range 0..9998 (could use !6890)
                    $      / string
               " ",'       / prepend " " to each (lower than "0" in ascii)
            >:'            / greater-than each-previous?
         1_'               / drop first result from each
      &/'                  / max (&) over (/)
    &                      / indices where true
   $                       / convert to string
`0:                        / print to stdout
— streetster
source
2

JavaScript REPL, 64 octets

Un peu de pub golf donc probablement loin d'être optimal.

(f=n=>n&&f(n-1)+([...n+``].every(x=>y<(y=x),y=0)?`
`+n:``))(7e3)

Essayez-le en ligne

Oui, le faire sans IIFE serait plus court de quelques octets mais cela déclenche une erreur de débordement lors de l'appel, ce qui serait normalement bien car nous pouvons supposer une mémoire infinie aux fins du code golf mais, à mon avis, ne semble pas être dans l'esprit des défis KC.

— Hirsute
source
Je n'ai pas d'erreur de débordement sans IIFE.
— Spitemaster
S'agit-il d'une soumission de fonction ou d'un programme complet? Si ce n'est pas le cas, vous devez soit compter la, console.logsoit renommer votre soumission en JavaScript REPL .
— Dennis
1

Gelée , 7 octets

<ƝẠ$⁹#Y

Essayez-le en ligne!

Comment?

<ƝẠ$⁹#Y - Main Link: no arguments (implicit z=0)
    ⁹   - literal 256
     #  - count up from n=z (0) finding the first 256 for which this is truthy:
   $    -   last two links as a monad:
 Ɲ      -     neighbours (implicitly gets digits of n):
<       -       less than?
  Ạ     -     all truthy? (N.B. yields 1 for an empty list)
      Y - join with newlines
— Jonathan Allan
source
1

MATLAB, 52 octets

arrayfun(@(n)disp(n(all(diff(num2str(n))>0))),0:1e4)
— Luis Mendo
source
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.