Gli ingranaggi trasferiscono velocità diverse, a seconda delle dimensioni dell'ingranaggio a maglie.

Jack ha una macchina che ruota un treno di ingranaggi. ma non conosci la velocità dell'ultima marcia.

Fortunatamente, sei un grande golfista di codice, quindi puoi aiutarlo!

Quindi cosa dovrei fare?

Ogni ingranaggio è rappresentato da 2 numeri, il raggio dell'ingranaggio interno e il raggio degli ingranaggi esterni.

Se la marcia Aè [a,b]e la marcia Bè [c,d], allora il rapporto tra la velocità di Ae la velocità di Bsarebbe c:b.

Dato un elenco di ingranaggi (elenco di 2 tuple), visualizza la velocità dell'ultima marcia.

Puoi presumere che la velocità della prima marcia sia 1.

Esempio risolto

Diciamo che il nostro input è [[6,12],[3,10],[5,8]].

La prima marcia, [6,12]avrebbe una velocità di 1.

Quindi, la seconda marcia [3,10], avrebbe una velocità di 1*12/3 = 4.

Quindi, l'ultima marcia [5,8], avrebbe una velocità di 4*10/5 = 8.

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

Regole

Si applicano le regole di base del code-golf .

Haskell, 19 byte

foldr1(/).tail.init

Dato un elenco piatta come [a,b,c,d,e,f], tail.initrimuove il primo e l'ultimo elemento, e quindi foldr1(/)crea una cascata di divisioni b/(c/(d/e))))che funziona a alternato *e /: b/c*d/e.

Gelatina , 6 byte

ḊṖU÷@/

Suite di test.

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

Gelatina , 7 byte

U÷Ḣµ2\P

Provalo online! o verifica tutti i casi di test .

C, 115 123 121 83 80 76 71 70 byte

4 byte salvati grazie a @LeakyNun!

Il mio primo golf, probabilmente non il migliore.

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

Accetta una matrice e una dimensione.

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 byte per un array appiattito:

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

A differenza (ad esempio) di Haskell, reduceRightè un nome così lungo che è più economico nel reducemodo sbagliato e prende il reciproco alla fine.

Pyth, 8 byte

.UcZb_Pt

Suite di test.

J, 8 byte

%/@}:@}.

Provalo online!

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

dove si >>trova STDIN e<< è STDOUT.

Spiegazione

"Riduci" nelle Jimpostazioni predefinite da destra a sinistra, che è decollato di pochi byte: p

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

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

Mathematica, 26 byte

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

Una funzione senza nome che accetta un elenco uniforme di valori di lunghezza pari e restituisce il risultato esatto (come frazione se necessario).

Questo utilizza lo stesso approccio di alcune altre risposte di divisione pieghevole sull'elenco invertito (dopo aver rimosso il primo e l'ultimo elemento).

MATL , 9 byte

6L)9L&)/p

Il formato di input è uno di questi:

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

EDIT (30 lug 2016): le sostituisce codice legato 9Lda 1Ladattare ai recenti cambiamenti nel linguaggio.

Provalo online!

Spiegazione

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

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

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

Certo, la variante golfata è un po 'diversa. Con .map(), sostituisce il primo valore dell'array con la velocità dopo la seconda ruota, il secondo valore con la velocità della terza ruota e l'ultimo valore e il secondo ultimo valore con la velocità dell'ultima ruota. Quindi, prendiamo solo l'ultimo elemento con .pop().

PHP, 80 79 69 byte

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

accetta input dal parametro GET a ; stampa il risultato

inizializza $r con 1, quindi passa dalla seconda all'ultima tupla per moltiplicarsi con il primo elemento del precedente e dividere per il secondo elemento della tupla corrente.

Grazie a Jörg per avermelo ricordato $_GET ; che ha salvato 7 byte.

versione più elegante, 88 byte:

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

JavaScript, 59 58 56 byte

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

Spiegazione

Ridurre l'array e moltiplicare per ogni secondo valore e dividere per ogni primo valore. Quindi per [[6,12],[3,10],[5,8]]quello 12/6*10/3*8/5. Naturalmente, il calcolo effettivo che volevamo era 12/3*10/5quindi vogliamo solo ignorare quello prima /6e l'ultimo *8, moltiplicandoli di *6nuovo dentro e dividendoli di /8nuovo. Tale annullamento viene effettuato impostando 6/8come valore iniziale per la riduzione.

Python 2, 52 byte

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

Una funzione anonima che accetta l'input di un elenco appiattito tramite argomento e restituisce l'output.

Questo si avvale dell'idea della divisione in cascata, come nella risposta di xnor .

Provalo su Ideone

Python 3, 59 byte

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

Una funzione anonima che accetta l'input di un elenco non appiattito tramite argomento e restituisce l'output.

Come funziona

Per ogni coppia di numeri interi nell'input, 'int1*int2'viene creata una stringa del modulo . Unendo tutte queste coppie su si /ottiene una stringa del modulo'int1*int2/int3*int4/...' , che è il calcolo desiderato, ma include il primo e l'ultimo numero intero indesiderati. Questi vengono rimossi tagliando i primi due e gli ultimi due caratteri nella puntura, lasciando il calcolo desiderato. Questo viene quindi valutato e restituito.

Provalo su Ideone

Pascal, 88 byte

Una funzione ricorsiva (doveva farlo ..) che accetta come input un array 2D statico e la sua lunghezza (n. Di righe). Utilizzando alcuni puntatori matematici sull'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;

Non registrato con esempio di utilizzo:

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.

In realtà, 14 byte

pXdX2@╪k`i/`Mπ

Provalo online! (al momento non funziona perché TIO è indietro di alcune versioni)

Questo programma accetta un elenco appiattito come input.

Spiegazione:

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 byte

Risulta l'approccio vettorializzato e il forloop sono equivalenti in questo caso:

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

o il forciclo:

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

`