Шестірні передають різну кількість швидкостей, залежно від розміру сітчастої передачі.

У Джека є машина, яка обертає шестерню. але ти не знаєш швидкості останньої передачі.

На щастя, ви чудовий гольфіст з кодом, тому можете допомогти йому!

Отже, що мені робити?

Кожна передача представлена ​​2 числами, радіусом внутрішньої передачі та радіусом зовнішніх передач.

Якщо передача 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.

Тестові шафи

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)

Правила

Діють основні правила гольф-коду .

Хаскелл, 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;}

Займає масив та розмір.

Безголівки:

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)

Математика, 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]

EDIT (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>'))

Безумовно

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)}

`