web-dev-qa-db-fra.com

Entier à Integer Array C #

J'ai dû diviser un int "123456" chaque valeur en int [] et j'ai déjà une solution, mais je ne sais pas s'il existe un meilleur moyen: Ma solution était:

public static int[] intToArray(int num){
    String holder = num.ToString();
    int[] numbers = new int[Holder.ToString().Length]; 
    for(int i=0;i<numbers.length;i++){
        numbers[i] = Convert.toInt32(holder.CharAt(i));
    }
    return numbers;
}
c#arraysint
14
Burimi

Je crois que ce sera mieux que de convertir en arrière. Contrairement à la réponse de JBSnorro, j’inverse après la conversion en tableau et évite donc les variables IEnumerable qui, je pense, contribueront à un code un peu plus rapide. Cette méthode fonctionne pour les nombres non négatifs, donc 0 renverra new int[1] { 0 }.

Si cela fonctionne pour les nombres négatifs, vous pourriez faire un n = Math.Abs(n) mais je ne pense pas que cela ait du sens.

De plus, s'il devait être plus performant, je pourrais commencer par créer le tableau final en effectuant une recherche binaire semblable à une combinaison d'instructions if pour déterminer le nombre de chiffres.

public static int[] digitArr(int n)
{
    if (n == 0) return new int[1] { 0 };

    var digits = new List<int>();

    for (; n != 0; n /= 10)
        digits.Add(n % 10);

    var arr = digits.ToArray();
    Array.Reverse(arr);
    return arr;
}

Mise à jour 2018: 

public static int numDigits(int n) {
    if (n < 0) {
        n = (n == Int32.MinValue) ? Int32.MaxValue : -n;
    }
    if (n < 10) return 1;
    if (n < 100) return 2;
    if (n < 1000) return 3;
    if (n < 10000) return 4;
    if (n < 100000) return 5;
    if (n < 1000000) return 6;
    if (n < 10000000) return 7;
    if (n < 100000000) return 8;
    if (n < 1000000000) return 9;
    return 10;
}

public static int[] digitArr2(int n)
{
    var result = new int[numDigits(n)];
    for (int i = result.Length - 1; i >= 0; i--) {
        result[i] = n % 10;
        n /= 10;
    }
    return result;
}
15
Lasse Espeholt

Une solution simple utilisant LINQ

 int[] result = yourInt.ToString().Select(o=> Convert.ToInt32(o)).ToArray()
22
Jahan Zinedine
int[] outarry = Array.ConvertAll(num.ToString().ToArray(), x=>(int)x);

mais si vous voulez le convertir en 1,2,3,4,5:

int[] outarry = Array.ConvertAll(num.ToString().ToArray(), x=>(int)x - 48);
11
Saeed Amiri

Utiliser la conversion de int en chaîne et retour n'est probablement pas si rapide. Je voudrais utiliser ce qui suit

public static int[] ToDigitArray(int i)
{
    List<int> result = new List<int>();
    while (i != 0)
    {
        result.Add(i % 10);
        i /= 10;
    }
    return result.Reverse().ToArray();
}

Je dois noter que cela ne fonctionne que pour les entiers strictement positifs.

MODIFIER:

Je suis venu avec une alternative. Si les performances sont réellement un problème, cela sera probablement plus rapide, même si vous ne pouvez en être sûr qu'en le vérifiant vous-même pour votre utilisation et votre application spécifiques.

public static int[] ToDigitArray(int n)
{
    int[] result = new int[GetDigitArrayLength(n)];
    for (int i = 0; i < result.Length; i++)
    {
        result[result.Length - i - 1] = n % 10;
        n /= 10;
    }
    return result;
}
private static int GetDigitArrayLength(int n)
{
    if (n == 0)
        return 1;
    return 1 + (int)Math.Log10(n);
}

Cela fonctionne lorsque n est non négatif.

5
JBSnorro

Je le ferais comme ça:

var result = new List<int>();
while (num != 0) {
    result.Insert(0, num % 10);
    num = num / 10;
}
return result.ToArray();

Un peu moins performant mais peut-être plus élégant est:

return num.ToString().Select(c => Convert.ToInt32(c.ToString())).ToArray();

Notez que tous deux renvoient 1,2,3,4,5,6 au lieu de 49,50,51,52,53,54 (c’est-à-dire les codes d’octet pour les caractères '1', '2', '3', ' 4 ',' 5 ',' 6 ') comme votre code. Je suppose que c'est l'intention réelle?

2
MarkXA

j'avais les mêmes exigences. J'ai repris de nombreuses bonnes idées et ajouté quelques pièces manquantes. Beaucoup de gens ne traitaient pas les valeurs zéro ou négatives. Voici ce que je suis venu avec:

    public static int[] DigitsFromInteger(int n)
    {
        int _n = Math.Abs(n);
        int length = ((int)Math.Log10(_n > 0 ? _n : 1)) + 1;
        int[] digits = new int[length];
        for (int i = 0; i < length; i++)
        {
            digits[(length - i) - 1] = _n % 10 * ((i == (length - 1) && n < 0) ? -1 : 1);
            _n /= 10;
        }
        return digits;
    }

je pense que cela est assez propre .. bien que, il est vrai, nous effectuons une vérification conditionnelle et plusieurs calculs superflus à chaque itération .. alors que je pense qu’ils sont nominaux dans ce cas, vous pouvez optimiser un pas supplémentaire de cette façon:

    public static int[] DigitsFromInteger(int n)
    {
        int _n = Math.Abs(n);
        int length = ((int)Math.Log10(_n > 0 ? _n : 1)) + 1;
        int[] digits = new int[length];
        for (int i = 0; i < length; i++)
        {
            //digits[(length - i) - 1] = _n % 10 * ((i == (length - 1) && n < 0) ? -1 : 1);
            digits[(length - i) - 1] = _n % 10;
            _n /= 10;
        }
        if (n < 0)
            digits[0] *= -1;
        return digits;
    }
1
jared

Vous pouvez faire cela sans le convertir en chaîne et vice versa:

public static int[] intToArray(int num) {
  List<int> numbers = new List<int>();
  do {
    numbers.Insert(0, num % 10);
    num /= 10;
  } while (num > 0);
  return numbers.ToArray();
}

Bien sûr, cela ne fonctionne que pour les valeurs positives, mais votre code d'origine a également cette limitation.

1
Guffa
string DecimalToBase(int iDec, int numbase)
        {
            string strBin = "";
            int[] result = new int[32];
            int MaxBit = 32;
            for(; iDec > 0; iDec/=numbase)
            {
                int rem = iDec % numbase;
                    result[--MaxBit] = rem;
            } 
            for (int i=0;i<result.Length;i++)
                if ((int)result.GetValue(i) >= base10)
                    strBin += cHexa[(int)result.GetValue(i)%base10];
                else
                    strBin += result.GetValue(i);
            strBin = strBin.TrimStart(new char[] {'0'});
            return strBin;
        }
        int BaseToDecimal(string sBase, int numbase)
        {
            int dec = 0;
            int b;
            int iProduct=1;
            string sHexa = "";
            if (numbase > base10)
                for (int i=0;i<cHexa.Length;i++)
                    sHexa += cHexa.GetValue(i).ToString();
            for(int i=sBase.Length-1; i>=0; i--,iProduct *= numbase)
            {
                string sValue = sBase[i].ToString();
                if (sValue.IndexOfAny(cHexa) >=0)
                    b=iHexaNumeric[sHexa.IndexOf(sBase[i])];
                else 
                    b= (int) sBase[i] - asciiDiff;
                dec += (b * iProduct);
            } 
            return dec; 
        }
1
Muthu
 private static int[] ConvertIntToArray(int variable)
        {
            string converter = "" + variable;
            int[] convertedArray = new int[converter.Length];
            for (int i=0; i < convertedArray.Length;i++) //it can be also converter.Length
            {
                convertedArray[i] = int.Parse(converter.Substring(i, 1));
            }
            return convertedArray;
        }

Nous obtenons int via using method. Ensuite, convertissez-le immédiatement en string (123456 -> "123456"). Nous avons une chaîne appelée converter et une valeur int. Notre chaîne a un string.Length, en particulier la même longueur de int. Nous créons donc une array appelée convertedArray dont nous avons la longueur, c’est-à-dire la longueur du convertisseur (string). Ensuite, nous entrons dans la boucle où nous convertissons la chaîne en int un par un en utilisant string.Substring(i,1), et affectons la valeur convertedArray[i]. Ensuite, renvoyez la convertedArray.A la main ou toute autre méthode, vous pouvez facilement appeler la méthode.

0
T.c. Dönüş Mahmut Safa

Voici une bonne solution pour convertir votre entier en tableau, par exemple: .string str = 4561; //Convertir en
array [0] = 4;
array [1] = 5;
array [2] = 6;
array [3] = 7;

Remarque: Le nombre de zéro (0) dans le diviseur est égal à la longueur de l'entrée et définissez la longueur de votre tableau en fonction de la longueur de votre entrée.
Maintenant, vérifiez le codage:

         string str=4587;
            int value = Convert.ToInt32(str);
            int[] arr = new int[4];
            int devider = 10000;
            for (int i = 0; i < str.Length; i++)
            {
                int m = 0;
                devider /= 10;
                arr[i] = value / devider;
                m = value / devider;
                value -= (m * devider);
            }
0
Muhammad Irfan

Merci à ASCII tableau de caractères . La réponse simple en utilisant LINQ ci-dessus donne la réponse + 48.

Non plus 

int[] result = youtInt.ToString().Select(o => Convert.ToInt32(o) - 48).ToArray();

ou

int[] result = youtInt.ToString().Select(o => int.Parse(o.ToString())).ToArray();

peut être utilisé

0
Sri Ram Lakshmi Narasimhan
public static int[] intToArray(int num)
{
    num = Math.Abs(num);
    int length = num.ToString().Length;
    int[] arr = new int[length];
    do
    {
        arr[--length] = num % 10;
        num /= 10;
    } while (num != 0);

    return arr;
}

La division par base système (décimale dans ce cas) supprime le chiffre le plus à droite et nous obtenons ce chiffre par opérateur restant. Nous répétons jusqu'à ce que nous obtenions un zéro. Chaque fois qu'un chiffre est supprimé, il sera stocké dans un tableau en commençant par la fin du tableau et en arrière pour éviter d'avoir à revenir à la fin du tableau. La fonction Math.Abs ​​() doit gérer l'entrée négative. Le tableau est également instancié avec la même taille que la longueur d'entrée.

0
M.Khalil