Механизмы передают различное количество скоростей, в зависимости от размера зубчатой ​​передачи.

У Джека есть машина, которая вращает зубчатую передачу. но вы не знаете скорость последней передачи.

К счастью, вы отличный игрок в код, так что вы можете помочь ему!

И что же мне делать?

Каждая шестерня представлена ​​двумя числами: радиус внутренней шестерни и радиус внешней шестерни.

Если шестеренка Aесть [a,b]и шестеренка Bесть [c,d], то соотношение между скоростью Aи скоростью Bбудет c:b.

Учитывая список передач (список из 2-х кортежей), выведите скорость последней передачи.

Можно предположить, что скорость первой передачи равна 1.

Разработанный пример

Допустим, наш вклад [[6,12],[3,10],[5,8]].

Первая передача, [6,12]будет иметь скорость 1.

Тогда вторая передача [3,10]будет иметь скорость 1*12/3 = 4.

Тогда последняя передача [5,8]будет иметь скорость 4*10/5 = 8.

Testcases

input                    output
[[1,1],[2,2]]            0.5     (1/2)
[[1,2],[1,2],[1,2]]      4       (2/1*2/1)
[[6,12],[3,10],[5,8]]    8       (12/3*10/5)

правила

Применяются основные правила игры в гольф .

Haskell, 19 байтов

foldr1(/).tail.init

Учитывая плоский список , как [a,b,c,d,e,f], tail.initудаляет первые и последние элементы, а затем foldr1(/)создает каскад разделений , b/(c/(d/e))))который работает, чтобы чередующиеся *и /: b/c*d/e.

Желе , 6 байт

ḊṖU÷@/

Тестирование.

ḊṖU÷@/   Main monadic chain. temp <- third argument (first input)
Ḋ        temp <- temp with first element removed
 Ṗ       temp <- temp with last element removed
  U      temp <- temp reversed
   ÷@/   temp <- temp reduced by reversed floating-point division.
         implicitly output temp.

Желе , 7 байт

U÷Ḣµ2\P

Попробуйте онлайн! или проверьте все контрольные примеры .

C 115 123 121 83 80 76 71 70 байт

4 байта сохранены благодаря @LeakyNun!

Мой первый гольф, наверное, не самый лучший.

c;float r=1;float g(a,s)int*a;{for(;c<s-2;)r*=a[++c]/a[++c];return r;}

Принимает массив и размер.

Ungolfed:

int counter;
float ret=1;
float gear(int *arr, int size) {
    for(; counter < size-2; )
        ret = ret * arr[++counter] / arr[++counter];
    return ret;
}

JavaScript (ES6), 44 байта

a=>(t=1,a.reduce((x,y)=>(t*=x[1]/y[0],y)),t)

37 байтов для уплощенного массива:

a=>1/a.slice(1,-1).reduce((x,y)=>y/x)

В отличие от (например) Haskell, reduceRightэто такое длинное имя, что оно дешевле reduceв неправильном направлении и принимает ответное в конце.

Pyth, 8 байт

.UcZb_Pt

Тестирование.

J, 8 байт

%/@}:@}.

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

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

>> f =: %/@}:@}.

>> f 1 1 2 2
<< 0.5

>> f 1 2 1 2 1 2
<< 4

>> f 6 12 3 10 5 8
<< 8

где >>STDIN и <<STDOUT.

объяснение

«Уменьшить» по Jумолчанию справа налево, что позволило снять несколько байтов: p

divide       =: %
reduce       =: /
atop         =: @
remove_first =: }.
remove_last  =: }:

f =: (divide reduce) atop (remove_last) atop (remove_first)

Mathematica, 26 байтов

#2/#&~Fold~#[[-2;;2;;-1]]&

Неименованная функция, которая принимает плоский список значений четной длины и возвращает точный результат (в виде дроби, если необходимо).

Это использует тот же подход, что и некоторые другие ответы сворачивания деления по перевернутому списку (после удаления первого и последнего элемента).

MATL , 9 байт

6L)9L&)/p

Формат ввода любой из этих:

[[6,12],[3,10],[5,8]]
[6,12,3,10,5,8]
[6 12 3 10 5 8]

РЕДАКТИРОВАТЬ (30 июля 2016 г.): связанный код заменяется 9Lна, 1Lчтобы адаптироваться к последним изменениям в языке.

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

объяснение

6L    % Predefined literal: index from second to second-last element
)     % Apply index to implicit input. Removes first and last elements
9L    % Predefined literal: index for elements at odd positions
&)    % Two-output indexing. Gives an array with the odd-position elements
      % and the complementary array, with the even-position elements of the
      % original array
/     % Divide those two arrays element-wise
p     % Product of all entries. Implicitly display

JavaScript, 54 байта

(a,s=1)=>a.map((v,i)=>s*=(x=a[i+1])?v[1]/x[0]:1).pop()

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

f=(a,s=1)=>a.map((v,i)=>s*=(x=a[i+1])?v[1]/x[0]:1).pop()

document.write([
  f([[1,1],[2,2]]),
  f([[1,2],[1,2],[1,2]]),
  f([[6,12],[3,10],[5,8]])
].join('<br>'))

Ungolfed

function ( array ) {
  var s = 1;                                  // Set initial speed

  for ( var i = 0; i < array.length ; i++ ) { // Loop through array
    if ( array[i + 1] === undefined ) {       // If last element
      return s;                               // Return speed
    } else {                                  // Else
      s = s * ( array[i][0] / array[i+1][0])  // Calculate speed
    }
  }
}

Конечно, гольф-вариант немного отличается. С помощью .map()он заменяет первое значение массива на скорость после второго колеса, второе значение на скорость третьего колеса, а последнее значение и второе последнее значение на скорость последнего колеса. Итак, мы просто берем последний элемент с .pop().

PHP, 80 79 69 байт

<?for($r=1;++$i<count($a=$_GET[a]);)$r*=$a[$i-1][1]/$a[$i][0];echo$r;

принимает входные данные из параметра GET a ; результат печати

инициализируется $rс 1, затем переходит от второго к последнему кортежу для умножения на первый элемент предыдущего и деления на второй элемент текущего кортежа.

Спасибо Йорг за напоминание о $_GET; это сэкономило 7 байтов.

более элегантная версия, 88 байт:

<?=array_reduce($a=$_GET[a],function($r,$x){return$r*$x[1]/$x[0];},$a[0][0]/end($a)[1]);

JavaScript, 59 58 56 байт

a=>a.reduce((p,c)=>p*c[1]/c[0],a[0][0]/a[a.length-1][1])

объяснение

Уменьшите массив и умножьте на каждое второе значение и разделите на каждое первое значение. Так и для [[6,12],[3,10],[5,8]]этого 12/6*10/3*8/5. Конечно, реальное вычисление, которое мы хотели, состояло в том, 12/3*10/5что мы просто хотим игнорировать это первое /6и последнее *8путем умножения *6обратно и деления /8обратно. Это устранение делается путем установки 6/8в качестве начального значения для уменьшения.

Python 2, 52 байта

lambda x:reduce(lambda x,y:y/float(x),x[1:-1][::-1])

Анонимная функция, которая принимает вход сплющенного списка через аргумент и возвращает результат.

Это использует идею каскадного деления, как в ответе xnor .

Попробуйте это на Ideone

Python 3, 59 байт

lambda x:eval('/'.join('{}*{}'.format(*i)for i in x)[2:-2])

Анонимная функция, которая принимает ввод не сплющенного списка через аргумент и возвращает вывод.

Как это устроено

Для каждой пары целых чисел на входе создается строка вида 'int1*int2'. Соединение всех этих пар /дает строку вида'int1*int2/int3*int4/...' , которая является желаемым вычислением, но включает нежелательные первое и последнее целые числа. Они удаляются путем вырезания первых двух и двух последних символов в строке, оставляя желаемый расчет. Это затем оценивается и возвращается.

Попробуйте это на Ideone

Паскаль, 88 байт

Рекурсивная (должна была это сделать ..) функция, которая принимает статический 2D-массив и его длину (количество строк) в качестве входных данных. Использование некоторого математического указателя на массив.

function r(a:p;n:integer):double;begin r:=a[1]/a[2];if n=2then exit;r:=r*r(a+2,n-1);end;

Разобраться с примером использования:

type
  p = ^double;
var
  n: integer = 3;
  garray: array [0..2, 0..1] of double;

function ratio(a: p; n: integer): double;
begin
  ratio := a[1] / a[2];
  if n=2 then
    Exit;
  ratio := ratio * ratio(a+2, n-1);
end;

begin
  garray[0,0] := 6; garray[0,1] := 12;
  garray[1,0] := 3; garray[1,1] := 10;
  garray[2,0] := 5; garray[2,1] := 8;
  writeln(ratio(@garray, n));
end.

На самом деле, 14 байтов

pXdX2@╪k`i/`Mπ

Попробуйте онлайн! (в настоящее время не работает, потому что TIO отстает от нескольких версий)

Эта программа принимает плоский список в качестве входных данных.

Объяснение:

pXdX2@╪k`i/`Mπ
pXdX            remove the first and last elements
    2@╪k        push a list where each element is a list containing every two elements of the original list (chunk into length-2 lists)
        `i/`M   map division over each sublist
             π  product

R, 64 байта

Получается, что векторизованный подход и forцикл эквивалентны в этом случае:

x=scan();prod(sapply(1:(sum(1|x)/2-1)*2,function(i)x[i]/x[i+1]))

или forцикл:

x=scan();for(i in 1:(sum(1|x)/2-1)*2)T=c(T,x[i]/x[i+1]);prod(T)}

`