Bánh răng truyền số lượng tốc độ khác nhau, tùy thuộc vào kích thước của bánh răng có lưới.

Jack có một cỗ máy, làm quay một chiếc Gear Train. nhưng bạn không biết tốc độ của thiết bị cuối cùng.

May mắn thay, bạn là một tay golf mã tuyệt vời, vì vậy bạn có thể giúp anh ta!

Vậy, tôi nên làm gì?

Mỗi bánh răng được đại diện bởi 2 số, bán kính của bánh răng bên trong và bán kính của bánh răng bên ngoài.

Nếu bánh răng Alà [a,b]và bánh răng Blà [c,d], thì tỷ lệ giữa tốc độ Avà tốc độ Bsẽ là c:b.

Đưa ra một danh sách các bánh răng (danh sách 2 tuple), xuất tốc độ của bánh răng cuối cùng.

Bạn có thể giả sử tốc độ của thiết bị đầu tiên là 1.

Làm việc ví dụ

Hãy nói rằng đầu vào của chúng tôi là [[6,12],[3,10],[5,8]].

Các thiết bị đầu tiên [6,12], sẽ có tốc độ 1.

Sau đó, thiết bị thứ hai [3,10], sẽ có tốc độ 1*12/3 = 4.

Sau đó, thiết bị cuối cùng [5,8], sẽ có tốc độ 4*10/5 = 8.

Tủ thử

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)

Quy tắc

Quy tắc golf-golf cơ bản được áp dụng.

Haskell, 19 byte

foldr1(/).tail.init

Đưa ra một danh sách phẳng như [a,b,c,d,e,f], tail.initloại bỏ các yếu tố đầu tiên và cuối cùng, sau đó foldr1(/)tạo ra một loạt các phân chia b/(c/(d/e))))hoạt động xen kẽ *và /: b/c*d/e.

Thạch , 6 byte

ḊṖU÷@/

Bộ thử nghiệm.

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

Thạch , 7 byte

U÷Ḣµ2\P

Hãy thử trực tuyến! hoặc xác minh tất cả các trường hợp thử nghiệm .

C, 115 123 121 83 80 76 71 70 byte

4 byte được lưu nhờ @LeakyNun!

Golf đầu tiên của tôi, có lẽ không phải là tốt nhất.

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

Có một mảng và kích thước.

Ung dung:

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 cho một mảng phẳng:

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

Không giống như (ví dụ) Haskell, reduceRightlà một cái tên dài đến mức rẻ hơn reducevà đi ngược lại ở cuối.

Bình thường, 8 byte

.UcZb_Pt

Bộ thử nghiệm.

J, 8 byte

%/@}:@}.

Hãy thử trực tuyến!

Sử dụng

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

>> f 1 1 2 2
<< 0.5

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

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

Ở đâu >>STDIN và <<là STDOUT.

Giải trình

"Giảm" theo Jmặc định từ phải sang trái, mất một vài byte: p

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

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

Toán học, 26 byte

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

Hàm không tên có danh sách các giá trị có độ dài bằng phẳng và trả về kết quả chính xác (dưới dạng phân số nếu cần).

Điều này sử dụng cách tiếp cận tương tự như một số câu trả lời khác của phép chia gấp so với danh sách đảo ngược (sau khi loại bỏ phần tử đầu tiên và cuối cùng).

TOÁN , 9 byte

6L)9L&)/p

Định dạng đầu vào là bất kỳ trong số này:

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

EDIT (ngày 30 tháng 7 năm 2016): mã được liên kết thay thế 9L bằng cách 1Lthích ứng với những thay đổi gần đây trong ngôn ngữ.

Hãy thử trực tuyến!

Giải trình

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

Sử dụng

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

Bị đánh cắp

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

Tất nhiên, biến thể golf là một chút khác nhau. Với .map(), nó thay thế giá trị đầu tiên của mảng bằng tốc độ sau bánh xe thứ hai, giá trị thứ hai bằng tốc độ của bánh xe thứ ba và giá trị cuối cùng và giá trị cuối cùng thứ hai bằng tốc độ của bánh xe cuối cùng. Vì vậy, chúng tôi chỉ lấy yếu tố cuối cùng với .pop().

PHP 80 79 69 byte

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

lấy đầu vào từ tham số GET a; kết quả in

khởi tạo $rvới 1, sau đó các vòng lặp từ lần thứ hai đến lần cuối để nhân với phần tử đầu tiên của phần trước và chia cho phần tử thứ hai của bộ hiện tại.

Cảm ơn Jörg đã nhắc nhở tôi về $_GET; đã lưu 7 byte.

phiên bản thanh lịch hơn, 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])

Giải trình

Giảm mảng và nhân với mỗi giá trị thứ hai và chia cho mỗi giá trị đầu tiên. Vì vậy đối với[[6,12],[3,10],[5,8]] nó làm 12/6*10/3*8/5. Tất nhiên, tính toán thực tế mà chúng tôi muốn là 12/3*10/5vì vậy chúng tôi chỉ muốn bỏ qua điều đó trước tiên /6và cuối cùng *8bằng cách nhân *6trở lại và chia /8ra. Việc hủy bỏ đó được thực hiện bằng cách đặt 6/8làm giá trị ban đầu cho mức giảm.

Python 2, 52 byte

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

Một hàm ẩn danh nhận đầu vào của danh sách dẹt thông qua đối số và trả về đầu ra.

Điều này sử dụng ý tưởng phân tầng, như trong câu trả lời của xnor .

Hãy thử nó trên Ideone

Python 3, 59 byte

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

Một hàm ẩn danh nhận đầu vào của danh sách không làm phẳng thông qua đối số và trả về đầu ra.

Làm thế nào nó hoạt động

Đối với mỗi cặp số nguyên trong đầu vào, một chuỗi biểu mẫu 'int1*int2'được tạo. Tham gia tất cả các cặp trên /sẽ tạo ra một chuỗi mẫu'int1*int2/int3*int4/...' , đó là phép tính mong muốn, nhưng bao gồm các số nguyên đầu tiên và cuối cùng không mong muốn. Chúng được loại bỏ bằng cách cắt ra hai ký tự đầu tiên và hai ký tự cuối cùng trong sting, để lại phép tính mong muốn. Điều này sau đó được đánh giá và trả lại.

Hãy thử nó trên Ideone

Pascal, 88 byte

Hàm đệ quy (phải thực hiện ..) lấy một mảng 2D tĩnh và độ dài của nó (số hàng) làm đầu vào. Sử dụng một số toán con trỏ trên mảng.

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 với ví dụ sử dụng:

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.

Trên thực tế, 14 byte

pXdX2@╪k`i/`Mπ

Hãy thử trực tuyến! (hiện không hoạt động vì TIO là một vài phiên bản phía sau)

Chương trình này lấy một danh sách làm phẳng làm đầu vào.

Giải trình:

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

Hóa ra cách tiếp cận véc tơ và forvòng lặp là tương đương trong trường hợp này:

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

hoặc forvòng lặp:

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

`