Quarante-cinquième question « Prouver offre de sécurité »: le plus petit nombre disposé dans un tableau

// questions face 45: le nombre minimum de tableau disposés
 // Titre: entrez un tableau entier positif, le tableau de tous les nombres disposés en assemblant un certain nombre d'impressions peuvent se battre
 // à un minimum tout de l'interface numérique. 3 tableau d'entrée {par exemple, 32, 321}, puis imprimez ce numéro 3
 // nombre minimum de mots qui peuvent être disposés à 321323. 

#include " cstdio " 
#include < Chaîne > 
#include <algorithme>

#pragma avertissement (désactiver: 4996) // faible vs ignorer les avertissements de sécurité

int comparer ( const  vide * strNumber1, const  vide * strNumber2);

// int type représente un nombre entier d'au plus 10 décimal 
const  int g_MaxNumberLength = 10 ;

carbonisation * g_StrCombine1 = nouveau  charbon [g_MaxNumberLength * 2 + 1 ];
carbonisation * g_StrCombine2 = nouveau  charbon [g_MaxNumberLength * 2 + 1 ];

vide PrintMinNumber ( const  int * nombres, int longueur)
{
    si (numéros de lien de nullptr || <= 0 )
         retour ;

    // tableau dans une chaîne, un tableau à deux dimensions Note ** 
    ombles ** strNumber = ( omble **) ( nouvelle nouvelle  int [longueur]);
     pour ( int I = 0 ; I <longueur; ++ I)
    {
        strNumber [i] = nouveau  charbon [g_MaxNumberLength + 1 ];
        sprintf (strNumber [i], " % d " , les nombres [i]);
    }

    qsort (strNumber, longueur, sizeof ( omble * ), comparer);

    pour ( int i = 0 ; i <longueur; ++ i)
        printf ( " % s " , strNumber [i]);
    printf ( " \ n " );

    pour ( int i = 0 ; i <longueur; ++ i)   // souviens de créer un tableau à deux dimensions pour supprimer 
        la suppression [] strNumber [i],
     la suppression [] strNumber;
}

// Si [strNumber1] [strNumber2]> [ strNumber2] [strNumber1], la valeur de retour est supérieur à 0
 // Si [strNumber1] [strNumber2] = [ strNumber2] [strNumber1], la valeur de retour est égal à 0
 // Si [strNumber1] [strNumber2 ] <[strNumber2] [strNumber1] , renvoie une valeur inférieure à 0 
int Compare ( const  vide * strNumber1, const  vide * strNumber2)
{
    // [strNumber1] [strNumber2] 
    strcpy (g_StrCombine1, * ( const  omble chevalier ** ) strNumber1);
    strcat (g_StrCombine1, * ( const  omble chevalier ** ) strNumber2);

    // [strNumber2] [strNumber1] 
    strcpy (g_StrCombine2, * ( const  omble chevalier ** ) strNumber2);
    strcat (g_StrCombine2, * ( const  omble chevalier ** ) strNumber1);

    retour strcmp (g_StrCombine1, g_StrCombine2);
}

// ==================== code de test ==================== 
annuler le test ( const  ombles * TestName, int * Numéros, int longueur, const  carbonisation * expectedResult)
{
    si (TESTNAME! = nullptr)
        printf ( " % s commence: \ n " , TESTNAME);

    si (expectedResult! = nullptr)
        printf ( " résultat attendu est: \ t% s \ n " , expectedResult);

    printf ( " résultat réel est la suivante : \ t " );
    PrintMinNumber (nombre, longueur);

    printf ( " \ n " );
}

vide Test1 ()
{
    int nombres [] = { 3 , 5 , 1 , 4 , 2 };
    Test ( " Test1 " , nombres, sizeof (chiffres) / sizeof ( int ), " 12345 " );
}

vide Test2 ()
{
    int nombres [] = { 3 , 32 , 321 };
    Test ( " Test2 " , nombres, sizeof (chiffres) / sizeof ( int ), " 321323 " );
}

vide Test3 ()
{
    int nombres [] = { 3 , 323 , 32123 };
    Test ( " Test3 " , nombres, sizeof (chiffres) / sizeof ( int ), " 321233233 " );
}

vide Test4 ()
{
    int nombres [] = { 1 , 11 , 111 };
    Test ( " Test4 " , nombres, sizeof (chiffres) / sizeof ( int ), " 111111 " );
}

// matrice de seulement un convertisseur numérique 
vide Test5 ()
{
    int nombres [] = { 321 };
    Test ( " Test5 " , nombres, sizeof (chiffres) / sizeof ( int ), " 321 " );
}

vide Test6 ()
{
    Test ( " Test6 " , nullptr, 0 , " Ne rien imprimer. " );
}


int main ( int argc, carbonisation * argv [])
{
    Test1 ();
    Test2 ();
    Test3 ();
    Test4 ();
    Test5 ();
    Test6 ();

    retourner  0 ;
}

Code d'essai

Analyse: algorithme de ligne rapide.

classe Solution {
 publique :
     string PrintMinNumber (vector < int > nombres) {
        
        int longueur = ( int ) numbers.size ();
        chaîne strNumber = "" ;
        
        tri (numbers.begin (), numbers.end (), comparer);
        
        pour ( int i = 0 ; i <longueur; ++ i)
            strNumber + = to_string (numéros [i]);
        
        retourner strNumber;
    }
    statique  bool comparer ( int strNumber1, int strNumber2)
    {
        chaîne g_StrCombine1 = "" ;
        chaîne g_StrCombine2 = "" ;
        
        // [strNumber1] [strNumber2] 
        g_StrCombine1 + = to_string (strNumber1);
        g_StrCombine1 + = to_string (strNumber2);

        // [strNumber2] [strNumber1] 
        g_StrCombine2 + = to_string (strNumber2);
        g_StrCombine2 + = to_string (strNumber1);

        retour g_StrCombine1 < g_StrCombine2;
    }
};

Cattle net hors soumettre du code