乐高齿轮比

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

如果想要的齿轮比是不可能的，打印“不可能”。如果不需要齿轮，打印空字符串。

这是密码高尔夫，最短答案获胜。

Answer 1

Python-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个字符。

Answer 2

Pyth，101个字节

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的python回答的一个实现，但对Pyth进行了半优化。

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 3

ES6,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` `)

我最长的高尔夫球员之一，所以我一定做错了什么.未高尔夫球：

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(" ");
}