康托尔难以置信的数字


58

不可说的数字是可以被7整除或以7作为其数字之一的数字。一个儿童游戏是要计算跳过无法说出的数字

1 2 3 4 5 6 ( ) 8 9 10 11 12 13 ( ) 15 16 ( ) 18 ...

Cantor版本的游戏是通过将序列“ 1 2 3 4 5 6()8 ...”递归填充到上面的间隙()中来定义的序列。

1 2 3 4 5 6 1 8 9 10 11 12 13 2 15 16 3 18 19 20 4 22 23 24 25 26 5 6 29 30 31 32 33 34 1 36 8 38 ...

打印/输出至少Cantor难以置信的数字游戏的前7 ^ 7个数字...

尽管递归地给出了定义,但是您没有义务在代码中使用递归。

这是,因此字节数最少的程序将获胜!

注意:1到7 ^ 7中的数字总和为203511962727。该范围内的最后10个数字为823534 823535 221563 108068 823538 823539 823540 823541 823542 221565。

前1000个迭代的Pastebin转储:http//pastebin.com/Ksiu9Svf


8
请提供该序列的前7 ^ 7个数字,以便我们检查解决方案。
瑕疵的


2
如果有人想产生一些数字和比较结果:该序列中的第7 ^ 77的数字的总和是3336402440238885119980169136020683586413168645292341926482898521634332654984279162327502549917668322950744929983987545341421076028
尼克拉斯B.

当然,1层的在该序列的数量是22977,这意味着如果在随机挑选的元件从第一7 ^ 77的均匀,你有它是一个1的2 * 10 ^ -61机会
尼古拉斯B.

1
如果您有兴趣的话,下面的图表显示重复次数的增长:drive.google.com/file/d/0B71iQwGfNtw5NGladjdOZVhoNkk/…–
Niklas B.

Answers:


6

Pyth25 23 22字节

感谢@Maltysen提供-2个字节

.V1=+Y
?}7+PbjbT@Y~hZb

一个打印无限流的程序。

在线尝试!(每隔一段时间刷新输出并在1分钟后超时)

这个怎么运作

.V1=+Y
?}7+PbjbT@Y~hZb

Z = 0, Y = []    Implicit variable assignment
.V1              Infinite incrementing for loop with variable b, starting at 1:
   =+Y            Y = Y +
(newline)          (Implicitly print the result of the following:)
?                   If
 }7                  7 is in
    Pb                the prime factorisation of b
   +                  or
      jbT             the digits of b:
         @Y            Index into Y at index
             Z          Z
           ~h          (Increment Z)
                    else:
              b      b

1
23个字节。它可以工作,因为cuz 7是素数,因此可以通过检查素因数分解来完成
除法

您可以发布它,它的主要部分
Maltysen,2016年

1
恭喜您赢得了比赛。我也喜欢@Maltysen的把戏!
mschauer '16

23

Python 2,77 75 74 70字节

由于@MartinEnder为暗示的限制9e5,其恩德[R卯起来改变之后的工作。
感谢@mschauer建议无限流,节省了4个字节。

def f(n=0):
 i=f()
 while 1:n+=1;yield next(i)if'7'in`n`or n%7<1else n

这是一个生成无限个数字流的生成器。


您不能完全删除上限吗?
mschauer

@mschauer谢谢,没想到那个。
PurkkaKoodari '16

if n%7<1or'7'in`n`else n可能会稍快一些(相同的字节数),因为n%7<1它比检查字符串快,而且or短路。太糟糕了,yield[n,next(i)][n%7<1or'7'in`n`]无法正常工作。
mbomb007 '16

@ mbomb007我认为速度不是这里的问题,但谢谢。:)
PurkkaKoodari's

10

Perl,47 46 41 39字节

@Dada节省了5个字节

say$_=$_%7*!/7/?$_:$a[$b++]for@a=1..1e6

在线尝试!TIO Nexus,现已支持Perl!这将在特定时间点后截断输出,但是如果您安装了Perl,则可以在本地运行它以产生完整的输出。

该代码利用了Perl语法的几个奇怪的怪癖,因此我将在下面细分其工作方式。

代码细目:

say$_=$_%7*!/7/?$_:$a[$b++]for@a=1..1e6
                              @a=1..1e6 #Assign the range (1..1,000,000) to the array @a
                           for          #and then loop through this list, with $_ as an alias for the list member.  As an alias, modifying $_ modifies @a.
      $_%7*!/7/?$_:$a[$b++]             #Ternary operation
      $_%7                              #Returns the residue modulo 7...
          *!/7/                         #...and multiplies it by the negation of whether or not there exists a 7 $_
                                        #Since % and * have the same operator precedence, it must be evaluated in this order
                                        #otherwise we would get (!/7/*$_)%7 instead of ($_%7)*!/7/
               ?$_                      #If the result is non-zero (i.e. truthy), then return $_
                  :$a[$b++]             #Otherwise, return the $b-th element of @a, and increment $b
   $_=                                  #Reassign the result back to $_, modifying @a
say                                     #Prints the result of the assignment, separated by newlines

1
say$a[@a]=$_=...如果我没记错的话赢2个字节。
达达

@Dada实际上因为这使我不必分配给$_,所以它节省了5个字节。谢谢!
加布里埃尔·贝纳米

1
哦,的确,我只是快速浏览了一下,却没有注意到中间的作业..干得好:)
Dada

正是在这一刻(仅此刻!),我才明白“ Perl可以完全是只写语言”的说法。
haneefmubarak

@Grimy,请不要编辑其他代码。如果您想改善答案,请添加包含该改善的评论,或发布您自己的答案。由于您可能不会通过评论进入OP,只需发布​​您自己的答案即可。
ovs

5

PHP,80(Wahooka)57 54字节

这个想法来自Wahooka。我认为我的版本与众不同,可以自己回答:

for(;;)echo$a[]=strpos(++$n,55)<-$n%7?"$n ":$a[+$b++];

5

Haskell,67 66字节

i#x|mod x 7<1||'7'`elem`show x=f!!i:(i+1)#(x+1)|y<-x+1=x:i#y
f=0#1

f 是数字的无限列表。

在线尝试!

f开始一个新的迭代,1并使用一个索引选择要从0开始的数字。每当有间隔时,我们都会选择一个新的迭代作为它的ith元素,并使用继续当前的迭代i+1。如果没有差距,我们采用当前数字x并继续增加i

编辑:-1字节感谢@BMO。


4

MATL26 25字节

9e5:`t7\yFYA!7-A*~s:2M(2M

在线尝试!9e5替换为9e4,因此不超过在线编译器的最大运行时间和输出大小。

这个怎么运作

这使用迭代而不是递归。(实际上,MATL没有递归)。

首先生成一个从1到的数字数组9e5(这已经足够了,因为9e5超过了7^7)。然后,是的倍数的数字7或有7作为数字标识,并取而代之12......重复该过程,直到没有需要更换号码。

9e5:       % Generate array of numbers [1 2 ... 9e5]. This array will become the
           % output, after some numbers have been replaced
`          % Do...while
  t        %   Duplicate the array of numbers
  7\       %   Modulo 7. Gives zero for multiples of 7
  y        %   Duplicate the array of numbers
  FYA!     %   Matrix of decimal digits, with a column for each number
  7-       %   Subtract 7 to each entry of that matrix
  A        %   Array that contains "true" for columns that only contain nonzeros;
           %   that is, for numbers that do not have 7 as digit 
  *        %   Multiply. This corresponds to a logical "and" of the two conditions.
           %   A zero indicates that the number at that index needs to be replaced
  ~        %   Logical negate. Each "true" corresponds to a number to be replaced
  s        %   Sum. This is the amount of numbers to be replaced, say n
  :        %   Push array [1 2 ... n]
  2M       %   Push array of logical values again
  (        %   Replace the numbers at the positions indicated by the logical array
           %   by the values [1 2 ... n]
  2M       %   Push n again. This is used as loop condition, so if it is nonzero
           %   the next iteration will be executed. Note that this executes one
           %   too many iterations: the exit condition is that no replacing has
           %   been needed in the current iteration; but then the current iteration 
           %   (which will be the last) was not really necessary. This does not
           %   matter; the last iteration is useless but also harmless
           % End do...while implicitly. Display implicitly

3

Tcl,121字节

使用无限循环的简单解决方案,没什么花哨的..

set r 0;set n 0;while {[set r [expr $r+1]]} {if {![expr $r%7]||(7 in[split $r ""])} {puts [set n [expr $n+1]]} {puts $r}}

取消高尔夫:

set r 0
set n 0
while {[set r [expr $r+1]]} {
  if {![expr $r % 7] || (7 in [split $r ""])} {
    puts [set n [expr $n+1]]
  } {
    puts $r
  }
}

您可以使用incr。如果tcl版本> = 8.6,则incr假定第一次迭代是变量从0到的增量(1如果之前未设置);因此您可以摆脱前两个set说明。
sergiol

我打高尔夫球 -我还删除了一些不需要的空白区域。
sergiol '17

我为您发布高尔夫建议的网站丢失了这些建议,所以我做了一个新的回答
sergiol

3

PHP,106 80字节

谢谢Ismael Miguel在三元解决方案和使用for而不是while的较短循环代码方面的帮助。

由于PhpFiddle的最长30秒运行时间,因此无法验证完整序列的最后一部分。根据OP提供的样本输出,似乎至少可以工作到1K。

高尔夫球:

for($n=1;;$n++)echo$a[]=!(strpos($n,"7")>-1||$n%7==0)?"$n ":array_shift($a)." ";

原始的高尔夫球版本

$n=1;while(1){if(!(strpos($n,"7")>-1||$n%7==0)){echo$a[]=$n." ";}else{echo$a[]=array_shift($a)." ";}$n++;}

1
for($n=1;;$n++)echo$a[]=!(strpos($n,7)>-1||$n%7==0)?"$n ":array_shift($a)." ";我不知道字节数,但是我敢肯定它比106字节低很多。试试看,看看是否可行。
伊斯梅尔·米格尔

非常好,谢谢您的帮助。对代码的唯一修改是将前7个引号引起来,这为您的78字节版本增加了两个字节。
Wahooka '16

这样做可以节省3个字节左右for($n=1;;$n++)echo$a[]=strpos($n,"7")>-1||$n%7==0?array_shift($a)." ":"$n ";。我不确定是否可以替换为$n%7==0!$n%7但是值得一试。
伊斯梅尔·米格尔

1
继续前进-6:$ n = 0没用,“ 7”可以是
7。– Crypto

1
为什么要换班?for(;;)echo$a[]=strpos(++$n,55)<-1&&$n%7?"$n ":$a[++$b-1];(58字节)。++$b-1因为$a[null] === null
Christoph

3

朱莉娅62字节

x=[];j=0;for i=1:7^7;x=[x;i%7<1||('7' in "$i")?x[j+=1]:i]end;x

没有什么花哨。使用间隙内的序列是序列本身。进行过多的数组复制以节省一些字节。


3

Perl 6的 74个57 54  53字节

sub u{my@u;(1..*).map: {if $_%%7||.comb('7') {@u||=u;@u.shift} else {$_}}}
sub u{(1..*).map: {$_%%7||.comb('7')??(@||=u).shift!!$_}}
sub u{map {$_%%7||.comb('7')??(@||=u).shift!!$_},1..*}
sub u{map {$_%%7||.comb(~7)??(@||=u).shift!!$_},1..*}

试试吧

展开:

sub u{
  map             # for each element transform using:

  { # bare block lambda with implicit parameter 「$_」

      $_ %% 7     # if it is divisible by 7
      ||          # or
      .comb(~7)   # contains the number 7 (implicit method call on 「$_」)

    ??            # then
      ( @ ||= u ) # store a new instance of the Seq into an unnamed state array if it is empty
                  # ( it is only empty the first time it is seen in this Seq instance )
      .shift      # pull one off of the front

    !!            # else
      $_          # return the value
  },

  1 .. *          # infinite range starting at one ( elements to be mapped over )
}

测试:

$ time perl6 -e'sub u{map {$_%%7||.comb(~7)??(@||=u).shift!!$_},1..*};put 203511962727 == sum u()[^7**7]'
True

real    2m45.744s
user    2m45.416s
sys     0m0.212s

看来您可以说~7而不是来节省一个字节'7'
肖恩

2

锡兰,202字节

object u satisfies{Integer*}{iterator()=>object satisfies Iterator<Integer>{variable value i=0;late Iterator<Integer>n;next()=>if(++i%7<1||'7'in"``i``")then(i<8then(n=iterator())else n).next()else i;};}

这不是函数,而是实现无限序列(可迭代)的对象声明。该对象可以直接打印,print(u)输出如下:

{ 1, 2, 3, 4, 5, 6, 1, 8, 9, 10, 11, 12, 13, 2, 15, 16, 3, 18, 19, 20, 4, 22, 23, 24, 25, 26, 5, 6, 29, 30, ... }

要打印更多,请使用printAll(u)。以下代码使用换行符,并打印总和(以及上面显示的前30个元素):

shared void run() {
    printAll(u.take(7^7), "\n");
    print(sum({0, * u.take(7^7)}));
    print(u);
}

这是取消评论的版本:

// Prints cantor's unspeakable numbers.
//
// Question:  http://codegolf.stackexchange.com/q/101231/2338
// My answer: http://codegolf.stackexchange.com/a/101297/2338

// this object u (which is like a singleton class with its single instance)
// implements the Iterable<Integer> interface.
object u satisfies {Integer*} {
    // That interface has just one formal method,
    // `shared formal Iterator<Integer> iterator()`.
    // Lets implement it by ...
    iterator()
    // ... providing for each call ...
            =>
                // ... a new (anonymous) object, which
                // implements the Iterator<Integer> interface.
                object satisfies Iterator<Integer> {
                    // This is the counter (the type `Integer`
                    // is longer than `value`, so we infer it).
                    // We start at 0.
                    variable value i = 0;
                    // This is a nested Iterator. It will be
                    // initialized when first needed, so we don't
                    // get an endless recursion when creating the
                    // first iterator.
                    late Iterator<Integer> n;
                    // `shared formal Integer next()` is the single method
                    // of Iterator which needs to be implemented.
                    next()
                    // each time it is called, the following
                    // expression will be evaluated.
                            =>
                                // increment the counter, then check if it
                                // is an unspeakable number.
                                if (++i % 7 < 1 || '7' in "``i``")
                                then
                                    // if so, take the nested iterator (and the
                                    //  first time, for i == 7, create it first),
                                    // and take its next element.
                                    (i < 8 then (n = iterator()) else n).next()
                                else
                                    // otherwise, just return i.
                                    i;
                };
}

2

Ruby,80个字节

l=->x{x%7==0||x.to_s[/7/]};a=(1..100);b=a.reject &l p a.map{|x|!l[x]?x:b.shift}

第一次提交,我敢肯定它可以改善:)


1
欢迎来到PPCG!这是否上升到至少7 ^ 7(即823543),并且是否考虑到包含数字 7(即17)的数字
ETHproductions 2016年

当然没有。立即修复。认为这个问题有点太简单了:)
Christopher Lates'Nov

很好,但是我不确定它是否符合条件。之后的数字348当前为当前数字)应为7,但由于7该数字难以置信,因此程序应开始第三次迭代并改为print 1
ETHproductions 2016年

2

Dyalog APL,39 个字节

{(⍵⍴⍨⍴i)@(i←⍸('7'∊¨⍕¨⍵)∨0=7|⍵)⊢⍵}⍣≡⍳7*7

⍳7*7是1 2 3 ... 7 7

{ }⍣≡定点运算符-重复应用功能直到结果稳定

A@I⊢B 修改操作员-取代在指数中的元素IBA

0=7|⍵ 参数可被7整除的位掩码

'7'∊¨⍕¨⍵ 位掩码,其中参数的十进制格式包含7

要么

上述位掩码中的哪一个是正确的?

i← 分配给 i

⍵⍴⍨⍴i 将参数重塑为 i


很好 如果您将mask7 * 7与位掩码相乘并获得修改序列中零的固定点,是否有帮助?
mschauer

2

C 157155字节

int c[999999],r;main(_,p){if(_){p=--_;c[_]=1;for(;;){printf("%d ",c[_]);main(0,++_+1);c[_]=r?_+1:c[p++];}}else!p?r=1:p%7?p%10-7?main(0,p/10):(r=0):(r=0);}

看起来不错,我没有费心去检查。上升到999999,这显然足够大。

非高尔夫版本:

int cantor_n[1000000];

int cantor_n_safe(int x) {
    if (!x) return 1;
    if (x % 7 == 0) return 0;
    if (x % 10 == 7) return 0;
    return cantor_n_safe(x / 10);
}

int main(_, prev_index) {
    prev_index = --_;
    cantor_n[_] = 1;
    for(;;) {
        printf("%d ", cantor_n[_]);
        _++;
        if (!cantor_n_safe(_+1)) {
            cantor_n[_] = cantor_n[prev_index++];
        } else {
            cantor_n[_] = _+1;
        }
    }
    return 0;
}

部分高尔夫版本:

int c[999999];int r;
safe(x){ 
    !x?
        r=1:
        x%7?
            x%10-7?
                safe(x/10):
                (r=0):
            (r=0);
}

main(_){
    int p;
    p=--_;
    c[_]=1;
    for(;;){
        printf("%d ",c[_]);
        safe(++_+1);
        if (!r) {
            c[_]=c[p++];
        } else {
            c[_]=_+1;
        }
    }
}

之后需要大括号else吗?
扎卡里

我不,谢谢。从技术上讲,我(r=0)大部分时间也不需要括号。但是有些编译器很挑剔。我太懒了,现在无法检查规格。
LambdaBeta

2

R,86个字节

x=1;while(T<7^7){T=T+1;x[T]=if(!T%%7|7%in%el(strsplit(c(T,""),""))){F=F+1;x[F]}else T}

使用R的Truthy内置T函数(初始化为TRUE/ 1)对序列中的数字进行计数,并使用Falsy值F(初始化为FALSE/ 0)对无法发音的变量进行计数。除此之外,程序仅检查每个数字是否可被7整除或包含数字。


-4字节替换7%in%el(strsplit(c(T,""),""))55%in%utf8ToInt(paste(T))?(未经测试)
JayCe

2

C-115字节

s[99],r;g(x){return x%10-7&&(!x||g(x/10));};f(i){(r=++s[i])%7&&g(r)||f(i+1);}main(){for(;;f(0),printf("%d\n",r));}

编辑:感谢@mschauer,他指出我错过了一些东西。


好的方法。两句话。r%10-7仅捕获尾随的7,并且不会破坏您的堆:堆栈深度以多项式增长... s [99]是安全的。
mschauer

2

Javascript,80个字节

n=[]
r=l=>(m=n[l]=++n[l]||1,!/7/.test(m)m%7?m:r(l+1))
for(;;)console.log(r(0))

由于仅存在最低要求,而没有最高要求,因此该解决方案将无限期继续输出。

要验证算法是否正确,您可以执行相同的代码,仅打印最后10个数字和总和:

n = []
r = l => (m = n[l] = ++n[l] || 1, !/7/.test(m) && m % 7 ? m : r(l + 1))
var tot = 0
for (i = 0; i + 1; i++) {
    v = r(0)
    tot += v
        if (i > Math.pow(7, 7) - 11) {
        console.log(v)
    }
    if (i === Math.pow(7, 7) - 1) {
        console.log(tot)
        break
    }
}

SyntaxError:缺少),放在括号中
l4m2,18年


1

JavaScript 81个字节

原始(98字节)

for(c=0,i=1;i<=Math.pow(7,7);i++)/7/.test(i)||i%7==0?(6==c?c=1:c++,console.log(c)):console.log(i);

打高尔夫球

p=console.log;for(c=0,i=1;i<9e5;i++)/7/.test(i)||i%7==0?(6==c?c=1:c++,p(c)):p(i);

欢迎光临本站!我对javascript不太了解,但是你能做些什么p=console.log;for(c=0,i=1;i<=Math.pow(7,7);i++)/7/.test(i)||i%7==0?(6==c?c=1:c++,p(c)):p(i);吗?
DJMcMayhem

感谢@DrMcMoylex,它又丢了几个字节。我毫不怀疑仍有改进的空间。
理查德·森

很高兴我能帮上忙!我刚刚意识到的另一件事是,您可以9e5代替Math.pow(7,7)挑战,因为挑战说:Print/output AT LEAST the first 7^7
DJMcMayhem

是的,好医生Doc!这也使我也可以从比较运算符中删除等于。
理查德·森

它似乎没有达到预期的效果。填补空白时,您显然必须再次应用规则,而不仅仅是重置计数器(请参阅序列的这一部分:)34 1 36 **8** 38。但就其价值而言,当前版本可能还会推出更多:for(c=i=0;++i<9e5;)console.log(!/7/.test(i)&&i%7?i:c++%6+1)
阿纳尔德

1

Befunge,100或156个字节

第一个版本是两者中更便携的版本,将其自身限制为7位存储单元,这是您在参考解释器中获得的。

"O":0>\#09#:p#-:#1_v<0$.< 
9\*"~"g9+1:+1::p00:<+3$_^#g01$$<v"~":/"~"p9g00%"~"::+1+g9\*"~"+g
:#15#+5#g+#0%#17#\-#/!#+\#5:#5_^>%00g1+9p"~"/00g2+9p::7%!10>>p#0

第二个版本仅适用于具有32位存储单元的解释器,因此严格来说不是标准的Befunge,但是这使我们可以在内存中存储较大的值,而不必将其拆分为多个单元。

"O":0>\#09#:p#-:#1_v<0$.< 
%7::p9g00:+1g9:p00:<+1$_^#g01$$<v01!
:#15#+5#g+#0%#17#\-#/!#+\#5:#5_^>p#0

在这两种情况下,程序都可以无限期运行,但是第一个版本将溢出大约200万个标记,而第二个版本应达到最大int值(大约20亿)。

您可以在线尝试,但您需要终止该进程以防止其永远运行。


1

Clojure,130字节

#(let[R(range(inc %))](rest((reduce(fn[[r s]i](if(or(=(mod i 7)0)((set(str i))\7))[(assoc r i(r s))(inc s)][r s]))[(vec R)0]R)0)))

基本减少,跟踪结果向量的内容以及已跳过多少个值。最后一个0采用reduce的第一个元素[r s]rest删除0索引结果的第一个元素。


1

Perl6,41个字节

put {($_=++$)%%7|m/7/??@_[$++]!!$_}…1e6

1

Tcl,64字节

while 1 {puts [expr {[incr i]%7&&7ni[split $i ""]?$i:[incr s]}]}

在线尝试!


真好!比我的短得多……
hdrz

这样写的是“ ... 33 34 7 36 8 38 ...”而不是“ ... 33 34 1 36 8 38 ...”
mschauer

@mschauer:好的,有时间我会解决的……
sergiol

@hdrz我尝试了您的解决方案,它与mschauer讲述的问题相同!
sergiol

1

JavaScript,64字节

for(f=n=>!/7/.test(m=++n[0])*m%7?m:f(n.t=n.t||[0]);;)alert(f(f))

output=[];index=0;for(f=n=>!/7/.test(m=++n[0])*m%7?m:f(n.t=n.t||[0]);index<100;)output[index++]=f(f);console.log(output.join(','))


ps与其他几个(console.log)JavaScript答案进行比较,它是70个字节
l4m2,18年

1

Japt,25个字节

[]L³õ@pX%7«/7/tX ?X:UgV°

测试总和最后10个元素。

生成序列的前1,000,000个条目并将其打印。一百万是7**7 == 823543Japt中最短的数字。

尾随换行符很重要,因为它激活了对的隐式赋值U

生成列表仅需一秒钟左右,但是输出整个数组可能会使浏览器挂起。

开箱及其工作方式

[]L³õX{UpX%7&&!/7/tX ?X:UgV++

[]                            Assign empty array to U
  L³õX{                       Map over 1 to 1,000,000 inclusive...
         X%7&&                  If X is not divisible by 7 and
              !/7/tX            X does not have a digit 7
                     ?X:UgV++   then X, otherwise the next element already in U
       Up                       Push it to the end of U

                              Implicit print U

使用可以通过查看已生成的序列来解析递归定义的属性。

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.