Um controle de cruzeiro tem 3 opções diferentes para mover a alavanca e definir a velocidade com a qual você deseja dirigir.

• Em sua direção: Adiciona 1 velocidade.
• Para cima: aumenta a velocidade para o próximo múltiplo de 10 (por exemplo, 20 -> 30, 32 -> 40)
• Para baixo: diminui a velocidade para o próximo múltiplo de 10 (por exemplo, 20 -> 10, 32 -> 30)

Entrada

• 2 números inteiros: o primeiro é a velocidade inicial e o segundo é a velocidade desejada, não-negativa e da forma que você desejar (matriz, dois argumentos etc.)

Tarefa

• Determine a maneira ideal de usar a alça para atingir a velocidade desejada e imprima os movimentos na ordem correta.

Regras

• Se você tiver a opção entre puxar em sua direção e subir (como de 39 a 40), poderá escolher qualquer uma das opções, mas fique com o que escolher para casos semelhantes
• Você pode usar quaisquer três símbolos diferentes (de preferência visíveis) para distinguir entre os movimentos na saída (T, U e D, por exemplo).
• Os símbolos podem ser separados por novas linhas, espaços, etc., mas não precisam ser

Aqui estão alguns casos de teste:

start speed, desired speed  -->  output
30, 40  -->  U
30, 43  -->  UTTT
43, 30  -->  DD
51, 39  -->  DDDTTTTTTTTT
29, 30  -->  T or U
29, 50  -->  TUU or UUU
12, 12  -->  

Isso é código-golfe, então a resposta mais curta em bytes vence.

JavaScript (ES6), 91 84 75 bytes

Guardado 4 bytes graças a @Neil

f=(s,d)=>s-d?(q=s+10-s%10)>d?s>d?0+f(s-(s%10||10),d):1+f(s+1,d):2+f(q,d):""

Usa 0para D, 1para Te 2para U.

Java, 144 139

Economizou 5 bytes graças a Kevin.

void o(int s,int e){int t=10,x=s/t;System.out.print(s>e?"D":s<e?x<e/t?"U":"T":"");if‌​(s!=e)o(s>e?x*t-(s%t‌​<1?t:0):s<e?x<e/t?(x‌​+1)*t:s+1:0,e);

Ungolfed

public static void optimalCruise(int start, int end){

    if(start > end) {
        System.out.print("D");
        optimalCruise(start/10*10-(start%10<1?10:0), end);
    } else if(start < end){
        if(start/10 < end/10){
            System.out.print("U");
            optimalCruise(((start/10)+1)*10, end);
        } else {
            System.out.print("T");
            optimalCruise(start+1, end);
        }
    }
}

Lote, 175 bytes

@set/as=%1,d=%2,e=d/10*10
:d
@if %s% gtr %d% echo d&set/as=~-s/10*10&goto d
:u
@if %s% lss %e% echo u&set/as=s/10*10+10&goto u
:t
@if %s% neq %d% echo t&set/as+=1&goto t

Bastante direto desta vez. Recebe a entrada como parâmetros da linha de comando, que salva em se d. eé darredondado para o múltiplo anterior de 10. Se sfor maior que d, então obviamente precisamos chamar daté que sseja menor que d. Caso contrário, precisamos verificar se sé menor que e; Nesse caso, podemos invocar uaté sigual e. Neste ponto sé agora entre ee de podemos simplesmente invocar taté chegarmos d. Eu olhei para forloops, mas eles usam pontos de extremidade inclusivos para que se tornassem muito detalhados.

Python, 76 bytes

lambda a,b: "U"*(b//10-a//10)+"D"*(a//10-b//10+(b<a))+"T"*min(b%10,(b-a)%99)

C, 156 bytes

t,x,y;main(int s,char**a){x=(s=atoi(a[1]))/10,y=(t=atoi(a[2]))/10;if(s^t){for(;y>x;++x)puts("U");for(x+=(s-t>10);x>y;--x)puts("D");for(;t--%10;)puts("T");}}

Ungolfed:

#include <stdio.h>
#include <stdlib.h>
int t, x, y;
int main(int s, char **a)
{
    x = (s = atoi(a[1])) / 10,
    y = (t = atoi(a[2])) / 10;

    if (s ^ t) {
        for ( ; y > x; ++x)
            puts("U");

        for (x += (s - t > 10) ; x > y; --x)
            puts("D");

        for ( ; t-- % 10; )
            puts("T");
    }
    return 0;
}