打印所有按字典顺序递增的数字，小于10000

32

按字典顺序递增的数字是整数，其数字严格按升序排列。打印所有按字典顺序递增的数字（小于10000）。

以下是预期输出的行：

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

这是代码挑战赛！最短答案胜出！

（PS正在寻找python解决方案）

code-golf  number  sequence  kolmogorov-complexity 
— 瓦伦·帕特罗（Varun Patro）
source
3
我们需要将它们打印在单独的行上还是用空格分隔吗？
— 朱塞佩
3
欢迎来到PPCG！不错的第一个挑战。对于未来的挑战，我建议您使用沙盒优化挑战并获得有意义的反馈，然后再将其发布到main。
— AdmBorkBork
4
为了扩展@Giuseppe的问题，我们可以用逗号，空格，数组格式[0,1,...]等输出，还是必须在单独的行上输出每个数字？
— ETHproductions
10
数字是否需要按特定顺序排列，还是只需要全部都存在？
— 卡米尔·德拉卡里
14
@VarunPatro，请更新挑战以明确声明每个数字都放在单独的行中（尽管我建议反对该要求），并确保告知所有不这样做的解决方案。
— 毛茸茸的

Answers:

30

Python 2，56个字节

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

在线尝试！

将每个数字都转换124为一个表达式，1<2<4然后对其求值以检查数字是否已排序，

一位数字出现打h，给出的表达式就是数字本身。0即使应该打印，这也会导致评估结果为Falsey。这是由埃里克建议做的Outgolfer一招固定**n，这给truthy值0**0的n=0和并不影响真值。

— 异或
source
什么是`做`n`？
— BruceWayne
1
@BruceWayne它采用字符串表示形式。这是在Python 3.删除
— 同或
5
@BruceWayne注意，它与repr()函数相同，而不是str()函数。它们并不总是相同的。这是一个例子。
— mbomb007 '18
1
@ mbomb007感谢您的评论！我会以为这是str()等效的。
— BruceWayne
2
我们可以通过一些技巧来处理0情况。
— xsot
11

哈斯克尔，50个字节

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

在线尝试！

输出多行字符串。我们检查号码s使用进行s==scanl1(max.succ)s排序，以增加，这是通常的排序检查的一种变体，该检查s==scanl1 max s通过在增加每个数字字符和下一个数字的最大值之前递增每个数字字符来确保严格的排序。

Ourous通过使用6^5上限代替4位数字来保存一个字节。

— 异或
source
8

果冻，7个字节

9ŒPḌḣ⁹Y

在线尝试！

怎么运行的

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.
— 丹尼斯
source
2
我试图弄清楚如何0包含在这里，但我不知道果冻。我是否纠正Jelly的幂集包含空数组，然后0在“未十进制”时将其转换为空数组？
— 毛茸茸的
1
是的，就是这样。
— 丹尼斯
8

Japt -R，12 11 8字节

L²Ç¶ìüÃð

测试一下

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

*或，为了提供更好的解释：该ü方法对数组进行排序并将其拆分为相等的元素（例如[8,4,8,4].ü() -> [[4,4],[8,8]]），然后ì在将数组转换回为一个数字，它采用每个嵌套数组的第一个元素，而不是首先展平该数组，这是我尝试此技巧时所期望的（例如[[4,4],[8,8]].ì() -> 48）。

— 毛茸茸
source
1
真好 类似于我所拥有的：L²Ç¥ì ü ¬Ãð
— 奥利弗·奥利弗
2
我不得不说，ü你们使用的这个技巧是天才：-) @Oliver
— ETHproductions
1
@Oliver，您一定已经发布了我正在更新的内容；伟大的思想... :)
— Shaggy
@ETHproductions像大多数东西一样，我一时兴起尝试了-惊讶它的工作原理。
— 毛茸茸的
6

R，62 49字节

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

在线尝试！

因为combn按照给定的顺序遍历其输入，所以容易创建所有按字典顺序递增的整数，并按顺序打印出它们。以宽度的行write打印它们的每个i数字i，也完全满足换行要求。

— 朱塞佩
source
好主意combn！
— digEmAll
极其聪明的混叠！
— J.Doe
6

Perl 6，25个字节

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

-1字节感谢nwellnhof

在线尝试！

.comb产生每个数字的数字列表，并[<]对该列表进行小于等于的缩减，等效于：digit1 < digit2 <... < digitN。

— 肖恩
source
2
[<](.comb)&&.say保存一个字节。
— nwellnhof
这是令人惊讶的可读性。（我已经知道一些Perl 6，但仍然...）
— JL
5

Haskell，56 55字节

编辑：-1字节感谢@Ourous

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

在线尝试！

— 妮米
source
5

的PowerShell，42 40字节

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

在线尝试！

从循环0到1e4（即10000）。拔出这些对象，其中|?{...}作为一个字符串的数目$_是-eqUAL与数铸造toCharArra y然后sort与编-uNIQUE标志。换句话说，只有与已排序和去重复的字符串相同的数字。这些都留在管道上，并且输出是隐式的。

— AdmBorkBork
source
4

Pyth，10个字节

jiRThc2yS9

在线尝试！

怎么运行的

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.
— 丹尼斯
source
3

J，26个字节

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

在线尝试！

说明

,. (#~ (-: /:~@~.)@":"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
— 约拿
source
3

05AB1E（旧版），8个字节

4°ÝD€êû

在线尝试！

也可以在新版本的05AB1E中使用，但是由于某种原因它运行缓慢。

怎么样？

4°D€êû–完整程序。
4°Ý–按下[0 ... 10000]。
   Dâê–同时按[0 ... 10000]排序和重复数据删除每个整数。
      Ö并用换行符添加两个列表的交集。
— Xcoder先生
source
好答案。比我拥有的9更好（仅适用于旧版）。
— 凯文·克鲁伊森
2

Python 2中，64 61个字节

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

在线尝试！

获取整数的字符串表示形式的唯一字符，对它们进行排序，然后将结果与原始数字进行比较。

— 触发法
source
您可以使用range(9999)6790到9999之间的任何其他数字来保存字节。我们的解决方案几乎是相同的BTW :)
— DJMcMayhem
@DJMcMayhem但是，它不会检查所有10,000以下的数字。...：P谢谢！有时候，我对这些挑战过于直白。
— Triggernometry '18
2

V，41字节

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

在线尝试！

十六进制转储：

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

木炭，19字节

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

在线尝试！链接是详细版本的代码。说明：

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

果冻，13 9 8个字节

@Dennis节省了5个字节

9œcⱮ4ẎŻY

在线尝试！

说明

通过采用数字[1 ... 9]并找到所有长度≤4的组合，生成所有小于10000的按字典顺序递增的数字。

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.

果冻，11 10 9字节

感谢@EriktheOutgolfer保存了一个字节

ȷ4Ḷ<ƝẠ$ƇY

在线尝试！

说明

筛选范围，保持按字典顺序递增的数字。

ȷ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.
— ETH生产
source
2

C＃（Visual C＃中交互式编译器），102 101 ... 73个字节

-12 和 -4感谢@Dennis！

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

在线尝试！

通过首先将0到7k的每个整数转换为字符串来进行测试。利用C＃将字符串视为可枚举的字符和LINQ的事实，将为每个可枚举的字符计算汇总，如下所示：

  • 比较累计值和当前字符
  • 如果当前字符大于累加，则返回当前字符
  • 否则返回:大于9

如果其结果小于:，则该数字按字典顺序递增数字。

— 达娜
source
挑战是否指出必须打印0-10000之间的所有数字？我很确定这会打印数字0-7000
— 无知的体现
相信最大的有效数字是6789？该值小于7000，因此您不必再高一些。
— dana
哦，我懂了。愚弄我
— 无知的体现
一点也不愚蠢:)我很确定我是从别人的答案中借来的，我为他们为什么这么做it了ing头。
— dana
2

Wolfram语言（Mathematica），36字节

在我写完这篇文章之后，我们明确了每个数字必须换行，因此+7个字节用于 Print/@。

此方法利用以下事实：Subsets函数1）不复制任何数字，并且2）按设置的大小和设置的内容对输出进行排序。FromDigits组装每个数字列表。

-1字节感谢@ Mr.Xcoder

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

在线尝试！

— 凯莉·洛德（Kelly Lowder）
source
1
Print/@FromDigits/@Range@9~Subsets~4为36个字节。
— Xcoder先生18年
有趣的是，我想到了这一点，但是没有这样做，因为我认为〜的优先级比@
— Kelly Lowder '18
2

K（ngn / k） / K（oK），32 30 26字节

解：

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

在线尝试！

说明：

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

JavaScript REPL，64字节

一些酒吧高尔夫可能远非最佳。

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

在线尝试

是的，在没有IIFE的情况下执行此操作会缩短几个字节，但在调用时会引发溢出错误，这通常会很好，因为我们可以假设出于代码高尔夫目的而使用无限内存，但是对我来说似乎并不本着KC挑战的精神。

— 毛茸茸
source
没有IIFE，我不会收到溢出错误。
— Spitemaster '18
这是功能提交还是完整的程序？如果不是，则应该console.log将提交计数为或将其提交重新标记为JavaScript REPL。
— 丹尼斯
1

果冻，7 个字节

<ƝẠ$⁹#Y

在线尝试！

怎么样？

<ƝẠ$⁹#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
— 乔纳森·艾伦
source
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.