Невимовні номери Кантора


58

Невимовне число - це число, яке ділиться на сім або має сім як одну з його цифр. Дитяча гра - це підрахунок пропуску невимовних чисел

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

Варіант гри Кантора - це послідовність, визначена рекурсивним заповненням послідовності "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 ...

Роздрукуйте / виведіть щонайменше перші 7 ^ 7 номерів невимовної гри числа Кантора ...

Хоча визначення дається рекурсивно, ви не зобов'язані використовувати рекурсію в коді.

Це , тому програма з найменшим числом байтів виграє!

Примітка: Сума чисел у 1 до 7 ^ 7 становить 203511962727. Останніми 10 числами в цьому діапазоні є 823534 823535 221563 108068 823538 823539 823540 823541 823542 221565.

Пастель-дамп з перших 1000 ітерацій: http://pastebin.com/Ksiu9Svf


8
Надайте перші 7 ^ 7 номерів цієї послідовності, щоб ми могли перевірити наші рішення.
flawr


2
У разі , якщо хто -то хоче створити ще кілька чисел і порівняти результати: сума перших 7 ^ 77 чисел в послідовності 3336402440238885119980169136020683586413168645292341926482898521634332654984279162327502549917668322950744929983987545341421076028
Ніклас B.

Звичайно, число 1 у цій послідовності становить 22977, а це означає, що якщо ви вибрали елемент з перших 7 ^ 77 рівномірно випадково, у вас є 2 * 10 ^ -61 шанс, що це буде 1
Niklas B.

1
Якщо вам це цікаво, ось графік, що показує зростання кількості повторних: drive.google.com/file/d/0B71iQwGfNtw5NGladjdOZVhoNkk/…
Niklas B.

Відповіді:


6

Pyth , 25 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 байти . Це працює 7, тому що це прем'єр, тому поділ можна зробити, перевіривши основну факторизацію, яка добре відповідає іншій чеку
Мальтісен

ви можете опублікувати її, основна її частина
Малтісен

1
Вітаємо за перемогу в цьому конкурсі. Мені також подобається хитрість @Maltysen!
mschauer

23

Python 2, 77 75 74 70 байт

Завдяки @MartinEnder , який запропонував межа 9e5якого Ende г d до роботи після зміни.
Завдяки @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

if n%7<1or'7'in`n`else nможе бути трохи швидшим (той самий кількість байтів), оскільки n%7<1швидше, ніж перевірка рядка, і orє коротким замиканням. Це дуже погано, що yield[n,next(i)][n%7<1or'7'in`n`]не вийде.
mbomb007

@ mbomb007 Я не думаю, що швидкість тут не проблема, але дякую. :)
PurkkaKoodari

10

Perl, 47 46 41 39 байт

Збережено 5 байт завдяки @Dada

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

Спробуйте в Інтернеті! TIO Nexus, тепер із підтримкою 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
О, справді, я просто швидко подивився і не помітив цього завдання в середині .. хороша робота :)
Дада

Саме в цей момент (і лише цей момент!) Я зрозумів твердження "Perl може бути цілком єдиною мовою для запису".
haneefmubarak

@Grimy, не редагуйте інший код. Якщо ви хочете покращити відповідь, додайте коментар, включаючи покращення або опублікуйте власну відповідь. Оскільки ви, мабуть, не дістанетесь до ОП через коментар, просто опублікуйте власну відповідь.
ов

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

MATL , 26 25 байт

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

Спробуйте в Інтернеті! з 9e5замінено на 9e4, щоб максимальний час роботи та розмір виводу веб-компілятора не перевищували.

Як це працює

Для цього використовується ітерація замість рекурсії. (Насправді у MATL немає рекурсії).

Спочатку формується масив чисел від 1до 9e5(цього достатньо, тому що 9e5перевищує 7^7). Тоді числа, кратні 7або мають , 7як цифри будуть визначені, і замінені 1, 2... Процес повторюється до тих пір, поки немає числа , які повинні бути замінені.

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

3

PHP, 106 80 байт

Дякую Ісмаелю Мігелю за допомогу в потрійному рішенні та використанні коротшого циклу циклу замість часу.

Не вдалося перевірити останні частини повної послідовності через 30-секундний час виконання PhpFiddle. Здається, що працює як мінімум до 1 К на основі вибірки, отриманої ОП.

Гольф:

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 байт.
Вахука

Ви можете зберегти 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.
Крипто

1
чому зміщення? for(;;)echo$a[]=strpos(++$n,55)<-1&&$n%7?"$n ":$a[++$b-1];(58 байт). ++$b-1бо$a[null] === null
Крістоф

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;};}

Це не функція, а об'єктне оголошення, що реалізує нескінченну послідовність (Iterable). Об'єкт можна надрукувати безпосередньо, 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

Рубін, 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

Це точно не було. Виправлено зараз. Думав, що ця проблема була занадто простою :)
Крістофер пізно

Приємно, але я не впевнений, що він досі відповідає. Число після 34(яке 8наразі є ) повинно бути 7, але оскільки 7це невимовне число, програма повинна запустити третю ітерацію і замість цього надрукувати 1.
ETHproductions

2

Діалог APL , 39 байт

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

⍳7*7є 1 2 3 ... 7 7

{ }⍣≡є оператором з фіксованою точкою - застосовуйте функцію повторно, поки результат не стабілізується

A@I⊢B змінити оператор - замінити на індекси елементів Iв BсA

0=7|⍵ бітмаска, де аргумент ділиться на 7

'7'∊¨⍕¨⍵ бітова маска, де десяткове форматування аргументу містить 7

або

за яких індексів відповідає одна з перерахованих вище бітових масок?

i← призначити i

⍵⍴⍨⍴i переформатуйте аргумент на кількість елементів у i


Це добре. Чи допоможе це, якщо ви помножите ⍳7 * 7 за допомогою бітової маски і приймете точку внесення змін до нулів у послідовності?
mschauer

2

C 157 155 байт

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?
Zacharý

Я ні, дякую. Мені також технічно не потрібні брекети (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}

Використовує вбудований Truthy R T(ініціалізований на TRUE/ 1) для підрахунку чисел у послідовності, а значення Falsy F(ініціалізовано на FALSE/ 0) для підрахунку невимовних значень . Крім цього програма просто перевіряє, чи кожне число ділиться на сім чи містить число.


-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));}

EDIT: Завдяки @mschauer, який зазначив, що я пропустив деякі речі.


Гарний підхід. Два зауваження. r% 10-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


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

Так, приємно вистрілив Док! Це дозволило мені також відмовитись від оператора порівняння.
Річард Симе

Схоже, це не те, що очікується. Заповнюючи прогалини, вам, мабуть, доведеться знову застосувати правила, а не просто скидати лічильник (див. Цю частину послідовності:) 34 1 36 **8** 38. Але для чого це коштує, поточна версія може бути golfed дещо більше: 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

В обох випадках програма працює нескінченно, але перша версія переповниться біля позначки в 2 мільйони, тоді як друга версія повинна досягати максимального значення (близько 2 мільярдів).

Ви можете спробувати його в Інтернеті , але вам потрібно вбити процес, щоб запобігти його спробі запуститись назавжди.


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бере перший елемент зменшеного [r s], restвипадає першого елемента 0-індексованого результату.



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: Гаразд, я виправлю це, коли
встигну

@hdrz Я спробував ваше рішення, і це те саме питання, про яке розповів mschauer!
серхіол

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

1

Japt , 25 байт

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

Перевірте суму та останні 10 елементів.

Створює перші 1 000 000 записів послідовності та друкує їх. Один мільйон - це найкоротша кількість 7**7 == 823543у Japt.

Новий рядок є важливим, оскільки він активує неявне призначення 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

Використовує властивість, за допомогою якої можна визначити рекурсивне визначення, переглянувши вже створену послідовність.

Використовуючи наш веб-сайт, ви визнаєте, що прочитали та зрозуміли наші Політику щодо файлів cookie та Політику конфіденційності.
Licensed under cc by-sa 3.0 with attribution required.