Les engrenages transfèrent différentes vitesses, selon la taille de l'engrenage maillé.

Jack a une machine qui fait tourner un train d'engrenages. mais vous ne connaissez pas la vitesse du dernier rapport.

Heureusement, vous êtes un grand golfeur de code, vous pouvez donc l'aider!

Donc qu'est ce que je devrais faire?

Chaque engrenage est représenté par 2 chiffres, le rayon de l'engrenage intérieur et le rayon des engrenages extérieurs.

Si la vitesse Aest [a,b]et la vitesse Best [c,d], alors le rapport entre la vitesse de Aet la vitesse de Bserait c:b.

Étant donné une liste de vitesses (liste de 2-tuples), affichez la vitesse du dernier rapport.

Vous pouvez supposer que la vitesse de la première vitesse est 1.

Exemple élaboré

Disons que notre contribution est [[6,12],[3,10],[5,8]].

Le premier rapport [6,12]aurait une vitesse de 1.

Ensuite, le deuxième rapport [3,10]aurait une vitesse de 1*12/3 = 4.

Ensuite, le dernier engrenage [5,8], aurait une vitesse de 4*10/5 = 8.

Cas de test

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)

Règles

Les règles de base du code-golf s'appliquent.

Haskell, 19 octets

foldr1(/).tail.init

Étant donné une liste plate comme [a,b,c,d,e,f], tail.initsupprime les premier et dernier éléments, puis foldr1(/)crée une cascade de divisionsb/(c/(d/e)))) qui fonctionne à alternance *et /: b/c*d/e.

Gelée , 6 octets

ḊṖU÷@/

Suite de tests.

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

Gelée , 7 octets

U÷Ḣµ2\P

Essayez-le en ligne! ou vérifiez tous les cas de test .

C, 115 123 121 83 80 76 71 70 octets

4 octets enregistrés grâce à @LeakyNun!

Mon premier golf, probablement pas le meilleur.

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

Prend un tableau et une taille.

Non 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 octets

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

37 octets pour un tableau aplati:

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

Contrairement à (par exemple) Haskell, reduceRightest un nom si long qu'il est moins cher dans reducele mauvais sens et prend l'inverse à la fin.

Pyth, 8 octets

.UcZb_Pt

Suite de tests.

J, 8 octets

%/@}:@}.

Essayez-le en ligne!

Usage

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

>> f 1 1 2 2
<< 0.5

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

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

où >>est STDIN et <<STDOUT.

Explication

"Réduire" dans les Jvaleurs par défaut de droite à gauche, ce qui a pris quelques octets: p

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

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

Mathematica, 26 octets

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

Une fonction sans nom qui prend une liste plate de valeurs paires et renvoie le résultat exact (sous forme de fraction si nécessaire).

Cela utilise la même approche que certaines autres réponses de division de pliage sur la liste inversée (après avoir supprimé le premier et le dernier élément).

MATL , 9 octets

6L)9L&)/p

Le format d'entrée est l'un de ceux-ci:

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

EDIT (30 juillet 2016): le code lié remplace 9Lpar 1Lpour s'adapter aux évolutions récentes de la langue.

Essayez-le en ligne!

Explication

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 octets

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

Usage

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

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

Bien sûr, la variante golfée est un peu différente. Avec .map(), il remplace la première valeur du tableau par la vitesse après la deuxième roue, la deuxième valeur par la vitesse de la troisième roue, et la dernière valeur et l'avant-dernière valeur par la vitesse de la dernière roue. Donc, nous prenons simplement le dernier élément avec .pop().

PHP, 80 79 69 octets

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

prend l'entrée du paramètre GET a; résultat des impressions

initialise $ravec 1, puis passe de l'avant-dernier au dernier tuple pour se multiplier avec le premier élément du précédent et se diviser par le deuxième élément du tuple actuel.

Merci à Jörg de me l'avoir rappelé $_GET; qui a sauvé 7 octets.

version plus élégante, 88 octets:

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

JavaScript, 59 58 56 octets

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

Explication

Réduisez le tableau et multipliez par chaque seconde valeur et divisez par chaque première valeur. Donc pour [[6,12],[3,10],[5,8]]ça 12/6*10/3*8/5. Bien sûr, le calcul réel que nous voulions était 12/3*10/5donc nous voulons simplement ignorer cela en premier /6et en dernier *8en multipliant *6et en divisant /8. Cette annulation est effectuée en définissant 6/8la valeur initiale de la réduction.

Python 2, 52 octets

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

Une fonction anonyme qui prend l'entrée d'une liste aplatie via un argument et renvoie la sortie.

Cela utilise l'idée de cascade de divisions, comme dans la réponse de xnor .

Essayez-le sur Ideone

Python 3, 59 octets

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

Une fonction anonyme qui prend l'entrée d'une liste non aplatie via un argument et renvoie la sortie.

Comment ça fonctionne

Pour chaque paire d'entiers dans l'entrée, une chaîne du formulaire 'int1*int2'est créée. Joindre toutes ces paires /donne une chaîne de la forme 'int1*int2/int3*int4/...', qui est le calcul souhaité, mais inclut les premier et dernier entiers indésirables. Ceux-ci sont supprimés en découpant les deux premiers et les deux derniers caractères de la piqûre, en laissant le calcul souhaité. Celui-ci est ensuite évalué et renvoyé.

Essayez-le sur Ideone

Pascal, 88 octets

Une fonction récursive (devait le faire ..) qui prend en entrée un tableau 2D statique et sa longueur (nombre de lignes). Utilisation de mathématiques de pointeur sur le tableau.

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 avec un exemple d'utilisation:

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 fait, 14 octets

pXdX2@╪k`i/`Mπ

Essayez-le en ligne! (ne fonctionne pas actuellement car TIO est derrière quelques versions)

Ce programme prend une liste aplatie en entrée.

Explication:

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 octets

Il s'avère que l'approche vectorisée et la forboucle sont équivalentes dans ce cas:

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

ou la forboucle:

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

"