Print all lexicographically increasing numbers under 10000











up vote
29
down vote

favorite
4












A lexicographically increasing number is an integer whose digits are in strictly increasing order. Print all lexicographically increasing numbers under 10000.



Here are lines of the expected output:



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


This is a code golf challenge! Shortest answer wins!



(P.S. looking for a python solution)










share|improve this question









New contributor




Varun Patro is a new contributor to this site. Take care in asking for clarification, commenting, and answering.
Check out our Code of Conduct.
















  • 3




    do we need to print them on separate lines or is space-separated OK?
    – Giuseppe
    2 days ago






  • 3




    Welcome to PPCG! Nice first challenge. For future challenges, I can recommend using the Sandbox to refine a challenge and get meaningful feedback before posting it to main.
    – AdmBorkBork
    2 days ago






  • 4




    To expand on @Giuseppe's question, can we output separated by commas, spaces, in array format [0,1,...], etc. or must we output each number on a separate line?
    – ETHproductions
    2 days ago






  • 10




    Do the numbers need to be in a specific order, or do they just need to all exist?
    – Kamil Drakari
    2 days ago






  • 13




    @VarunPatro, please update the challenge to explicitly state that each number by on a separate line (although I'd recommend against that requirement) and make sure to inform any existing solutions that don't do so.
    – Shaggy
    2 days ago















up vote
29
down vote

favorite
4












A lexicographically increasing number is an integer whose digits are in strictly increasing order. Print all lexicographically increasing numbers under 10000.



Here are lines of the expected output:



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


This is a code golf challenge! Shortest answer wins!



(P.S. looking for a python solution)










share|improve this question









New contributor




Varun Patro is a new contributor to this site. Take care in asking for clarification, commenting, and answering.
Check out our Code of Conduct.
















  • 3




    do we need to print them on separate lines or is space-separated OK?
    – Giuseppe
    2 days ago






  • 3




    Welcome to PPCG! Nice first challenge. For future challenges, I can recommend using the Sandbox to refine a challenge and get meaningful feedback before posting it to main.
    – AdmBorkBork
    2 days ago






  • 4




    To expand on @Giuseppe's question, can we output separated by commas, spaces, in array format [0,1,...], etc. or must we output each number on a separate line?
    – ETHproductions
    2 days ago






  • 10




    Do the numbers need to be in a specific order, or do they just need to all exist?
    – Kamil Drakari
    2 days ago






  • 13




    @VarunPatro, please update the challenge to explicitly state that each number by on a separate line (although I'd recommend against that requirement) and make sure to inform any existing solutions that don't do so.
    – Shaggy
    2 days ago













up vote
29
down vote

favorite
4









up vote
29
down vote

favorite
4






4





A lexicographically increasing number is an integer whose digits are in strictly increasing order. Print all lexicographically increasing numbers under 10000.



Here are lines of the expected output:



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


This is a code golf challenge! Shortest answer wins!



(P.S. looking for a python solution)










share|improve this question









New contributor




Varun Patro is a new contributor to this site. Take care in asking for clarification, commenting, and answering.
Check out our Code of Conduct.











A lexicographically increasing number is an integer whose digits are in strictly increasing order. Print all lexicographically increasing numbers under 10000.



Here are lines of the expected output:



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


This is a code golf challenge! Shortest answer wins!



(P.S. looking for a python solution)







code-golf number sequence kolmogorov-complexity






share|improve this question









New contributor




Varun Patro is a new contributor to this site. Take care in asking for clarification, commenting, and answering.
Check out our Code of Conduct.











share|improve this question









New contributor




Varun Patro is a new contributor to this site. Take care in asking for clarification, commenting, and answering.
Check out our Code of Conduct.









share|improve this question




share|improve this question








edited 2 days ago









Shaggy

18.1k21663




18.1k21663






New contributor




Varun Patro is a new contributor to this site. Take care in asking for clarification, commenting, and answering.
Check out our Code of Conduct.









asked Nov 16 at 19:08









Varun Patro

14926




14926




New contributor




Varun Patro is a new contributor to this site. Take care in asking for clarification, commenting, and answering.
Check out our Code of Conduct.





New contributor





Varun Patro is a new contributor to this site. Take care in asking for clarification, commenting, and answering.
Check out our Code of Conduct.






Varun Patro is a new contributor to this site. Take care in asking for clarification, commenting, and answering.
Check out our Code of Conduct.








  • 3




    do we need to print them on separate lines or is space-separated OK?
    – Giuseppe
    2 days ago






  • 3




    Welcome to PPCG! Nice first challenge. For future challenges, I can recommend using the Sandbox to refine a challenge and get meaningful feedback before posting it to main.
    – AdmBorkBork
    2 days ago






  • 4




    To expand on @Giuseppe's question, can we output separated by commas, spaces, in array format [0,1,...], etc. or must we output each number on a separate line?
    – ETHproductions
    2 days ago






  • 10




    Do the numbers need to be in a specific order, or do they just need to all exist?
    – Kamil Drakari
    2 days ago






  • 13




    @VarunPatro, please update the challenge to explicitly state that each number by on a separate line (although I'd recommend against that requirement) and make sure to inform any existing solutions that don't do so.
    – Shaggy
    2 days ago














  • 3




    do we need to print them on separate lines or is space-separated OK?
    – Giuseppe
    2 days ago






  • 3




    Welcome to PPCG! Nice first challenge. For future challenges, I can recommend using the Sandbox to refine a challenge and get meaningful feedback before posting it to main.
    – AdmBorkBork
    2 days ago






  • 4




    To expand on @Giuseppe's question, can we output separated by commas, spaces, in array format [0,1,...], etc. or must we output each number on a separate line?
    – ETHproductions
    2 days ago






  • 10




    Do the numbers need to be in a specific order, or do they just need to all exist?
    – Kamil Drakari
    2 days ago






  • 13




    @VarunPatro, please update the challenge to explicitly state that each number by on a separate line (although I'd recommend against that requirement) and make sure to inform any existing solutions that don't do so.
    – Shaggy
    2 days ago








3




3




do we need to print them on separate lines or is space-separated OK?
– Giuseppe
2 days ago




do we need to print them on separate lines or is space-separated OK?
– Giuseppe
2 days ago




3




3




Welcome to PPCG! Nice first challenge. For future challenges, I can recommend using the Sandbox to refine a challenge and get meaningful feedback before posting it to main.
– AdmBorkBork
2 days ago




Welcome to PPCG! Nice first challenge. For future challenges, I can recommend using the Sandbox to refine a challenge and get meaningful feedback before posting it to main.
– AdmBorkBork
2 days ago




4




4




To expand on @Giuseppe's question, can we output separated by commas, spaces, in array format [0,1,...], etc. or must we output each number on a separate line?
– ETHproductions
2 days ago




To expand on @Giuseppe's question, can we output separated by commas, spaces, in array format [0,1,...], etc. or must we output each number on a separate line?
– ETHproductions
2 days ago




10




10




Do the numbers need to be in a specific order, or do they just need to all exist?
– Kamil Drakari
2 days ago




Do the numbers need to be in a specific order, or do they just need to all exist?
– Kamil Drakari
2 days ago




13




13




@VarunPatro, please update the challenge to explicitly state that each number by on a separate line (although I'd recommend against that requirement) and make sure to inform any existing solutions that don't do so.
– Shaggy
2 days ago




@VarunPatro, please update the challenge to explicitly state that each number by on a separate line (although I'd recommend against that requirement) and make sure to inform any existing solutions that don't do so.
– Shaggy
2 days ago










34 Answers
34






active

oldest

votes













1 2
next











up vote
23
down vote














Python 2, 56 bytes





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


Try it online!



Converts each number like 124 to an expression 1<2<4 and evaluates it to check if the digits are sorted,



A hiccup happens for one-digit numbers giving an expression that just is the number itself. This causes 0 to evaluate to a Falsey value even though it should be printed. This is fixed by a trick suggested by Erik the Outgolfer of doing **n, which gives truthy value 0**0 for n=0 and doesn't affect the truth value otherwise.






share|improve this answer























  • What does the ` do in `n`?
    – BruceWayne
    2 days ago








  • 1




    @BruceWayne It takes the string representation. This was removed in Python 3.
    – xnor
    2 days ago






  • 4




    @BruceWayne Note that it's the same as the repr() function, not the str() function. They aren't always the same. Here's an example.
    – mbomb007
    2 days ago












  • @mbomb007 thanks for that comment! I would have thought it was str() equivalent.
    – BruceWayne
    2 days ago






  • 1




    We can handle the 0 case with a bit of trickery.
    – xsot
    2 days ago


















up vote
10
down vote














Haskell, 50 bytes





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


Try it online!



Outputs a multiline string. We check that the number s increasing using s==scanl1(max.succ)s, a variant of the usual sortedness check s==scanl1 max s that ensures strict sortedness by incrementing each digit character before taking the maximum of it and the next digit.



Ourous saved a byte by using 6^5 as the upper bound in place of a 4-digit number.






share|improve this answer






























    up vote
    8
    down vote














    Python 2, 55 bytes





    i=0
    exec"print ini+=1nif eval('<'.join(`i`)):1;"*7000


    Try it online!






    share|improve this answer




























      up vote
      7
      down vote













      Japt -R, 12 11 8 bytes



      L²Ç¶ìüÃð


      Test it



      L            :100
      ² :Squared
      Ç :Map the range [0,L²)
      ì : Split to a digit array
      ü : For the sake if 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


      *Or, to offer a better explanation: the ü method sorts an array and splits it into equal elements (e.g., [8,4,8,4].ü() -> [[4,4],[8,8]]) and then, in what seems to be a strange quirk and hopefully not a bug, the ì method, when converting the array back to a number, takes the first element of each nested array, rather than first flattening the array, which is what I expected when I tried this trick (e.g., [[4,4],[8,8]].ì() -> 48).






      share|improve this answer



















      • 1




        Nice. Similar to what I had: L²Ç¥ì ü ¬Ãð
        – Oliver
        2 days ago






      • 2




        I have to say, that ü trick you guys used is genius :-) @Oliver
        – ETHproductions
        2 days ago






      • 1




        @Oliver, you must have posted that as I was updating; great minds ... :)
        – Shaggy
        2 days ago










      • @ETHproductions, like most things, I tried it on a whim - amazed it works.
        – Shaggy
        2 days ago


















      up vote
      7
      down vote














      Jelly, 7 bytes



      9ŒPḌḣ⁹Y


      Try it online!



      How it works



      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.





      share|improve this answer



















      • 1




        I'm trying to figure out how 0 gets included here but I don't know Jelly. Am I correct that Jelly's powerset includes the empty array which then gets converted to 0 when "undecimaled"?
        – Shaggy
        2 days ago






      • 1




        Yes, that's exactly what happens.
        – Dennis
        2 days ago


















      up vote
      5
      down vote














      R, 62 49 bytes





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


      Try it online!



      Because combn iterates through its input in the order given, it's easy to create all the lexicographically increasing integers, printing them out in order. write prints them each i-digit number in lines of width i, neatly fulfilling the newline requirement as well.






      share|improve this answer























      • great idea exploiting combn !
        – digEmAll
        2 days ago










      • Extremely clever aliasing!
        – J.Doe
        yesterday


















      up vote
      5
      down vote













      Haskell, 56 55 bytes



      Edit: -1 byte thanks to @Ourous



      mapM print$filter(and.(zipWith(<)<*>tail).show)[0..6^5]


      Try it online!






      share|improve this answer






























        up vote
        4
        down vote














        PowerShell, 42 40 bytes





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


        Try it online!



        Loop from 0 to 1e4 (i.e., 10000). Pull out those objects where |?{...} the number as a string $_ is -equal to the number cast toCharArray and then sorted with the -unique flag. In other words, only numbers that are the same as their sorted and deduplicated strings. Each of those are left on the pipeline and output is implicit.






        share|improve this answer






























          up vote
          3
          down vote













          J, 26 bytes



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


          Try it online!



          explanation



          ,. (#~ (-: /:~@~.)@":"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





          share|improve this answer






























            up vote
            3
            down vote














            Common Lisp, 74 72 bytes



            (dotimes(i 7e3)(format(apply'char<(coerce(format()"~d"i)'list))"~d~%"i))


            Try it online!



            -2 bytes thank to @Shaggy!






            share|improve this answer






























              up vote
              2
              down vote














              Perl 6, 26 bytes



              .say if [<] .comb for ^1e4


              Try it online!



              .comb produces a list of the digits of each number, and [<] does a less-than reduction on that list, equivalent to: digit1 < digit2 < ... < digitN.






              share|improve this answer

















              • 1




                [<](.comb)&&.say saves a byte.
                – nwellnhof
                2 days ago


















              up vote
              2
              down vote














              V, 41 bytes



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


              Try it online!



              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





              share|improve this answer




























                up vote
                2
                down vote














                Perl 5, 55 bytes





                $"=$,;map"@{[sort{$a-$b}/./g]}"-$_||/(.)1/||say,0..1E4


                Try it online!






                share|improve this answer




























                  up vote
                  2
                  down vote














                  Charcoal, 19 bytes



                  ΦEXχ⁴Iι¬Φι∧쬋§ι⊖μλ


                  Try it online! Link is to verbose version of code. Explanation:



                     χ                Predefined variable 10
                  X To the power
                  ⁴ Literal 4
                  E Map over implicit range
                  ι Current value
                  I 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





                  share|improve this answer




























                    up vote
                    2
                    down vote














                    Pyth, 10 bytes



                    jiRThc2yS9


                    Try it online!



                    How it works



                    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.





                    share|improve this answer




























                      up vote
                      2
                      down vote














                      05AB1E (legacy), 8 bytes



                      4°ÝD€êû


                      Try it online!



                      Works in the new version of 05AB1E as well but is painfully slow for some reason.



                      How?




                      4°ÝD€êû – Full program.
                      4°Ý – Push [0 ... 10000].
                      Dې РPush each integer in [0 ... 10000] sorted and deduplicated at the same time.
                      û – And join the interection of the two lists by newlines.





                      share|improve this answer





















                      • Nice answer. Better than the 9 byter I had (which only works in the legacy).
                        – Kevin Cruijssen
                        5 hours ago










                      • 4°Ýʒ¥P.± is my alternate 8-byter in the rewrite.
                        – Magic Octopus Urn
                        4 hours ago


















                      up vote
                      2
                      down vote














                      Jelly, 13 9 8 bytes



                      Saved 5 bytes thanks to @Dennis



                      9œcⱮ4ẎŻY


                      Try it online!



                      Explanation



                      Generates all lexicographically increasing numbers below 10000 by taking the digits [1...9] and finding all combinations of length ≤ 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.





                      Jelly, 11 10 9 bytes



                      Saved a byte thanks to @EriktheOutgolfer



                      ȷ4Ḷ<ƝẠ$ƇY


                      Try it online!



                      Explanation



                      Filters through the range, keeping the numbers that are lexicographically increasing.



                      ȷ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.





                      share|improve this answer






























                        up vote
                        2
                        down vote














                        Wolfram Language (Mathematica), 36 bytes



                        After I wrote this, it was clarified that each number must be on a new line, so +7 bytes for the Print/@.



                        This method takes advantage of the fact that the Subsets function 1) doesn't replicate any digits and 2) sorts the output by set size and set contents. FromDigits assembles each list of digits.



                        -1 byte thanks to @Mr.Xcoder



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


                        Try it online!






                        share|improve this answer



















                        • 1




                          Print/@FromDigits/@Range@9~Subsets~4 for 36 bytes.
                          – Mr. Xcoder
                          2 days ago










                        • Funny, I thought of that and just didn't do it because I thought ~ had higher precedence than @
                          – Kelly Lowder
                          16 hours ago


















                        up vote
                        1
                        down vote














                        Python 2, 63 bytes





                        for i in range(6790):
                        if`i`=="".join(sorted(set(`i`))):print i


                        Try it online!






                        share|improve this answer




























                          up vote
                          1
                          down vote














                          Python 2, 61 bytes





                          for i in range(9999):
                          if list(`i`)==sorted(set(`i`)):print i


                          Try it online!






                          share|improve this answer




























                            up vote
                            1
                            down vote














                            Python 2, 64 61 bytes





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


                            Try it online!



                            Gets the unique characters of the integer's string representation, sorts them, and compares the result to the original number.






                            share|improve this answer























                            • You can save a byte by using range(9999) or any other number between 6790 and 9999. Our solutions are almost identical BTW :)
                              – DJMcMayhem
                              2 days ago










                            • @DJMcMayhem But then it wouldn't check ALL numbers under 10,000....:P Thanks! Sometimes I get too literal with these challenges.
                              – Triggernometry
                              2 days ago


















                            up vote
                            1
                            down vote













                            T-SQL, 188 bytes



                            WITH a AS(SELECT 0n UNION ALL SELECT n+1FROM a WHERE n<9)
                            SELECT ABS(CONCAT(a.n,b.n,c.n,d.n))
                            FROM a,a b,a c,a d
                            WHERE(a.n<b.n OR a.n+b.n=0)
                            AND(b.n<c.n OR b.n+c.n=0)
                            AND(c.n<d.n OR c.n+d.n=0)


                            Line breaks are for readability only.



                            I'm certain there must be more efficient ways to do this in SQL, but this was the first thing I thought of. Explanation:




                            1. Declare an in-memory table with values 0 to 9

                            2. Cross-join 4 copies of this table for all possible values from 0000 to 9999

                            3. Messy WHERE clause to ensure the digits are strictly increasing (or both 0)

                            4. Smash the digits together (CONCAT) and convert to integer (ABS)

                            5. The resulting rows may or may not be sorted, but the challenge doesn't appear to require that.






                            share|improve this answer




























                              up vote
                              1
                              down vote














                              Stax, 8 bytes



                              ¬ ▬A♥¶N∙


                              Run and debug it






                              share|improve this answer




























                                up vote
                                1
                                down vote














                                Clean, 90 bytes



                                import StdEnv
                                Start=(0,[('
                                ',n)\n<-[1..6^5]|(l=removeDup l==sort l)[c\c<-:toString n]])


                                Try it online!






                                share|improve this answer






























                                  up vote
                                  1
                                  down vote














                                  Red, 59 bytes



                                  repeat n 9999[if(d: n - 1)= do sort unique form d[print d]]


                                  Try it online!






                                  share|improve this answer




























                                    up vote
                                    1
                                    down vote














                                    K (ngn/k) / K (oK), 32 30 bytes



                                    Solution:



                                    `0:$&{x~|x:>':(6#10)x}'!9999


                                    Try it online!



                                    Explanation:



                                    `0:$&{x~|x:>':(6#10)x}'!9999 / the solution
                                    !9999 / range 0..9998 (could use !6890)
                                    { }' / apply lambda to each (')
                                    x / split x to base
                                    ( ) / do together
                                    6#10 / 6 take 10 -> 10 10 10 10 10 10
                                    >:' / greater-than each-previous?
                                    x: / save as x
                                    | / max scan
                                    x~ / does x match this?
                                    & / indices where true
                                    $ / convert to string
                                    `0: / print to stdout





                                    share|improve this answer






























                                      up vote
                                      1
                                      down vote














                                      Jelly, 7 bytes



                                      <ƝẠ$⁹#Y


                                      Try it online!



                                      How?



                                      <ƝẠ$⁹#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





                                      share|improve this answer




























                                        up vote
                                        1
                                        down vote














                                        C (gcc), 97 bytes





                                        g(n,l,r){for(r=l=10;n;n/=10)r*=n%10<l,l=n%10;n=r;}f(i){for(i=0;i<1e4;i++)g(i)&&printf("%dn",i);}


                                        Try it online!






                                        share|improve this answer





















                                        • Why not use puts?
                                          – markasoftware
                                          yesterday










                                        • @markasoftware Puts is for strings. i is an integer.
                                          – gastropner
                                          yesterday


















                                        up vote
                                        1
                                        down vote













                                        JavaScript, 64 bytes



                                        A bit of pub golf so probably far from optimal.



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


                                        Try it online



                                        Yes, doing it without an IIFE would be a few bytes shorter but that throws an overflow error when called, which would normally be fine as we can assume infinite memory for the purposes of code golf but, to me, doesn't seem to be in the spirit of KC challenges.






                                        share|improve this answer























                                        • I don't get an overflow error without an IIFE.
                                          – Spitemaster
                                          2 days ago


















                                        up vote
                                        1
                                        down vote














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



                                        -12 and -4 thanks @Dennis!





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


                                        Try it online!



                                        Each integer from 0 to 7k tested by first converting it into a string. Leveraging the fact that C# treats strings as character enumerables and LINQ, an aggregate is calculated for each character enumerable as follows:




                                        • compare the accumulated value with the current character

                                        • if the current character is greater than the accumulation, return the current character

                                        • otherwise return : which is greater than 9


                                        If the result of this is less than :, then the number has lexicographically increasing digits.






                                        share|improve this answer



























                                          1 2
                                          next



                                          Your Answer





                                          StackExchange.ifUsing("editor", function () {
                                          return StackExchange.using("mathjaxEditing", function () {
                                          StackExchange.MarkdownEditor.creationCallbacks.add(function (editor, postfix) {
                                          StackExchange.mathjaxEditing.prepareWmdForMathJax(editor, postfix, [["\$", "\$"]]);
                                          });
                                          });
                                          }, "mathjax-editing");

                                          StackExchange.ifUsing("editor", function () {
                                          StackExchange.using("externalEditor", function () {
                                          StackExchange.using("snippets", function () {
                                          StackExchange.snippets.init();
                                          });
                                          });
                                          }, "code-snippets");

                                          StackExchange.ready(function() {
                                          var channelOptions = {
                                          tags: "".split(" "),
                                          id: "200"
                                          };
                                          initTagRenderer("".split(" "), "".split(" "), channelOptions);

                                          StackExchange.using("externalEditor", function() {
                                          // Have to fire editor after snippets, if snippets enabled
                                          if (StackExchange.settings.snippets.snippetsEnabled) {
                                          StackExchange.using("snippets", function() {
                                          createEditor();
                                          });
                                          }
                                          else {
                                          createEditor();
                                          }
                                          });

                                          function createEditor() {
                                          StackExchange.prepareEditor({
                                          heartbeatType: 'answer',
                                          convertImagesToLinks: false,
                                          noModals: true,
                                          showLowRepImageUploadWarning: true,
                                          reputationToPostImages: null,
                                          bindNavPrevention: true,
                                          postfix: "",
                                          imageUploader: {
                                          brandingHtml: "Powered by u003ca class="icon-imgur-white" href="https://imgur.com/"u003eu003c/au003e",
                                          contentPolicyHtml: "User contributions licensed under u003ca href="https://creativecommons.org/licenses/by-sa/3.0/"u003ecc by-sa 3.0 with attribution requiredu003c/au003e u003ca href="https://stackoverflow.com/legal/content-policy"u003e(content policy)u003c/au003e",
                                          allowUrls: true
                                          },
                                          onDemand: true,
                                          discardSelector: ".discard-answer"
                                          ,immediatelyShowMarkdownHelp:true
                                          });


                                          }
                                          });






                                          Varun Patro is a new contributor. Be nice, and check out our Code of Conduct.










                                           

                                          draft saved


                                          draft discarded


















                                          StackExchange.ready(
                                          function () {
                                          StackExchange.openid.initPostLogin('.new-post-login', 'https%3a%2f%2fcodegolf.stackexchange.com%2fquestions%2f176095%2fprint-all-lexicographically-increasing-numbers-under-10000%23new-answer', 'question_page');
                                          }
                                          );

                                          Post as a guest















                                          Required, but never shown

























                                          34 Answers
                                          34






                                          active

                                          oldest

                                          votes








                                          34 Answers
                                          34






                                          active

                                          oldest

                                          votes









                                          active

                                          oldest

                                          votes






                                          active

                                          oldest

                                          votes








                                          1 2
                                          next









                                          up vote
                                          23
                                          down vote














                                          Python 2, 56 bytes





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


                                          Try it online!



                                          Converts each number like 124 to an expression 1<2<4 and evaluates it to check if the digits are sorted,



                                          A hiccup happens for one-digit numbers giving an expression that just is the number itself. This causes 0 to evaluate to a Falsey value even though it should be printed. This is fixed by a trick suggested by Erik the Outgolfer of doing **n, which gives truthy value 0**0 for n=0 and doesn't affect the truth value otherwise.






                                          share|improve this answer























                                          • What does the ` do in `n`?
                                            – BruceWayne
                                            2 days ago








                                          • 1




                                            @BruceWayne It takes the string representation. This was removed in Python 3.
                                            – xnor
                                            2 days ago






                                          • 4




                                            @BruceWayne Note that it's the same as the repr() function, not the str() function. They aren't always the same. Here's an example.
                                            – mbomb007
                                            2 days ago












                                          • @mbomb007 thanks for that comment! I would have thought it was str() equivalent.
                                            – BruceWayne
                                            2 days ago






                                          • 1




                                            We can handle the 0 case with a bit of trickery.
                                            – xsot
                                            2 days ago















                                          up vote
                                          23
                                          down vote














                                          Python 2, 56 bytes





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


                                          Try it online!



                                          Converts each number like 124 to an expression 1<2<4 and evaluates it to check if the digits are sorted,



                                          A hiccup happens for one-digit numbers giving an expression that just is the number itself. This causes 0 to evaluate to a Falsey value even though it should be printed. This is fixed by a trick suggested by Erik the Outgolfer of doing **n, which gives truthy value 0**0 for n=0 and doesn't affect the truth value otherwise.






                                          share|improve this answer























                                          • What does the ` do in `n`?
                                            – BruceWayne
                                            2 days ago








                                          • 1




                                            @BruceWayne It takes the string representation. This was removed in Python 3.
                                            – xnor
                                            2 days ago






                                          • 4




                                            @BruceWayne Note that it's the same as the repr() function, not the str() function. They aren't always the same. Here's an example.
                                            – mbomb007
                                            2 days ago












                                          • @mbomb007 thanks for that comment! I would have thought it was str() equivalent.
                                            – BruceWayne
                                            2 days ago






                                          • 1




                                            We can handle the 0 case with a bit of trickery.
                                            – xsot
                                            2 days ago













                                          up vote
                                          23
                                          down vote










                                          up vote
                                          23
                                          down vote










                                          Python 2, 56 bytes





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


                                          Try it online!



                                          Converts each number like 124 to an expression 1<2<4 and evaluates it to check if the digits are sorted,



                                          A hiccup happens for one-digit numbers giving an expression that just is the number itself. This causes 0 to evaluate to a Falsey value even though it should be printed. This is fixed by a trick suggested by Erik the Outgolfer of doing **n, which gives truthy value 0**0 for n=0 and doesn't affect the truth value otherwise.






                                          share|improve this answer















                                          Python 2, 56 bytes





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


                                          Try it online!



                                          Converts each number like 124 to an expression 1<2<4 and evaluates it to check if the digits are sorted,



                                          A hiccup happens for one-digit numbers giving an expression that just is the number itself. This causes 0 to evaluate to a Falsey value even though it should be printed. This is fixed by a trick suggested by Erik the Outgolfer of doing **n, which gives truthy value 0**0 for n=0 and doesn't affect the truth value otherwise.







                                          share|improve this answer














                                          share|improve this answer



                                          share|improve this answer








                                          edited 2 days ago

























                                          answered 2 days ago









                                          xnor

                                          88.8k18183437




                                          88.8k18183437












                                          • What does the ` do in `n`?
                                            – BruceWayne
                                            2 days ago








                                          • 1




                                            @BruceWayne It takes the string representation. This was removed in Python 3.
                                            – xnor
                                            2 days ago






                                          • 4




                                            @BruceWayne Note that it's the same as the repr() function, not the str() function. They aren't always the same. Here's an example.
                                            – mbomb007
                                            2 days ago












                                          • @mbomb007 thanks for that comment! I would have thought it was str() equivalent.
                                            – BruceWayne
                                            2 days ago






                                          • 1




                                            We can handle the 0 case with a bit of trickery.
                                            – xsot
                                            2 days ago


















                                          • What does the ` do in `n`?
                                            – BruceWayne
                                            2 days ago








                                          • 1




                                            @BruceWayne It takes the string representation. This was removed in Python 3.
                                            – xnor
                                            2 days ago






                                          • 4




                                            @BruceWayne Note that it's the same as the repr() function, not the str() function. They aren't always the same. Here's an example.
                                            – mbomb007
                                            2 days ago












                                          • @mbomb007 thanks for that comment! I would have thought it was str() equivalent.
                                            – BruceWayne
                                            2 days ago






                                          • 1




                                            We can handle the 0 case with a bit of trickery.
                                            – xsot
                                            2 days ago
















                                          What does the ` do in `n`?
                                          – BruceWayne
                                          2 days ago






                                          What does the ` do in `n`?
                                          – BruceWayne
                                          2 days ago






                                          1




                                          1




                                          @BruceWayne It takes the string representation. This was removed in Python 3.
                                          – xnor
                                          2 days ago




                                          @BruceWayne It takes the string representation. This was removed in Python 3.
                                          – xnor
                                          2 days ago




                                          4




                                          4




                                          @BruceWayne Note that it's the same as the repr() function, not the str() function. They aren't always the same. Here's an example.
                                          – mbomb007
                                          2 days ago






                                          @BruceWayne Note that it's the same as the repr() function, not the str() function. They aren't always the same. Here's an example.
                                          – mbomb007
                                          2 days ago














                                          @mbomb007 thanks for that comment! I would have thought it was str() equivalent.
                                          – BruceWayne
                                          2 days ago




                                          @mbomb007 thanks for that comment! I would have thought it was str() equivalent.
                                          – BruceWayne
                                          2 days ago




                                          1




                                          1




                                          We can handle the 0 case with a bit of trickery.
                                          – xsot
                                          2 days ago




                                          We can handle the 0 case with a bit of trickery.
                                          – xsot
                                          2 days ago










                                          up vote
                                          10
                                          down vote














                                          Haskell, 50 bytes





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


                                          Try it online!



                                          Outputs a multiline string. We check that the number s increasing using s==scanl1(max.succ)s, a variant of the usual sortedness check s==scanl1 max s that ensures strict sortedness by incrementing each digit character before taking the maximum of it and the next digit.



                                          Ourous saved a byte by using 6^5 as the upper bound in place of a 4-digit number.






                                          share|improve this answer



























                                            up vote
                                            10
                                            down vote














                                            Haskell, 50 bytes





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


                                            Try it online!



                                            Outputs a multiline string. We check that the number s increasing using s==scanl1(max.succ)s, a variant of the usual sortedness check s==scanl1 max s that ensures strict sortedness by incrementing each digit character before taking the maximum of it and the next digit.



                                            Ourous saved a byte by using 6^5 as the upper bound in place of a 4-digit number.






                                            share|improve this answer

























                                              up vote
                                              10
                                              down vote










                                              up vote
                                              10
                                              down vote










                                              Haskell, 50 bytes





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


                                              Try it online!



                                              Outputs a multiline string. We check that the number s increasing using s==scanl1(max.succ)s, a variant of the usual sortedness check s==scanl1 max s that ensures strict sortedness by incrementing each digit character before taking the maximum of it and the next digit.



                                              Ourous saved a byte by using 6^5 as the upper bound in place of a 4-digit number.






                                              share|improve this answer















                                              Haskell, 50 bytes





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


                                              Try it online!



                                              Outputs a multiline string. We check that the number s increasing using s==scanl1(max.succ)s, a variant of the usual sortedness check s==scanl1 max s that ensures strict sortedness by incrementing each digit character before taking the maximum of it and the next digit.



                                              Ourous saved a byte by using 6^5 as the upper bound in place of a 4-digit number.







                                              share|improve this answer














                                              share|improve this answer



                                              share|improve this answer








                                              edited 2 days ago

























                                              answered 2 days ago









                                              xnor

                                              88.8k18183437




                                              88.8k18183437






















                                                  up vote
                                                  8
                                                  down vote














                                                  Python 2, 55 bytes





                                                  i=0
                                                  exec"print ini+=1nif eval('<'.join(`i`)):1;"*7000


                                                  Try it online!






                                                  share|improve this answer

























                                                    up vote
                                                    8
                                                    down vote














                                                    Python 2, 55 bytes





                                                    i=0
                                                    exec"print ini+=1nif eval('<'.join(`i`)):1;"*7000


                                                    Try it online!






                                                    share|improve this answer























                                                      up vote
                                                      8
                                                      down vote










                                                      up vote
                                                      8
                                                      down vote










                                                      Python 2, 55 bytes





                                                      i=0
                                                      exec"print ini+=1nif eval('<'.join(`i`)):1;"*7000


                                                      Try it online!






                                                      share|improve this answer













                                                      Python 2, 55 bytes





                                                      i=0
                                                      exec"print ini+=1nif eval('<'.join(`i`)):1;"*7000


                                                      Try it online!







                                                      share|improve this answer












                                                      share|improve this answer



                                                      share|improve this answer










                                                      answered 2 days ago









                                                      xsot

                                                      4,7791921




                                                      4,7791921






















                                                          up vote
                                                          7
                                                          down vote













                                                          Japt -R, 12 11 8 bytes



                                                          L²Ç¶ìüÃð


                                                          Test it



                                                          L            :100
                                                          ² :Squared
                                                          Ç :Map the range [0,L²)
                                                          ì : Split to a digit array
                                                          ü : For the sake if 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


                                                          *Or, to offer a better explanation: the ü method sorts an array and splits it into equal elements (e.g., [8,4,8,4].ü() -> [[4,4],[8,8]]) and then, in what seems to be a strange quirk and hopefully not a bug, the ì method, when converting the array back to a number, takes the first element of each nested array, rather than first flattening the array, which is what I expected when I tried this trick (e.g., [[4,4],[8,8]].ì() -> 48).






                                                          share|improve this answer



















                                                          • 1




                                                            Nice. Similar to what I had: L²Ç¥ì ü ¬Ãð
                                                            – Oliver
                                                            2 days ago






                                                          • 2




                                                            I have to say, that ü trick you guys used is genius :-) @Oliver
                                                            – ETHproductions
                                                            2 days ago






                                                          • 1




                                                            @Oliver, you must have posted that as I was updating; great minds ... :)
                                                            – Shaggy
                                                            2 days ago










                                                          • @ETHproductions, like most things, I tried it on a whim - amazed it works.
                                                            – Shaggy
                                                            2 days ago















                                                          up vote
                                                          7
                                                          down vote













                                                          Japt -R, 12 11 8 bytes



                                                          L²Ç¶ìüÃð


                                                          Test it



                                                          L            :100
                                                          ² :Squared
                                                          Ç :Map the range [0,L²)
                                                          ì : Split to a digit array
                                                          ü : For the sake if 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


                                                          *Or, to offer a better explanation: the ü method sorts an array and splits it into equal elements (e.g., [8,4,8,4].ü() -> [[4,4],[8,8]]) and then, in what seems to be a strange quirk and hopefully not a bug, the ì method, when converting the array back to a number, takes the first element of each nested array, rather than first flattening the array, which is what I expected when I tried this trick (e.g., [[4,4],[8,8]].ì() -> 48).






                                                          share|improve this answer



















                                                          • 1




                                                            Nice. Similar to what I had: L²Ç¥ì ü ¬Ãð
                                                            – Oliver
                                                            2 days ago






                                                          • 2




                                                            I have to say, that ü trick you guys used is genius :-) @Oliver
                                                            – ETHproductions
                                                            2 days ago






                                                          • 1




                                                            @Oliver, you must have posted that as I was updating; great minds ... :)
                                                            – Shaggy
                                                            2 days ago










                                                          • @ETHproductions, like most things, I tried it on a whim - amazed it works.
                                                            – Shaggy
                                                            2 days ago













                                                          up vote
                                                          7
                                                          down vote










                                                          up vote
                                                          7
                                                          down vote









                                                          Japt -R, 12 11 8 bytes



                                                          L²Ç¶ìüÃð


                                                          Test it



                                                          L            :100
                                                          ² :Squared
                                                          Ç :Map the range [0,L²)
                                                          ì : Split to a digit array
                                                          ü : For the sake if 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


                                                          *Or, to offer a better explanation: the ü method sorts an array and splits it into equal elements (e.g., [8,4,8,4].ü() -> [[4,4],[8,8]]) and then, in what seems to be a strange quirk and hopefully not a bug, the ì method, when converting the array back to a number, takes the first element of each nested array, rather than first flattening the array, which is what I expected when I tried this trick (e.g., [[4,4],[8,8]].ì() -> 48).






                                                          share|improve this answer














                                                          Japt -R, 12 11 8 bytes



                                                          L²Ç¶ìüÃð


                                                          Test it



                                                          L            :100
                                                          ² :Squared
                                                          Ç :Map the range [0,L²)
                                                          ì : Split to a digit array
                                                          ü : For the sake if 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


                                                          *Or, to offer a better explanation: the ü method sorts an array and splits it into equal elements (e.g., [8,4,8,4].ü() -> [[4,4],[8,8]]) and then, in what seems to be a strange quirk and hopefully not a bug, the ì method, when converting the array back to a number, takes the first element of each nested array, rather than first flattening the array, which is what I expected when I tried this trick (e.g., [[4,4],[8,8]].ì() -> 48).







                                                          share|improve this answer














                                                          share|improve this answer



                                                          share|improve this answer








                                                          edited 2 days ago

























                                                          answered 2 days ago









                                                          Shaggy

                                                          18.1k21663




                                                          18.1k21663








                                                          • 1




                                                            Nice. Similar to what I had: L²Ç¥ì ü ¬Ãð
                                                            – Oliver
                                                            2 days ago






                                                          • 2




                                                            I have to say, that ü trick you guys used is genius :-) @Oliver
                                                            – ETHproductions
                                                            2 days ago






                                                          • 1




                                                            @Oliver, you must have posted that as I was updating; great minds ... :)
                                                            – Shaggy
                                                            2 days ago










                                                          • @ETHproductions, like most things, I tried it on a whim - amazed it works.
                                                            – Shaggy
                                                            2 days ago














                                                          • 1




                                                            Nice. Similar to what I had: L²Ç¥ì ü ¬Ãð
                                                            – Oliver
                                                            2 days ago






                                                          • 2




                                                            I have to say, that ü trick you guys used is genius :-) @Oliver
                                                            – ETHproductions
                                                            2 days ago






                                                          • 1




                                                            @Oliver, you must have posted that as I was updating; great minds ... :)
                                                            – Shaggy
                                                            2 days ago










                                                          • @ETHproductions, like most things, I tried it on a whim - amazed it works.
                                                            – Shaggy
                                                            2 days ago








                                                          1




                                                          1




                                                          Nice. Similar to what I had: L²Ç¥ì ü ¬Ãð
                                                          – Oliver
                                                          2 days ago




                                                          Nice. Similar to what I had: L²Ç¥ì ü ¬Ãð
                                                          – Oliver
                                                          2 days ago




                                                          2




                                                          2




                                                          I have to say, that ü trick you guys used is genius :-) @Oliver
                                                          – ETHproductions
                                                          2 days ago




                                                          I have to say, that ü trick you guys used is genius :-) @Oliver
                                                          – ETHproductions
                                                          2 days ago




                                                          1




                                                          1




                                                          @Oliver, you must have posted that as I was updating; great minds ... :)
                                                          – Shaggy
                                                          2 days ago




                                                          @Oliver, you must have posted that as I was updating; great minds ... :)
                                                          – Shaggy
                                                          2 days ago












                                                          @ETHproductions, like most things, I tried it on a whim - amazed it works.
                                                          – Shaggy
                                                          2 days ago




                                                          @ETHproductions, like most things, I tried it on a whim - amazed it works.
                                                          – Shaggy
                                                          2 days ago










                                                          up vote
                                                          7
                                                          down vote














                                                          Jelly, 7 bytes



                                                          9ŒPḌḣ⁹Y


                                                          Try it online!



                                                          How it works



                                                          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.





                                                          share|improve this answer



















                                                          • 1




                                                            I'm trying to figure out how 0 gets included here but I don't know Jelly. Am I correct that Jelly's powerset includes the empty array which then gets converted to 0 when "undecimaled"?
                                                            – Shaggy
                                                            2 days ago






                                                          • 1




                                                            Yes, that's exactly what happens.
                                                            – Dennis
                                                            2 days ago















                                                          up vote
                                                          7
                                                          down vote














                                                          Jelly, 7 bytes



                                                          9ŒPḌḣ⁹Y


                                                          Try it online!



                                                          How it works



                                                          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.





                                                          share|improve this answer



















                                                          • 1




                                                            I'm trying to figure out how 0 gets included here but I don't know Jelly. Am I correct that Jelly's powerset includes the empty array which then gets converted to 0 when "undecimaled"?
                                                            – Shaggy
                                                            2 days ago






                                                          • 1




                                                            Yes, that's exactly what happens.
                                                            – Dennis
                                                            2 days ago













                                                          up vote
                                                          7
                                                          down vote










                                                          up vote
                                                          7
                                                          down vote










                                                          Jelly, 7 bytes



                                                          9ŒPḌḣ⁹Y


                                                          Try it online!



                                                          How it works



                                                          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.





                                                          share|improve this answer















                                                          Jelly, 7 bytes



                                                          9ŒPḌḣ⁹Y


                                                          Try it online!



                                                          How it works



                                                          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.






                                                          share|improve this answer














                                                          share|improve this answer



                                                          share|improve this answer








                                                          edited 2 days ago

























                                                          answered 2 days ago









                                                          Dennis

                                                          184k32293729




                                                          184k32293729








                                                          • 1




                                                            I'm trying to figure out how 0 gets included here but I don't know Jelly. Am I correct that Jelly's powerset includes the empty array which then gets converted to 0 when "undecimaled"?
                                                            – Shaggy
                                                            2 days ago






                                                          • 1




                                                            Yes, that's exactly what happens.
                                                            – Dennis
                                                            2 days ago














                                                          • 1




                                                            I'm trying to figure out how 0 gets included here but I don't know Jelly. Am I correct that Jelly's powerset includes the empty array which then gets converted to 0 when "undecimaled"?
                                                            – Shaggy
                                                            2 days ago






                                                          • 1




                                                            Yes, that's exactly what happens.
                                                            – Dennis
                                                            2 days ago








                                                          1




                                                          1




                                                          I'm trying to figure out how 0 gets included here but I don't know Jelly. Am I correct that Jelly's powerset includes the empty array which then gets converted to 0 when "undecimaled"?
                                                          – Shaggy
                                                          2 days ago




                                                          I'm trying to figure out how 0 gets included here but I don't know Jelly. Am I correct that Jelly's powerset includes the empty array which then gets converted to 0 when "undecimaled"?
                                                          – Shaggy
                                                          2 days ago




                                                          1




                                                          1




                                                          Yes, that's exactly what happens.
                                                          – Dennis
                                                          2 days ago




                                                          Yes, that's exactly what happens.
                                                          – Dennis
                                                          2 days ago










                                                          up vote
                                                          5
                                                          down vote














                                                          R, 62 49 bytes





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


                                                          Try it online!



                                                          Because combn iterates through its input in the order given, it's easy to create all the lexicographically increasing integers, printing them out in order. write prints them each i-digit number in lines of width i, neatly fulfilling the newline requirement as well.






                                                          share|improve this answer























                                                          • great idea exploiting combn !
                                                            – digEmAll
                                                            2 days ago










                                                          • Extremely clever aliasing!
                                                            – J.Doe
                                                            yesterday















                                                          up vote
                                                          5
                                                          down vote














                                                          R, 62 49 bytes





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


                                                          Try it online!



                                                          Because combn iterates through its input in the order given, it's easy to create all the lexicographically increasing integers, printing them out in order. write prints them each i-digit number in lines of width i, neatly fulfilling the newline requirement as well.






                                                          share|improve this answer























                                                          • great idea exploiting combn !
                                                            – digEmAll
                                                            2 days ago










                                                          • Extremely clever aliasing!
                                                            – J.Doe
                                                            yesterday













                                                          up vote
                                                          5
                                                          down vote










                                                          up vote
                                                          5
                                                          down vote










                                                          R, 62 49 bytes





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


                                                          Try it online!



                                                          Because combn iterates through its input in the order given, it's easy to create all the lexicographically increasing integers, printing them out in order. write prints them each i-digit number in lines of width i, neatly fulfilling the newline requirement as well.






                                                          share|improve this answer















                                                          R, 62 49 bytes





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


                                                          Try it online!



                                                          Because combn iterates through its input in the order given, it's easy to create all the lexicographically increasing integers, printing them out in order. write prints them each i-digit number in lines of width i, neatly fulfilling the newline requirement as well.







                                                          share|improve this answer














                                                          share|improve this answer



                                                          share|improve this answer








                                                          edited 2 days ago

























                                                          answered 2 days ago









                                                          Giuseppe

                                                          16k31052




                                                          16k31052












                                                          • great idea exploiting combn !
                                                            – digEmAll
                                                            2 days ago










                                                          • Extremely clever aliasing!
                                                            – J.Doe
                                                            yesterday


















                                                          • great idea exploiting combn !
                                                            – digEmAll
                                                            2 days ago










                                                          • Extremely clever aliasing!
                                                            – J.Doe
                                                            yesterday
















                                                          great idea exploiting combn !
                                                          – digEmAll
                                                          2 days ago




                                                          great idea exploiting combn !
                                                          – digEmAll
                                                          2 days ago












                                                          Extremely clever aliasing!
                                                          – J.Doe
                                                          yesterday




                                                          Extremely clever aliasing!
                                                          – J.Doe
                                                          yesterday










                                                          up vote
                                                          5
                                                          down vote













                                                          Haskell, 56 55 bytes



                                                          Edit: -1 byte thanks to @Ourous



                                                          mapM print$filter(and.(zipWith(<)<*>tail).show)[0..6^5]


                                                          Try it online!






                                                          share|improve this answer



























                                                            up vote
                                                            5
                                                            down vote













                                                            Haskell, 56 55 bytes



                                                            Edit: -1 byte thanks to @Ourous



                                                            mapM print$filter(and.(zipWith(<)<*>tail).show)[0..6^5]


                                                            Try it online!






                                                            share|improve this answer

























                                                              up vote
                                                              5
                                                              down vote










                                                              up vote
                                                              5
                                                              down vote









                                                              Haskell, 56 55 bytes



                                                              Edit: -1 byte thanks to @Ourous



                                                              mapM print$filter(and.(zipWith(<)<*>tail).show)[0..6^5]


                                                              Try it online!






                                                              share|improve this answer














                                                              Haskell, 56 55 bytes



                                                              Edit: -1 byte thanks to @Ourous



                                                              mapM print$filter(and.(zipWith(<)<*>tail).show)[0..6^5]


                                                              Try it online!







                                                              share|improve this answer














                                                              share|improve this answer



                                                              share|improve this answer








                                                              edited 2 days ago

























                                                              answered 2 days ago









                                                              nimi

                                                              30.8k31985




                                                              30.8k31985






















                                                                  up vote
                                                                  4
                                                                  down vote














                                                                  PowerShell, 42 40 bytes





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


                                                                  Try it online!



                                                                  Loop from 0 to 1e4 (i.e., 10000). Pull out those objects where |?{...} the number as a string $_ is -equal to the number cast toCharArray and then sorted with the -unique flag. In other words, only numbers that are the same as their sorted and deduplicated strings. Each of those are left on the pipeline and output is implicit.






                                                                  share|improve this answer



























                                                                    up vote
                                                                    4
                                                                    down vote














                                                                    PowerShell, 42 40 bytes





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


                                                                    Try it online!



                                                                    Loop from 0 to 1e4 (i.e., 10000). Pull out those objects where |?{...} the number as a string $_ is -equal to the number cast toCharArray and then sorted with the -unique flag. In other words, only numbers that are the same as their sorted and deduplicated strings. Each of those are left on the pipeline and output is implicit.






                                                                    share|improve this answer

























                                                                      up vote
                                                                      4
                                                                      down vote










                                                                      up vote
                                                                      4
                                                                      down vote










                                                                      PowerShell, 42 40 bytes





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


                                                                      Try it online!



                                                                      Loop from 0 to 1e4 (i.e., 10000). Pull out those objects where |?{...} the number as a string $_ is -equal to the number cast toCharArray and then sorted with the -unique flag. In other words, only numbers that are the same as their sorted and deduplicated strings. Each of those are left on the pipeline and output is implicit.






                                                                      share|improve this answer















                                                                      PowerShell, 42 40 bytes





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


                                                                      Try it online!



                                                                      Loop from 0 to 1e4 (i.e., 10000). Pull out those objects where |?{...} the number as a string $_ is -equal to the number cast toCharArray and then sorted with the -unique flag. In other words, only numbers that are the same as their sorted and deduplicated strings. Each of those are left on the pipeline and output is implicit.







                                                                      share|improve this answer














                                                                      share|improve this answer



                                                                      share|improve this answer








                                                                      edited 5 hours ago

























                                                                      answered 2 days ago









                                                                      AdmBorkBork

                                                                      25.5k363224




                                                                      25.5k363224






















                                                                          up vote
                                                                          3
                                                                          down vote













                                                                          J, 26 bytes



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


                                                                          Try it online!



                                                                          explanation



                                                                          ,. (#~ (-: /:~@~.)@":"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





                                                                          share|improve this answer



























                                                                            up vote
                                                                            3
                                                                            down vote













                                                                            J, 26 bytes



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


                                                                            Try it online!



                                                                            explanation



                                                                            ,. (#~ (-: /:~@~.)@":"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





                                                                            share|improve this answer

























                                                                              up vote
                                                                              3
                                                                              down vote










                                                                              up vote
                                                                              3
                                                                              down vote









                                                                              J, 26 bytes



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


                                                                              Try it online!



                                                                              explanation



                                                                              ,. (#~ (-: /:~@~.)@":"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





                                                                              share|improve this answer














                                                                              J, 26 bytes



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


                                                                              Try it online!



                                                                              explanation



                                                                              ,. (#~ (-: /:~@~.)@":"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






                                                                              share|improve this answer














                                                                              share|improve this answer



                                                                              share|improve this answer








                                                                              edited 2 days ago

























                                                                              answered 2 days ago









                                                                              Jonah

                                                                              1,921816




                                                                              1,921816






















                                                                                  up vote
                                                                                  3
                                                                                  down vote














                                                                                  Common Lisp, 74 72 bytes



                                                                                  (dotimes(i 7e3)(format(apply'char<(coerce(format()"~d"i)'list))"~d~%"i))


                                                                                  Try it online!



                                                                                  -2 bytes thank to @Shaggy!






                                                                                  share|improve this answer



























                                                                                    up vote
                                                                                    3
                                                                                    down vote














                                                                                    Common Lisp, 74 72 bytes



                                                                                    (dotimes(i 7e3)(format(apply'char<(coerce(format()"~d"i)'list))"~d~%"i))


                                                                                    Try it online!



                                                                                    -2 bytes thank to @Shaggy!






                                                                                    share|improve this answer

























                                                                                      up vote
                                                                                      3
                                                                                      down vote










                                                                                      up vote
                                                                                      3
                                                                                      down vote










                                                                                      Common Lisp, 74 72 bytes



                                                                                      (dotimes(i 7e3)(format(apply'char<(coerce(format()"~d"i)'list))"~d~%"i))


                                                                                      Try it online!



                                                                                      -2 bytes thank to @Shaggy!






                                                                                      share|improve this answer















                                                                                      Common Lisp, 74 72 bytes



                                                                                      (dotimes(i 7e3)(format(apply'char<(coerce(format()"~d"i)'list))"~d~%"i))


                                                                                      Try it online!



                                                                                      -2 bytes thank to @Shaggy!







                                                                                      share|improve this answer














                                                                                      share|improve this answer



                                                                                      share|improve this answer








                                                                                      edited 2 days ago

























                                                                                      answered 2 days ago









                                                                                      Renzo

                                                                                      1,570516




                                                                                      1,570516






















                                                                                          up vote
                                                                                          2
                                                                                          down vote














                                                                                          Perl 6, 26 bytes



                                                                                          .say if [<] .comb for ^1e4


                                                                                          Try it online!



                                                                                          .comb produces a list of the digits of each number, and [<] does a less-than reduction on that list, equivalent to: digit1 < digit2 < ... < digitN.






                                                                                          share|improve this answer

















                                                                                          • 1




                                                                                            [<](.comb)&&.say saves a byte.
                                                                                            – nwellnhof
                                                                                            2 days ago















                                                                                          up vote
                                                                                          2
                                                                                          down vote














                                                                                          Perl 6, 26 bytes



                                                                                          .say if [<] .comb for ^1e4


                                                                                          Try it online!



                                                                                          .comb produces a list of the digits of each number, and [<] does a less-than reduction on that list, equivalent to: digit1 < digit2 < ... < digitN.






                                                                                          share|improve this answer

















                                                                                          • 1




                                                                                            [<](.comb)&&.say saves a byte.
                                                                                            – nwellnhof
                                                                                            2 days ago













                                                                                          up vote
                                                                                          2
                                                                                          down vote










                                                                                          up vote
                                                                                          2
                                                                                          down vote










                                                                                          Perl 6, 26 bytes



                                                                                          .say if [<] .comb for ^1e4


                                                                                          Try it online!



                                                                                          .comb produces a list of the digits of each number, and [<] does a less-than reduction on that list, equivalent to: digit1 < digit2 < ... < digitN.






                                                                                          share|improve this answer













                                                                                          Perl 6, 26 bytes



                                                                                          .say if [<] .comb for ^1e4


                                                                                          Try it online!



                                                                                          .comb produces a list of the digits of each number, and [<] does a less-than reduction on that list, equivalent to: digit1 < digit2 < ... < digitN.







                                                                                          share|improve this answer












                                                                                          share|improve this answer



                                                                                          share|improve this answer










                                                                                          answered 2 days ago









                                                                                          Sean

                                                                                          3,08636




                                                                                          3,08636








                                                                                          • 1




                                                                                            [<](.comb)&&.say saves a byte.
                                                                                            – nwellnhof
                                                                                            2 days ago














                                                                                          • 1




                                                                                            [<](.comb)&&.say saves a byte.
                                                                                            – nwellnhof
                                                                                            2 days ago








                                                                                          1




                                                                                          1




                                                                                          [<](.comb)&&.say saves a byte.
                                                                                          – nwellnhof
                                                                                          2 days ago




                                                                                          [<](.comb)&&.say saves a byte.
                                                                                          – nwellnhof
                                                                                          2 days ago










                                                                                          up vote
                                                                                          2
                                                                                          down vote














                                                                                          V, 41 bytes



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


                                                                                          Try it online!



                                                                                          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





                                                                                          share|improve this answer

























                                                                                            up vote
                                                                                            2
                                                                                            down vote














                                                                                            V, 41 bytes



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


                                                                                            Try it online!



                                                                                            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





                                                                                            share|improve this answer























                                                                                              up vote
                                                                                              2
                                                                                              down vote










                                                                                              up vote
                                                                                              2
                                                                                              down vote










                                                                                              V, 41 bytes



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


                                                                                              Try it online!



                                                                                              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





                                                                                              share|improve this answer













                                                                                              V, 41 bytes



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


                                                                                              Try it online!



                                                                                              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






                                                                                              share|improve this answer












                                                                                              share|improve this answer



                                                                                              share|improve this answer










                                                                                              answered 2 days ago









                                                                                              DJMcMayhem

                                                                                              40.5k11144307




                                                                                              40.5k11144307






















                                                                                                  up vote
                                                                                                  2
                                                                                                  down vote














                                                                                                  Perl 5, 55 bytes





                                                                                                  $"=$,;map"@{[sort{$a-$b}/./g]}"-$_||/(.)1/||say,0..1E4


                                                                                                  Try it online!






                                                                                                  share|improve this answer

























                                                                                                    up vote
                                                                                                    2
                                                                                                    down vote














                                                                                                    Perl 5, 55 bytes





                                                                                                    $"=$,;map"@{[sort{$a-$b}/./g]}"-$_||/(.)1/||say,0..1E4


                                                                                                    Try it online!






                                                                                                    share|improve this answer























                                                                                                      up vote
                                                                                                      2
                                                                                                      down vote










                                                                                                      up vote
                                                                                                      2
                                                                                                      down vote










                                                                                                      Perl 5, 55 bytes





                                                                                                      $"=$,;map"@{[sort{$a-$b}/./g]}"-$_||/(.)1/||say,0..1E4


                                                                                                      Try it online!






                                                                                                      share|improve this answer













                                                                                                      Perl 5, 55 bytes





                                                                                                      $"=$,;map"@{[sort{$a-$b}/./g]}"-$_||/(.)1/||say,0..1E4


                                                                                                      Try it online!







                                                                                                      share|improve this answer












                                                                                                      share|improve this answer



                                                                                                      share|improve this answer










                                                                                                      answered 2 days ago









                                                                                                      Xcali

                                                                                                      4,990520




                                                                                                      4,990520






















                                                                                                          up vote
                                                                                                          2
                                                                                                          down vote














                                                                                                          Charcoal, 19 bytes



                                                                                                          ΦEXχ⁴Iι¬Φι∧쬋§ι⊖μλ


                                                                                                          Try it online! Link is to verbose version of code. Explanation:



                                                                                                             χ                Predefined variable 10
                                                                                                          X To the power
                                                                                                          ⁴ Literal 4
                                                                                                          E Map over implicit range
                                                                                                          ι Current value
                                                                                                          I 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





                                                                                                          share|improve this answer

























                                                                                                            up vote
                                                                                                            2
                                                                                                            down vote














                                                                                                            Charcoal, 19 bytes



                                                                                                            ΦEXχ⁴Iι¬Φι∧쬋§ι⊖μλ


                                                                                                            Try it online! Link is to verbose version of code. Explanation:



                                                                                                               χ                Predefined variable 10
                                                                                                            X To the power
                                                                                                            ⁴ Literal 4
                                                                                                            E Map over implicit range
                                                                                                            ι Current value
                                                                                                            I 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





                                                                                                            share|improve this answer























                                                                                                              up vote
                                                                                                              2
                                                                                                              down vote










                                                                                                              up vote
                                                                                                              2
                                                                                                              down vote










                                                                                                              Charcoal, 19 bytes



                                                                                                              ΦEXχ⁴Iι¬Φι∧쬋§ι⊖μλ


                                                                                                              Try it online! Link is to verbose version of code. Explanation:



                                                                                                                 χ                Predefined variable 10
                                                                                                              X To the power
                                                                                                              ⁴ Literal 4
                                                                                                              E Map over implicit range
                                                                                                              ι Current value
                                                                                                              I 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





                                                                                                              share|improve this answer













                                                                                                              Charcoal, 19 bytes



                                                                                                              ΦEXχ⁴Iι¬Φι∧쬋§ι⊖μλ


                                                                                                              Try it online! Link is to verbose version of code. Explanation:



                                                                                                                 χ                Predefined variable 10
                                                                                                              X To the power
                                                                                                              ⁴ Literal 4
                                                                                                              E Map over implicit range
                                                                                                              ι Current value
                                                                                                              I 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






                                                                                                              share|improve this answer












                                                                                                              share|improve this answer



                                                                                                              share|improve this answer










                                                                                                              answered 2 days ago









                                                                                                              Neil

                                                                                                              78k744175




                                                                                                              78k744175






















                                                                                                                  up vote
                                                                                                                  2
                                                                                                                  down vote














                                                                                                                  Pyth, 10 bytes



                                                                                                                  jiRThc2yS9


                                                                                                                  Try it online!



                                                                                                                  How it works



                                                                                                                  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.





                                                                                                                  share|improve this answer

























                                                                                                                    up vote
                                                                                                                    2
                                                                                                                    down vote














                                                                                                                    Pyth, 10 bytes



                                                                                                                    jiRThc2yS9


                                                                                                                    Try it online!



                                                                                                                    How it works



                                                                                                                    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.





                                                                                                                    share|improve this answer























                                                                                                                      up vote
                                                                                                                      2
                                                                                                                      down vote










                                                                                                                      up vote
                                                                                                                      2
                                                                                                                      down vote










                                                                                                                      Pyth, 10 bytes



                                                                                                                      jiRThc2yS9


                                                                                                                      Try it online!



                                                                                                                      How it works



                                                                                                                      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.





                                                                                                                      share|improve this answer













                                                                                                                      Pyth, 10 bytes



                                                                                                                      jiRThc2yS9


                                                                                                                      Try it online!



                                                                                                                      How it works



                                                                                                                      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.






                                                                                                                      share|improve this answer












                                                                                                                      share|improve this answer



                                                                                                                      share|improve this answer










                                                                                                                      answered 2 days ago









                                                                                                                      Dennis

                                                                                                                      184k32293729




                                                                                                                      184k32293729






















                                                                                                                          up vote
                                                                                                                          2
                                                                                                                          down vote














                                                                                                                          05AB1E (legacy), 8 bytes



                                                                                                                          4°ÝD€êû


                                                                                                                          Try it online!



                                                                                                                          Works in the new version of 05AB1E as well but is painfully slow for some reason.



                                                                                                                          How?




                                                                                                                          4°ÝD€êû – Full program.
                                                                                                                          4°Ý – Push [0 ... 10000].
                                                                                                                          Dې РPush each integer in [0 ... 10000] sorted and deduplicated at the same time.
                                                                                                                          û – And join the interection of the two lists by newlines.





                                                                                                                          share|improve this answer





















                                                                                                                          • Nice answer. Better than the 9 byter I had (which only works in the legacy).
                                                                                                                            – Kevin Cruijssen
                                                                                                                            5 hours ago










                                                                                                                          • 4°Ýʒ¥P.± is my alternate 8-byter in the rewrite.
                                                                                                                            – Magic Octopus Urn
                                                                                                                            4 hours ago















                                                                                                                          up vote
                                                                                                                          2
                                                                                                                          down vote














                                                                                                                          05AB1E (legacy), 8 bytes



                                                                                                                          4°ÝD€êû


                                                                                                                          Try it online!



                                                                                                                          Works in the new version of 05AB1E as well but is painfully slow for some reason.



                                                                                                                          How?




                                                                                                                          4°ÝD€êû – Full program.
                                                                                                                          4°Ý – Push [0 ... 10000].
                                                                                                                          Dې РPush each integer in [0 ... 10000] sorted and deduplicated at the same time.
                                                                                                                          û – And join the interection of the two lists by newlines.





                                                                                                                          share|improve this answer





















                                                                                                                          • Nice answer. Better than the 9 byter I had (which only works in the legacy).
                                                                                                                            – Kevin Cruijssen
                                                                                                                            5 hours ago










                                                                                                                          • 4°Ýʒ¥P.± is my alternate 8-byter in the rewrite.
                                                                                                                            – Magic Octopus Urn
                                                                                                                            4 hours ago













                                                                                                                          up vote
                                                                                                                          2
                                                                                                                          down vote










                                                                                                                          up vote
                                                                                                                          2
                                                                                                                          down vote










                                                                                                                          05AB1E (legacy), 8 bytes



                                                                                                                          4°ÝD€êû


                                                                                                                          Try it online!



                                                                                                                          Works in the new version of 05AB1E as well but is painfully slow for some reason.



                                                                                                                          How?




                                                                                                                          4°ÝD€êû – Full program.
                                                                                                                          4°Ý – Push [0 ... 10000].
                                                                                                                          Dې РPush each integer in [0 ... 10000] sorted and deduplicated at the same time.
                                                                                                                          û – And join the interection of the two lists by newlines.





                                                                                                                          share|improve this answer













                                                                                                                          05AB1E (legacy), 8 bytes



                                                                                                                          4°ÝD€êû


                                                                                                                          Try it online!



                                                                                                                          Works in the new version of 05AB1E as well but is painfully slow for some reason.



                                                                                                                          How?




                                                                                                                          4°ÝD€êû – Full program.
                                                                                                                          4°Ý – Push [0 ... 10000].
                                                                                                                          Dې РPush each integer in [0 ... 10000] sorted and deduplicated at the same time.
                                                                                                                          û – And join the interection of the two lists by newlines.






                                                                                                                          share|improve this answer












                                                                                                                          share|improve this answer



                                                                                                                          share|improve this answer










                                                                                                                          answered 2 days ago









                                                                                                                          Mr. Xcoder

                                                                                                                          31.2k758197




                                                                                                                          31.2k758197












                                                                                                                          • Nice answer. Better than the 9 byter I had (which only works in the legacy).
                                                                                                                            – Kevin Cruijssen
                                                                                                                            5 hours ago










                                                                                                                          • 4°Ýʒ¥P.± is my alternate 8-byter in the rewrite.
                                                                                                                            – Magic Octopus Urn
                                                                                                                            4 hours ago


















                                                                                                                          • Nice answer. Better than the 9 byter I had (which only works in the legacy).
                                                                                                                            – Kevin Cruijssen
                                                                                                                            5 hours ago










                                                                                                                          • 4°Ýʒ¥P.± is my alternate 8-byter in the rewrite.
                                                                                                                            – Magic Octopus Urn
                                                                                                                            4 hours ago
















                                                                                                                          Nice answer. Better than the 9 byter I had (which only works in the legacy).
                                                                                                                          – Kevin Cruijssen
                                                                                                                          5 hours ago




                                                                                                                          Nice answer. Better than the 9 byter I had (which only works in the legacy).
                                                                                                                          – Kevin Cruijssen
                                                                                                                          5 hours ago












                                                                                                                          4°Ýʒ¥P.± is my alternate 8-byter in the rewrite.
                                                                                                                          – Magic Octopus Urn
                                                                                                                          4 hours ago




                                                                                                                          4°Ýʒ¥P.± is my alternate 8-byter in the rewrite.
                                                                                                                          – Magic Octopus Urn
                                                                                                                          4 hours ago










                                                                                                                          up vote
                                                                                                                          2
                                                                                                                          down vote














                                                                                                                          Jelly, 13 9 8 bytes



                                                                                                                          Saved 5 bytes thanks to @Dennis



                                                                                                                          9œcⱮ4ẎŻY


                                                                                                                          Try it online!



                                                                                                                          Explanation



                                                                                                                          Generates all lexicographically increasing numbers below 10000 by taking the digits [1...9] and finding all combinations of length ≤ 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.





                                                                                                                          Jelly, 11 10 9 bytes



                                                                                                                          Saved a byte thanks to @EriktheOutgolfer



                                                                                                                          ȷ4Ḷ<ƝẠ$ƇY


                                                                                                                          Try it online!



                                                                                                                          Explanation



                                                                                                                          Filters through the range, keeping the numbers that are lexicographically increasing.



                                                                                                                          ȷ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.





                                                                                                                          share|improve this answer



























                                                                                                                            up vote
                                                                                                                            2
                                                                                                                            down vote














                                                                                                                            Jelly, 13 9 8 bytes



                                                                                                                            Saved 5 bytes thanks to @Dennis



                                                                                                                            9œcⱮ4ẎŻY


                                                                                                                            Try it online!



                                                                                                                            Explanation



                                                                                                                            Generates all lexicographically increasing numbers below 10000 by taking the digits [1...9] and finding all combinations of length ≤ 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.





                                                                                                                            Jelly, 11 10 9 bytes



                                                                                                                            Saved a byte thanks to @EriktheOutgolfer



                                                                                                                            ȷ4Ḷ<ƝẠ$ƇY


                                                                                                                            Try it online!



                                                                                                                            Explanation



                                                                                                                            Filters through the range, keeping the numbers that are lexicographically increasing.



                                                                                                                            ȷ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.





                                                                                                                            share|improve this answer

























                                                                                                                              up vote
                                                                                                                              2
                                                                                                                              down vote










                                                                                                                              up vote
                                                                                                                              2
                                                                                                                              down vote










                                                                                                                              Jelly, 13 9 8 bytes



                                                                                                                              Saved 5 bytes thanks to @Dennis



                                                                                                                              9œcⱮ4ẎŻY


                                                                                                                              Try it online!



                                                                                                                              Explanation



                                                                                                                              Generates all lexicographically increasing numbers below 10000 by taking the digits [1...9] and finding all combinations of length ≤ 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.





                                                                                                                              Jelly, 11 10 9 bytes



                                                                                                                              Saved a byte thanks to @EriktheOutgolfer



                                                                                                                              ȷ4Ḷ<ƝẠ$ƇY


                                                                                                                              Try it online!



                                                                                                                              Explanation



                                                                                                                              Filters through the range, keeping the numbers that are lexicographically increasing.



                                                                                                                              ȷ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.





                                                                                                                              share|improve this answer















                                                                                                                              Jelly, 13 9 8 bytes



                                                                                                                              Saved 5 bytes thanks to @Dennis



                                                                                                                              9œcⱮ4ẎŻY


                                                                                                                              Try it online!



                                                                                                                              Explanation



                                                                                                                              Generates all lexicographically increasing numbers below 10000 by taking the digits [1...9] and finding all combinations of length ≤ 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.





                                                                                                                              Jelly, 11 10 9 bytes



                                                                                                                              Saved a byte thanks to @EriktheOutgolfer



                                                                                                                              ȷ4Ḷ<ƝẠ$ƇY


                                                                                                                              Try it online!



                                                                                                                              Explanation



                                                                                                                              Filters through the range, keeping the numbers that are lexicographically increasing.



                                                                                                                              ȷ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.






                                                                                                                              share|improve this answer














                                                                                                                              share|improve this answer



                                                                                                                              share|improve this answer








                                                                                                                              edited 2 days ago

























                                                                                                                              answered 2 days ago









                                                                                                                              ETHproductions

                                                                                                                              44.1k572219




                                                                                                                              44.1k572219






















                                                                                                                                  up vote
                                                                                                                                  2
                                                                                                                                  down vote














                                                                                                                                  Wolfram Language (Mathematica), 36 bytes



                                                                                                                                  After I wrote this, it was clarified that each number must be on a new line, so +7 bytes for the Print/@.



                                                                                                                                  This method takes advantage of the fact that the Subsets function 1) doesn't replicate any digits and 2) sorts the output by set size and set contents. FromDigits assembles each list of digits.



                                                                                                                                  -1 byte thanks to @Mr.Xcoder



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


                                                                                                                                  Try it online!






                                                                                                                                  share|improve this answer



















                                                                                                                                  • 1




                                                                                                                                    Print/@FromDigits/@Range@9~Subsets~4 for 36 bytes.
                                                                                                                                    – Mr. Xcoder
                                                                                                                                    2 days ago










                                                                                                                                  • Funny, I thought of that and just didn't do it because I thought ~ had higher precedence than @
                                                                                                                                    – Kelly Lowder
                                                                                                                                    16 hours ago















                                                                                                                                  up vote
                                                                                                                                  2
                                                                                                                                  down vote














                                                                                                                                  Wolfram Language (Mathematica), 36 bytes



                                                                                                                                  After I wrote this, it was clarified that each number must be on a new line, so +7 bytes for the Print/@.



                                                                                                                                  This method takes advantage of the fact that the Subsets function 1) doesn't replicate any digits and 2) sorts the output by set size and set contents. FromDigits assembles each list of digits.



                                                                                                                                  -1 byte thanks to @Mr.Xcoder



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


                                                                                                                                  Try it online!






                                                                                                                                  share|improve this answer



















                                                                                                                                  • 1




                                                                                                                                    Print/@FromDigits/@Range@9~Subsets~4 for 36 bytes.
                                                                                                                                    – Mr. Xcoder
                                                                                                                                    2 days ago










                                                                                                                                  • Funny, I thought of that and just didn't do it because I thought ~ had higher precedence than @
                                                                                                                                    – Kelly Lowder
                                                                                                                                    16 hours ago













                                                                                                                                  up vote
                                                                                                                                  2
                                                                                                                                  down vote










                                                                                                                                  up vote
                                                                                                                                  2
                                                                                                                                  down vote










                                                                                                                                  Wolfram Language (Mathematica), 36 bytes



                                                                                                                                  After I wrote this, it was clarified that each number must be on a new line, so +7 bytes for the Print/@.



                                                                                                                                  This method takes advantage of the fact that the Subsets function 1) doesn't replicate any digits and 2) sorts the output by set size and set contents. FromDigits assembles each list of digits.



                                                                                                                                  -1 byte thanks to @Mr.Xcoder



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


                                                                                                                                  Try it online!






                                                                                                                                  share|improve this answer















                                                                                                                                  Wolfram Language (Mathematica), 36 bytes



                                                                                                                                  After I wrote this, it was clarified that each number must be on a new line, so +7 bytes for the Print/@.



                                                                                                                                  This method takes advantage of the fact that the Subsets function 1) doesn't replicate any digits and 2) sorts the output by set size and set contents. FromDigits assembles each list of digits.



                                                                                                                                  -1 byte thanks to @Mr.Xcoder



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


                                                                                                                                  Try it online!







                                                                                                                                  share|improve this answer














                                                                                                                                  share|improve this answer



                                                                                                                                  share|improve this answer








                                                                                                                                  edited 16 hours ago

























                                                                                                                                  answered 2 days ago









                                                                                                                                  Kelly Lowder

                                                                                                                                  2,968416




                                                                                                                                  2,968416








                                                                                                                                  • 1




                                                                                                                                    Print/@FromDigits/@Range@9~Subsets~4 for 36 bytes.
                                                                                                                                    – Mr. Xcoder
                                                                                                                                    2 days ago










                                                                                                                                  • Funny, I thought of that and just didn't do it because I thought ~ had higher precedence than @
                                                                                                                                    – Kelly Lowder
                                                                                                                                    16 hours ago














                                                                                                                                  • 1




                                                                                                                                    Print/@FromDigits/@Range@9~Subsets~4 for 36 bytes.
                                                                                                                                    – Mr. Xcoder
                                                                                                                                    2 days ago










                                                                                                                                  • Funny, I thought of that and just didn't do it because I thought ~ had higher precedence than @
                                                                                                                                    – Kelly Lowder
                                                                                                                                    16 hours ago








                                                                                                                                  1




                                                                                                                                  1




                                                                                                                                  Print/@FromDigits/@Range@9~Subsets~4 for 36 bytes.
                                                                                                                                  – Mr. Xcoder
                                                                                                                                  2 days ago




                                                                                                                                  Print/@FromDigits/@Range@9~Subsets~4 for 36 bytes.
                                                                                                                                  – Mr. Xcoder
                                                                                                                                  2 days ago












                                                                                                                                  Funny, I thought of that and just didn't do it because I thought ~ had higher precedence than @
                                                                                                                                  – Kelly Lowder
                                                                                                                                  16 hours ago




                                                                                                                                  Funny, I thought of that and just didn't do it because I thought ~ had higher precedence than @
                                                                                                                                  – Kelly Lowder
                                                                                                                                  16 hours ago










                                                                                                                                  up vote
                                                                                                                                  1
                                                                                                                                  down vote














                                                                                                                                  Python 2, 63 bytes





                                                                                                                                  for i in range(6790):
                                                                                                                                  if`i`=="".join(sorted(set(`i`))):print i


                                                                                                                                  Try it online!






                                                                                                                                  share|improve this answer

























                                                                                                                                    up vote
                                                                                                                                    1
                                                                                                                                    down vote














                                                                                                                                    Python 2, 63 bytes





                                                                                                                                    for i in range(6790):
                                                                                                                                    if`i`=="".join(sorted(set(`i`))):print i


                                                                                                                                    Try it online!






                                                                                                                                    share|improve this answer























                                                                                                                                      up vote
                                                                                                                                      1
                                                                                                                                      down vote










                                                                                                                                      up vote
                                                                                                                                      1
                                                                                                                                      down vote










                                                                                                                                      Python 2, 63 bytes





                                                                                                                                      for i in range(6790):
                                                                                                                                      if`i`=="".join(sorted(set(`i`))):print i


                                                                                                                                      Try it online!






                                                                                                                                      share|improve this answer













                                                                                                                                      Python 2, 63 bytes





                                                                                                                                      for i in range(6790):
                                                                                                                                      if`i`=="".join(sorted(set(`i`))):print i


                                                                                                                                      Try it online!







                                                                                                                                      share|improve this answer












                                                                                                                                      share|improve this answer



                                                                                                                                      share|improve this answer










                                                                                                                                      answered 2 days ago









                                                                                                                                      DJMcMayhem

                                                                                                                                      40.5k11144307




                                                                                                                                      40.5k11144307






















                                                                                                                                          up vote
                                                                                                                                          1
                                                                                                                                          down vote














                                                                                                                                          Python 2, 61 bytes





                                                                                                                                          for i in range(9999):
                                                                                                                                          if list(`i`)==sorted(set(`i`)):print i


                                                                                                                                          Try it online!






                                                                                                                                          share|improve this answer

























                                                                                                                                            up vote
                                                                                                                                            1
                                                                                                                                            down vote














                                                                                                                                            Python 2, 61 bytes





                                                                                                                                            for i in range(9999):
                                                                                                                                            if list(`i`)==sorted(set(`i`)):print i


                                                                                                                                            Try it online!






                                                                                                                                            share|improve this answer























                                                                                                                                              up vote
                                                                                                                                              1
                                                                                                                                              down vote










                                                                                                                                              up vote
                                                                                                                                              1
                                                                                                                                              down vote










                                                                                                                                              Python 2, 61 bytes





                                                                                                                                              for i in range(9999):
                                                                                                                                              if list(`i`)==sorted(set(`i`)):print i


                                                                                                                                              Try it online!






                                                                                                                                              share|improve this answer













                                                                                                                                              Python 2, 61 bytes





                                                                                                                                              for i in range(9999):
                                                                                                                                              if list(`i`)==sorted(set(`i`)):print i


                                                                                                                                              Try it online!







                                                                                                                                              share|improve this answer












                                                                                                                                              share|improve this answer



                                                                                                                                              share|improve this answer










                                                                                                                                              answered 2 days ago









                                                                                                                                              Chas Brown

                                                                                                                                              4,6541519




                                                                                                                                              4,6541519






















                                                                                                                                                  up vote
                                                                                                                                                  1
                                                                                                                                                  down vote














                                                                                                                                                  Python 2, 64 61 bytes





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


                                                                                                                                                  Try it online!



                                                                                                                                                  Gets the unique characters of the integer's string representation, sorts them, and compares the result to the original number.






                                                                                                                                                  share|improve this answer























                                                                                                                                                  • You can save a byte by using range(9999) or any other number between 6790 and 9999. Our solutions are almost identical BTW :)
                                                                                                                                                    – DJMcMayhem
                                                                                                                                                    2 days ago










                                                                                                                                                  • @DJMcMayhem But then it wouldn't check ALL numbers under 10,000....:P Thanks! Sometimes I get too literal with these challenges.
                                                                                                                                                    – Triggernometry
                                                                                                                                                    2 days ago















                                                                                                                                                  up vote
                                                                                                                                                  1
                                                                                                                                                  down vote














                                                                                                                                                  Python 2, 64 61 bytes





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


                                                                                                                                                  Try it online!



                                                                                                                                                  Gets the unique characters of the integer's string representation, sorts them, and compares the result to the original number.






                                                                                                                                                  share|improve this answer























                                                                                                                                                  • You can save a byte by using range(9999) or any other number between 6790 and 9999. Our solutions are almost identical BTW :)
                                                                                                                                                    – DJMcMayhem
                                                                                                                                                    2 days ago










                                                                                                                                                  • @DJMcMayhem But then it wouldn't check ALL numbers under 10,000....:P Thanks! Sometimes I get too literal with these challenges.
                                                                                                                                                    – Triggernometry
                                                                                                                                                    2 days ago













                                                                                                                                                  up vote
                                                                                                                                                  1
                                                                                                                                                  down vote










                                                                                                                                                  up vote
                                                                                                                                                  1
                                                                                                                                                  down vote










                                                                                                                                                  Python 2, 64 61 bytes





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


                                                                                                                                                  Try it online!



                                                                                                                                                  Gets the unique characters of the integer's string representation, sorts them, and compares the result to the original number.






                                                                                                                                                  share|improve this answer















                                                                                                                                                  Python 2, 64 61 bytes





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


                                                                                                                                                  Try it online!



                                                                                                                                                  Gets the unique characters of the integer's string representation, sorts them, and compares the result to the original number.







                                                                                                                                                  share|improve this answer














                                                                                                                                                  share|improve this answer



                                                                                                                                                  share|improve this answer








                                                                                                                                                  edited 2 days ago

























                                                                                                                                                  answered 2 days ago









                                                                                                                                                  Triggernometry

                                                                                                                                                  44617




                                                                                                                                                  44617












                                                                                                                                                  • You can save a byte by using range(9999) or any other number between 6790 and 9999. Our solutions are almost identical BTW :)
                                                                                                                                                    – DJMcMayhem
                                                                                                                                                    2 days ago










                                                                                                                                                  • @DJMcMayhem But then it wouldn't check ALL numbers under 10,000....:P Thanks! Sometimes I get too literal with these challenges.
                                                                                                                                                    – Triggernometry
                                                                                                                                                    2 days ago


















                                                                                                                                                  • You can save a byte by using range(9999) or any other number between 6790 and 9999. Our solutions are almost identical BTW :)
                                                                                                                                                    – DJMcMayhem
                                                                                                                                                    2 days ago










                                                                                                                                                  • @DJMcMayhem But then it wouldn't check ALL numbers under 10,000....:P Thanks! Sometimes I get too literal with these challenges.
                                                                                                                                                    – Triggernometry
                                                                                                                                                    2 days ago
















                                                                                                                                                  You can save a byte by using range(9999) or any other number between 6790 and 9999. Our solutions are almost identical BTW :)
                                                                                                                                                  – DJMcMayhem
                                                                                                                                                  2 days ago




                                                                                                                                                  You can save a byte by using range(9999) or any other number between 6790 and 9999. Our solutions are almost identical BTW :)
                                                                                                                                                  – DJMcMayhem
                                                                                                                                                  2 days ago












                                                                                                                                                  @DJMcMayhem But then it wouldn't check ALL numbers under 10,000....:P Thanks! Sometimes I get too literal with these challenges.
                                                                                                                                                  – Triggernometry
                                                                                                                                                  2 days ago




                                                                                                                                                  @DJMcMayhem But then it wouldn't check ALL numbers under 10,000....:P Thanks! Sometimes I get too literal with these challenges.
                                                                                                                                                  – Triggernometry
                                                                                                                                                  2 days ago










                                                                                                                                                  up vote
                                                                                                                                                  1
                                                                                                                                                  down vote













                                                                                                                                                  T-SQL, 188 bytes



                                                                                                                                                  WITH a AS(SELECT 0n UNION ALL SELECT n+1FROM a WHERE n<9)
                                                                                                                                                  SELECT ABS(CONCAT(a.n,b.n,c.n,d.n))
                                                                                                                                                  FROM a,a b,a c,a d
                                                                                                                                                  WHERE(a.n<b.n OR a.n+b.n=0)
                                                                                                                                                  AND(b.n<c.n OR b.n+c.n=0)
                                                                                                                                                  AND(c.n<d.n OR c.n+d.n=0)


                                                                                                                                                  Line breaks are for readability only.



                                                                                                                                                  I'm certain there must be more efficient ways to do this in SQL, but this was the first thing I thought of. Explanation:




                                                                                                                                                  1. Declare an in-memory table with values 0 to 9

                                                                                                                                                  2. Cross-join 4 copies of this table for all possible values from 0000 to 9999

                                                                                                                                                  3. Messy WHERE clause to ensure the digits are strictly increasing (or both 0)

                                                                                                                                                  4. Smash the digits together (CONCAT) and convert to integer (ABS)

                                                                                                                                                  5. The resulting rows may or may not be sorted, but the challenge doesn't appear to require that.






                                                                                                                                                  share|improve this answer

























                                                                                                                                                    up vote
                                                                                                                                                    1
                                                                                                                                                    down vote













                                                                                                                                                    T-SQL, 188 bytes



                                                                                                                                                    WITH a AS(SELECT 0n UNION ALL SELECT n+1FROM a WHERE n<9)
                                                                                                                                                    SELECT ABS(CONCAT(a.n,b.n,c.n,d.n))
                                                                                                                                                    FROM a,a b,a c,a d
                                                                                                                                                    WHERE(a.n<b.n OR a.n+b.n=0)
                                                                                                                                                    AND(b.n<c.n OR b.n+c.n=0)
                                                                                                                                                    AND(c.n<d.n OR c.n+d.n=0)


                                                                                                                                                    Line breaks are for readability only.



                                                                                                                                                    I'm certain there must be more efficient ways to do this in SQL, but this was the first thing I thought of. Explanation:




                                                                                                                                                    1. Declare an in-memory table with values 0 to 9

                                                                                                                                                    2. Cross-join 4 copies of this table for all possible values from 0000 to 9999

                                                                                                                                                    3. Messy WHERE clause to ensure the digits are strictly increasing (or both 0)

                                                                                                                                                    4. Smash the digits together (CONCAT) and convert to integer (ABS)

                                                                                                                                                    5. The resulting rows may or may not be sorted, but the challenge doesn't appear to require that.






                                                                                                                                                    share|improve this answer























                                                                                                                                                      up vote
                                                                                                                                                      1
                                                                                                                                                      down vote










                                                                                                                                                      up vote
                                                                                                                                                      1
                                                                                                                                                      down vote









                                                                                                                                                      T-SQL, 188 bytes



                                                                                                                                                      WITH a AS(SELECT 0n UNION ALL SELECT n+1FROM a WHERE n<9)
                                                                                                                                                      SELECT ABS(CONCAT(a.n,b.n,c.n,d.n))
                                                                                                                                                      FROM a,a b,a c,a d
                                                                                                                                                      WHERE(a.n<b.n OR a.n+b.n=0)
                                                                                                                                                      AND(b.n<c.n OR b.n+c.n=0)
                                                                                                                                                      AND(c.n<d.n OR c.n+d.n=0)


                                                                                                                                                      Line breaks are for readability only.



                                                                                                                                                      I'm certain there must be more efficient ways to do this in SQL, but this was the first thing I thought of. Explanation:




                                                                                                                                                      1. Declare an in-memory table with values 0 to 9

                                                                                                                                                      2. Cross-join 4 copies of this table for all possible values from 0000 to 9999

                                                                                                                                                      3. Messy WHERE clause to ensure the digits are strictly increasing (or both 0)

                                                                                                                                                      4. Smash the digits together (CONCAT) and convert to integer (ABS)

                                                                                                                                                      5. The resulting rows may or may not be sorted, but the challenge doesn't appear to require that.






                                                                                                                                                      share|improve this answer












                                                                                                                                                      T-SQL, 188 bytes



                                                                                                                                                      WITH a AS(SELECT 0n UNION ALL SELECT n+1FROM a WHERE n<9)
                                                                                                                                                      SELECT ABS(CONCAT(a.n,b.n,c.n,d.n))
                                                                                                                                                      FROM a,a b,a c,a d
                                                                                                                                                      WHERE(a.n<b.n OR a.n+b.n=0)
                                                                                                                                                      AND(b.n<c.n OR b.n+c.n=0)
                                                                                                                                                      AND(c.n<d.n OR c.n+d.n=0)


                                                                                                                                                      Line breaks are for readability only.



                                                                                                                                                      I'm certain there must be more efficient ways to do this in SQL, but this was the first thing I thought of. Explanation:




                                                                                                                                                      1. Declare an in-memory table with values 0 to 9

                                                                                                                                                      2. Cross-join 4 copies of this table for all possible values from 0000 to 9999

                                                                                                                                                      3. Messy WHERE clause to ensure the digits are strictly increasing (or both 0)

                                                                                                                                                      4. Smash the digits together (CONCAT) and convert to integer (ABS)

                                                                                                                                                      5. The resulting rows may or may not be sorted, but the challenge doesn't appear to require that.







                                                                                                                                                      share|improve this answer












                                                                                                                                                      share|improve this answer



                                                                                                                                                      share|improve this answer










                                                                                                                                                      answered 2 days ago









                                                                                                                                                      BradC

                                                                                                                                                      3,564522




                                                                                                                                                      3,564522






















                                                                                                                                                          up vote
                                                                                                                                                          1
                                                                                                                                                          down vote














                                                                                                                                                          Stax, 8 bytes



                                                                                                                                                          ¬ ▬A♥¶N∙


                                                                                                                                                          Run and debug it






                                                                                                                                                          share|improve this answer

























                                                                                                                                                            up vote
                                                                                                                                                            1
                                                                                                                                                            down vote














                                                                                                                                                            Stax, 8 bytes



                                                                                                                                                            ¬ ▬A♥¶N∙


                                                                                                                                                            Run and debug it






                                                                                                                                                            share|improve this answer























                                                                                                                                                              up vote
                                                                                                                                                              1
                                                                                                                                                              down vote










                                                                                                                                                              up vote
                                                                                                                                                              1
                                                                                                                                                              down vote










                                                                                                                                                              Stax, 8 bytes



                                                                                                                                                              ¬ ▬A♥¶N∙


                                                                                                                                                              Run and debug it






                                                                                                                                                              share|improve this answer













                                                                                                                                                              Stax, 8 bytes



                                                                                                                                                              ¬ ▬A♥¶N∙


                                                                                                                                                              Run and debug it







                                                                                                                                                              share|improve this answer












                                                                                                                                                              share|improve this answer



                                                                                                                                                              share|improve this answer










                                                                                                                                                              answered 2 days ago









                                                                                                                                                              recursive

                                                                                                                                                              4,9541221




                                                                                                                                                              4,9541221






















                                                                                                                                                                  up vote
                                                                                                                                                                  1
                                                                                                                                                                  down vote














                                                                                                                                                                  Clean, 90 bytes



                                                                                                                                                                  import StdEnv
                                                                                                                                                                  Start=(0,[('
                                                                                                                                                                  ',n)\n<-[1..6^5]|(l=removeDup l==sort l)[c\c<-:toString n]])


                                                                                                                                                                  Try it online!






                                                                                                                                                                  share|improve this answer



























                                                                                                                                                                    up vote
                                                                                                                                                                    1
                                                                                                                                                                    down vote














                                                                                                                                                                    Clean, 90 bytes



                                                                                                                                                                    import StdEnv
                                                                                                                                                                    Start=(0,[('
                                                                                                                                                                    ',n)\n<-[1..6^5]|(l=removeDup l==sort l)[c\c<-:toString n]])


                                                                                                                                                                    Try it online!






                                                                                                                                                                    share|improve this answer

























                                                                                                                                                                      up vote
                                                                                                                                                                      1
                                                                                                                                                                      down vote










                                                                                                                                                                      up vote
                                                                                                                                                                      1
                                                                                                                                                                      down vote










                                                                                                                                                                      Clean, 90 bytes



                                                                                                                                                                      import StdEnv
                                                                                                                                                                      Start=(0,[('
                                                                                                                                                                      ',n)\n<-[1..6^5]|(l=removeDup l==sort l)[c\c<-:toString n]])


                                                                                                                                                                      Try it online!






                                                                                                                                                                      share|improve this answer















                                                                                                                                                                      Clean, 90 bytes



                                                                                                                                                                      import StdEnv
                                                                                                                                                                      Start=(0,[('
                                                                                                                                                                      ',n)\n<-[1..6^5]|(l=removeDup l==sort l)[c\c<-:toString n]])


                                                                                                                                                                      Try it online!







                                                                                                                                                                      share|improve this answer














                                                                                                                                                                      share|improve this answer



                                                                                                                                                                      share|improve this answer








                                                                                                                                                                      edited 2 days ago

























                                                                                                                                                                      answered 2 days ago









                                                                                                                                                                      Οurous

                                                                                                                                                                      5,77311031




                                                                                                                                                                      5,77311031






















                                                                                                                                                                          up vote
                                                                                                                                                                          1
                                                                                                                                                                          down vote














                                                                                                                                                                          Red, 59 bytes



                                                                                                                                                                          repeat n 9999[if(d: n - 1)= do sort unique form d[print d]]


                                                                                                                                                                          Try it online!






                                                                                                                                                                          share|improve this answer

























                                                                                                                                                                            up vote
                                                                                                                                                                            1
                                                                                                                                                                            down vote














                                                                                                                                                                            Red, 59 bytes



                                                                                                                                                                            repeat n 9999[if(d: n - 1)= do sort unique form d[print d]]


                                                                                                                                                                            Try it online!






                                                                                                                                                                            share|improve this answer























                                                                                                                                                                              up vote
                                                                                                                                                                              1
                                                                                                                                                                              down vote










                                                                                                                                                                              up vote
                                                                                                                                                                              1
                                                                                                                                                                              down vote










                                                                                                                                                                              Red, 59 bytes



                                                                                                                                                                              repeat n 9999[if(d: n - 1)= do sort unique form d[print d]]


                                                                                                                                                                              Try it online!






                                                                                                                                                                              share|improve this answer













                                                                                                                                                                              Red, 59 bytes



                                                                                                                                                                              repeat n 9999[if(d: n - 1)= do sort unique form d[print d]]


                                                                                                                                                                              Try it online!







                                                                                                                                                                              share|improve this answer












                                                                                                                                                                              share|improve this answer



                                                                                                                                                                              share|improve this answer










                                                                                                                                                                              answered 2 days ago









                                                                                                                                                                              Galen Ivanov

                                                                                                                                                                              5,89711032




                                                                                                                                                                              5,89711032






















                                                                                                                                                                                  up vote
                                                                                                                                                                                  1
                                                                                                                                                                                  down vote














                                                                                                                                                                                  K (ngn/k) / K (oK), 32 30 bytes



                                                                                                                                                                                  Solution:



                                                                                                                                                                                  `0:$&{x~|x:>':(6#10)x}'!9999


                                                                                                                                                                                  Try it online!



                                                                                                                                                                                  Explanation:



                                                                                                                                                                                  `0:$&{x~|x:>':(6#10)x}'!9999 / the solution
                                                                                                                                                                                  !9999 / range 0..9998 (could use !6890)
                                                                                                                                                                                  { }' / apply lambda to each (')
                                                                                                                                                                                  x / split x to base
                                                                                                                                                                                  ( ) / do together
                                                                                                                                                                                  6#10 / 6 take 10 -> 10 10 10 10 10 10
                                                                                                                                                                                  >:' / greater-than each-previous?
                                                                                                                                                                                  x: / save as x
                                                                                                                                                                                  | / max scan
                                                                                                                                                                                  x~ / does x match this?
                                                                                                                                                                                  & / indices where true
                                                                                                                                                                                  $ / convert to string
                                                                                                                                                                                  `0: / print to stdout





                                                                                                                                                                                  share|improve this answer



























                                                                                                                                                                                    up vote
                                                                                                                                                                                    1
                                                                                                                                                                                    down vote














                                                                                                                                                                                    K (ngn/k) / K (oK), 32 30 bytes



                                                                                                                                                                                    Solution:



                                                                                                                                                                                    `0:$&{x~|x:>':(6#10)x}'!9999


                                                                                                                                                                                    Try it online!



                                                                                                                                                                                    Explanation:



                                                                                                                                                                                    `0:$&{x~|x:>':(6#10)x}'!9999 / the solution
                                                                                                                                                                                    !9999 / range 0..9998 (could use !6890)
                                                                                                                                                                                    { }' / apply lambda to each (')
                                                                                                                                                                                    x / split x to base
                                                                                                                                                                                    ( ) / do together
                                                                                                                                                                                    6#10 / 6 take 10 -> 10 10 10 10 10 10
                                                                                                                                                                                    >:' / greater-than each-previous?
                                                                                                                                                                                    x: / save as x
                                                                                                                                                                                    | / max scan
                                                                                                                                                                                    x~ / does x match this?
                                                                                                                                                                                    & / indices where true
                                                                                                                                                                                    $ / convert to string
                                                                                                                                                                                    `0: / print to stdout





                                                                                                                                                                                    share|improve this answer

























                                                                                                                                                                                      up vote
                                                                                                                                                                                      1
                                                                                                                                                                                      down vote










                                                                                                                                                                                      up vote
                                                                                                                                                                                      1
                                                                                                                                                                                      down vote










                                                                                                                                                                                      K (ngn/k) / K (oK), 32 30 bytes



                                                                                                                                                                                      Solution:



                                                                                                                                                                                      `0:$&{x~|x:>':(6#10)x}'!9999


                                                                                                                                                                                      Try it online!



                                                                                                                                                                                      Explanation:



                                                                                                                                                                                      `0:$&{x~|x:>':(6#10)x}'!9999 / the solution
                                                                                                                                                                                      !9999 / range 0..9998 (could use !6890)
                                                                                                                                                                                      { }' / apply lambda to each (')
                                                                                                                                                                                      x / split x to base
                                                                                                                                                                                      ( ) / do together
                                                                                                                                                                                      6#10 / 6 take 10 -> 10 10 10 10 10 10
                                                                                                                                                                                      >:' / greater-than each-previous?
                                                                                                                                                                                      x: / save as x
                                                                                                                                                                                      | / max scan
                                                                                                                                                                                      x~ / does x match this?
                                                                                                                                                                                      & / indices where true
                                                                                                                                                                                      $ / convert to string
                                                                                                                                                                                      `0: / print to stdout





                                                                                                                                                                                      share|improve this answer















                                                                                                                                                                                      K (ngn/k) / K (oK), 32 30 bytes



                                                                                                                                                                                      Solution:



                                                                                                                                                                                      `0:$&{x~|x:>':(6#10)x}'!9999


                                                                                                                                                                                      Try it online!



                                                                                                                                                                                      Explanation:



                                                                                                                                                                                      `0:$&{x~|x:>':(6#10)x}'!9999 / the solution
                                                                                                                                                                                      !9999 / range 0..9998 (could use !6890)
                                                                                                                                                                                      { }' / apply lambda to each (')
                                                                                                                                                                                      x / split x to base
                                                                                                                                                                                      ( ) / do together
                                                                                                                                                                                      6#10 / 6 take 10 -> 10 10 10 10 10 10
                                                                                                                                                                                      >:' / greater-than each-previous?
                                                                                                                                                                                      x: / save as x
                                                                                                                                                                                      | / max scan
                                                                                                                                                                                      x~ / does x match this?
                                                                                                                                                                                      & / indices where true
                                                                                                                                                                                      $ / convert to string
                                                                                                                                                                                      `0: / print to stdout






                                                                                                                                                                                      share|improve this answer














                                                                                                                                                                                      share|improve this answer



                                                                                                                                                                                      share|improve this answer








                                                                                                                                                                                      edited 2 days ago

























                                                                                                                                                                                      answered 2 days ago









                                                                                                                                                                                      streetster

                                                                                                                                                                                      2,384515




                                                                                                                                                                                      2,384515






















                                                                                                                                                                                          up vote
                                                                                                                                                                                          1
                                                                                                                                                                                          down vote














                                                                                                                                                                                          Jelly, 7 bytes



                                                                                                                                                                                          <ƝẠ$⁹#Y


                                                                                                                                                                                          Try it online!



                                                                                                                                                                                          How?



                                                                                                                                                                                          <ƝẠ$⁹#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





                                                                                                                                                                                          share|improve this answer

























                                                                                                                                                                                            up vote
                                                                                                                                                                                            1
                                                                                                                                                                                            down vote














                                                                                                                                                                                            Jelly, 7 bytes



                                                                                                                                                                                            <ƝẠ$⁹#Y


                                                                                                                                                                                            Try it online!



                                                                                                                                                                                            How?



                                                                                                                                                                                            <ƝẠ$⁹#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





                                                                                                                                                                                            share|improve this answer























                                                                                                                                                                                              up vote
                                                                                                                                                                                              1
                                                                                                                                                                                              down vote










                                                                                                                                                                                              up vote
                                                                                                                                                                                              1
                                                                                                                                                                                              down vote










                                                                                                                                                                                              Jelly, 7 bytes



                                                                                                                                                                                              <ƝẠ$⁹#Y


                                                                                                                                                                                              Try it online!



                                                                                                                                                                                              How?



                                                                                                                                                                                              <ƝẠ$⁹#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





                                                                                                                                                                                              share|improve this answer













                                                                                                                                                                                              Jelly, 7 bytes



                                                                                                                                                                                              <ƝẠ$⁹#Y


                                                                                                                                                                                              Try it online!



                                                                                                                                                                                              How?



                                                                                                                                                                                              <ƝẠ$⁹#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






                                                                                                                                                                                              share|improve this answer












                                                                                                                                                                                              share|improve this answer



                                                                                                                                                                                              share|improve this answer










                                                                                                                                                                                              answered 2 days ago









                                                                                                                                                                                              Jonathan Allan

                                                                                                                                                                                              50k534163




                                                                                                                                                                                              50k534163






















                                                                                                                                                                                                  up vote
                                                                                                                                                                                                  1
                                                                                                                                                                                                  down vote














                                                                                                                                                                                                  C (gcc), 97 bytes





                                                                                                                                                                                                  g(n,l,r){for(r=l=10;n;n/=10)r*=n%10<l,l=n%10;n=r;}f(i){for(i=0;i<1e4;i++)g(i)&&printf("%dn",i);}


                                                                                                                                                                                                  Try it online!






                                                                                                                                                                                                  share|improve this answer





















                                                                                                                                                                                                  • Why not use puts?
                                                                                                                                                                                                    – markasoftware
                                                                                                                                                                                                    yesterday










                                                                                                                                                                                                  • @markasoftware Puts is for strings. i is an integer.
                                                                                                                                                                                                    – gastropner
                                                                                                                                                                                                    yesterday















                                                                                                                                                                                                  up vote
                                                                                                                                                                                                  1
                                                                                                                                                                                                  down vote














                                                                                                                                                                                                  C (gcc), 97 bytes





                                                                                                                                                                                                  g(n,l,r){for(r=l=10;n;n/=10)r*=n%10<l,l=n%10;n=r;}f(i){for(i=0;i<1e4;i++)g(i)&&printf("%dn",i);}


                                                                                                                                                                                                  Try it online!






                                                                                                                                                                                                  share|improve this answer





















                                                                                                                                                                                                  • Why not use puts?
                                                                                                                                                                                                    – markasoftware
                                                                                                                                                                                                    yesterday










                                                                                                                                                                                                  • @markasoftware Puts is for strings. i is an integer.
                                                                                                                                                                                                    – gastropner
                                                                                                                                                                                                    yesterday













                                                                                                                                                                                                  up vote
                                                                                                                                                                                                  1
                                                                                                                                                                                                  down vote










                                                                                                                                                                                                  up vote
                                                                                                                                                                                                  1
                                                                                                                                                                                                  down vote










                                                                                                                                                                                                  C (gcc), 97 bytes





                                                                                                                                                                                                  g(n,l,r){for(r=l=10;n;n/=10)r*=n%10<l,l=n%10;n=r;}f(i){for(i=0;i<1e4;i++)g(i)&&printf("%dn",i);}


                                                                                                                                                                                                  Try it online!






                                                                                                                                                                                                  share|improve this answer













                                                                                                                                                                                                  C (gcc), 97 bytes





                                                                                                                                                                                                  g(n,l,r){for(r=l=10;n;n/=10)r*=n%10<l,l=n%10;n=r;}f(i){for(i=0;i<1e4;i++)g(i)&&printf("%dn",i);}


                                                                                                                                                                                                  Try it online!







                                                                                                                                                                                                  share|improve this answer












                                                                                                                                                                                                  share|improve this answer



                                                                                                                                                                                                  share|improve this answer










                                                                                                                                                                                                  answered yesterday









                                                                                                                                                                                                  gastropner

                                                                                                                                                                                                  1,8201410




                                                                                                                                                                                                  1,8201410












                                                                                                                                                                                                  • Why not use puts?
                                                                                                                                                                                                    – markasoftware
                                                                                                                                                                                                    yesterday










                                                                                                                                                                                                  • @markasoftware Puts is for strings. i is an integer.
                                                                                                                                                                                                    – gastropner
                                                                                                                                                                                                    yesterday


















                                                                                                                                                                                                  • Why not use puts?
                                                                                                                                                                                                    – markasoftware
                                                                                                                                                                                                    yesterday










                                                                                                                                                                                                  • @markasoftware Puts is for strings. i is an integer.
                                                                                                                                                                                                    – gastropner
                                                                                                                                                                                                    yesterday
















                                                                                                                                                                                                  Why not use puts?
                                                                                                                                                                                                  – markasoftware
                                                                                                                                                                                                  yesterday




                                                                                                                                                                                                  Why not use puts?
                                                                                                                                                                                                  – markasoftware
                                                                                                                                                                                                  yesterday












                                                                                                                                                                                                  @markasoftware Puts is for strings. i is an integer.
                                                                                                                                                                                                  – gastropner
                                                                                                                                                                                                  yesterday




                                                                                                                                                                                                  @markasoftware Puts is for strings. i is an integer.
                                                                                                                                                                                                  – gastropner
                                                                                                                                                                                                  yesterday










                                                                                                                                                                                                  up vote
                                                                                                                                                                                                  1
                                                                                                                                                                                                  down vote













                                                                                                                                                                                                  JavaScript, 64 bytes



                                                                                                                                                                                                  A bit of pub golf so probably far from optimal.



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


                                                                                                                                                                                                  Try it online



                                                                                                                                                                                                  Yes, doing it without an IIFE would be a few bytes shorter but that throws an overflow error when called, which would normally be fine as we can assume infinite memory for the purposes of code golf but, to me, doesn't seem to be in the spirit of KC challenges.






                                                                                                                                                                                                  share|improve this answer























                                                                                                                                                                                                  • I don't get an overflow error without an IIFE.
                                                                                                                                                                                                    – Spitemaster
                                                                                                                                                                                                    2 days ago















                                                                                                                                                                                                  up vote
                                                                                                                                                                                                  1
                                                                                                                                                                                                  down vote













                                                                                                                                                                                                  JavaScript, 64 bytes



                                                                                                                                                                                                  A bit of pub golf so probably far from optimal.



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


                                                                                                                                                                                                  Try it online



                                                                                                                                                                                                  Yes, doing it without an IIFE would be a few bytes shorter but that throws an overflow error when called, which would normally be fine as we can assume infinite memory for the purposes of code golf but, to me, doesn't seem to be in the spirit of KC challenges.






                                                                                                                                                                                                  share|improve this answer























                                                                                                                                                                                                  • I don't get an overflow error without an IIFE.
                                                                                                                                                                                                    – Spitemaster
                                                                                                                                                                                                    2 days ago













                                                                                                                                                                                                  up vote
                                                                                                                                                                                                  1
                                                                                                                                                                                                  down vote










                                                                                                                                                                                                  up vote
                                                                                                                                                                                                  1
                                                                                                                                                                                                  down vote









                                                                                                                                                                                                  JavaScript, 64 bytes



                                                                                                                                                                                                  A bit of pub golf so probably far from optimal.



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


                                                                                                                                                                                                  Try it online



                                                                                                                                                                                                  Yes, doing it without an IIFE would be a few bytes shorter but that throws an overflow error when called, which would normally be fine as we can assume infinite memory for the purposes of code golf but, to me, doesn't seem to be in the spirit of KC challenges.






                                                                                                                                                                                                  share|improve this answer














                                                                                                                                                                                                  JavaScript, 64 bytes



                                                                                                                                                                                                  A bit of pub golf so probably far from optimal.



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


                                                                                                                                                                                                  Try it online



                                                                                                                                                                                                  Yes, doing it without an IIFE would be a few bytes shorter but that throws an overflow error when called, which would normally be fine as we can assume infinite memory for the purposes of code golf but, to me, doesn't seem to be in the spirit of KC challenges.







                                                                                                                                                                                                  share|improve this answer














                                                                                                                                                                                                  share|improve this answer



                                                                                                                                                                                                  share|improve this answer








                                                                                                                                                                                                  edited yesterday

























                                                                                                                                                                                                  answered 2 days ago









                                                                                                                                                                                                  Shaggy

                                                                                                                                                                                                  18.1k21663




                                                                                                                                                                                                  18.1k21663












                                                                                                                                                                                                  • I don't get an overflow error without an IIFE.
                                                                                                                                                                                                    – Spitemaster
                                                                                                                                                                                                    2 days ago


















                                                                                                                                                                                                  • I don't get an overflow error without an IIFE.
                                                                                                                                                                                                    – Spitemaster
                                                                                                                                                                                                    2 days ago
















                                                                                                                                                                                                  I don't get an overflow error without an IIFE.
                                                                                                                                                                                                  – Spitemaster
                                                                                                                                                                                                  2 days ago




                                                                                                                                                                                                  I don't get an overflow error without an IIFE.
                                                                                                                                                                                                  – Spitemaster
                                                                                                                                                                                                  2 days ago










                                                                                                                                                                                                  up vote
                                                                                                                                                                                                  1
                                                                                                                                                                                                  down vote














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



                                                                                                                                                                                                  -12 and -4 thanks @Dennis!





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


                                                                                                                                                                                                  Try it online!



                                                                                                                                                                                                  Each integer from 0 to 7k tested by first converting it into a string. Leveraging the fact that C# treats strings as character enumerables and LINQ, an aggregate is calculated for each character enumerable as follows:




                                                                                                                                                                                                  • compare the accumulated value with the current character

                                                                                                                                                                                                  • if the current character is greater than the accumulation, return the current character

                                                                                                                                                                                                  • otherwise return : which is greater than 9


                                                                                                                                                                                                  If the result of this is less than :, then the number has lexicographically increasing digits.






                                                                                                                                                                                                  share|improve this answer



























                                                                                                                                                                                                    up vote
                                                                                                                                                                                                    1
                                                                                                                                                                                                    down vote














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



                                                                                                                                                                                                    -12 and -4 thanks @Dennis!





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


                                                                                                                                                                                                    Try it online!



                                                                                                                                                                                                    Each integer from 0 to 7k tested by first converting it into a string. Leveraging the fact that C# treats strings as character enumerables and LINQ, an aggregate is calculated for each character enumerable as follows:




                                                                                                                                                                                                    • compare the accumulated value with the current character

                                                                                                                                                                                                    • if the current character is greater than the accumulation, return the current character

                                                                                                                                                                                                    • otherwise return : which is greater than 9


                                                                                                                                                                                                    If the result of this is less than :, then the number has lexicographically increasing digits.






                                                                                                                                                                                                    share|improve this answer

























                                                                                                                                                                                                      up vote
                                                                                                                                                                                                      1
                                                                                                                                                                                                      down vote










                                                                                                                                                                                                      up vote
                                                                                                                                                                                                      1
                                                                                                                                                                                                      down vote










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



                                                                                                                                                                                                      -12 and -4 thanks @Dennis!





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


                                                                                                                                                                                                      Try it online!



                                                                                                                                                                                                      Each integer from 0 to 7k tested by first converting it into a string. Leveraging the fact that C# treats strings as character enumerables and LINQ, an aggregate is calculated for each character enumerable as follows:




                                                                                                                                                                                                      • compare the accumulated value with the current character

                                                                                                                                                                                                      • if the current character is greater than the accumulation, return the current character

                                                                                                                                                                                                      • otherwise return : which is greater than 9


                                                                                                                                                                                                      If the result of this is less than :, then the number has lexicographically increasing digits.






                                                                                                                                                                                                      share|improve this answer















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



                                                                                                                                                                                                      -12 and -4 thanks @Dennis!





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


                                                                                                                                                                                                      Try it online!



                                                                                                                                                                                                      Each integer from 0 to 7k tested by first converting it into a string. Leveraging the fact that C# treats strings as character enumerables and LINQ, an aggregate is calculated for each character enumerable as follows:




                                                                                                                                                                                                      • compare the accumulated value with the current character

                                                                                                                                                                                                      • if the current character is greater than the accumulation, return the current character

                                                                                                                                                                                                      • otherwise return : which is greater than 9


                                                                                                                                                                                                      If the result of this is less than :, then the number has lexicographically increasing digits.







                                                                                                                                                                                                      share|improve this answer














                                                                                                                                                                                                      share|improve this answer



                                                                                                                                                                                                      share|improve this answer








                                                                                                                                                                                                      edited yesterday









                                                                                                                                                                                                      Dennis

                                                                                                                                                                                                      184k32293729




                                                                                                                                                                                                      184k32293729










                                                                                                                                                                                                      answered 2 days ago









                                                                                                                                                                                                      dana

                                                                                                                                                                                                      1714




                                                                                                                                                                                                      1714






















                                                                                                                                                                                                          1 2
                                                                                                                                                                                                          next









                                                                                                                                                                                                          Varun Patro is a new contributor. Be nice, and check out our Code of Conduct.










                                                                                                                                                                                                           

                                                                                                                                                                                                          draft saved


                                                                                                                                                                                                          draft discarded


















                                                                                                                                                                                                          Varun Patro is a new contributor. Be nice, and check out our Code of Conduct.













                                                                                                                                                                                                          Varun Patro is a new contributor. Be nice, and check out our Code of Conduct.












                                                                                                                                                                                                          Varun Patro is a new contributor. Be nice, and check out our Code of Conduct.















                                                                                                                                                                                                           


                                                                                                                                                                                                          draft saved


                                                                                                                                                                                                          draft discarded














                                                                                                                                                                                                          StackExchange.ready(
                                                                                                                                                                                                          function () {
                                                                                                                                                                                                          StackExchange.openid.initPostLogin('.new-post-login', 'https%3a%2f%2fcodegolf.stackexchange.com%2fquestions%2f176095%2fprint-all-lexicographically-increasing-numbers-under-10000%23new-answer', 'question_page');
                                                                                                                                                                                                          }
                                                                                                                                                                                                          );

                                                                                                                                                                                                          Post as a guest















                                                                                                                                                                                                          Required, but never shown





















































                                                                                                                                                                                                          Required, but never shown














                                                                                                                                                                                                          Required, but never shown












                                                                                                                                                                                                          Required, but never shown







                                                                                                                                                                                                          Required, but never shown

































                                                                                                                                                                                                          Required, but never shown














                                                                                                                                                                                                          Required, but never shown












                                                                                                                                                                                                          Required, but never shown







                                                                                                                                                                                                          Required, but never shown







                                                                                                                                                                                                          Popular posts from this blog

                                                                                                                                                                                                          Can a sorcerer learn a 5th-level spell early by creating spell slots using the Font of Magic feature?

                                                                                                                                                                                                          Does disintegrating a polymorphed enemy still kill it after the 2018 errata?

                                                                                                                                                                                                          A Topological Invariant for $pi_3(U(n))$