Ein Tempomat verfügt über 3 verschiedene Optionen zum Bewegen des Griffs, um die Geschwindigkeit einzustellen, mit der Sie fahren möchten.

• Auf dich zu: Fügt 1 Geschwindigkeit hinzu.
• Aufwärts: Erhöht die Geschwindigkeit auf das nächste Vielfache von 10 (z. B. 20 -> 30, 32 -> 40)
• Abwärts: Verringert die Geschwindigkeit auf das nächste Vielfache von 10 (z. B. 20 -> 10, 32 -> 30).

Eingang

• 2 Ganzzahlen: Die erste ist die Startgeschwindigkeit und die zweite ist Ihre gewünschte Geschwindigkeit, sowohl nicht negativ als auch in beliebiger Form (Array, zwei Argumente usw.)

Aufgabe

• Bestimmen Sie die optimale Verwendung des Griffs, um die gewünschte Geschwindigkeit zu erreichen, und drucken Sie die Bewegungen in der richtigen Reihenfolge aus.

Regeln

• Wenn Sie die Wahl haben, ob Sie zu sich ziehen oder nach oben gehen möchten (z. B. von 39 bis 40), können Sie eine der beiden Optionen wählen, aber bei ähnlichen Fällen bei allem bleiben, was Sie wählen
• Sie können 3 verschiedene (vorzugsweise sichtbare) Symbole verwenden, um zwischen den Bewegungen in der Ausgabe zu unterscheiden (z. B. T, U und D).
• Die Symbole können durch neue Linien, Leerzeichen usw. getrennt werden, müssen es aber nicht sein

Hier einige Testfälle:

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

Dies ist Code-Golf, also gewinnt die kürzeste Antwort in Bytes.

JavaScript (ES6), 91 84 75 Byte

4 Bytes dank @Neil gespeichert

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):""

Verwendet 0für D, 1für Tund 2für U.

Java, 144 139

5 Bytes dank Kevin gespeichert.

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

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

Diesmal ziemlich unkompliziert. Übernimmt Eingaben als Befehlszeilenparameter, die in sund gespeichert werden d. ewird dauf das vorherige Vielfache von 10 abgerundet. Wenn sgrößer als ist d, müssen wir offensichtlich aufrufen, dbis es skleiner als wird d. Andernfalls müssen wir prüfen, ob sniedriger als ist e; Wenn ja, können wir aufrufen, ubis sgleich ist e. An diesem Punkt sliegt nun zwischen eund dund wir können einfach aufrufen, tbis wir erreichen d. Ich habe mir forSchleifen angesehen, aber sie verwenden inklusive Endpunkte, wären also zu ausführlich geworden.

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