Los engranajes transfieren diferentes cantidades de velocidades, dependiendo del tamaño del engranaje engranado.

Jack tiene una máquina que gira un tren de engranajes. pero no sabes la velocidad de la última marcha.

Afortunadamente, eres un gran jugador de código, ¡así que puedes ayudarlo!

¿Entonces qué debo hacer?

Cada engranaje está representado por 2 números, el radio del engranaje interno y el radio de los engranajes externos.

Si el engranaje Aes [a,b]y el engranaje Bes [c,d], entonces la relación entre la velocidad de Ay la velocidad de Bsería c:b.

Dada una lista de engranajes (lista de 2 tuplas), genera la velocidad del último engranaje.

Puede suponer que la velocidad de la primera marcha es 1.

Ejemplo resuelto

Digamos que nuestra entrada es [[6,12],[3,10],[5,8]].

La primera marcha, [6,12]tendría una velocidad de 1.

Entonces, la segunda marcha [3,10], tendría una velocidad de 1*12/3 = 4.

Entonces, la última marcha [5,8], tendría una velocidad de 4*10/5 = 8.

Casos de prueba

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)

Reglas

Se aplican reglas básicas de código de golf .

Haskell, 19 bytes

foldr1(/).tail.init

Dada una lista plana como [a,b,c,d,e,f], tail.initelimina el primer y el último elemento, y luego foldr1(/)crea una cascada de divisiones b/(c/(d/e))))que funciona alternando* y /: b/c*d/e.

Jalea , 6 bytes

ḊṖU÷@/

Banco de pruebas.

ḊṖ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.

Jalea , 7 bytes

U÷Ḣµ2\P

Pruébalo en línea! o verificar todos los casos de prueba .

C, 115 123 121 83 80 76 71 70 bytes

¡4 bytes guardados gracias a @LeakyNun!

Mi primer golf, probablemente no el mejor.

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

Toma una matriz y un tamaño.

Sin golf:

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 bytes

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

37 bytes para una matriz aplanada:

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

A diferencia de (por ejemplo) Haskell, reduceRightes un nombre tan largo que es más barato por reduceel camino equivocado y toma el recíproco al final.

Pyth, 8 bytes

.UcZb_Pt

Banco de pruebas.

J, 8 bytes

%/@}:@}.

Pruébalo en línea!

Uso

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

>> f 1 1 2 2
<< 0.5

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

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

dónde >> está STDIN y<< es STDOUT.

Explicación

"Reducir" en los Jvalores predeterminados de derecha a izquierda, que despegó algunos bytes: p

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

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

Mathematica, 26 bytes

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

Una función sin nombre que toma una lista plana de valores de longitud par y devuelve el resultado exacto (como una fracción si es necesario).

Esto utiliza el mismo enfoque que algunas otras respuestas de división plegable sobre la lista inversa (después de eliminar el primer y último elemento).

MATL , 9 bytes

6L)9L&)/p

El formato de entrada es cualquiera de estos:

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

EDITAR (30 de julio de 2016): el código vinculado se reemplaza 9Lpor 1Lpara adaptarse a los cambios recientes en el idioma.

Pruébalo en línea!

Explicación

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 bytes

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

Uso

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

Sin golf

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

Por supuesto, la variante de golf es un poco diferente. Con .map(), reemplaza el primer valor de la matriz con la velocidad después de la segunda rueda, el segundo valor con la velocidad de la tercera rueda, y el último valor y el segundo último valor con la velocidad de la última rueda. Entonces, simplemente tomamos el último elemento con .pop().

PHP, 80 79 69 bytes

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

toma la entrada del parámetro GET a ; resultado de impresiones

se inicializa $rcon 1, luego pasa de la segunda a la última tupla para multiplicar con el primer elemento de la anterior y dividir a través del segundo elemento de la tupla actual.

Gracias a Jörg por recordarme $_GET; eso ahorró 7 bytes.

versión más elegante, 88 bytes:

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

JavaScript, 59 58 56 bytes

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

Explicación

Reduzca la matriz y multiplique por cada segundo valor y divida por cada primer valor. Entonces para que [[6,12],[3,10],[5,8]]lo haga 12/6*10/3*8/5. Por supuesto, el cálculo real que queríamos era 12/3*10/5así que solo queremos ignorar eso primero /6y último *8multiplicando *6y dividiendo de /8nuevo. Esa cancelación se realiza estableciendo 6/8como el valor inicial para la reducción.

Python 2, 52 bytes

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

Una función anónima que toma la entrada de una lista aplanada a través de un argumento y devuelve la salida.

Esto hace uso de la idea de la cascada de división, como en la respuesta de xnor .

Pruébalo en Ideone

Python 3, 59 bytes

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

Una función anónima que toma la entrada de una lista no aplanada a través de un argumento y devuelve la salida.

Cómo funciona

Por cada par de enteros en la entrada, 'int1*int2'se crea una cadena del formulario . Unir todos estos pares /proporciona una cadena de la forma 'int1*int2/int3*int4/...', que es el cálculo deseado, pero incluye los primeros y últimos enteros no deseados. Estos se eliminan cortando los primeros dos y últimos dos caracteres en la picadura, dejando el cálculo deseado. Esto luego se evalúa y se devuelve.

Pruébalo en Ideone

Pascal, 88 bytes

Una función recursiva (tenía que hacerlo ...) que toma una matriz 2D estática y su longitud (no. De filas) como entrada. Usando algunas matemáticas de puntero en la matriz.

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;

Ungolfed con ejemplo de uso:

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.

En realidad, 14 bytes

pXdX2@╪k`i/`Mπ

Pruébalo en línea! (actualmente no funciona porque TIO tiene algunas versiones detrás)

Este programa toma una lista aplanada como entrada.

Explicación:

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 bytes

Resulta el enfoque vectorizado y el for bucle son equivalentes en este caso:

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

o la for bucle:

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

``