Zahnräder übertragen je nach Größe des kämmenden Zahnrads unterschiedliche Geschwindigkeiten.

Jack hat eine Maschine, die einen Gear Train dreht. aber Sie kennen die Geschwindigkeit des letzten Gangs nicht.

Zum Glück bist du ein großartiger Code-Golfer, also kannst du ihm helfen!

Also was soll ich tun?

Jedes Zahnrad wird durch 2 Zahlen dargestellt, den Radius des inneren Zahnrads und den Radius der äußeren Zahnräder.

Wenn Zahnrad Aist [a,b]und das Zahnrad Bist [c,d], dann ist das Verhältnis zwischen der Geschwindigkeit Aund der Geschwindigkeit Bwäre c:b.

Bei einer Liste von Gängen (Liste mit 2 Tupeln) wird die Geschwindigkeit des letzten Gangs ausgegeben.

Sie können davon ausgehen, dass die Geschwindigkeit des ersten Gangs ist 1.

Beispiel ausgearbeitet

Nehmen wir an, unser Input ist [[6,12],[3,10],[5,8]].

Der erste Gang [6,12]hätte eine Geschwindigkeit von 1.

Dann hätte der zweite Gang [3,10]eine Geschwindigkeit von 1*12/3 = 4.

Dann hätte der letzte Gang [5,8]eine Geschwindigkeit von 4*10/5 = 8.

Testfälle

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)

Regeln

Grundlegende Code-Golf- Regeln gelten.

Haskell, 19 Bytes

foldr1(/).tail.init

Bei einer flachen Liste wie [a,b,c,d,e,f], tail.initentfernt die ersten und letzten Elemente, und dann foldr1(/)schafft eine Kaskade von Spaltungen b/(c/(d/e)))), die abwechselnd ausarbeitet *und /: b/c*d/e.

Gelee , 6 Bytes

ḊṖU÷@/

Testsuite.

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

Gelee , 7 Bytes

U÷Ḣµ2\P

Probieren Sie es online! oder überprüfen Sie alle Testfälle .

C 115 123 121 83 80 76 71 70 Bytes

4 Bytes gespart dank @LeakyNun!

Mein erster Golf, wahrscheinlich nicht der beste.

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

Nimmt ein Array und eine Größe an.

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 Byte

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

37 Bytes für ein abgeflachtes Array:

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

Im Gegensatz zu (zB) Haskell reduceRightist ein so langer Name, dass er in reducedie falsche Richtung billiger ist und am Ende das Gegenteil annimmt.

Pyth, 8 Bytes

.UcZb_Pt

Testsuite.

J, 8 Bytes

%/@}:@}.

Probieren Sie es online!

Verwendung

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

>> f 1 1 2 2
<< 0.5

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

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

wo >>ist STDIN und <<ist STDOUT.

Erläuterung

"Verkleinern" der JStandardeinstellungen von rechts nach links, wodurch einige Bytes verloren gingen: 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]]&

Eine unbenannte Funktion, die eine flache Liste von Werten mit gerader Länge verwendet und das genaue Ergebnis zurückgibt (bei Bedarf als Bruchzahl).

Dies verwendet den gleichen Ansatz wie einige andere Antworten der Faltungsteilung über die umgekehrte Liste (nachdem das erste und das letzte Element entfernt wurden).

MATL , 9 Bytes

6L)9L&)/p

Das Eingabeformat ist eines der folgenden:

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

EDIT (30. Juli 2016): der verknüpften Code ersetzt 9Ldurch 1Ldie jüngsten Änderungen in der Sprache anzupassen.

Probieren Sie es online!

Erläuterung

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 Byte

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

Verwendung

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

Natürlich ist die Golfvariante etwas anders. Mit .map()wird der erste Wert des Arrays durch die Geschwindigkeit nach dem zweiten Rad, der zweite Wert durch die Geschwindigkeit des dritten Rads und der letzte Wert und der vorletzte Wert durch die Geschwindigkeit des letzten Rads ersetzt. Also nehmen wir nur das letzte Element mit .pop().

PHP, 80 79 69 Bytes

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

Übernimmt die Eingabe vom GET-Parameter a. druckt Ergebnis

Initialisiert $rmit 1 und durchläuft dann die Schleife vom vorletzten Tupel, um mit dem ersten Element des vorherigen zu multiplizieren und durch das zweite Element des aktuellen Tupels zu teilen.

Danke an Jörg, der mich daran erinnert hat $_GET; das sparte 7 Bytes.

elegantere Version, 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])

Erläuterung

Reduzieren Sie das Array und multiplizieren Sie es mit jedem zweiten Wert und dividieren Sie es durch jeden ersten Wert. So ist [[6,12],[3,10],[5,8]]es auch 12/6*10/3*8/5. Die eigentliche Berechnung, die wir wollten, war natürlich so, 12/3*10/5dass wir das zuerst /6und zuletzt einfach ignorieren wollten, indem wir wieder *8reinmultiplizieren *6und /8wieder raus dividieren . Diese Aufhebung erfolgt, indem 6/8der Anfangswert für die Reduzierung festgelegt wird.

Python 2, 52 Bytes

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

Eine anonyme Funktion, die die Eingabe einer reduzierten Liste über ein Argument akzeptiert und die Ausgabe zurückgibt.

Dies nutzt die Idee der Teilungskaskade, wie in der Antwort von xnor .

Probieren Sie es auf Ideone

Python 3, 59 Bytes

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

Eine anonyme Funktion, die die Eingabe einer nicht abgeflachten Liste über ein Argument akzeptiert und die Ausgabe zurückgibt.

Wie es funktioniert

Für jedes Ganzzahlpaar in der Eingabe wird eine Zeichenfolge des Formulars 'int1*int2'erstellt. Wenn Sie alle diese Paare zusammenfügen, erhalten Sie /eine Zeichenfolge der Form'int1*int2/int3*int4/...' , die die gewünschte Berechnung darstellt, die jedoch die unerwünschten ersten und letzten Ganzzahlen enthält. Diese werden entfernt, indem die ersten beiden und die letzten beiden Zeichen im Stich herausgeschnitten werden, wobei die gewünschte Berechnung verbleibt. Dies wird dann ausgewertet und zurückgegeben.

Probieren Sie es auf Ideone

Pascal, 88 Bytes

Eine rekursive (musste es tun ..) Funktion, die ein statisches 2D-Array und seine Länge (Anzahl der Zeilen) als Eingabe verwendet. Verwenden Sie eine Zeigermathematik für das Array.

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 mit Anwendungsbeispiel:

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.

Eigentlich 14 Bytes

pXdX2@╪k`i/`Mπ

Probieren Sie es online! (Funktioniert derzeit nicht, da TIO einige Versionen hinter sich hat)

Dieses Programm verwendet eine abgeflachte Liste als Eingabe.

Erläuterung:

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

Es stellt sich heraus, dass der vektorisierte Ansatz und die forSchleife in diesem Fall äquivalent sind:

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

oder die forSchleife:

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

`