Hola.

¿En qué lenguaje lo necesitas?

No parece algo complicado.

No tengo noción de C, pero no debe ser complicado la verdad.

Yo creo que alguien con una idea en el lenguaje puede hacerlo sin problemas, pero bueno...

Te dejo una referencia de lo que deberías hacer pero en Python a ver si te sirve de algo:

ejemplo = "1359182"
presolucion = max(ejemplo)
presolucion2 = ejemplo.replace(presolucion, '')
solucionfinal = presolucion2+presolucion
print("Ejemplo: "+ejemplo)
print("Solucion: "+solucionfinal)
 
#El code de arriba devuelve:
 
Ejemplo: 1359182
Solucion: 1351829
 

Te advierto de antemano, que aquí no realizan tareas y hubo revuelo sobre eso hace poco, así que te recomiendo aportar lo que intentaste.

Edito:
En cuando a la recursividad, lo mismo, no es nada complejo hacer algo así...

Saludos.

Hola @ronbay

Las reglas dictan que no está permitido la realización de tareas, pero estoy seguro que muchos te ayudarán si dejas un adelanto, con un esfuerzo notorio.

Lo que se me ocurre para realizar lo que quieres, es usar Módulo (en C y muchos otros lenguajes es %) primero contra el número, el resultado almacenarlo en un arreglo, luego dividirlo entre 10 y realizar esta operación sucesivamente hasta que la variable donde se haga referencia al número sea 0.

Una vez realizado todas estas operaciones, puedes hacer dos cosas, aunque eso depende de tus necesidades: puedes usar algún algoritmo de ordenamiento si deseas un orden de menor a mayor, aunque no quedará exactamente como la solución que propones; también puedes usar otra variable donde hará referencia al número mayor del arreglo que se está recorriendo, que a su vez éste debe intercambiarse con el último elemento del arreglo.

Por último, pero esto puede ser opcional si desea "reconstruir el número", es, a partir del inicio del inicio del arreglo, obtener ese elemento, multiplicarlo con 10, sumarle el segundo elemento, y así con los mismos números. Debería obtener el número "reconstruido" pero con el número mayor recorrido.

Es opcional, como le dije, ya que si no es importante, puede imprimir la lista tal cual recorriendo el arreglo y después de ello, imprimir una nueva línea.

Espero le sirva.

~ DtxdF

@ronbay

#include <stdio.h>
#include <stdlib.h>
 
#define MAX_N 9
 
typedef struct {
    int max_number;
    int index;
} number;
 
int main(void)
{
    int n = 358267;
    int array[MAX_N], *array_ptr = array;
    int aux, tmp;
    register int i = 0;
 
    /* Extraemos cada digito */
    while (n != 0 && i < MAX_N) {
        *array_ptr++ = n % 10;
 
        n /= 10;
        i++;
    }
 
    /* Usamos el ordenamiento burbuja */
    for (int aux_i = 0; aux_i < i; aux_i++) {
        for (int aux_j = 0; aux_j < i-1; aux_j++) {
            if (array[aux_j] > array[aux_j+1]) {
                aux = array[aux_j];
                array[aux_j] = array[aux_j+1];
                array[aux_j+1] = aux;
            }
        }
    }
 
    number mynumber;
    mynumber.index = 0;
    mynumber.max_number = 0;
 
    /* Extraemos el número mayor */
    int j;
    for (j = 0; j < i; j++)
        if (array[j] > mynumber.max_number) {
            mynumber.max_number = array[j];
            mynumber.index = j;
        }
 
    /* Lo intercambiamos con el último y el número mayor */
    tmp = array[--j];
    array[j] = mynumber.max_number;
    array[mynumber.index] = tmp;
 
    /* Reconstruimos el número */
    int k, r = 0;
    for (k = 0; k < i; k++) {
        r *= 10;
        r += array[k];
    }
 
    printf("%d\n", r);
 
    return EXIT_SUCCESS;
}

No es recursivo, y tampoco sé si es lo que deseas, pero te puede servir para dar un paso más.

~ DtxdF

 
#include <stdlib.h>
#include <stdio.h>
void recursive(int number, int *arr, int *i)
{
    arr[*i] = number % 10;
    *i += 1;
    if (number >= 10)
        recursive(number / 10, arr, i);
    else
    {
        //Ordenas el arreglo y corres las posiciones
    }
}
int main(void)
{
    int num = 382731, arr[10], size = 0;
    recursive(num, arr, &size);
    for (int i = size - 1; i >= 0; i--)
        printf("%d", arr[i]);
}
 

Esta es una implementación recursiva, estas obteniendo digito a digito guardandolo en arr , en el else solo debes obtener el mayor e intercambiar posiciones deberias usar un arreglo auxiliar para correr las posiciones.

Espero te sea util