लेगो गियर अनुपात

Question

मैं एक विशाल लेगो रोबोट का निर्माण कर रहा हूं और मुझे गियर के सेट का उपयोग करके कुछ विशेष गियर अनुपात उत्पन्न करने की आवश्यकता है। मेरे पास आम लेगो गियर के आकार के साथ बहुत सारे गियर हैं: 8, 16, 24, या 40 दांत। एक प्रोग्राम लिखें जिसका मैं उपयोग कर सकता हूं जहां मैं एक गियरिंग अनुपात इनपुट करता हूं और कार्यक्रम मुझे बताता है कि अनुरोधित अनुपात प्राप्त करने के लिए मुझे गियर का कौन सा संयोजन उपयोग करना चाहिए।

इनपुट अनुपात मानक इनपुट (या आपकी भाषा के समतुल्य) पर एक कॉलोन द्वारा अलग किए गए दो पूर्णांकों के साथ निर्दिष्ट किया जाएगा। अनुपात का a:bअर्थ है कि आउटपुट शाफ्ट को a/bइनपुट शाफ्ट के रूप में तेजी से मोड़ना चाहिए ।

मानक आउटपुट का आउटपुट एकल पंक्ति होना चाहिए जिसमें गियर अनुपात की अंतरिक्ष-पृथक सूची होती है, x:yजहां xइनपुट शाफ्ट पर गियर yका आकार होता है और आउटपुट शाफ्ट पर गियर का आकार होता है। आपको दिए गए अनुपात के लिए न्यूनतम संभव संख्या का उपयोग करना चाहिए। प्रत्येक xऔर yसे एक होना चाहिए 8,16,24,40।

उदाहरण:

1:5 -> 8:40
10:1 -> 40:8 16:8
9:4 -> 24:16 24:16
7:1 -> IMPOSSIBLE
7:7 ->
6:15 -> 16:40

यदि वांछित गियर अनुपात असंभव है, तो "IMPOSSIBLE" प्रिंट करें। यदि कोई गियर की आवश्यकता नहीं है, तो खाली स्ट्रिंग प्रिंट करें।

यह कोड गोल्फ, सबसे छोटी उत्तर जीत है।

Comments

कोणीय वेग के विपरीत आनुपातिक रूप से दांतों का अनुपात नहीं है? उदाहरण के लिए, यदि वांछित इनपुट आउटपुट वेग 1: 5 है, तो अनुपात 8: 8:40 के बजाय 40: 8 नहीं होना चाहिए? या बाएं हाथ के अनुपात में वास्तविक गियर दांतों के लिए प्रभावी गियर दांत आप चाहते हैं?

— डेविड

दिलचस्प सवाल ... 1:5 -> 8:40और 10:1 -> 40:8समझ में आता है लेकिन दूसरों को इतना नहीं।

— रोब

@DavidCarraher: मुझे लगता है कि आप इसे किसी भी तरह से परिभाषित कर सकते हैं। मैंने आंतरिक रूप से सुसंगत होने की कोशिश की। 1:5इसका मतलब है कि आउटपुट शाफ्ट 5 गुना धीमा होता है, और इनपुट पर 8 टूथ गियर और आउटपुट पर 40 टूथ गियर होता है।

— कीथ रान्डेल

@ मायकेड्रिक: ठीक है, 10:1 -> 40:8 16:8नहीं, जो आपने कहा। दूसरों के बारे में आपको क्या भ्रम है? दो बार 9:4कर लागू 3:2किया गया है। 3:2का उपयोग कर कार्यान्वित किया जाता है 24:16।

— कीथ रान्डेल

@ मायकेड्रिक: आपके पहले प्रश्न के लिए हाँ। 10: 1 प्राप्त करने के लिए आप 5: 1 कर सकते हैं (40 दांत / 8 दांत का उपयोग करके) और फिर 2: 1 (16 दांत / 8 दांत का उपयोग करके)। 7:7के रूप में ही है 1:1, इसलिए इसे लागू करने के लिए कोई गियर की आवश्यकता नहीं है।

— कीथ रान्डेल

Answer 1

अजगर - 204

ठीक है, मैं पहले जाऊंगा:

def p(n,a=[1]*9):
 n=int(n)
 for i in(2,3,5):
    while n%i<1:n/=i;a=[i]+a
 return a,n
(x,i),(y,j)=map(p,raw_input().split(':'))
print[' '.join(`a*8`+':'+`b*8`for a,b in zip(x,y)if a!=b),'IMPOSSIBLE'][i!=j]

संपादित करें:

आउटपुट को 'ऑप्टिमाइज़' करने के लिए, इसे printस्टेटमेंट से पहले जोड़ा जा सकता है ,

for e in x:
 if e in y:x.remove(e);y.remove(e)

कुल 266 पात्रों को लाने पर , मुझे विश्वास है।

Comments

<1प्रतिस्थापित कर सकता है ==0। भी, if b:a=...return aहो सकता है return b and...or a।

— ugoren

के लिए काम नहीं करता है, जैसे 23:12,।

— कीथ रान्डेल

अच्छी तरह से देखा गया। यह 12 से होकर गुजरता है। elif i!=1:return[]मूल में जोड़ने से समस्या हल हो जाती है लेकिन एक और परिचय देता है। $ python gears.py <<< 21:28=> 24:16.. मैं इसे देखने जा रहा हूँ। ऐसा लगता है कि समस्या इतनी सरल नहीं थी: DI लगता है कि कोड को अधिक लंबा होना है, या मुझे एक और दृष्टिकोण की आवश्यकता है।

— डेनियरो

तुम वहाँ जाओ; मुझे लगता है कि यह उम्मीद के मुताबिक काम करता है। यहाँ तक कि इसे छोटा कर दिया :)

— daniero

बहुत अच्छा लग रहा है, लेकिन यह इष्टतम नहीं है। 6:15के साथ किया जा सकता है 16:40लेकिन आपका कोड वापस आ जाता है 24:40 16:24।

— कीथ रान्डेल

Answer 2

पर्ल - 310 306 294 288 272

मैं पर्ल के साथ थोड़ा कठोर हूँ और कोड-गोल्फ कभी नहीं किया ... लेकिन कोई बहाना नहीं। चार-गिनती बिना लाइन-ब्रेक के होती है। Perl v5.14.2 का उपयोग करना।

($v,$n)=<>=~/(.+):(.+)/;
($x,$y)=($v,$n);($x,$y)=($y,$x%$y)while$y;
sub f{$p=shift;$p/=$x;for(5,3,2){
while(!($p%$_)){$p/=$_;push@_,$_*8}}
$o="IMPOSSIBLE"if$p!=1;
@_}
@a=f($v);@b=f($n);
if(!$o){for(0..($#b>$#a?$#b:$#a)){
$a[$_]||=8;
$b[$_]||=8;
push@_,"$a[$_]:$b[$_]"}}
print"$o@_\n"

मैं आलोचकों और संकेत का इंतजार कर रहा हूं। कोड-गोल्फ (पेरल में) के लिए टिप्स और ट्रिक ढूंढना इतना आसान नहीं है।

Comments

आप हटाने से 9 वर्णों को बचा सकते हैं $1:$2 -> , आउटपुट में इसकी आवश्यकता नहीं है।

— डेवग्रैंडम

ओह, मैंने कल्पना को गलत बताया। धन्यवाद।

— पैट्रिक बी।

आप जैसे बयानों को कम कर सकते $a[$_]=8 if!$a[$_];करने के लिए$a[$_]||=8;

— ardnew

न्यूलाइन्स को एक चरित्र के रूप में गिना जाता है।

— टिमटेक

पहली पंक्ति संक्षिप्त ($v,$n)=split/:|\s/,<>;(अप्रकाशित) की जा सकती है ।

— msh210

Answer 3

swi-prolog, 324 250 248 204 बाइट्स

Prolog इस तरह की समस्या को हल करने में बहुत अच्छा करता है।

m(P):-(g(P,L),!;L='IMPOSSIBLE'),write(L).
g(A:A,''):-!.
g(A:B,L):-A/C/X,C>1,B/C/Y,!,g(X:Y,L);A/C/X,!,B/D/Y,C*D>1,g(X:Y,T),format(atom(L),'~D:~D ~a',[C*8,D*8,T]).
X/Y/Z:-(Y=5;Y=3;Y=2;Y=1),Z is X//Y,Y*Z>=X.

इनपुट की भविष्यवाणी करने के लिए एक टर्म पैरामीटर के रूप में पारित किया जाता है m। आउटपुट stdout को लिखा जाता है। अनुगामी 'सत्य' के बारे में क्षमा करें; यह सिर्फ दुभाषिया का तरीका है जिससे मुझे पता चलता है कि सब कुछ ठीक था।

?- m(54:20).
24:40 24:16 24:8 
true.

?- m(7:7).
true.

?- m(7:1).
IMPOSSIBLE
true.

Answer 4

सी, 246 216 213 बाइट्स

(व्यर्थ) अपने स्वयं के प्रोलॉग समाधान को हरा देने के प्रयास में, मैंने सी समाधान को पूरी तरह से फिर से लिखा।

b,c,d;f(a,b,p){while(c=a%5?a%3?a%2?1:2:3:5,d=b%5?b%3?b%2?1:2:3:5,c*d>1)c<2|b%c?d<2|a%d?p&&printf("%d:%d ",8*c,8*d):(c=d):(d=c),a/=c,b/=d;c=a-b;}main(a){scanf("%d:%d",&a,&b);f(a,b,0);c?puts("IMPOSSIBLE"):f(a,b,1);}

मेरा मूल सी समाधान (246 बाइट्स):

#define f(c,d) for(;a%d<1;a/=d)c++;for(;b%d<1;b/=d)c--;
b,x,y,z;main(a){scanf("%d:%d",&a,&b);f(x,2)f(y,3)f(z,5)if(a-b)puts("IMPOSSIBLE");else
while((a=x>0?--x,2:y>0?--y,3:z>0?--z,5:1)-(b=x<0?++x,2:y<0?++y,3:z<0?++z,5:1))printf("%d:%d ",a*8,b*8);}

यह एक अच्छा अभ्यास था यह साबित करने के लिए कि यह सूची बनाए बिना किया जा सकता है।

Answer 5

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

(लगभग निश्चित रूप से गैर-प्रतिस्पर्धा में प्रतिस्पर्धा के रूप में sep / 2012 की तुलना में एक भाषा का उपयोग करता है)

D'HJH=Y[)VP30W!%JN=/JN=Y+NY))R,YJ;IneKhm'vdcz\:J"IMPOSSIBLE").?V.t,.-Y.-hK=J.-hKYJ1In.*Npj\:m*8d_Np\ 

@Daniero 'अजगर जवाब का कार्यान्वयन लेकिन पाइथ के लिए अर्ध-अनुकूलित।

D'H                               - Define a function (') which takes an argument, H.
   JH                             - J = H (H can't be changed in the function)
     =Y[)                         - Y = []
         V                        - For N in ...
          P30                     - Prime factors of 30 (2,3,5)
             W!%JN                - While not J%N
                  =/JN            - J /= N
                      =Y+NY       - Y = N + Y
                           ))R,YJ - To start of function, return [Y,J]

ENDFUNCTION

If 
         cz\:  - Split the input by the ':'
     m'vd      - ['(eval(d)) for d in ^]
   Kh          - Set K to the first element of the map (before the :)
  e            - The second returned value
             J - The second returned value after the : (The variables are globals)
 n             - Are not equal

Then 
"IMPOSSIBLE" - Print "IMPOSSIBLE"

Else
V                                      - For N in
 .t                1                   - transpose, padded with 1's
             .-hKY                     - 1st function first return - 2nd function first return
           =J                          - Set this to J
       .-hK                            - 1st function first return - ^
    .-Y                                - 2nd function first return - ^
   ,              J                    - [^, J]
                                         (Effectively XOR the 2 lists with each other)
                    I                  - If
                     n.*N              - __ne__(*N) (if n[0]!=n[1])
                         pj\:m*8d_N    - print ":".join([`d*8` for d in reversed(N)])
                                   p\  - print a space seperator

इसे यहाँ आज़माएँ

या हर मामले का परीक्षण करें

Answer 6

ईएस 6, 230 बाइट्स

x=>([a,b]=x.split`:`,f=(x,y)=>y?f(y,x%y):x,g=f(a,b),d=[],a/=g,f=x=>{while(!(a%x))a/=x,d.push(x*8)},[5,3,2].map(f),c=d,d=[],a*=b/g,[5,3,2].map(f),a>1?'IMPOSSIBLE':(c.length<d.length?d:c).map((_,i)=>(c[i]||8)+':'+(d[i]||8)).join` `)

मेरे सबसे लंबे गोल्फों में से एक है, इसलिए मैंने कुछ गलत किया होगा ... Ungolfed:

x => {
    [a, b] = x.split(":");
    f = (x, y) => y ? f(y, x % y) : x; // GCD
    g = f(a, b);
    f = x => {
        r = [];
        while (!(x % 5)) { x /= 5; r.push(5); }
        while (!(x % 3)) { x /= 3; r.push(3); }
        while (!(x % 2)) { x /= 2; r.push(2); }
        if (x > 1) throw "IMPOSSIBLE!";
        return r;
    }
    c = f(a);
    d = f(b);
    r = [];
    for (i = 0; c[i] || d[i]; i++) {
        if (!c[i]) c[i] = 8;
        if (!d[i]) d[i] = 8;
        r[i] = c[i] + ":" + d[i];
    }
    return r.join(" ");
}