Есть последовательность. Допустим
х[0]=2017
х[1]=2018

и далее рекуррентное выражение х[n+1] = х[n-1]-1/х[n]

Итак, упрется данная последовательность во что-нибудь или зациклится или она бесконечна и сходящаяся/расходящаяся?

(0) Для n > 1 последовательность убывающая.

Хотя нет, это же прямая минус гипербола.

убывающая последовательность не гарантирует сходимость .

а вообще математика же строгая наука..надо от автора узнать что такое "упрется".
Дай определение

Если последовательность закончится,то Х(н+1)=Х(н)
или Х=Х-(1/Х) ответ очевиден
можно еще рассмотреть вариант,когда идут скачки
Х1=Х2-(1/Х1) и Х2=Х1-(1/Х2)

(5)не научно

на компьютере же из за ограниченности разрядной сетки последовательность найдет машинный ноль.

(4) видимо имеется в виду предел последовательности при n стремящемся к бесконечности.

(8) есть признаки сходимости. Даламбера или Коши. Интегральный признак.

(4) специально в этот раз не скажу
проявите собственную фантазию

Что-то из разряда чему равно (x-a)(x-b)...(x-z)
а если
х[0]=2017,0000001
х[1]=2018

(11) результат изменится кардинально

Х[8000001]=-0,00000000000000035203296976519521763926843568
Х[9000000]=12502763442543763254605,67856292239846365202003919
Х[9000001]=-0,000000000000000394288352543365707084127417483
Х[10000000]=13712359097589733057451,55618791239846365202003919
Х[10000001]=-0,000000000000000432434270266615321243204806686

Х[6000000]=7822403641917245403402,83950212639846365202003919
Х[6000001]=-0,000000000000000246688113824696260201613048152
Х[7000000]=9638448892748395083971,76485681539846365202003919
Х[7000001]=-0,000000000000000303959073975501505757024568694
Х[8000000]=11162857849993687829840,34751568639846365202003919
Х[8000001]=-0,00000000000000035203296976519521763926843568
Х[9000000]=12502763442543763254605,67856292239846365202003919
Х[9000001]=-0,000000000000000394288352543365707084127417483
Х[10000000]=13712359097589733057451,55618791239846365202003919
Х[10000001]=-0,000000000000000432434270266615321243204806686

Х[17000000]=20248374756225609613024,49581634139846365202003919
Х[17000001]=-0,000000000000000638554657134869947431192871915
Х[18000000]=21016811808397528052157,69894779939846365202003919
Х[18000001]=-0,000000000000000662788158688950997066623866731
Х[19000000]=21758126686611626450760,20368989539846365202003919
Х[19000001]=-0,000000000000000686166332930980275162751236404
Х[20000000]=22475003342195175242098,79912642039846365202003919
Х[20000001]=-0,000000000000000708773821185297196733865965727

Аналитика:
x[n+1]*x[n] = x[n]*x[n-1]-1
Ряд из произведений соседних членов - линейно убывающий

Из (15) видно, что начиная с некоторого n подпоследовательность с четными номерами монотонно возрастает и больше 0. Подпоследовательность с нечетными номерами монотонно убывает и меньше 0.

+(16)
x[n]*x[n-1] = 2017*2018+1-n=4070307-n

x[n+2] = x[n]*(x[n]*x[n-1] - 2)/(x[n]*x[n-1] - 1)=
=x[n]*(4070305-n)/(4070306-n)

(17)+ К пределу эти последовательности стремиться не будут.

(19) Если не наткнуться на земную ось, точнее машинный ноль... а может и не машинный...

(18)
x[4070307]=0 (Абсолютный математический ноль!)

(21) вот именно

+(21)
x[4070308] очевидно не определено
Решено!

Х[4070301]=2,350546619069195710984191751
Х[4070302]=2,127164787729236405386438455
Х[4070303]=1,880437295255356568787378612
Х[4070304]=1,59537359079692730403986449
Х[4070305]=1,253624863503571045858308432
Х[4070306]=0,79768679539846365202003919
Х[4070307]=-0,000000000000000000141691568
Х[4070308]=7057582988989154245,79768679539846365202003919
Х[4070309]=-0,000000000000000000283383135999999999988532667
Х[4070310]=10586374483483731368,79768679539846365202003919

То есть при попытке непосредственного вычисления (15) компьютер проскочил мимо нуля за счет ошибок округления

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

P.S. Если есть проблемы с пониманием ответа, проявите фантазию.

(24) и потом пошел треш, не все задачи можно на компьютере решать
(0) за задачу спс, решал как 18. Задача как то не на фантазию,  не думая первая же попытка посмотреть н+2

(25) если бы я сразу сказал, что "упрется" это значит не возможно ее продолжить с определенного момента, то была бы слишком явная подсказка на то, что она достигнет 0

(24) Чем считал?
Я на haskell попробовал через тип Rational, но оно долго считает.

(28) 1С 8. Время расчета несколько минут.

&НаКлиенте
Процедура Сформировать(Команда)
    Пер1 = 2017;
    Пер2 = 2018;
    Для нпп = 1 По 4070307 + 3 Цикл
        Пер_ = Пер1 - 1/Пер2;
        Пер1 = Пер2;
        Пер2 = Пер_;
        //Если Нпп % 1000000 = 0 Тогда
        Если Нпп > 4070300 Тогда
            Сообщить("Х[" + Формат(нпп,"ЧДЦ=; ЧГ=") +"]="  + Формат(Пер1,"ЧГ=") );
            //Сообщить("Х[" + Формат(нпп+1,"ЧДЦ=; ЧГ=") +"]="  + Формат(Пер2,"ЧГ=") );
        КонецЕсли;
    КонецЦикла;
КонецПроцедуры

В качестве "наводки".
Вместо разностного соотношения возьмем дифф. уравнение, примерно такое:
dX/dt = -1/X. X(0)=X0 (2017)
Решение: X(t)=SQRT(X0^2-t). При t=X0^2 особенность. Т.е. смахивает на точку бифуркации, но я в этом - ноль.
На бифуркацию намекает и (12) - неустойчивость решения при малом изменении нач. условий.

(29) Так не интересно, в 1С у чисел ограниченная точность.
Rational в Haskell выглядит как пара (Числитель, Знаменатель), где Числитель и Знаменатель типа Integer, который в Haskell имеет произвольную точность.

(31)
>>Числитель и Знаменатель типа Integer
этого явно мало для данной задачи

(28) возьми вводные поменьше, 507 и 508 например

кмк компьютерной точности  не хватит для данной задачи, если только делать Числитель и Знаменатель большими массивами

(32) Почему? В этой задаче иррационального значения не получится.

(33) да теоретически решаема, но разрядность числителя и знаменателя должна быть очень большой

(34) В Haskell тип Integer имеет произвольную (читай "неограниченную") точность.

(35) ааа..., тогда должно работать. Именно это я имел в виду, когда говорил про массивы. В Haskell встроена такая математика, это же должно быть очень медленно. Или там есть другие целые типы для обычных целей?

(36) Там есть Int, который обычный int, и есть Integer. Плюс умный компилятор, который понимает, когда Integer можно преобразовать в Int.

(37) круто. Только очень медленно, цикл 10^6 не должен долго выполняться

(38) Rational в конструкторе упрощает дробь. Ясен пень, это небыстро.