任务

打印整数n，其中 12 <= n <= 123456789和中的所有连续数字对在它们之间具有相同的正差（例如2468，但不是2469）。

没有输入。

输出：

规则

有标准漏洞。
没有输入

最短的代码胜出。

学分无政府状态高尔夫

— 0x45
source

8

这个问题来自无政府状态的高尔夫。您应该给予它荣誉（即使您是提交它的人也是如此）

— xnor

5

是否必须按顺序打印？

— H.PWiz

11

我在anagol上提交了此问题：）

— Lynn

2

为什么列表中不是每个0≤n<100的整数？

— DonielF

3

@DonielF因为整数必须大于或等于12，并且正向差异必须为正。

— 丹尼斯，

11

果冻，12 11字节

9œcḊẎIE$ÐfY

在线尝试！

怎么运行的

9œcḊẎIE$ÐfY  Main link. No arguments.

9            Set the argument and return value to 9.
   Ḋ         Dequeue; yield [2, ..., 9].
 œc          Take all k-combinations of [1, ..., 9], for each k in [2, ..., 9].
    Ẏ        Concatenate the arrays of k-combinations.
        Ðf   Filter the result by the link to the left.
     IE$         Compute the increments (I) of the combination / digit list and
                 tests if all are equal (E).
          Y  Join the results, separating by linefeeds.

— 丹尼斯
source

ìà Find fastest route between two points using Dykstra's Algorithm

— 尼尔

7

Python 2，81个字节

k=71
exec"k+=1;r=range(k/8%9+1,10,k%8+1)\nif r[k/72:]:print`r`[1:k/24+2:3]\n"*576

在线尝试！

我从无政府状态高尔夫解决方案。这个想法是迭代长度，起始值和步长的所有可能的三元组，从而给出排序的输出。三重编码为值r从72到647，并且部件被提取为k/72，k/8%9，和k%8。从k足够高的位置开始可避免输出一位数字。

xsot 通过用一个硬编码的数字字符串替换，从而节省了两个字节。range'123456789'

这是在两秒钟的运行时限制的约束下编写的。过滤数字而不是生成数字的较慢策略可能会更短。

— 异或
source

1

有趣的事实：这个问题实际上是“设计”用于无政府状态高尔夫运行时限制的，这就是为什么我没有将其提交给PPCG的原因。我想取消从1到的循环提交的参赛资格123456789，而是强迫答案提出一些巧妙的方法来按正确的（排序的）顺序生成正确的数字。

— 林恩

6

C，166152字节

p,l,d,i=11;main(){for(char s[10];i<=1e9;){sprintf(s,"%d",++i);p=0;for(l=strlen(s);--l>0;){d=s[l]-s[l-1];if(!p)p=d;if(p^d|d<1)break;p=d;}if(!l)puts(s);}}

感谢@KevinCruijssen，节省了6个字节！

@JonathanFrech节省了8个字节！

在线尝试

上面的代码的完整格式版本可以在下面看到。

#include <string.h>
#include <stdio.h>

int main( void )
{
int prev_diff, diff, len;
int num = 11;
char str[10];

while(num<123456789)
    {
    prev_diff = 0;
    sprintf(str,"%d",++num);
    len = strlen(str)-1;
    for( ; len > 0; len-- )
        {
        diff = str[len] - str[len-1];
        if( prev_diff == 0 )
            {
            prev_diff = diff;
            }
        if( prev_diff != diff || diff < 1 )
            {
            break;
            }
        prev_diff = diff;
        }
    if ( len == 0 )
        {
        puts(str);
        }
    }
}

— 雅各宾斯基
source

除非我缺少任何东西，否则不while(i<123456789)应该while(i<=123456789)根据挑战范围来代替吗？另外，您可以按6个字节来打高尔夫球：

p,l,d,i=11;main(){for(char s[10];i<=123456789;){sprintf(s,"%d",++i);p=0;for(l=strlen(s);--l>0;){d=s[l]-s[l-1];if(p<1)p=d;if(p^d|d<1)break;p=d;}if(l<1)puts(s);}}

— Kevin Cruijssen

@KevinCruijssen我同意，尽管很可能可以通过选择一个更高的值来继续使用一字节比较。i<1e9。

— 乔纳森·弗雷奇

@KevinCruijssen另外，如果我没有记错的话，l<1可以打高尔夫球!l，因为它l永远不会达到负值。

— 乔纳森·弗雷奇

@JonathanFrech关于的好点i<1e9。对于CI来说，!l什么时候听起来l总是>=0合理的（我自己从来没有用C编程过）。

— 凯文·克鲁伊森

@KevinCruijssen“ i”在sprintf（）中增加，允许我们到达，让我们在i == 123456788时进入循环，并保留123456789。我将为循环添加这些多用途，并且（l == 0 ）->（l <1）的优化，谢谢:)

— Jacobinski

5

果冻，14，13个字节

DIµEȧ>0Ȧ
Ç77#

在线尝试！

@MrXcoder节省了一个字节！

这效率极低，因此在TIO上将超时，但是一旦完成，它将产生正确的输出。您可以在此处尝试使用较小的数字：在线尝试！

说明：

            # Helper link:
            #
D           # The Digits of 'n'
 I          # The increments (deltas, differences) between digits
  µ         # Give that array as an argument to the rest of this link:
   E        # Are all elements equal?
    ȧ       #   AND
     >0     # Are all elements greater then 0?
       Ȧ    # And is there at least one element?
            # (in the differences, so that numbers < 10 are false)
            #
            # Main link:
            #
 77#        # Return the first 77 'n's for which
Ç           #   The helper link is truthy

— 詹姆士
source

1

啊。击败我。+1

— caird coinheringaahing

您不需要$在助手链接的末尾。

— Xcoder先生

一个更清晰的方法是DIµ>0ȦȧE¶Ç77#

— Egg the Outgolfer

4

05AB1E，23个字节

•7=›ζ•FNS¥DËs0›PN11›&&–

在线尝试！

替换•7=›ζ•为7000，以使其在TIO上完成，或者在超时之前单击“终止”按钮，直到此为止打印出数字。

— 魔术章鱼缸
source

尝试使用此功能：žh

— Okx

@Okx我认为这不起作用，它不仅是的子字符串'0123456789'，1357例如也是需要输出的有效数字。

— 暴民埃里克（Erik the Outgolfer）'17年

@EriktheOutgolfer我的意思是替换•7=›ζ•

— Okx

@Okx就是我本来的样子，但是会引起一些奇怪的事情（？）。不知道为什么，所以我最终做到了这一点，它始终如一。

— 魔术章鱼缸

@MagicOctopusUrn为什么不尝试一开始就删除0？

— Okx

4

Mathematica，79个字节

Select[Range@123456789,Min[s=Union@Differences@IntegerDigits@#]>0&&Tr[1^s]==1&]

在线尝试！使用较低的数字，因为它非常慢

这是另一种在1秒内构造所有数字的方法

Mathematica，123个字节

Union[FromDigits/@(F=Flatten)[Table[Partition[#,i,1],{i,2,9}]&/@Select[F[Table[Range[j,9,k],{j,9},{k,9}],1],Tr[1^#]>1&],2]]

在线尝试！一秒钟内所有数字

— J42161217
source

4

外壳，14 13字节

ÖifȯεuẊ≠Ṗ…"19

将以换行符分隔的数字打印到STDOUT。在线尝试！

由于H.PWiz的启发，-1个字节。

说明

ÖifȯεuẊ≠Ṗ…"19
         …"19  The string "19" rangified: "123456789"
        Ṗ      Powerset: ["","1","2","12","3",...,"123456789"]
  fȯ           Filter by function: (input is sublist, say "2469")
      Ẋ≠        Consecutive codepoint differences: [2,2,3]
     u          Remove duplicates: [2,3]
    ε           Is it a one-element list? No, so "2469" is dropped.
Öi             Sort the result by integer value, implicitly print separated by newlines.

— 兹加布
source

4

Wolfram语言（Mathematica），76字节

Differences@IntegerDigits@#~MatchQ~{a_?Positive..}&&Print@#&~Array~123456789

在线尝试！

— 郑焕民
source

3

APL（Dyalog），37 28字节

⍪x/⍨{1=≢∪2-/⍎¨⍕⍵}¨x←11+⍳1E9

在线尝试！（由于超时，范围更短）

怎么样？

x←11+⍳123456789- 11, 12... 1e9成x

¨ -每个

⍎¨⍕⍵ -分解成数字

2-/ -获取差异列表

∪ -获得独特的元素

1=≢ -长度== 1？

x/⍨ -将其用作创建范围的遮罩

⍪ -并列化

— 乌里尔
source

3

外壳，14个字节

ÖifoEẊ≠ftṖ…"19

在线尝试！

— 普维兹
source

我偷了你≠。：PI忘记了它也适用于角色

— Zgarb

3

批处理，210200字节

没有优化，因此非常缓慢-大约需要25秒才能达到12345，因此要获得完整的输出，您将需要等待3天左右。

@set z=@set/a
%z%c=12
:a
@echo %c%
:c
%z%c+=1&if %c%==123456790 exit/b
%z%n=c
%z%d=n%%10-n/10%%10
@if %d% leq 0 goto c
:d
%z%n=n/10
@if %n% leq 9 goto a
%z%e=n%%10-n/10%%10
@if %e%==%d% goto d
@goto c

— 施纳德
source

3

Java的8，169个 168 145字节

v->{byte[]a;for(int i=9,d,l;++i<1e9;System.out.print(l<1?i+"\n":""))for(a=(i+"").getBytes(),d=0,l=a.length;--l>0&&d*(d^(d=a[l]-a[l-1]))<1&d>0;);}

@Jacobinski C答案的端口（我打了一下球）。
-23个字节感谢@Nevay。

说明：

在这里尝试。（快结束时有点太慢，因此不会在TIO上打印最终号码。不过，它会在大约20秒内在本地打印最终号码。）

v->{                         // Method with empty unused parameter and no return-type
  byte[]a;                   //  Byte-array
  for(int i=9,               //  Index integer, starting at 9
          d,                 //  Difference-integer
          l;                 //  Length integer
      ++i<1e9;               //  Loop (1) from 10 to 1,000,000,000 (exclusive)
      System.out.print(      //    After every iteration: print:
        l<1?                 //     If `l` is 0:
         i+"\n"              //      The current integer + a new-line
        :                    //     Else:
         ""))                //      Nothing
    for(a=(i+"").getBytes(), //   Convert the current item as String to a byte-array
        d=0,                 //   Reset the previous integer to 0
        l=a.length;          //   Set `l` to the length of the byte-array
        --l>0                //   Inner loop (2) from `l-1` down to 0 (exclusive)
        &&d*(d^(d=a[l]-a[l-1]))<1
                             //    As long as the previous difference is either 0
                             //    or the current diff is not equal to the previous diff
        &d>0;                //    and the current diff is larger than 0
    );                       //   End of inner loop (2)
                             //  End of loop (1) (implicit / single-line body)
}                            // End of method

— 凯文·克鲁伊森
source

1

145个字节：

v->{byte[]a;for(int i=9,p,l;++i<1e9;System.out.print(l<1?i+"\n":""))for(a=(i+"").getBytes(),p=0,l=a.length;--l>0&&p*(p^(p=a[l]-a[l-1]))<1&p>0;);}

— Nevay

@Nevay我知道它应该能够以break某种方式将其删除并将其添加到for循环检查中，但是我自己不会想出来。;）谢谢！

— 凯文·克鲁伊森

2

05AB1E，14个字节

TžhŸʒS¥D0›PsË&

在线尝试！

— 奥克斯
source

那就是我最初拥有的东西，除了我拥有的东西之外12žhŸʒS¥D0›PsË&，我无法使其在本地运行。您可以实际执行吗？

— 魔术章鱼缸

@MagicOctopusUrn如果我尝试替换之前的数字Ÿ，则可以正常工作

— Okx

我让我的另一个在本地运行而无需替换数字，但是我仍然不能这样做。Idk为什么，我只是真的想知道有什么不同。

— 魔术章鱼缸

2

Python 2中，103个 97 95字节

-2个字节，感谢@JonathanFrech

n=11
while n<1e9:
 n+=1;Q=`n`[1:]
 if`n`<Q>1==len({int(a)-int(b)for a,b in zip(`n`,Q)}):print n

在线尝试！

— ovs
source

108个字节或106字节的是运行的内存，但可以用较低的数字进行测试

— 棒

95个字节 ; 使用重复变量`n`[1:]。

— 乔纳森·弗雷希

2

Python 2中，76 75个字节

n=9
while n<2e8:
 n+=1
 if`n`in`range(n%10,0,~n%100%11-11)`[-2::-3]:print n

在本地大约需要3分钟。

在线尝试！（已修改以打印除最后一个数字以外的所有数字）

— 丹尼斯
source

2

JavaScript（Firefox 30-57），105个字节

document.write(`<pre>`+(

_=>[for(x of s=`123456789`)for(y of s)for(z of s)if(x*z<10-y)s.replace(/./g,c=>c<y|(c-y)%z|c-y>x*z?``:c)]

)().join`\n`+`</pre>`);

展开摘要

循环从2到10的长度（x是最后一个字符的索引，因此比长度小1），从1到9的起始数字和从1到9的步进，然后在结束数字上筛选小于10的字符，如果因此通过从数字字符串中过滤出数字来生成结果。

— 尼尔
source

“运行代码段”导致错误：Uncaught SyntaxError: Unexpected token for

— schnaader

2

@schnaader您是否在Firefox 30+中运行它？此答案使用了仅Firefox支持的非标准数组理解语法。

— 伯乔拉修（Birjolaxew）

啊，没看到这句话，对此表示抱歉。在Chrome中运行，在Firefox中运行良好

— schnaader

1

腐霉菌, 21 bytes

丹尼斯港的巧妙做法。

jjLkf!t{.+Tsm.cS9dtS9

在这里尝试！

Pyth，23个字节

j.f&!tl{K.+jZT*F>R0K77T

这在在线解释器上超时，但是如果有足够的时间和内存，则可以使用。

尝试以更低的价格在线尝试。

— Mr. Xcoder
source

1

MATL, 17 16 bytes

1e9:"@Vdu0>TX=?@

Try it online! with 1e9 replaced by 1e3 so that it doesn't time out in the online compiler.

— Luis Mendo
source

1

JavaScript (ES6), 121 bytes

Not nearly as short as Neil's answer, but I thought it was still worth posting.

Works by building a powerset of '123456789' where all non-matching entries are truncated and prefixed with 0, sorting the results in numerical order and keeping only the 77 relevant ones.

_=>[...'123456789'].reduce((a,x)=>[...a,...a.map(y=>y[1]-y[0]+(y.slice(-1)-x)?'0':y+x)],['']).sort((a,b)=>a-b).slice(-77)

Demo

Show code snippet

let f =

_=>[...'123456789'].reduce((a,x)=>[...a,...a.map(y=>y[1]-y[0]+(y.slice(-1)-x)?'0':y+x)],['']).sort((a,b)=>a-b).slice(-77)

console.log(f().join` `)

Expand snippet

— Arnauld
source

1

C (gcc), 106 bytes

main(i,j,k,l){for(i=1;i<9;i++)for(j=8;j;j--)for(k=0;k<j/i;puts(""))for(l=0*k++;l<=i;)putchar(57-j+k*l++);}

Try it online!

The ungolfed (prettified) version:

int main() {
  int length, start_with, max_step, step, nth;
  for (length = 2; length <= 9; length++) {
    for (start_with = 1; start_with < 9; start_with++) {
      max_step = (9 - start_with) / (length - 1);
      for (step = 1; step <= max_step; step++) {
        for (nth = 0; nth < length; nth++) {
          putchar('0' + start_with + step * nth);
        }
        puts("");
      }
    }
  }
  return 0;
}

— tsh
source

1

JavaScript (ES6), 109 104 bytes

Works by generating all possible numbers: loops through each increment from 8 to 1 (variable i), loops through each starting digit from 8 to 1 (variable j), loops through each digit between j and 10-i (variable k) and generates a string t by appending k to the current t. At each step t is added to the output array.

(o=[],i=9)=>{while(--i){j=9;while(k=--j){t=""+k;while(k<10-i)o.push(t+=k+=i)}}return o.sort((a,b)=>a-b)}

Try it online!

f=

(o=[],i=9)=>{while(--i){j=9;while(k=--j){t=""+k;while(k<10-i)o.push(t+=k+=i)}}return o.sort((a,b)=>a-b)}

;
console.log(f().join("\n"))

Expand snippet

— Birjolaxew
source

1

Wolfram Language (Mathematica), 71 bytes

Flatten@Array[If[(x=#2+#3 #)<10,FromDigits@Range[#2,x,#3],{}]&,{8,8,8}]

Try it online!

Lightning fast due to constructing rather than selecting the output.

— Kelly Lowder
source

0

Java (OpenJDK 8), 228 174 170 163 bytes

o->{int i=11,x,y,z,l;for(;i++<1e9;){char[]w=(""+i).toCharArray();for(x=w[1]-w[0],y=1,z=0;y<w.length;z+=l>0&l==x?0:1)l=w[y]-w[y++-1];if(z<1)System.out.println(i);}}

Try it online!

— Roberto Graham
source

0

JavaScript (ES6), 145 bytes

A straight-forward approach with little magic.

Array(123456790).fill().map((x,i)=>(''+i).split('')).map((a,i,d) => {d=a[1]-a[0];d>0&a.every((n,j)=>j<1||n-a[j-1]==d)?console.log(a.join('')):0})

Expand snippet

Running the snippet will consume a lot of memory...

— sshow
source

0

PHP, 85 84 bytes

for(;++$d<9||++$a<9*$d=1;sort($r))for($x=$y=$a+1;10>$y+=$d;)$r[]=$x.=$y;print_r($r);

try it online.

sorting cost 17 bytes. This version prints the results ordered differently:

while(++$d<9||++$a<9*$d=1)for($x=$y=$a+1;10>$y+=$d;)echo"
",$x.=$y;

— Titus
source

跳数

任务

没有输入。

输出：

规则

果冻，12 11字节

怎么运行的

Python 2，81个字节

C，166152字节

果冻，14，13个字节

05AB1E，23个字节

Mathematica，79个字节

Mathematica，123个字节

外壳，14 13字节

说明

Wolfram语言（Mathematica），76字节

APL（Dyalog），37 28字节

外壳，14个字节

批处理，210200字节

Java的8，169个 168 145字节

05AB1E，14个字节

Python 2中，103个 97 95字节

Python 2中，76 75个字节

JavaScript（Firefox 30-57），105个字节

腐霉菌, 21 bytes

Pyth，23个字节

MATL, 17 16 bytes

JavaScript (ES6), 121 bytes

Demo

C (gcc), 106 bytes

JavaScript (ES6), 109 104 bytes

Wolfram Language (Mathematica), 71 bytes

Java (OpenJDK 8), 228 174 170 163 bytes

JavaScript (ES6), 145 bytes

PHP, 85 84 bytes