기어는 메쉬 기어의 크기에 따라 다른 속도를 전달합니다.

잭에는 기어 트레인을 회전시키는 기계가 있습니다. 그러나 당신은 마지막 기어의 속도를 모른다.

운 좋게도, 당신은 훌륭한 코드 골퍼이기 때문에 그를 도울 수 있습니다!

그래서 내가 무엇을해야하니?

각 기어는 내부 기어 반경과 외부 기어 반경의 두 숫자로 표시됩니다.

기어 A가 기어 [a,b]이고 기어 B가 [c,d]속도이면 속도 A와 속도의 비율 B이 c:b됩니다.

기어 목록 (2 튜플 목록)이 주어지면 마지막 기어의 속도를 출력하십시오.

첫 번째 기어의 속도는이라고 가정 할 수 있습니다 1.

해결 된 예

입력 값이이라고 가정 해 봅시다 [[6,12],[3,10],[5,8]].

첫 번째 기어 [6,12]의 속도는 1입니다.

그런 다음 두 번째 기어 [3,10]의 속도는 1*12/3 = 4입니다.

그러면 마지막 기어 [5,8]의 속도는 4*10/5 = 8입니다.

테스트 케이스

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)

규칙

기본 코드 골프 규칙이 적용됩니다.

하스켈, 19 바이트

foldr1(/).tail.init

단순 목록처럼 감안할 때 [a,b,c,d,e,f], tail.init처음과 마지막 요소를 제거하고 foldr1(/)부서의 폭포 생성 b/(c/(d/e))))교류에 밖으로 작동 *과 /: b/c*d/e.

젤리 , 6 바이트

ḊṖU÷@/

테스트 스위트.

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

젤리 , 7 바이트

U÷Ḣµ2\P

온라인으로 사용해보십시오! 또는 모든 테스트 사례를 확인하십시오 .

C, 115 (123) 121 83 80 76 71 70 바이트

@LeakyNun 덕분에 4 바이트가 절약되었습니다!

내 첫 골프, 아마도 최고는 아닙니다.

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

배열과 크기를 취합니다.

언 골프 드 :

int counter;
float ret=1;
float gear(int *arr, int size) {
    for(; counter < size-2; )
        ret = ret * arr[++counter] / arr[++counter];
    return ret;
}

자바 스크립트 (ES6), 44 바이트

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

평탄화 배열의 경우 37 바이트 :

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

(예를 들어) Haskell과는 달리, 길은 길을 잘못해서 reduceRight싸고 reduce마지막에 상호를 취합니다.

Pyth, 8 바이트

.UcZb_Pt

테스트 스위트.

J, 8 바이트

%/@}:@}.

온라인으로 사용해보십시오!

용법

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

>> f 1 1 2 2
<< 0.5

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

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

여기서 >>STDIN <<은 STDOUT입니다.

설명

J기본값은 오른쪽에서 왼쪽으로 "축소"이며 몇 바이트가 소요되었습니다. : p

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

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

Mathematica, 26 바이트

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

이름이 균일하지 않은 평평한 값 목록을 가져와 정확한 결과를 반환합니다 (필요한 경우 분수로 표시).

이것은 첫 번째 요소와 마지막 요소를 제거한 후 반전 된 목록에서 접는 구분에 대한 다른 대답과 동일한 접근 방식을 사용합니다.

MATL , 9 바이트

6L)9L&)/p

입력 형식은 다음 중 하나입니다.

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

EDIT (2016 년 7 월 30) : 링크 된 코드를 대체합니다 9L으로는 1L언어의 최근 변화에 적응합니다.

온라인으로 사용해보십시오!

설명

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

자바 스크립트, 54 바이트

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

용법

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

언 골프

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

물론 골프 변형은 약간 다릅니다. 로 .map()배열의 첫 번째 값을 두 번째 휠 이후의 속도로 바꾸고 두 번째 값을 세 번째 휠의 속도로 바꾸고 마지막 값과 두 번째 마지막 값을 마지막 휠의 속도로 바꿉니다. 따라서 우리는 마지막 요소를로 사용 .pop()합니다.

PHP, 80 79 69 바이트

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

GET 매개 변수에서 입력을받습니다 a. 결과를 인쇄합니다

$r1로 초기화 한 다음 두 번째에서 마지막 튜플로 반복하여 이전의 첫 번째 요소와 곱하고 현재 튜플의 두 번째 요소를 나눕니다.

저를 상기시켜 준 Jörg에게 감사합니다 $_GET; 7 바이트를 절약했습니다.

더 우아한 버전, 88 바이트 :

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

자바 스크립트, 59 58 56 바이트

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

설명

배열을 줄이고 매 초 값을 곱하고 매 첫 값으로 나눕니다. 그래서 [[6,12],[3,10],[5,8]]그렇습니다 12/6*10/3*8/5. 물론 우리가 원하는 실제 계산 12/3*10/5은 처음 /6부터 다시 *8곱하고 *6다시 나누어서 무시하고 싶었 /8습니다. 취소 6/8는 감소의 초기 값 으로 설정 하여 수행됩니다 .

파이썬 2, 52 바이트

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

인수를 통해 병합 된 목록을 입력하고 출력을 반환하는 익명 함수입니다.

이것은 xnor의 답변 에서와 같이 나누기 캐스케이드 아이디어를 사용합니다 .

Ideone에서 사용해보십시오

파이썬 3, 59 바이트

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

인수를 통해 전개되지 않은 목록을 입력하고 출력을 리턴하는 익명 함수입니다.

작동 원리

입력의 모든 정수 쌍에 대해 양식 문자열 'int1*int2'이 작성됩니다. 이 모든 쌍을 결합하면 다음 /과 같은 형식의 문자열이 제공됩니다.'int1*int2/int3*int4/...' 하면 원하는 계산 이지만 원하지 않는 첫 번째 정수와 마지막 정수를 포함하는 됩니다. 찌르기에서 처음 두 문자와 마지막 두 문자를 잘라서 원하는 계산을 남기면 제거됩니다. 그런 다음 평가 및 반환됩니다.

Ideone에서 사용해보십시오

파스칼, 88 바이트

정적 2D 배열과 길이 (행 수)를 입력으로 사용하는 재귀 함수 (해야 할 일). 배열에서 일부 포인터 수학을 사용합니다.

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 :

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.

실제로 14 바이트

pXdX2@╪k`i/`Mπ

온라인으로 사용해보십시오! (현재 TIO는 몇 가지 버전이 없기 때문에 작동하지 않습니다)

이 프로그램은 평평한 목록을 입력으로 사용합니다.

설명:

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 바이트

이 경우 벡터화 접근 방식을 확인하고 for루프는 동일합니다.

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

또는 for루프 :

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

`