История
Давным-давно Бобби создал биткойн-кошелек с 1 сатоши (1e-8 BTC, самая маленькая единица валюты) и забыл об этом. Как и многие другие, он позже, хотя: «Черт, если бы я вложил больше тогда ...».
Не останавливаясь на мечтах, он посвящает все свое время и деньги на создание машины времени. Он проводит большую часть своего времени в своем гараже, не подозревая о мирских делах и слухах, циркулирующих вокруг него. Он завершает создание прототипа за день до того, как его электричество вот-вот отключится из-за пропущенных платежей. Поднявшись со своего рабочего места, он видит полицейский фургон, подъезжающий к его дому, похоже, что любопытные соседи подумали, что он работает в своей лаборатории, и вызвали полицию.
Не имея времени для проведения тестов, он берет USB-флешку с данными обменного курса за последние годы, подключает конденсатор Flux к квантовому дискомбобулятору и обнаруживает, что его транспортируют обратно в тот день, когда он создал свой кошелек.

Задача
С учетом данных о валютном курсе выяснить, сколько денег может заработать Бобби. Он следует очень простому правилу: «покупай дешево - продавай дорого», и, поскольку он начинает с бесконечно малого капитала, мы предполагаем, что его действия не окажут влияния на обменные курсы в будущем.

Входные данные
Список с плавающей точкой> 0, либо в виде строки, разделенной одним символом (новая строка, табуляция, пробел, точка с запятой, что вы предпочитаете), переданной программе в качестве аргумента командной строки, считанной из текстового файла или STDIN или переданной в качестве параметра к функции. Вы можете использовать числовые типы данных или массивы вместо строки, потому что в основном это просто строка в скобках.

Выходные данные
Коэффициент, на который капитал Bobbys умножается на конец торгов.

пример

Input:  0.48 0.4 0.24 0.39 0.74 1.31 1.71 2.1 2.24 2.07 2.41

Обменный курс: 0,48 $ / BTC, так как он вот-вот упадет, мы продаем все биткойны за 4,8 нанодоллара. Коэффициент = 1 Обменный курс: 0,4, ничего не делать
Обменный курс: 0,24 $ / BTC и повышение: конвертируйте все $ в 2 сатоши. Коэффициент = 1 (стоимость в долларах все еще не изменилась).
Курс обмена: 0,39 - 2,1 долл. США / BTC: ничего не делать
Курс обмена: 2,24 долл. США / BTC: продавать все до падения. 44,8 нанодоллара, коэффициент = 9,33
Обменный курс: 2,07 $ / BTC: купить 2,164 сатоши, коэффициент = 9,33
Обменный курс: 2,41 $ / BTC: купить 52,15 нанодоллара, коэффициент = 10,86

Output: 10.86

Дополнительная информация
Вы можете игнорировать странные граничные случаи, такие как постоянный ввод, нулевые или отрицательные значения, только одно входное число и т. Д. Не
стесняйтесь создавать свои собственные случайные числа для тестирования или использования реальных графиков акций. Вот более длинный ввод для тестирования (ожидаемый вывод прибл. 321903884.638).
Кратко объясните, что делает ваш код.
Графики ценятся, но не нужны

APL, 16 символов

{×/1⌈÷/⊃⍵,¨¯1⌽⍵}

Эта версия использует @Frxstrem «S простой алгоритм и @xnor » сек max(r,1)идею.

Также предполагается, что ряд в целом растет, то есть первое значение биткойна меньше, чем последнее. Это согласуется с описанием проблемы. Чтобы получить более общую формулу, нужно отбросить первую пару ставок, добавив 2 символа:{×/1⌈÷/⊃1↓⍵,¨¯1⌽⍵}

Пример:

    {×/1⌈÷/⊃⍵,¨¯1⌽⍵}  0.48 0.4 0.24 0.39 0.74 1.31 1.71 2.1 2.24 2.07 2.41
10.86634461
    {×/1⌈÷/⊃⍵,¨¯1⌽⍵}  (the 1000 array from pastebin)
321903884.6

Объяснение:

Начнем с данных обменного курса:

    A←0.48 0.4 0.24 0.39 0.74 1.31 1.71 2.1 2.24 2.07 2.41

Соедините каждое число с предыдущим (первое будет связано с последним) и поместите их в матрицу:

    ⎕←M←⊃A,¨¯1⌽A
0.48 2.41
0.4  0.48
0.24 0.4
0.39 0.24
0.74 0.39
1.31 0.74
1.71 1.31
2.1  1.71
2.24 2.1
2.07 2.24
2.41 2.07

Сократите каждую строку делением, оставьте те, у которых отношение> 1, и объедините отношения умножением. Это исключит любые повторяющиеся факторы в ряду последовательных повышающихся ставок, а также ложное соотношение между первым и последним обменными курсами:

    ×/1⌈÷/M
10.86634461

Python, 47

f=lambda t:2>len(t)or max(t[1]/t[0],1)*f(t[1:])

Пример запуска на тестовом примере .

Взять список поплавков. Рекурсивно умножает на коэффициент прибыли от первых двух элементов до тех пор, пока не останется меньше двух элементов. Для базового случая дает, Trueкоторый равен 1.

Использование popдает одинаковое количество символов.

f=lambda t:2>len(t)or max(t[1]/t.pop(0),1)*f(t)

То же самое происходит с конца списка.

f=lambda t:2>len(t)or max(t.pop()/t[-1],1)*f(t)

Для сравнения, мой итерационный код в Python 2 составляет 49 символов, на 2 символа длиннее

p=c=-1
for x in input():p*=max(x/c,1);c=x
print-p

Начнем с того, что c=-1мы пытаемся заставить воображаемый первый «ход» никогда не показывать прибыль. Начиная продукт, -1а не 1позволяет нам назначить оба элемента вместе, и мы отрицательно отменили его обратно перед печатью.

Python, 79 81 76 77 байт

f=lambda x:reduce(float.__mul__,(a/b for a,b in zip(x[1:],x[:-1]) if a>b),1.)

xявляется входом, закодированным в виде списка. Функция возвращает коэффициент.

CJam, 33 байта

q~{X1$3$-:X*0>{\;}*}*](g\2/{~//}/

Это может быть в гольфе дальше.

Принимает участие от STDIN, как

[0.48 0.4 0.24 0.39 0.74 1.31 1.71 2.1 2.24 2.07 2.41]

и выводит коэффициент на STDOUT, как

10.866344605475046

Попробуйте онлайн здесь

Пиф , 18

u*GeS,1ceHhHC,QtQ1

Объяснение:

u                 reduce, G is accumulator, H iterates over sequence
 *G               multiply G by
   eS             max(               
     ,1               1,
       ceHhH            H[1]/H[0])
 C                H iterates over zip(
  ,QtQ                                Q,Q[1:])
 1                G is initialized to 1

max(H[1]/H[0],1) идея благодаря @xnor

C #, 333 , 313

Моя первая попытка Может быть, это может оптимизировать больше, но, как я уже сказал, первая попытка, так что поймете это!

double a(double [] b){var c=0.0;var d=1;for(int i=0;i<b.Count();i++){c=(d==1)?(((i+1)<b.Count()&&b[i+1]<=b[i]&&d==1)?((c==0)?b[i]:b[i]*c):((i+1)>=b.Count()?(c*b[i])/b[0]:c)):((i+1)<b.Count()&&b[i+1]>b[i]&&d==0)?c/b[i]:c;d=((i+1)<b.Count()&&b[i+1]<b[i]&&d==1)?0:((i+1)<b.Count()&&b[i+1]>b[i]&&d==0)?1:d;}return c;}

вход

0.48, 0.4, 0.24, 0.39, 0.74, 1.31, 1.71, 2.1, 2.24, 2.07, 2.41

Выход

10.86

Редактировать: Спасибо DenDenDo за предложение не использовать math.floor для округления и использование int вместо bool для вырезания символов. Будем помнить, что для будущих головоломок!