Фібоначчі-ориал

36

Визначення

Послідовність Фібоначчі F(n)на натуральних цілих числах визначається як така:

1. F(1) = 1
2. F(2) = 1
3. F(n) = F(n-1) + F(n-2), where n is an integer and n > 2

Оригінальним числом Фібоначчі з натурального числа є добуток [F(1), F(2), ..., F(n)].

Завдання

З огляду на додатне ціле число n, знайдіть фібональський оріал n.

Технічні характеристики

Оригінальний рівень поля 100повинен обчислювати менше 5 секунд на розумному комп'ютері.

Тестові шафи

n   Fibonacci-orial of n
1   1
2   1
3   2
4   6
5   30
6   240
7   3120
8   65520
9   2227680
10  122522400
11  10904493600
12  1570247078400
13  365867569267200
14  137932073613734400
15  84138564904377984000
16  83044763560621070208000
17  132622487406311849122176000
18  342696507457909818131702784000
19  1432814097681520949608649339904000
20  9692987370815489224102512784450560000
100 3371601853146468125386964065447576689828006172937411310662486977801540671138589868616500834190029067583665182291701553172011082574587431382310099030394306877775647395167143332483560925112960024644459715300507481235056111434293619038347456390454209587101225261757371666449068625033999573552165524529725467628060170886602001077137613803027158648329335507728698605769992818756765633305318529965186184043999696650407246193257877568825245646129366994079739720698147440310773871269639752334356493678913424390564535389212240038895626811627949132978086070255082668392290037141141291484839596694182152062726390364094447642643912371532491388089634845995941928089653751672688740718152064107169357399466473375804972260594768969952507346694189050233823596316467570584434128052398891223730335019092974935617029638919358286124350711360361279157416837428904150054292406756317837582840596331363581207781793070936765786629772999832857257349696094416616259974304208756997835360702840912518532683324936435856348020736000000000000000000000000

Список літератури

  • Обов’язковий OEIS A003266
  • OEIS A000045 - послідовність Фібоначчі
code-golf  math  sequence  arithmetic  fibonacci 
— Лина монахиня
джерело
— Leaky Nun
1
@LuisMendo Сума вибору - це, ви здогадалися, підняття. Ну, мінус один.
— Leaky Nun
2
@LeakyNun На даний момент відповідь JavaScript завершує лише тестові випадки до 15, оскільки JavaScript не може правильно порівняти (або маніпулювати) числами понад 2 ^ 53 - 1. Це, швидше за все, подібне для багатьох публікацій тут, оскільки більшість мов не відповідають номери підтримки, які великі
— MayorMonty
1
Що ви маєте на увазі під розумним комп'ютером?
— Ерік Аутгольфер
2
-1 тому, що це здається декількома викликами, вирішеними разом (діапазон, рівень кожного, фактичний) без особливо цікавих ярликів.
— Esolanging Fruit

Відповіді:

63

Математика, 10 байт

Fibonorial

Ще одна вбудована система Mathematica чудово побита мовою для гольфу без вбудованого.

— Мартін Ендер
джерело
49
Я… ш-що… чому, Mathematica ?!
— Лінн
3
Забули, що ця функція навіть існувала!
— LegionMammal978
3
@Lynn Правило 35 : Якщо воно існує, існує його функція Mathematica;)
— бета-розпад
9
@BetaDecay Я думав, що ми встановили, що це правило 110 .
— Мартін Ендер
1
Ні, правило 110 - це щось дуже інше. Хоча я впевнений, що в Mathematica теж є вбудований для цього.
— AdmBorkBork
27

Желе , 6 байт

+С1ḊP

Введення 100 завершується за 500 мс локально. Спробуйте в Інтернеті!

Як це працює

+С1ḊP  Niladic link. No input.
        Since the link doesn't start with a nilad, the argument 0 is used.

   1    Yield 1.
+       Add the left and right argument.
 С     Read a number n from STDIN.
        Repeatedly call the dyadic link +, updating the right argument with
        the value of the left one, and the left one with the return value.
        Collect all values of the left argument into an array.
    Ḋ   Dequeue; discard the first Fibonacci number (0).
     P  Product; multiply the remaining ones.
— Денніс
джерело
Отже, +¡1це не побудований в n-му рівні і +С1це перші n числа Фібоначчі?
— caird coinheringaahing
@cairdcoinheringaahing Досить сильно.
— Денніс
Я думав, що існує вбудована функція?
— MilkyWay90
21

Власне , 4 байти

Виконує вхід 100 протягом 0,2 секунд. Код:

R♂Fπ

Пояснення:

R     # Get the range [1, ..., input].
 ♂F   # Map over the array with the fibonacci command.
   π  # Take the product.

Використовує кодування CP-437 . Спробуйте в Інтернеті! .

— Аднан
джерело
1
Це правильний інструмент для роботи :) Завдяки деяким вдосконаленням функції Фібоначчі, які Leaky Nun зробила ще раз, тестовий випадок 100 запустився за TIO за 0,1 секунди .
— Mego
16

Brainfuck, 1198 1067 817 770 741 657 611 603

,[>++++++[-<-------->]<<[->++++++++++<]>>,]>+>+>>+>+<<<<<<[->>>[[-]
<[->+<]>>[-<+<+>>]<[->+<[->+<[->+<[->+<[->+<[->+<[->+<[->+<[->+<[->
[-]>>>>>>+>+<<<<<<<<[->+<]]]]]]]]]]]+>>>>>>>>]<<<<<<<<[->[-<+<<+>>>
]<[->+<]>>>[<<<<<[->>>>>>>>+<<<<<<<<]>>>>>>>>>>>>>]<<<<<<<<[->>>[-<
<<<<<<<+>>>>[->+>>+<<<]>[-<+>]>>>]<<[->>>>>>>+>+<<<<<<<<]<+<<<<<<<<
]>>>[-]>>>>>[[-]>[->+<]>[-<+>[-<+>[-<+>[-<+>[-<+>[-<+>[-<+>[-<+>[-<
+>[->>>>>>+>+<<<<<<<<[-]]]]]]]]]]>]<<[<]+>>>>>>>>]<<<<<<<<[<<<<<<<<
]>>>>>[>>>>>>>>]+<<<<<<<<]>>>>>>>>>>>[<[-]>>[-<<+>>]>>>>>>>]<<<<<<<
<[<<<<<<<<]>>]>>>>>>[>>>>>>>>]<<<<<<<<[+++++[-<++++++++>]<.<<<<<<<]

Без стиснення, з коментарями:

# parse input (max 255)
,[>++++++[-<-------->]<<[->++++++++++<]>>,]
>+>+>>+>+<<<<<<
[->>>
  # compute next fibonacci number
  [[-]<
    [->+<]>>
    [-<+<+>>]<
    # perform carries
    [->+<[->+<[->+<[->+<[->+<[->+<[->+<[->+<[->+<
      [->[-]>>>>>>+>+<<<<<<<<[->+<]]
    ]]]]]]]]]+>>>>>>>>
  ]<<<<<<<<
  # multiplication
  [->
    # extract next digit of F_n (most significant first)
    [-<+<<+>>>]<
    [->+<]>>>
    # move back to the end
    [<<<<<
      [->>>>>>>>+<<<<<<<<]>>>>>>>>>>>>>
    ]<<<<<<<<
    # digit wise multiplication (shifting current digit)
    [->>>
      [-<<<<<<<<+>>>>
        [->+>>+<<<]>
        [-<+>]>>>
      ]<<
      # shift previous total over one gap (in effect multiplying by 10)
      [->>>>>>>+>+<<<<<<<<]<+<<<<<<<<
    ]>>>[-]>>>>>
    # add product to total
    [[-]>
      [->+<]>
      # perform carries
      [-<+>
        [-<+>[-<+>[-<+>[-<+>[-<+>[-<+>[-<+>[-<+>
          [->>>>>>+>+<<<<<<<<[-]]
        ]]]]]]]]>
      ]<<[<]+>>>>>>>>
    ]<<<<<<<<
    [<<<<<<<<]>>>>>
    [>>>>>>>>]+<<<<<<<<
  ]>>>>>>>>>>>
  # overwrite previous product
  [<[-]>>
    [-<<+>>]>>>>>>>
  ]<<<<<<<<
  [<<<<<<<<]>>
]>>>>>>
# output product
[>>>>>>>>]<<<<<<<<
[+++++
  [-<++++++++>]<.<<<<<<<
]

Спробуйте в Інтернеті!

Час виконання n = 100 - менше 1 секунди для онлайн-перекладача (приблизно 0,2 секунди локально, використовуючи мій власний перекладач). Максимальний вхід - 255, але інтерпретатор потребує підтримки 54000 комірок (онлайн-перекладач, здається, має 64 к).

Журнал змін

Збережено близько 130 байт з кращим вилученням поточної цифри для множення на, об'єднанням додавання та перенесення в один прохід. Це також здається трохи швидшим.

Збережено ще 250 байт. Мені вдалося зменшити подряпину множення подряпини на дві комірки, що економить байти майже скрізь, не потрібно переходити так далеко між цифрами. Я також відкинув перенесення, перемноживши його на цифру, і замість цього виконую повне перенесення, додаючи при цьому загальну кількість.

Нарізав ще 50, знову з кращим вилученням поточної цифри, щоб помножити на, просто не перемістивши її вперед першою ітерацією, а працюючи звідки. Декілька мікрооптимізацій надалі становлять близько ~ 10 байт.

Ще 30 пішло. Позначення цифр, які вже прийняті з 0, а не з 1, полегшує їх пошук. Це також робить перевірку, чи закінчився цикл множення дещо простіше.

Я зменшив подряпину на ще одну клітинку на 80 байт. Я зробив це, об'єднавши маркер для попереднього продукту і поточний загальний обсяг, що зменшує зрушення між прогалинами та полегшує ведення бухгалтерського обліку.

Збережено ще 50, усунувши ще одну клітинку, повторно використовуючи маркер для цифр поля, щоб також позначити останню цифру, взяту. Я також зміг об'єднати цикл, щоб зрушити попередні підсумки з циклом множення цифр.

Збережено 8 байт під час синтаксичного аналізу. На жаль

— примо
джерело
14

Пітон, 45 байт

a=b=o=1
exec"o*=a;a,b=b,a+b;"*input()
print o

Введення взято з stdin. Виведення для n = 100 закінчується занадто швидко, щоб точно встигнути час. n = 1000 займає приблизно 1 с.

Використання зразків

$ echo 10 | python fib-orial.py
122522400

$ echo 100 | python fib-orial.py
3371601853146468125386964065447576689828006172937411310662486977801540671138589868616500834190029067583665182291701553172011082574587431382310099030394306877775647395167143332483560925112960024644459715300507481235056111434293619038347456390454209587101225261757371666449068625033999573552165524529725467628060170886602001077137613803027158648329335507728698605769992818756765633305318529965186184043999696650407246193257877568825245646129366994079739720698147440310773871269639752334356493678913424390564535389212240038895626811627949132978086070255082668392290037141141291484839596694182152062726390364094447642643912371532491388089634845995941928089653751672688740718152064107169357399466473375804972260594768969952507346694189050233823596316467570584434128052398891223730335019092974935617029638919358286124350711360361279157416837428904150054292406756317837582840596331363581207781793070936765786629772999832857257349696094416616259974304208756997835360702840912518532683324936435856348020736000000000000000000000000
— примо
джерело
13

Haskell 41 29 Байт

1 + 11 байтів, збережених за допомогою зауважень @ Лайконі.

f=1:scanl(+)1f
(scanl(*)1f!!)

1, fі !!є окремими лексемами. Перший рядок визначає послідовність поля, другий - це функція, яка обчислює послідовність фільмів-оригіналів і повертає n-ту для заданої n. Він починає друкувати цифри майже одразу навіть для n = 1000.

— Християнський Сіверс
джерело
1
Можна позбутися місця (scanl(*)1f!!).
— Лайконі
2
І є більш короткий генератор Фібоначчі тут :f=1:scanl(+)1f
— Laikoni
@Laikoni Це дивовижно, дякую!
— Крістіан Сіверс
2
@WillNess Я думаю, що я виправданий не лише тим, що роблять інші користувачі, але й мета.codegolf.stackexchange.com/ questions/ 2419/… та meta.codegolf.stackexchange.com/questions/9031/… (але є набагато більше, і я не все прочитав)
— Крістіан Сіверс
1
@flawr Ви б прийняли 42+функцію, яка додає 42? Не варто, бо це просто незавершений вираз. Але в Haskell ми можемо додати дужки і отримати розділ (42+) , спосіб записати функцію \n->42+n. Тут те саме, тільки з !!(оператор бінарної інфіксації для індексації) замість +і більш складний перший операнд.
— Крістіан Сіверс
11

Python 2, 39 байт

f=lambda n,a=1,b=1:n<1or a*f(n-1,b,a+b)

Перевірте це на Ideone .

— Денніс
джерело
Ви можете вказати, що він повертається Trueв деяких випадках.
— Leaky Nun
5
Це поверне лише Trueдля введення 0 , що не є позитивним.
— Денніс
6

J, 17 16 байт

1 байт гольфу з ще кращим рішенням за милі.

[:*/+/@(!|.)\@i.

Ідея така ж, як і оригінальна, але замість того, щоб формувати матрицю для роботи на другорядних діагоналях, ми формуємо діагоналі на ходу.

Оригінал

Щоб отримати перші російські фібономії:

*/\(#{.+//.)!/~i.

Читання справа наліво ...
Створіть масив послідовних цілих чисел ( i.) до вказаного, з цього масиву створіть таблицю ( /~) двочленних коефіцієнтів ( !), обчислену з кожної пари масиву, ця таблиця - це трикутник Паскаля, верхній відбілений на кінець першого ряду, а всі елементи під основною діагоналлю дорівнюють 0, на щастя реалізації !. Якщо підсумовувати ( +/) всі незначні діагоналі ( /.), ви отримуєте числа Фібоначчі, але вам потрібно взяти ( {.) стільки ж перших елементів з отриманого масиву, скільки довжина ( #) самої таблиці. Тоді продукт ( */), застосований до послідовних префіксів ( \) масиву, призводить до бажаної послідовності фібонаріалів.Якщо ви хочете, ви можете взяти лише останній, використовуючи ще 2 байти ( {:), але я подумав, що відображення їх усіх не є гріхом :).
NB. the previous code block is not a J function.

   {:*/\(#{.+//.)!/~i. 10
122522400

Для великих чисел у J ви використовуєте xв кінці:

   {:*/\(#{.+//.)!/~i. 100x
3371601853146468125386964065447576689828006172937411310662486977801540671138589868616500834190029067583665182291701553172011082574587431382310099030394306877775647395167143332483560925112960024644459715300507481235056111434293619038347456390454209587101225...

Програма працює на рівні 0.11s .

   100 timex '{:*/\(#{.+//.)!/~i.100x'
0.112124
— Ден Дуб
джерело
1
Альтернативою, яка є функцією, є [:*/+/@(!|.)\@i.використання 16 байт. Він утворює ті самі двочленні коефіцієнти уздовж таблиці, яку ви створюєте, за !/~винятком того, що він утворює, використовуючи префікси i..
— милі
4

Pyth, 13 байт

u*Gs=[sZhZ)Q1

Демонстрація

Це використовує розумний, нетиповий трюк. П’ять символів ( u*G ... Q1) кажуть, що вихід є добутком багатьох вхідних чисел. Решта коду генерує числа.

=[sZhZ)оновлює змінну Zдо списку [s(Z), h(Z)]. Потім sпідсумовує цей список, який потрібно помножити.

Zспочатку 0. s, на ints, це функція ідентичності. h, за своєю суттю - це + 1функція. Так на першій ітерації Zстає [0, 1]. sу списках - це сума, як згадувалося вище. h- це функція голови. Отже, друга ітерація [1, 0].

Ось список:

Iter  Z          Sum
0     0          Not used
1     [0, 1]     1
2     [1, 0]     1
3     [1, 1]     2
4     [2, 1]     3
5     [3, 2]     5

Ці суми множать, щоб дати результат.

— isaacg
джерело
4

Mathematica 25 24 байти

З подякою Мартіну Ендеру.

1##&@@Fibonacci@Range@#&

1##&@@Fibonacci@Range@#&@100

Час часу: 63 мікросекунди.

{0.000063, 
3371601853146468125386964065447576689828006172937411310662486977801540
6711385898686165008341900290675836651822917015531720110825745874313823
1009903039430687777564739516714333248356092511296002464445971530050748
1235056111434293619038347456390454209587101225261757371666449068625033
9995735521655245297254676280601708866020010771376138030271586483293355
0772869860576999281875676563330531852996518618404399969665040724619325
7877568825245646129366994079739720698147440310773871269639752334356493
6789134243905645353892122400388956268116279491329780860702550826683922
9003714114129148483959669418215206272639036409444764264391237153249138
8089634845995941928089653751672688740718152064107169357399466473375804
9722605947689699525073466941890502338235963164675705844341280523988912
2373033501909297493561702963891935828612435071136036127915741683742890
4150054292406756317837582840596331363581207781793070936765786629772999
8328572573496960944166162599743042087569978353607028409125185326833249
36435856348020736000000000000000000000000}
— DavidC
джерело
По черзі, з тим же числом байтів:1##&@@Fibonacci~Array~#&
— Грег Мартін
4

Желе, 8 байт

RḶUc$S€P

Моє перше подання в Jelly. Це не так коротко, як @Dennis ' відповідь , але його тільки 2 байта більше з іншим методом.

Місцево вимагає приблизно 400 мс порівняно з 380 мс з версією @Dennis для n = 100.

Спробуйте в Інтернеті!

Пояснення

RḶUc$S€P  Input: n
R         Generate the range [1, 2, ..., n]
          For each value x in that range
 Ḷ          Create another range [0, 1, ..., x-1]
  U         Reverse that list
   c        Compute the binomial coefficients between each pair of values
    $       Bind the last two links (Uc) as a monad
     S€   Sum each list of binomial coefficients
          This will give the first n Fibonacci numbers
       P  Take the product of those to compute the nth Fibonacci-orial
— миль
джерело
3

PARI / GP, 29 байт

f=n->prod(i=1,n,fibonacci(i))

Або в якості альтернативи:

f=n->prod(i=a=!b=0,n,b=a+a=b)
— примо
джерело
3

R, 99 96 78 76 66 байт

У цій відповіді використовується формула Біне , а також prod(x)функція. Оскільки R не має вбудованого Phiзначення, я сам його визначив:

p=(1+sqrt(5))/2;x=1;for(n in 1:scan())x=x*(p^n-(-1/p)^n)/sqrt(5);x

Він працює за 5 секунд, але R прагне дати Infвідповідь на великі цифри ...

Безголовки:

r=sqrt(5)
p=(1+r)/2 
x=1
for(n in 1:scan())        
    x=x*(p^n-(-1/p)^n)/r    
x

-2 байти завдяки @Cyoce!
О, я люблю цей сайт! -10 байт завдяки @ user5957401

— Фредерік
джерело
Ви можете трохи заощадити, зберігаючи sqrt(5)змінну
— Cyoce
оскільки ви використовуєте лише Nодин раз, ви можете просто викликати сканування всередині 1:Nбіта. тобто for(n in 1:scan()). Ви також можете зберегти кілька символів, просто скориставшись *замість prod()функції в циклі для циклу. Ваш цикл для циклу - лише один рядок, тому фігурні дужки вам також не потрібні.
— користувач5957401
Приємна ідея використовувати формулу Біне. У вашому дусі, але всього 53 байтиfunction(n,N=1:n,p=5^.5)prod(((1+p)^N-(1-p)^N)/2^N/p)
— Майкл М,
3

R, 82 , 53 , 49 байт (48 байт з різним стилем введення)

b=d=1;a=0;for(i in 1:scan()){d=d*b;b=a+b;a=b-a};d

Якщо ми можемо просто передувати коду з вхідним номером, ми отримаємо 48 байт

->n;b=d=1;a=0;for(i in 1:n){d=d*b;b=a+b;a=b-a};d

EDIT: Новий код. Оригінал нижче:

a=function(n)ifelse(n<3,1,{v=c(1,1,3:n);for(i in 3:n)v[i]=v[i-1]+v[i-2];prod(v)})

Не поверне нічого, крім Inf a(100) хоча. І це не буде працювати ні для чого, крім негативних цілих чисел.

Безголівки:

a=function(n){
   if(n<3) return(1)
   v=c(1,1,3:n)
   for(i in 3:n)
       v[i]=v[i-1]+v[i-2]
   prod(v)
}
— user5957401
джерело
3

Java, 165 байт

Гольф:

BigInteger f(int n){BigInteger[]a={BigInteger.ZERO,BigInteger.ONE,BigInteger.ONE};for(int i=0;i<n;){a[++i%2]=a[0].add(a[1]);a[2]=a[2].multiply(a[i%2]);}return a[2];}

Це ще один випадок, коли BigIntegerце вимагається через велику кількість. Однак я зміг зберегти текстBigInteger до мінімуму, не зменшуючи розмір. Я також порівняв зі статичним імпортом, і це зробило загальну довжину довшою.

Ця програма працює, відстежуючи три числа в масиві. Перші два - це попередні два числа Фібоначчі. Третє - накопичене значення. Цикл починається з обчислення наступного значення і зберігання його в чергуванні (0, 1, 0, 1, ...) індексів масиву. Це дозволяє уникнути необхідності зміщення значень на дорогі (з точки зору розміру джерела) операції з призначення. Потім візьміть це нове значення і помножте його на акумулятор.

Уникаючи тимчасових об'єктів і обмежуючи цикл двома операторами присвоєння, я зміг витіснити досить багато байтів.

Безголівки:

import java.math.BigInteger;

public class Fibonacci_orial {

  public static void main(String[] args) {
    // @formatter:off
    String[][] testData = new String[][] {
      { "1", "1" },
      { "2", "1" },
      { "3", "2" },
      { "4", "6" },
      { "5", "30" },
      { "6", "240" },
      { "7", "3120" },
      { "8", "65520" },
      { "9", "2227680" },
      { "10", "122522400" },
      { "11", "10904493600" },
      { "12", "1570247078400" },
      { "13", "365867569267200" },
      { "14", "137932073613734400" },
      { "15", "84138564904377984000" },
      { "16", "83044763560621070208000" },
      { "17", "132622487406311849122176000" },
      { "18", "342696507457909818131702784000" },
      { "19", "1432814097681520949608649339904000" },
      { "20", "9692987370815489224102512784450560000" },
      { "100", "3371601853146468125386964065447576689828006172937411310662486977801540671138589868616500834190029067583665182291701553172011082574587431382310099030394306877775647395167143332483560925112960024644459715300507481235056111434293619038347456390454209587101225261757371666449068625033999573552165524529725467628060170886602001077137613803027158648329335507728698605769992818756765633305318529965186184043999696650407246193257877568825245646129366994079739720698147440310773871269639752334356493678913424390564535389212240038895626811627949132978086070255082668392290037141141291484839596694182152062726390364094447642643912371532491388089634845995941928089653751672688740718152064107169357399466473375804972260594768969952507346694189050233823596316467570584434128052398891223730335019092974935617029638919358286124350711360361279157416837428904150054292406756317837582840596331363581207781793070936765786629772999832857257349696094416616259974304208756997835360702840912518532683324936435856348020736000000000000000000000000" }
    };
    // @formatter:on

    for (String[] data : testData) {
      System.out.println("Input: " + data[0]);
      System.out.println("Expected: " + data[1]);
      System.out.print("Actual:   ");
      System.out.println(new Fibonacci_orial().f(Integer.parseInt(data[0])));
      System.out.println();
    }
  }

  // Begin golf
  BigInteger f(int n) {
    BigInteger[] a = { BigInteger.ZERO, BigInteger.ONE, BigInteger.ONE };
    for (int i = 0; i < n;) {
      a[++i % 2] = a[0].add(a[1]);
      a[2] = a[2].multiply(a[i % 2]);
    }
    return a[2];
  }
  // End golf

}

Вихід програми:

Input: 1
Expected: 1
Actual:   1

Input: 2
Expected: 1
Actual:   1

Input: 3
Expected: 2
Actual:   2

Input: 4
Expected: 6
Actual:   6

Input: 5
Expected: 30
Actual:   30

Input: 6
Expected: 240
Actual:   240

Input: 7
Expected: 3120
Actual:   3120

Input: 8
Expected: 65520
Actual:   65520

Input: 9
Expected: 2227680
Actual:   2227680

Input: 10
Expected: 122522400
Actual:   122522400

Input: 11
Expected: 10904493600
Actual:   10904493600

Input: 12
Expected: 1570247078400
Actual:   1570247078400

Input: 13
Expected: 365867569267200
Actual:   365867569267200

Input: 14
Expected: 137932073613734400
Actual:   137932073613734400

Input: 15
Expected: 84138564904377984000
Actual:   84138564904377984000

Input: 16
Expected: 83044763560621070208000
Actual:   83044763560621070208000

Input: 17
Expected: 132622487406311849122176000
Actual:   132622487406311849122176000

Input: 18
Expected: 342696507457909818131702784000
Actual:   342696507457909818131702784000

Input: 19
Expected: 1432814097681520949608649339904000
Actual:   1432814097681520949608649339904000

Input: 20
Expected: 9692987370815489224102512784450560000
Actual:   9692987370815489224102512784450560000

Input: 100
Expected: 3371601853146468125386964065447576689828006172937411310662486977801540671138589868616500834190029067583665182291701553172011082574587431382310099030394306877775647395167143332483560925112960024644459715300507481235056111434293619038347456390454209587101225261757371666449068625033999573552165524529725467628060170886602001077137613803027158648329335507728698605769992818756765633305318529965186184043999696650407246193257877568825245646129366994079739720698147440310773871269639752334356493678913424390564535389212240038895626811627949132978086070255082668392290037141141291484839596694182152062726390364094447642643912371532491388089634845995941928089653751672688740718152064107169357399466473375804972260594768969952507346694189050233823596316467570584434128052398891223730335019092974935617029638919358286124350711360361279157416837428904150054292406756317837582840596331363581207781793070936765786629772999832857257349696094416616259974304208756997835360702840912518532683324936435856348020736000000000000000000000000
Actual:   3371601853146468125386964065447576689828006172937411310662486977801540671138589868616500834190029067583665182291701553172011082574587431382310099030394306877775647395167143332483560925112960024644459715300507481235056111434293619038347456390454209587101225261757371666449068625033999573552165524529725467628060170886602001077137613803027158648329335507728698605769992818756765633305318529965186184043999696650407246193257877568825245646129366994079739720698147440310773871269639752334356493678913424390564535389212240038895626811627949132978086070255082668392290037141141291484839596694182152062726390364094447642643912371532491388089634845995941928089653751672688740718152064107169357399466473375804972260594768969952507346694189050233823596316467570584434128052398891223730335019092974935617029638919358286124350711360361279157416837428904150054292406756317837582840596331363581207781793070936765786629772999832857257349696094416616259974304208756997835360702840912518532683324936435856348020736000000000000000000000000
2

Рубін, 39 байт

->n{f=i=b=1;n.times{f,i,b=i,f+i,b*f};b}
— Лінн
джерело
36: -> n {f = i = b = 1; n.times {b * = f; i = f + f = i}; b}
— GB
2

Javascript (ES6), 51 39 байт

Рекурсивна реалізація (39 байт)

f=(n,a=p=i=b=1)=>++i<n?f(n,b,p*=b+=a):p

Оригінальна реалізація (51 байт)

n=>{for(i=a=b=p=1;++i<n;){c=a;a=b;p*=b+=c}return p}

Примітка: Починає помилки округлення для орієнтала Фібоначчі 16, 100 - це просто нескінченність, працює за тим, що, здається, <1 секунда.

— Пандакодер
джерело
Я створив альтернативну 53-байтну версію n=>[...Array(n)].reduce(p=>(c=a,a=b,p*=b+=c),a=1,b=0)лише для того, щоб виявити, що ви порахували ту, f=що не потрібно, щоб заощадити 2 байти.
— Ніл
Справедлива точка. Моє обгрунтування було таким, що його можна було називати та використовувати повторно, а не просто називати.
— Pandacoder
Звичайно, але якщо хтось хоче його повторно використати, він все ще має можливість назвати його.
— Ніл
@Neil Ну тепер я перейшов і повторно реалізував це, і тепер f = обов'язковий, інакше він фактично не може виконати. : D
— Pandacoder
Ну принаймні ви фіксували кількість байтів для оригінальної реалізації.
— Ніл
2

DC (аромат GNU або OpenBSD) , 36 байт

Файл A003266-v2.dc:

0sA1sB1?[1-d0<LrlBdlA+sBdsA*r]dsLxrp

(немає останнього рядка)

... тепер результат тримається на стеці замість використання названого регістра (є Yу версії 1). rКоманда недоступна в оригіналіdc (див стор Dc RosettaCode в ).

Виконати:

$ time dc -f A003266-v2.dc <<< 100
337160185314646812538696406544757668982800617293741131066248697780154\
067113858986861650083419002906758366518229170155317201108257458743138\
231009903039430687777564739516714333248356092511296002464445971530050\
748123505611143429361903834745639045420958710122526175737166644906862\
503399957355216552452972546762806017088660200107713761380302715864832\
933550772869860576999281875676563330531852996518618404399969665040724\
619325787756882524564612936699407973972069814744031077387126963975233\
435649367891342439056453538921224003889562681162794913297808607025508\
266839229003714114129148483959669418215206272639036409444764264391237\
153249138808963484599594192808965375167268874071815206410716935739946\
647337580497226059476896995250734669418905023382359631646757058443412\
805239889122373033501909297493561702963891935828612435071136036127915\
741683742890415005429240675631783758284059633136358120778179307093676\
578662977299983285725734969609441661625997430420875699783536070284091\
2518532683324936435856348020736000000000000000000000000

real    0m0.005s
user    0m0.004s
sys     0m0.000s

Спроба пояснити:

tos- це вміст верхньої частини стека, не виймаючи його.
nos- елемент нижче tos.

0 sA # push(0) ; A=pop()
1 sB # push(1) ; B=pop()
1    # push(1)
     # this stack position will incrementally hold the product
?    # push( get user input and evaluate it )
[    # start string
 1-  # push(pop()-1)
 d   # push(tos)
 0   # push(0)
 <L  # if pop() < pop() then evaluate contents of register L
 r   # exchange tos and nos
     # now nos is the loop counter
     # and tos is the bucket for the product of the fibonacci numbers
 lB  # push(B)
 d   # push(tos)
 lA  # push(A)
 +   # push(pop()+pop())
     # now tos is A+B, nos still is B 
 sB  # B=pop()
     # completes B=A+B
 d   # push(tos)
 sA  # A=pop()
     # completes B=A
     # tos (duplicated new A from above) is the next fibonacci number
 *   # push(nos*tos)
     # tos now is the product of all fibonacci numbers calculated so far
 r   # exchange tos and nos
     # now tos is the loop counter, nos is the product bucket
]    # end string and push it
d    # push(tos)
sL   # L=pop()
x    # evaluate(pop())
r    # exchange tos and nos
     # nos now is the former loop counter
     # tos now is the complete product. \o/
p    # print(tos)
     # this does not pop() but who cares? :-P

Постійного струму , 41 байт

... прямо, без хитрощів:

Файл A003266-v1.dc:

0sA1sB1sY?[1-d0<LlBdlA+sBdsAlY*sY]dsLxlYp

(немає останнього рядка)

Виконати:

$ for i in $(seq 4) ; do dc -f A003266-v1.dc <<< $i ; done
1
1
2
6
$ time dc -f A003266-v1.dc <<< 100
337160185314646812538696406544757668982800617293741131066248697780154\
067113858986861650083419002906758366518229170155317201108257458743138\
231009903039430687777564739516714333248356092511296002464445971530050\
748123505611143429361903834745639045420958710122526175737166644906862\
503399957355216552452972546762806017088660200107713761380302715864832\
933550772869860576999281875676563330531852996518618404399969665040724\
619325787756882524564612936699407973972069814744031077387126963975233\
435649367891342439056453538921224003889562681162794913297808607025508\
266839229003714114129148483959669418215206272639036409444764264391237\
153249138808963484599594192808965375167268874071815206410716935739946\
647337580497226059476896995250734669418905023382359631646757058443412\
805239889122373033501909297493561702963891935828612435071136036127915\
741683742890415005429240675631783758284059633136358120778179307093676\
578662977299983285725734969609441661625997430420875699783536070284091\
2518532683324936435856348020736000000000000000000000000

real    0m0.006s
user    0m0.004s
sys     0m0.004s
1
* зітхнути! * ... писати dcкод, безумовно, простіше, ніж пояснити його ...
1
Так, нам справді потрібен IDE з якимось шаленим гаджетом для візуалізації з декількома стеками ... це було б солодко.
— Джо
1
У мене є кілька ідей, що додати як нові команди, але, здається, ідея з найбільшим впливом: Додати команду "змінити стек за замовчуванням". ;-)
2
... або поміняти за замовчуванням стек з іменованим регістром. Це зробило б більше вузлів у мозку користувачів, але не знадобиться стек за замовчуванням, щоб мати ім’я ...] :-)
1
Так, це точно було б корисно! Я також хотів би очистити один елемент, обертати елементи, які не знаходяться у верхній частині стека, і, можливо, перенести верхні nелементи в інший стек одразу. Поки що, я все ще не знаю, як компілювати dcз джерела. : /
— Джо
2

C # 110 109 107 103 101 94 байт

using i=System.Numerics.BigInteger;i f(i n){i a=0,b=1,x=1;for(;n-->0;)x*=a=(b+=a)-a;return x;}

Пояснення

//Aliasing BigInteger saves a few bytes
using i=System.Numerics.BigInteger;

//Since BigInteger has an implicit from int we can also change the input
//and save two more bytes.
i f(i n)
{
    //using an alternative iterative algorithm (link to source below) to cut out the temp variable
    //b is next iteration, a is current iteration, and x is the running product
    i a = 0, b = 1, x = 1; 

    //post decrement n down to zero instead of creating a loop variable
    for (; n-- > 0;)

        //The bracket portion sets the next iteration             
        //get the current iteration and update our running product
        x *= a = (b += a) - a;

    return x;
}

Ітеративний алгоритм Fib

— JustinM - Відновлення Моніки
джерело
Враховуючи, що це було набагато краще, ніж я очікував, я хотів знайти максимум N, який повернеться за 5 секунд, я вийшов з 1540, що дає число, яке становить 247441 цифру.
— JustinM
Вражає. Скільки часу потрібно 1541 для обчислення з цікавості?
— Пандакодер
@Pandacoder Отже, з недавньою зміною алгоритму це стало значно швидше. 1541 за 755 мс, тому я зараз збираюся знайти новий суб 5 макс.
— JustinM
@Pandacoder, тож час запуску змінюється на досить-таки трохи - 100 мс, але 2565, здається, в середньому близько 5 секунд
— JustinM - Відновити Моніку
Скільки часу для цього число?
— Pandacoder
2

Мозок-Флак , 54 байти

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

Спробуйте в Інтернеті!

Помноження в «Мозковий Флак» вимагає тривалого часу для великих вкладень. Просто множення F 100 на F 99 за алгоритмом загального множення зайняло б мільярди років.

На щастя, є більш швидкий шлях. Узагальнена послідовність Фібоначчи, що починається з (k, 0), генерує ті ж умови, що і звичайна послідовність, помножена на k. Використовуючи це спостереження, Мозок-Флак може множитися на число Фібоначчі так само легко, як і може генерувати числа Фібоначчі.

Якщо стек складається з -nдвох чисел, {({}()<([({})]({}{}))>)}{}{}обчислить nітерації узагальненої послідовності Фібоначчі і відкине всі останніми. У решті програми просто встановлюється початковий 1 і проходить через нього всі числа в діапазоніn...1 .

Ось такий же алгоритм в інших мовах, що надаються цим перекладачем:

Brain-Flak Classic, 52 байти

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

Спробуйте в Інтернеті!

Мозок-димохід, 58 байт

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

Спробуйте в Інтернеті!

Mini-Flak, 62 байти

([{}()](())){(({})()({({}()([({})]({}{}))[({})])}{}{})[{}])}{}

Спробуйте в Інтернеті!

— Нітродон
джерело
1

Mathematica - 32 26 байт

Fibonacci@i~Product~{i,#}&

@MartinEnder нарізав 6 байт!

— Yytsi
джерело
1

Мозг-Флак , 110 104 100 байт

Спробуйте в Інтернеті!

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

Пояснення

Спочатку ми запускаємо вдосконалену версію генератора послідовностей Фібоначчі з доктора Грін Яйця та Залізної людини

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

Тоді, поки стек містить більше одного елемента на ньому

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

помножте два найбільші пункти

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

і спливай зайвий нуль

{}
— Пшеничний майстер
джерело
1
На жаль, я вважаю, що це недійсно, оскільки для введення інформації потрібно більше 10 секунд. Алгоритм дуже неефективний (як і мова), тому обчислення його на 100, ймовірно, займе години.
— DJMcMayhem
1

Clojure, 70 байт

Clojure насправді не є гарною мовою для кодового гольфу. Ну добре.

Спробуйте це на веб-сайті http://tryclj.com .

(last(nth(iterate(fn[[a b r]][b(+ a b)(* r(+ a b))])[0N 1 1])(dec n)))
— користувач16973
джерело
1

JavaScript (ES6), 46 байт

f=(n,a=1,b=1,c=i=1)=>n==i?c:f(n,b,a+b,c*b,++i)

Використовує рекурсійні та акумуляторні змінні. Помилки округлення починаються з f(16).

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