Un regolatore di velocità ha 3 diverse opzioni per spostare la maniglia per impostare la velocità con cui si desidera guidare.

• Verso te: aggiunge 1 velocità.
• Verso l'alto: aumenta la velocità al multiplo successivo di 10 (ad es. 20 -> 30, 32 -> 40)
• Verso il basso: riduce la velocità al multiplo successivo di 10 (ad es. 20 -> 10, 32 -> 30)

Ingresso

• 2 numeri interi: il primo è la velocità iniziale e il secondo è la velocità desiderata, sia non negativa che in qualsiasi forma ti piaccia (array, due argomenti, ecc.)

Compito

• Determinare il modo ottimale di utilizzare la maniglia per raggiungere la velocità desiderata e stampare le mosse nell'ordine corretto.

Regole

• Se hai la scelta tra tirare verso di te e andare verso l'alto (come da 39 a 40) puoi scegliere entrambe le opzioni, ma resta con qualsiasi cosa tu scelga per casi simili
• È possibile utilizzare 3 simboli diversi (preferibilmente visibili) per distinguere le mosse nell'output (ad esempio T, U e D).
• I simboli possono essere separati da nuove linee, spazi, ecc. Ma non è necessario

Ecco alcuni casi di test:

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

Questo è code-golf quindi vince la risposta più breve in byte.

JavaScript (ES6), 91 84 75 byte

Salvato 4 byte grazie 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):""

Utilizza 0per D, 1per Te 2per U.

Java, 144 139

5 byte salvati grazie 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);
        }
    }
}

Lotto, 175 byte

@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

Abbastanza semplice questa volta. Accetta input come parametri della riga di comando, in cui salva se d. eviene darrotondato per difetto al multiplo precedente di 10. Se sè maggiore di d, allora ovviamente dobbiamo invocare dfino a quando non sdiventa inferiore a d. Altrimenti, dobbiamo verificare se sè inferiore a e; in tal caso, possiamo invocare ufino a quando non è suguale e. A questo punto sè ora tra ee de possiamo semplicemente invocare tfino a raggiungere d. Ho esaminato i forloop ma usano endpoint inclusivi, quindi sarebbe diventato troppo dettagliato.

Python, 76 byte

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

C, 156 byte

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