Последовательность суммирования

16

Последовательность:

  1. Мы начинаем с 1.
  2. Сначала мы добавляем текущее 1-индексированное значение к предыдущему числу в последовательности.
  3. Затем мы применяем следующие математические операции по порядку, если они применяются к этому текущему значению:
    • Делится на 2? => Дополнение
    • Делится на 3 ? => Вычитание
    • Делится на 4? => (Дополнение И) Умножить
    • Не делится ни на 2, 3ни 4? -> Продолжить с текущей суммой-результатом

Выход:

Выведите первые 100 чисел в этой последовательности:

1, 1, 21, 25, 30, 216, 223, 223, 2169, 2179, 2190, 2202, 2215, 2215, 2245, 2261, 2295, 2295, 2333, 2353, 2395, 2417, 56649, 56649, 56699, 56725, 1533033, 1533061, 1533090, 45993600, 45993631, 45993631, 1517792001, 1517792035, 1517792070, 1517792106, 1517792143, 1517792143, 1517792221, 1517792261, 1517792343, 1517792343, 1517792429, 1517792473, 1517792563, 1517792609, 71336257041, 71336257041, 71336257139, 71336257189, 3638149121841, 3638149121893, 3638149121946, 196460052588000, 196460052588055, 196460052588055, 11198222997525633, 11198222997525691, 11198222997525750, 11198222997525810, 11198222997525871, 11198222997525871, 11198222997525997, 11198222997526061, 11198222997526191, 11198222997526191, 11198222997526325, 11198222997526393, 11198222997526531, 11198222997526601, 795073832824398753, 795073832824398753, 795073832824398899, 795073832824398973, 59630537461829934225, 59630537461829934301, 59630537461829934378, 4651181922022734887568, 4651181922022734887647, 4651181922022734887647, 376745735683841525912529, 376745735683841525912611, 376745735683841525912694, 376745735683841525912778, 376745735683841525912863, 376745735683841525912863, 376745735683841525913037, 376745735683841525913125, 376745735683841525913303, 376745735683841525913303, 376745735683841525913485, 376745735683841525913577, 376745735683841525913763, 376745735683841525913857, 35790844889964944961834465, 35790844889964944961834465, 35790844889964944961834659, 35790844889964944961834757, 3543293644106529551221660545, 3543293644106529551221660645

Вот первые 10 чисел в последовательности с объяснением:

// Starting number of the sequence:
1

// 1 (previous number in the sequence)
// + 2 (current index in 1-indexed sequence)
// = 3 -> 3 - 2 (3 is divisible by 3, so we subtract the current index 2)
// = 1
1

// 1 (previous number in the sequence)
// + 3 (current index in 1-indexed sequence)
// = 4 -> 4 + 3 (4 is divisible by 2, so we first add the current index 3)
// = 7 -> 7 * 3 (and 4 is also divisible by 4, so we then also multiply the current index 3)
// = 21
21

// 21 (previous number in the sequence)
// + 4 (current index in 1-indexed sequence)
// = 25 (25 is not divisible by 2, 3 nor 4)
25

// 25 (previous number in the sequence)
// + 5 (current index in 1-indexed sequence)
// = 30 -> 30 + 5 (30 is divisible by 2, so we first add the current index 5)
// = 35 -> 35 - 5 (and 30 is also divisible by 3, so we then also subtract the current index 5)
// = 30
30

// 30 (previous number in the sequence)
// + 6 (current index in 1-indexed sequence)
// = 36 -> 36 + 6 (36 is divisible by 2, so we first add the current index 6)
// = 42 -> 42 - 6 (and 36 is also divisible by 3, so we then also subtract the current index 6)
// = 36 -> 36 * 6 (and 36 is also divisible by 4, so we then also multiply the current index 6)
// = 216
216

// 216 (previous number in the sequence)
// + 7 (current index in 1-indexed sequence)
// = 223 (223 is not divisible by 2, 3 nor 4)
223

// 223 (previous number in the sequence)
// + 8 (current index in 1-indexed sequence)
// = 231 -> 231 - 8 (231 is divisible by 3, so we subtract the current index 8)
// = 223
223

// 223 (previous number in the sequence)
// + 9 (current index in 1-indexed sequence)
// = 232 -> 232 + 9 (232 is divisible by 2, so we first add the current index 9)
// = 241 -> 241 * 9 (and 232 is also divisible by 4, so we then also multiply the current index 9)
// = 2169
2169

// 2169 (previous number in the sequence)
// + 10 (current index in 1-indexed sequence)
// 2179 (2179 is not divisible by 2, 3 nor 4)
2179

Правила вызова:

  • Если ваш язык не поддерживает ничего больше, чем 2 31 -1, вы можете продолжить последовательность до этого максимума (поэтому первые 46 чисел, вплоть до - и включая - 1,517,792,609).
  • Выходной формат гибкий. Вы можете вернуть массив или список, строку, разделенную пробелами, запятыми и т. Д. Ваш вызов.

Основные правила:

  • Это , поэтому выигрывает самый короткий ответ в байтах.
    Не позволяйте языкам кода-гольфа отговаривать вас от публикации ответов на языках, не относящихся к кодексу. Попробуйте найти как можно более короткий ответ для «любого» языка программирования.
  • К вашему ответу применяются стандартные правила , поэтому вы можете использовать STDIN / STDOUT, функции / метод с соответствующими параметрами, полные программы. Ваш звонок.
  • По умолчанию лазейки запрещены.
  • Если возможно, добавьте ссылку с тестом для вашего кода.
  • Также, пожалуйста, добавьте объяснение, если это необходимо.
Кевин Круйссен
источник
Выводим ли мы n-е значение, первые n-значения или только до нашего максимального целочисленного размера?
Габриэль Бенами
@GabrielBenamy Первые 100 в последовательности.
Кевин Круйссен
1
Я уверен, что у вас есть только 99 номеров в этом блоке.
Каде
2
Мой ответ не согласуется с вашим выводом только по последним 13 числам.
Габриэль Бенами
1
@Shebang Исправлено .. Извините за неаккуратное начало .. Это было в песочнице в течение 5 дней, но я предполагаю, что ни я, ни другие не заметили это ..: S Должно быть правильно сейчас.
Кевин Круйссен

Ответы:

1

05AB1E , 24 23 байта

-1 байт благодаря Кевину Круйссену

¼¾тF=¼¾+©…+-*v®NÌÖi¾y.V

Попробуйте онлайн!

Объяснение:

¼¾                        # set the counter to 1, then push 1
  тF                      # repeat the following 100 times
    =                     # print the current number in the sequence
     ¼¾                   # increment the counter
       +                  # add it to the current number
        ©                 # save the result in the register
         …+-*v            # for each of '+', '-', and '*'...
              ®   i       # if the register...
                 Ö        # is divisible by...
               NÌ         # the loop index + 2...
                   ¾y.V   # then apply the current operation
Grimmy
источник
1
Пытался найти что-то более короткое с помощью переменной counter, чтобы UXудалить ее, но я не могу. Я получаю 24 байта, потому что он начинается 0вместо 1. Я теперь увеличил это раньше, но тогда мы должны сделать циклическое 101время вместо 100... Ну, хорошо.
Кевин Круйссен
@KevinCruijssen да, UXэто бельмо на глазу. Я пытался избавиться от него на некоторое время , и в конечном итоге с кучей 24 и 25 вариаций: 1тF=NÌ©+DÑ3L>Ãv®…-*+yè.V, 1тL>v=y+©3F®NÌÖiy…+-*Nè.V... Я не считал , используя переменный счетчик, это интересно.
Grimmy
1
@KevinCruijssen ваши 24 вдохновили 23: просто используйте тFвместо Ƶ0µ. Я редактировал это, спасибо! (PS: там должно быть действительно один байт ¼¾...)
Grimmy
Ах, хорошо. Я подумал, что ты что-то найдешь, ха-ха. ;) И да, один байт for ¼¾был бы хорош, хотя, если честно, я почти никогда не использую его таким образом. Однобайтовая встроенная функция, которую я предпочел бы больше всего сейчас, - это вторая ©®переменная, которая не появляется. Возможно, начиная с пустой строки, ""как вы уже упоминали в другой задаче.
Кевин Круйссен
8

Р, 85 82 79 76 72 70 байт

for(i in 2:56)T[i]=((z=i+T[i-1])+i*(!z%%2)-i*(!z%%3))*`if`(z%%4,1,i);T

ungolfed:

s=1 ## formerly s=1:56, formerly s=1:100
for(i in 2:56){
    z=i+s[i-1]
    s[i]=(z+i*(z%%2<1)-i*(z%%3<1))*(1+(i-1)*(z%%4<1))
}
s

Спасибо @rturnbull за то, что он указал, что я могу использовать (!z%%3)вместо (z%%3<1)проверки модули, и что определение zслучается при его первом использовании.

Отбросил 3–4 символа, используя неправильное векторное расширение: ответ изначально начался, s=1:56...но нам не нужно этого делать, длина sбудет увеличена по мере необходимости.

Сохранено еще 3 байта путем замены последнего условия вызовом "if"функции (да, это правильная функция в R!)

Сохранено еще 4 байта путем замены sна T, который является встроенным, равным TRUEкоторому также равен 1. Я понял это одновременно с @rturnbull (честно!)

Это приводит к некоторым численным проблемам, когда мы превышаем 2 ^ 52, но я ничего не могу с этим поделать - R может использовать doubleтипы только для чисел, больших чем2^31-1 , но они точно хранят целые числа до 2 ^ 52. Таким образом, мне разрешено выводить только первые 56 членов (последний термин, который является «правильным»), который сохраняет один байт в случае длины 100.

Вот вывод из 56-длины версии:

    > for(i in 2:56){z=i+T[i-1];T[i]=(z+i*(!z%%2)-i*(!z%%3))*`if`(z%%4,1,i)};T
 [1]               1               1              21              25              30             216
 [7]             223             223            2169            2179            2190            2202
[13]            2215            2215            2245            2261            2295            2295
[19]            2333            2353            2395            2417           56649           56649
[25]           56699           56725         1533033         1533061         1533090        45993600
[31]        45993631        45993631      1517792001      1517792035      1517792070      1517792106
[37]      1517792143      1517792143      1517792221      1517792261      1517792343      1517792343
[43]      1517792429      1517792473      1517792563      1517792609     71336257041     71336257041
[49]     71336257139     71336257189   3638149121841   3638149121893   3638149121946 196460052588000
[55] 196460052588055 196460052588055
JDL
источник
1
Я бы сказал, что зацикливание только до 56 является честной игрой, учитывая описание проблемы.
Billywob
@Billywob действительно прав. В описании я заявляю: « Если ваш язык не поддерживает ничего больше, чем 2 ^ 31-1, вы можете продолжить последовательность до этого максимума (так что первые 46 чисел, вплоть до - и включая - 1,517,792,609). », Но это из Курс также распространяется на номера, отличные от 32-битных. Если R не может справиться с чем-то большим, чем первые 56 чисел, то все в порядке. И да, если вы знаете , что никогда не может пойти выше 56, вы можете изменить , 100чтобы 56сохранить байт.
Кевин Круйссен
1
Вы можете сохранить три байта, изменив z%%2<1(и так далее) на !z%%2злоупотребление неявным преобразованием типов.
rturnbull
Спасибо @rturnbull, по некоторым причинам я думал, !что не побил %%, но, видимо, это так!
JDL
2
Вы также можете Tиспользовать и использовать это вместо s, позволяя удалить s=1;, сохранив еще четыре байта. Можно сложить определение zв определение s[i](ну, T[i]сейчас), например, так T[i]=((z=i+T[i-1])+ ..., что означает, что вы можете потерять фигурные скобки, сохранив еще несколько байтов. РЕДАКТИРОВАТЬ: О, я вижу, что вы сделали Tтрюк, когда я писал свой комментарий! Великие умы думают одинаково, говорят они.
rturnbull
5

Питон 3, 82 78 76 74 72 байта

i=s=1
exec('print(s);i+=1;s+=i;s=(s+i-i*(s%2+(s%3<1)))*i**(s%4<1);'*100)

Выход:

1
1
21
25
30
216
223
223
2169
2179
2190
2202
2215
2215
2245
2261
2295
2295
2333
2353
2395
2417
56649
56649
56699
56725
1533033
1533061
1533090
45993600
45993631
45993631
1517792001
1517792035
1517792070
1517792106
1517792143
1517792143
1517792221
1517792261
1517792343
1517792343
1517792429
1517792473
1517792563
1517792609
71336257041
71336257041
71336257139
71336257189
3638149121841
3638149121893
3638149121946
196460052588000
196460052588055
196460052588055
11198222997525633
11198222997525691
11198222997525750
11198222997525810
11198222997525871
11198222997525871
11198222997525997
11198222997526061
11198222997526191
11198222997526191
11198222997526325
11198222997526393
11198222997526531
11198222997526601
795073832824398753
795073832824398753
795073832824398899
795073832824398973
59630537461829934225
59630537461829934301
59630537461829934378
4651181922022734887568
4651181922022734887647
4651181922022734887647
376745735683841525912529
376745735683841525912611
376745735683841525912694
376745735683841525912778
376745735683841525912863
376745735683841525912863
376745735683841525913037
376745735683841525913125
376745735683841525913303
376745735683841525913303
376745735683841525913485
376745735683841525913577
376745735683841525913763
376745735683841525913857
35790844889964944961834465
35790844889964944961834465
35790844889964944961834659
35790844889964944961834757
3543293644106529551221660545
3543293644106529551221660645

Предложения приветствуются!

Номер один
источник
4

05AB1E , 34 31 30 байт

XTnFD,NÌ©+D3L>%_`X®‚sèrŠs-®*+*

Попробуйте онлайн!

объяснение

X                               # initialize stack with 1
 TnF                            # for N in [0 ... 99]
    D,                          # print a copy of top of stack
      NÌ©                       # increase index N by 2 and store in register
         +                      # add this to current value
          D                     # make a copy of the current value
           3L>                  # push the list [2,3,4]
              %                 # take current value mod elements in list
               _                # invert this
                `               # push the elements from the list to stack
                 X®‚sè          # index into list [1,N+2] with the result of mod 4
                      rŠs-      # subtract result of mod 3 from result of mod 2
                          ®*    # multiply by N+2
                            +   # add this to current value
                             *  # multiply current value with the result from index operation
Emigna
источник
3

Python 2, 76 байт

Довольно стандартная реализация, я думаю, что использование оператора exec вместо цикла while позволило сэкономить 2 байта или около того. Рекурсивный метод может быть короче, я думаю, скоро появится xnor;)

n=1
f=1
exec'print f;n+=1;d=f+n;f=(d+n*(d%2<1)-n*(d%3<1))*[1,n][d%4<1];'*100

Если бы я использовал обновления, которые выяснил TheNumberOne, я был бы на 69 байтах (но тогда я бы копировал)

n=f=1;exec'print f;n+=1;d=f+n;f=(d+n-n*(d%2+(d%3<1))*n**(d%4<1);'*100

Выход:

1
1
21
25
30
216
223
223
2169
2179
2190
2202
2215
2215
2245
2261
2295
2295
2333
2353
2395
2417
56649
56649
56699
56725
1533033
1533061
1533090
45993600
45993631
45993631
1517792001
1517792035
1517792070
1517792106
1517792143
1517792143
1517792221
1517792261
1517792343
1517792343
1517792429
1517792473
1517792563
1517792609
71336257041
71336257041
71336257139
71336257189
3638149121841
3638149121893
3638149121946
196460052588000
196460052588055
196460052588055
11198222997525633
11198222997525691
11198222997525750
11198222997525810
11198222997525871
11198222997525871
11198222997525997
11198222997526061
11198222997526191
11198222997526191
11198222997526325
11198222997526393
11198222997526531
11198222997526601
795073832824398753
795073832824398753
795073832824398899
795073832824398973
59630537461829934225
59630537461829934301
59630537461829934378
4651181922022734887568
4651181922022734887647
4651181922022734887647
376745735683841525912529
376745735683841525912611
376745735683841525912694
376745735683841525912778
376745735683841525912863
376745735683841525912863
376745735683841525913037
376745735683841525913125
376745735683841525913303
376745735683841525913303
376745735683841525913485
376745735683841525913577
376745735683841525913763
376745735683841525913857
35790844889964944961834465
35790844889964944961834465
35790844889964944961834659
35790844889964944961834757
3543293644106529551221660545
3543293644106529551221660645
Када
источник
3

JavaScript, 75 63 байта

for(n=p=0;n++<57;alert(p=p%4?q:q*n))q=(p+=n)%2?p:p+n,q-=p%3?0:n

Другая версия:

for(n=p=0;n++<57;)alert(p=((p+=n)+(!(p%2)-!(p%3))*n)*(p%4?1:n))

Оба ограничиваются индексом 57 (с индексами 0), потому что тогда выходной сигнал превосходит размер безопасного числа JavaScript (2 53 - 1). Оказывается, цикл намного короче, чем рекурсивная функция, даже с ES6:

f=(n=0,p=0)=>n++>56?[]:(q=(p+=n)%2?p:p+n,q-=p%3?0:n,[q*=p%4?1:n,...f(n,q)])

Этот возвращает массив первых 57 элементов.

ETHproductions
источник
Я думаю, вам следует избегать превышения ~ 50-60, потому что тогда вы превысите Number.MAX_SAFE_INTEGER, и ваши подразделения станут неправильными. Я также попробовал mapверсию для полноты, и она тоже показала 75 байтов.
Нил
@ Нейл, спасибо. Чтобы быть точным, он превосходит Number.MAX_SAFE_INTEGER после 57 записей.
ETHproductions
3

Brain-Flak 476 466 462 456 446 байт

Сохранено 6 байт благодаря Wheat Wizard

(((((((())<>()(())()){}){}){}())){}{}){({}[()]<(((({})<>({}())<>))<({}(()())(<()>)){({}[()]<(({}()[({})])){{}(<({}({}))>)}{}>)}({}{}<{}(())>){((<{}{}>))}{}{(<{}({}<>({})<>)>)}{}>)(({})<({}(()()())(<()>)){({}[()]<(({}()[({})])){{}(<({}({}))>)}{}>)}({}{}<{}(())>){((<{}{}>))}{}{(<{}({}<>[({})]<>)>)}{}>)({}(()()()())(<()>)){({}[()]<(({}()[({})])){{}(<({}({}))>)}{}>)}({}{}<{}(())>){((<{}{}>))}{}{(<{}(<>({}))({<({}[()])><>({})<>}{}<><{}>)>)}{}>)}{}

Попробуйте онлайн!

Это действительно медленно. TIO не может обрабатывать целые 100 чисел (кажется, что предел 22 или 23). Итак, этот пример генерирует только первые 20, но код будет работать и для 100.

Краткое объяснение:

      (())<>                           # push a 1 (the index) and switch stacks 
            (())                       # then push a 1 (the starting number)
((((((          ()()){}){}){}())){}{}) # and a 99 (a counter so that we only print the 
                                       # first 100 numbers)

# repeat until the counter is 0
{
  # pop the counter and push it minus 1 after:
  ({}[()]<
    # hold onto the current number plus the index (leave a copy on the stack to be printed)
    # and increment the index
    (((({})<>({}())<>))<
      # push logical not of (current mod 2)
      ({}(()())(<()>)){({}[()]<(({}()[({})])){{}(<({}({}))>)}{}>)}({}{}<{}(())>){((<{}{}>))}{}
      # if !(current mod 2) is 1, add the index
      {(<{}({}<>({})<>)>)}{}
    # push the current number back on
    >)
    # hold onto the current number
    (({})<
     # push logical not of (current mod 3)
     ({}(()()())(<()>)){({}[()]<(({}()[({})])){{}(<({}({}))>)}{}>)}({}{}<{}(())>){((<{}{}>))}{}
     # if !(current mod 3) is 1, then subtract the index
     {(<{}({}<>[({})]<>)>)}{}
    # push the current number back on
    >)
    # push logical not of (current mod 4)
    ({}(()()()())(<()>)){({}[()]<(({}()[({})])){{}(<({}({}))>)}{}>)}({}{}<{}(())>){((<{}{}>))}{}
    # if !(current mod 4) is 1, multiply by the index
    {(<{}(<>({}))({<({}[()])><>({})<>}{}<><{}>)>)}{}
  # put the counter back on
  >)
# loop until done
}
# pop the counter
{}
Райли
источник
({}<>[({})]<>)(<()>)можно заменить на(<({}<>[({})]<>)>)
Post Rock Garf Hunter
@WheatWizard Обновлено. Благодарность!
Райли
1

Java 7, 316 байт

import java.math.*;String c(){String r="";BigInteger t=BigInteger.ONE,x,p;for(int i=2;i<102;){r+=t+" ";p=(t=t.add(x=new BigInteger(i+++"")));t=x(p,2)?t.add(x):t;t=x(p,3)?t.subtract(x):t;t=x(p,4)?t.multiply(x):t;}return r;}boolean x(BigInteger p,int i){return p.mod(new BigInteger(i+"")).compareTo(BigInteger.ONE)<0;}

Ungolfed & тестовый код:

Попробуй это здесь.

import java.math.*;
class M{
  static String c(){
    String r = "";
    BigInteger t = BigInteger.ONE,
               x,
               p;
    for(int i = 2; i < 102;){
      r += t+" ";
      p = (t = t.add(x = new BigInteger(i++ + "")));
      t = x(p, 2)
           ? t.add(x)
           : t;
      t = x(p, 3)
           ? t.subtract(x)
           : t;
      t = x(p, 4)
           ? t.multiply(x)
           : t;
    }
    return r;
  }

  public static void main(String[] a){
    System.out.println(c());
  }

  static boolean x(BigInteger p, int i){
    return p.mod(new BigInteger(i+"")).compareTo(BigInteger.ONE) < 0;
  }
}

Выход:

1 1 21 25 30 216 223 223 2169 2179 2190 2202 2215 2215 2245 2261 2295 2295 2333 2353 2395 2417 56649 56649 56699 56725 1533033 1533061 1533090 45993600 45993631 45993631 1517792001 1517792035 1517792070 1517792106 1517792143 1517792143 1517792221 1517792261 1517792343 1517792343 1517792429 1517792473 1517792563 1517792609 71336257041 3424140340272 3424140340321 3424140340371 3424140340473 3424140340525 3424140340631 3424140340631 3424140340741 3424140340797 3424140340911 3424140340969 202024280124133 202024280124193 202024280124315 202024280124377 12727529647843689 814561897462000192 52946523335030016705 52946523335030016771 52946523335030016905 52946523335030016973 52946523335030017111 52946523335030017111 52946523335030017253 52946523335030017253 52946523335030017399 52946523335030017473 3970989250127251321725 301795183009671100456876 301795183009671100456953 301795183009671100457031 301795183009671100457110 301795183009671100457270 301795183009671100457351 301795183009671100457433 25049000189802701337980717 25049000189802701337980801 25049000189802701337980971 25049000189802701337981057 2179263016512835016404367097 191775145453129481443584312280 17067987945328523848479003800841 1536118915079567146363110342083790 1536118915079567146363110342083790 1536118915079567146363110342083974 1536118915079567146363110342083974 144395178017479311758132372155911228 13717541911660534617022575354811575685 13717541911660534617022575354811575781 13717541911660534617022575354811575975 13717541911660534617022575354811576073 1358036649254392927085234960126346050829 
Кевин Круйссен
источник
1

C #, 120 байт

Так же, как ни один здравомыслящий человек не будет играть в гольф на Яве, ни один здравомыслящий человек не должен играть в гольф на C #! Но винт, я хотел посмотреть, что я могу сделать. В 1Mслепки fбыть десятичным , который имеет достаточную точность для этого ответа без меня того , чтобы писать decimal. Кроме того, увеличение на месте экономит несколько байтов в моем ответе на Python. в конце концов, это еще на 50 байтов больше.

void k(){int n=1;var f=1M;while(n<101){Console.WriteLine(f);var d=++n+f;f=(d+n*((d%2<1?1:0)-(d%3<1?1:0)))*(d%4<1?n:1);}}

Вот более читаемая (и запускаемая) версия:

using System;
class P
{
    static void Main(string[]a) 
    {
        int n = 1;
        var f = 1M;
        while (n < 101) 
        {
            Console.WriteLine(f);
            var d = ++n + f;
            f = (d + n * ((d % 2 < 1 ? 1 : 0) - (d % 3 < 1 ? 1 : 0))) * (d % 4 < 1 ? n : 1);
        }
        Console.Read();
    }
}
Када
источник
Вы можете whileforfor(int n=1;n<101;)
сыграть в
Вы можете даже void k(){for(decimal f=1,d,n=1;n<101;)Console.WriteLine(f=((d=++n+f)+n*((d%2<1?1:0)-(d%3<1?1:0)))*(d%4<1?n:1));}
поиграть в
1

Пакет, 110 байт

@set n=0
@for /l %%i in (1,1,46)do @set/an=((n+=%%i)+(!(n%%2)-!(n%%3))*%%i)*(~-%%i*!(n%%4)+1)&call echo %%n%%

Использует формулу @ETHproductions, но немного подправлен, потому что пакетный не имеет ?:. Пакет использует 32-битные целые числа со знаком, поэтому цикл останавливается на 46.

Нил
источник
1

Perl, 75 байт

use bigint;$a+=$_,say$a=($a+($a%2?0:$_)-($a%3?0:$_))*($a%4?1:$_)for(1..100)

Код выводит каждое значение в новой строке и вычисляет все 100 значений.

Габриэль Бенами
источник
-Mbigint, нет круглых скобок 1..100, и !($a%2)*$_вместо ($a%2?0:$_)(то же самое для a%3..) следует сохранить несколько байтов;)
Dada
Получает это до 60 байтов с этими предложениями и несколькими другими массажами.
Xcali
1

Haskell, 70 64 байта

a%b=0^mod a b
n#i|s<-n+i=(s+s%2*i-s%3*i)*i^s%4
scanl1(#)[1..100]

scanl1(#)[1..100]возвращает список с первыми 100 элементами. На один байт меньше, если я могу оставаться в диапазоне 2 ^ 31 (->[1..46] ).

scanl1Это как, foldl1но собирает промежуточные результаты в списке. Тесты делимости выполняются через вспомогательную функцию, %которая возвращает, 0^0 = 1если делится, а 0^x = 0если нет.

Ними
источник
1

J, 46 байт

(,{:((]^0=4|+)*(]*0=2|+)++-]*0=3|+)1+#)^:99]1x

Применяется метод, описанный в задании.

использование

Дополнительная команда (,.~#\)используется для добавления индексов к каждому значению.

   (,.~#\) (,{:((]^0=4|+)*(]*0=2|+)++-]*0=3|+)1+#)^:99]1x
  1                            1
  2                            1
  3                           21
  4                           25
  5                           30
  6                          216
  7                          223
  8                          223
  9                         2169
 10                         2179
 11                         2190
 12                         2202
 13                         2215
 14                         2215
 15                         2245
 16                         2261
 17                         2295
 18                         2295
 19                         2333
 20                         2353
 21                         2395
 22                         2417
 23                        56649
 24                        56649
 25                        56699
 26                        56725
 27                      1533033
 28                      1533061
 29                      1533090
 30                     45993600
 31                     45993631
 32                     45993631
 33                   1517792001
 34                   1517792035
 35                   1517792070
 36                   1517792106
 37                   1517792143
 38                   1517792143
 39                   1517792221
 40                   1517792261
 41                   1517792343
 42                   1517792343
 43                   1517792429
 44                   1517792473
 45                   1517792563
 46                   1517792609
 47                  71336257041
 48                  71336257041
 49                  71336257139
 50                  71336257189
 51                3638149121841
 52                3638149121893
 53                3638149121946
 54              196460052588000
 55              196460052588055
 56              196460052588055
 57            11198222997525633
 58            11198222997525691
 59            11198222997525750
 60            11198222997525810
 61            11198222997525871
 62            11198222997525871
 63            11198222997525997
 64            11198222997526061
 65            11198222997526191
 66            11198222997526191
 67            11198222997526325
 68            11198222997526393
 69            11198222997526531
 70            11198222997526601
 71           795073832824398753
 72           795073832824398753
 73           795073832824398899
 74           795073832824398973
 75         59630537461829934225
 76         59630537461829934301
 77         59630537461829934378
 78       4651181922022734887568
 79       4651181922022734887647
 80       4651181922022734887647
 81     376745735683841525912529
 82     376745735683841525912611
 83     376745735683841525912694
 84     376745735683841525912778
 85     376745735683841525912863
 86     376745735683841525912863
 87     376745735683841525913037
 88     376745735683841525913125
 89     376745735683841525913303
 90     376745735683841525913303
 91     376745735683841525913485
 92     376745735683841525913577
 93     376745735683841525913763
 94     376745735683841525913857
 95   35790844889964944961834465
 96   35790844889964944961834465
 97   35790844889964944961834659
 98   35790844889964944961834757
 99 3543293644106529551221660545
100 3543293644106529551221660645
миль
источник
1

Perl 6 , 62 байта

1,{((my \v=$_+my \n=++$+1)+n*(v%%2-v%%3))*(v%%4*n||1)}.../645/

Попробуйте онлайн!

ДЕЙСТВИТЕЛЬНО пришлось поработать, чтобы мой счетчик байтов был ниже, чем у других не-гольф-решений.

Шон
источник