गियर ट्रेन, घूर्णन

Question

गियर्स मेष की गियर के आकार के आधार पर, विभिन्न गति को स्थानांतरित करते हैं।

जैक के पास एक मशीन है, जो गियर ट्रेन को घुमाती है। लेकिन आपको पिछले गियर की गति का पता नहीं है।

सौभाग्य से, आप एक महान कोड गोल्फर हैं, तो आप उसकी मदद कर सकते हैं!

तो मुझे क्या करना चाहिए?

प्रत्येक गियर को 2 संख्याओं द्वारा दर्शाया जाता है, आंतरिक गियर की त्रिज्या और बाहरी गियर की त्रिज्या।

यदि गियर 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)

नियम

बुनियादी कोड-गोल्फ नियम लागू होते हैं।

Comments

चूंकि आप फ़्लोटिंग पॉइंट आउटपुट की अनुमति दे रहे हैं, आपको संभवतः स्पष्ट करना चाहिए कि परिणाम कितने सटीक हैं।

— मार्टिन एंडर

क्या हम ट्यूपल्स की सूची के बजाय चपटी सूची के रूप में इनपुट ले सकते हैं?

— लीक नून

हाँ, पसंद है [6,12,3,10,5,8]। यदि आप इसका उपयोग करना चाहते हैं तो बस इसका उल्लेख करें।

यह एक बालक अनुचित है। मेरे पास एक अलग 7-बाइट संस्करण था जिसे मैंने पोस्ट नहीं किया था क्योंकि मैंने इसे कम दिलचस्प माना था। यह बिना चपटे 6 बाइट्स होता। इस तरह की स्थिति से बचने के लिए कृपया अगली बार सैंडबॉक्स का उपयोग करने पर विचार करें।

— डेनिस

Answer 1

हास्केल, 19 बाइट्स

foldr1(/).tail.init

की तरह एक फ्लैट सूची को देखते हुए [a,b,c,d,e,f], tail.initपहली और आखिरी तत्वों निकाल देता है, और उसके बाद foldr1(/)विभाजन के एक झरना बनाता है b/(c/(d/e))))कि बारी करने के लिए बाहर काम करता है *और /: b/c*d/e।

Comments

लेकिन यह सवाल बताता है कि कार्यक्रमों को 2-टुपल्स की सूची मिलती है, एक फ्लैट सूची नहीं

— प्रदर्शन नाम

टिप्पणियों में एक फ्लैट सूची की अनुमति दी गई थी।

— xnor

Answer 2

जेली , 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.

Comments

आह, बारी-बारी से विभाजन। यह चालाकी है।

— डेनिस

Answer 3

जेली , 7 बाइट्स

U÷Ḣµ2\P

इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें ।

Answer 4

सी, 115 123 121 83 80 76 71 70 बाइट्स

4 बाइट्स @LeakyNun की बदौलत बच गए!

मेरा पहला गोल्फ, शायद सबसे अच्छा नहीं।

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

एक सरणी और आकार लेता है।

Ungolfed:

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

Comments

PPCG में आपका स्वागत है! :)

— मार्टिन एंडर

आपके द्वारा समर्थित अधिकतम संख्याओं की संख्या क्या है? PPCG में आपका स्वागत है!

— लीक नून

j;float r=1;float f(int a[]){for(;j<sizeof a;)r=r*a[j++]/a[j++];return r;}(परीक्षण नहीं किया गया)

— लीक नून

J ++, ++ j और sizeof-2 नहीं। 4 बाइट बच गईं। धन्यवाद!

— betseg

ऐसा लगता है कि हम पारित सरणियों के आकार को माप नहीं सकते हैं। मैंने उत्तर संपादित किया।

— १०:५० बजे सुपारी

Answer 5

जावास्क्रिप्ट (ईएस 6), 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)

विपरीत (जैसे) हास्केल, reduceRightएक ऐसा लंबा नाम है जो reduceगलत तरीके से सस्ता है और अंत में पारस्परिक ले लो।

Comments

वहाँ से प्रेरित उत्तर ... मैं इससे कम नहीं जा सकता था ...

— 23

Answer 6

पायथ, 8 बाइट्स

.UcZb_Pt

परीक्षण सूट।

Answer 7

जे, 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दाईं से बाईं ओर की डिफॉल्ट में "कम करें" , जिसने कुछ बाइट्स को बंद कर दिया: पी

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

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

Answer 8

गणितज्ञ, 26 बाइट्स

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

एक अनाम फ़ंक्शन जो मानों की एक समान सम-लंबाई सूची लेता है और सटीक परिणाम देता है (यदि आवश्यक हो तो एक अंश के रूप में)।

यह उलटी सूची पर तह विभाजन के कुछ अन्य उत्तरों के समान दृष्टिकोण का उपयोग करता है (पहले और अंतिम तत्व को हटाने के बाद)।

Answer 9

MATL , 9 बाइट्स

6L)9L&)/p

इनपुट प्रारूप इनमें से कोई भी है:

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

संपादित करें (30 जुलाई 2016): लिंक किए गए कोड की जगह 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

Answer 10

जावास्क्रिप्ट, 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>'))

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

बेशक, गोल्फ वाला संस्करण थोड़ा अलग है। इसके साथ .map(), यह दूसरे पहिये के बाद गति के साथ सरणी के पहले मूल्य को बदल देता है, दूसरे मूल्य को तीसरे पहिये की गति के साथ, और अंतिम मान और अंतिम पहिए की गति के साथ दूसरे अंतिम मान को। तो, हम सिर्फ अंतिम तत्व को लेते हैं .pop()।

Answer 11

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]);

Comments

<?for($r=$i=1;$i<count($a=$_GET[a]);)$r*=$a[$i-1][1]/$a[$i++][0];echo$r;72 बाइट्स

— जार्ग हुल्सरमन

Answer 12

जावास्क्रिप्ट, 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कम करने के लिए प्रारंभिक मूल्य के रूप में सेट करके किया जाता है ।

Comments

मैं उसी समाधान पर आया था। *.../...प्रारंभिक मूल्य पर पोस्ट-ऑपरेशंस को जोड़कर आप दो बाइट्स बचा सकते हैं 1।

— टाइटस

Answer 13

पायथन 2, 52 बाइट्स

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

एक अनाम फ़ंक्शन जो तर्क के माध्यम से एक चपटा सूची का इनपुट लेता है और आउटपुट देता है।

यह डिवीजन कैस्केड विचार का उपयोग करता है, जैसा कि xnor के उत्तर में है ।

Ideone पर इसे आज़माएं

Answer 14

पायथन 3, 59 बाइट्स

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

एक अनाम फ़ंक्शन जो तर्क के माध्यम से गैर-चपटा सूची का इनपुट लेता है और आउटपुट देता है।

यह काम किस प्रकार करता है

इनपुट में पूर्णांक के प्रत्येक जोड़े के लिए, प्रपत्र की एक स्ट्रिंग 'int1*int2'बनाई जाती है। इन सभी जोड़ियों को /जोड़कर फॉर्म की एक स्ट्रिंग दी जाती है'int1*int2/int3*int4/...' , जो वांछित गणना है, लेकिन इसमें अवांछित पहले और अंतिम पूर्णांक शामिल हैं। वांछित गणना को छोड़कर, स्टिंग में पहले दो और अंतिम दो पात्रों को बाहर निकालकर इन्हें हटा दिया जाता है। इसके बाद मूल्यांकन किया जाता है और वापस लौटा दिया जाता है।

Ideone पर इसे आज़माएं

Answer 15

पास्कल, 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;

उपयोग उदाहरण के साथ अधूरा:

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.

Answer 16

दरअसल, 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

Answer 17

आर, 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)}

`