Dev bir lego robotu yapıyorum ve bir takım dişliler kullanarak belirli dişli oranları oluşturmam gerekiyor. 8, 16, 24 veya 40 diş: Lego'nun ortak ebatlarına sahip çok fazla vitesim var. Bir dişli oranını girdiğim yerde kullanabileceğim bir program yazın ve program, istenen oranı elde etmek için hangi vites kombinasyonunu kullanmam gerektiğini söyler.

Giriş oranı standart girişte (veya dilinizin eşdeğeri) iki noktadan iki noktayla ayrılmış olarak belirtilecektir. Bir oran a:bçıkış mili dönüş gerektiği vasıtasıyla a/bgiriş mili gibi hızlı kez.

Standart çıktıya çıkış şeklinde dişli oranlarının bir boşluk ile ayrılmış listesini içeren tek bir çizgi olmalıdır x:yburada xgiriş mili üzerine dişli boyutundadır ve yçıkış mili üzerine dişli boyutundadır. Verilen oran için mümkün olan en düşük vites sayısını kullanmanız gerekir. Her biri xve ybiri olmalı 8,16,24,40.

örnekler:

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

İstenilen vites oranı imkansızsa, "GELİŞMİŞ" i yazdırın. Dişliler gerekli değilse, boş dizgeyi yazdırın.

Bu kod golf, en kısa cevap kazanıyor.

Python - 204

Tamam, önce ben gideceğim:

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]

Çıktıyı 'optimize etmek' için, bu printifadeden önce eklenebilir ,

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

toplamı 266 karakter getirdiğine inanıyorum.

Perl - 310 306 294 288 272

Perl ile biraz paslıyım ve asla bir kod golf yapmadım ... ama mazeret yok. Char-count, satır sonu olmadan. Perl v5.14.2 kullanımı.

($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"

Eleştirmen ve ipuçlarını sabırsızlıkla bekliyorum. Code-golf için ipuçları ve püf noktaları bulmak o kadar kolay değil (perl olarak).

swi-prolog, 324 250 248 204 bayt

Prolog böyle bir problemi çözmekte oldukça başarılı.

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.

Girdi, tahmin etmek için bir terim parametresi olarak iletilir m. Çıktı stdout'a yazılmıştır. İzleyen 'gerçek' için üzgünüm; bu sadece tercümanın bana her şeyin yolunda gittiğini bildirme şekli.

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

?- m(7:7).
true.

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

C, 246 216 213 bayt

Prolog çözümümü yenmek için (boşuna) bir girişimde, C çözümünü tamamen yeniden yazdım.

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

Orijinal C çözümüm (246 bayt):

#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);}

Listeler oluşturmadan yapılabileceğini kanıtlamak için güzel bir egzersizdi.

Pyth, 101 bayt

(Neredeyse kesinlikle eylül / 2012'den daha yeni bir dil kullanan yarışmada rekabet etmeyen)

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 yanıtının bir uygulaması ancak Pyth için yarı optimize edilmiş bir cevap .

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

Burada dene

Veya her vakayı test edin

ES6, 230 bayt

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

En uzun golf sahalarımdan biri, bu yüzden yanlış bir şey yapmış olmalıyım ... 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(" ");
}