Un régulateur de vitesse a 3 options différentes pour déplacer la poignée afin de régler la vitesse avec laquelle vous voulez conduire.

• Vers vous: ajoute 1 vitesse.
• Vers le haut: augmente la vitesse au multiple de 10 suivant (par exemple 20 -> 30, 32 -> 40)
• Vers le bas: diminue la vitesse au multiple de 10 suivant (par exemple 20 -> 10, 32 -> 30)

Contribution

• 2 entiers: le premier est la vitesse de départ et le second est la vitesse souhaitée, à la fois non négative et sous la forme que vous souhaitez (tableau, deux arguments, etc.)

Tâche

• Déterminez la manière optimale d'utiliser la poignée pour atteindre la vitesse souhaitée et imprimez les mouvements dans le bon ordre.

Règles

• Si vous avez le choix entre tirer vers vous et monter (comme de 39 à 40), vous pouvez choisir l'une ou l'autre option, mais restez avec ce que vous choisissez pour des cas similaires
• Vous pouvez utiliser 3 symboles différents (de préférence visibles) pour distinguer les mouvements dans la sortie (T, U et D par exemple).
• Les symboles peuvent être séparés par de nouvelles lignes, espaces, etc. mais ne doivent pas être

Voici quelques cas de 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  -->  

Il s'agit de code-golf donc la réponse la plus courte en octets l'emporte.

JavaScript (ES6), 91 84 75 octets

4 octets enregistrés grâce à @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):""

Utilise 0pour D, 1pour Tet 2pour U.

Java, 144 139

Enregistré 5 octets grâce à 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);

Non golfé

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

Lot, 175 octets

@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

Assez simple cette fois. Prend l'entrée en tant que paramètres de ligne de commande, qu'il enregistre dans set d. eest darrondi au multiple de 10. Si sest supérieur à d, alors nous devons évidemment invoquer djusqu'à ce que sdevienne inférieur à d. Sinon, nous devons vérifier si elle sest inférieure à e; si c'est le cas, nous pouvons invoquer ujusqu'à ce que ségal e. À ce stade sest maintenant entre eet det nous pouvons simplement invoquer tjusqu'à ce que nous atteignions d. J'ai examiné les forboucles mais elles utilisent des points de terminaison inclusifs, elles seraient donc devenues trop verbeuses.

Python, 76 octets

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

C, 156 octets

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

Non golfé:

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