Tempomat ma 3 różne opcje przesuwania dźwigni, aby ustawić prędkość, z którą chcesz jechać.

• W stronę ciebie: Dodaje 1 prędkość.
• W górę: Zwiększa prędkość do następnej wielokrotności 10 (np. 20 -> 30, 32 -> 40)
• W dół: zmniejsza prędkość do następnej wielokrotności 10 (np. 20 -> 10, 32 -> 30)

Wejście

• 2 liczby całkowite: pierwsza to prędkość początkowa, a druga to pożądana prędkość, zarówno nieujemna, jak i w dowolnej formie (tablica, dwa argumenty itp.)

Zadanie

• Określ optymalny sposób użycia uchwytu do osiągnięcia żądanej prędkości i wydrukuj ruchy we właściwej kolejności.

Zasady

• Jeśli masz wybór między przyciągnięciem do siebie a przejściem w górę (np. Od 39 do 40), możesz wybrać dowolną opcję, ale pozostań przy tym, co wybierzesz w podobnych przypadkach
• Możesz użyć dowolnych 3 różnych (najlepiej widocznych) symboli, aby rozróżnić ruchy na wyjściu (na przykład T, U i D).
• Symbole mogą być oddzielone nowymi liniami, spacjami itp., Ale nie muszą

Oto kilka przypadków testowych:

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

To jest golf golfowy, więc wygrywa najkrótsza odpowiedź w bajtach.

JavaScript (ES6), 91 84 75 bajtów

Zaoszczędź 4 bajty dzięki @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):""

Używa 0do D, 1do Ti 2do U.

Java, 144 139

Zaoszczędził 5 bajtów dzięki Kevinowi.

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

Nie golfił

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

Partia, 175 bajtów

@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

Tym razem dość proste. Pobiera dane wejściowe jako parametry wiersza polecenia, w których zapisuje si d. ejest dzaokrąglana w dół do poprzedniej wielokrotności 10. Jeśli sjest większa niż d, wtedy oczywiście musimy wywoływać, daż stanie ssię niższa niż d. W przeciwnym razie musimy sprawdzić, czy sjest niższy niż e; jeśli tak, możemy wywoływać, udopóki nie będzie srówny e. W tym miejscu sjest teraz między ea di możemy po prostu wywołać taż dotrzemy d. Zajrzałem do forpętli, ale używają one włączających punktów końcowych, więc stałoby się zbyt szczegółowe.

Python, 76 bajtów

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

C, 156 bajtów

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

Nie golfowany:

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