Nombre BigInteger vers binaire et inversement

Version imprimable

Salut, voici un code créer des mes propre main et sans aide, autant dire que j'en suis très fier car dès aujourd'hui, j'ai compris comment ça fonctionnais :D
C'est super facile en faite !

Le code fonctionne avec des BigInteger, comme ça, pas de soucis de débordement :D

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
Imports System.Numerics
 
Module Module1
 
    Function Bin(ByVal Nombre As BigInteger)
 
        Dim Binaire As String = ""
        Dim NombreSortie As BigInteger = 0
 
        Do
 
            NombreSortie = Nombre / 2
            Binaire += (Nombre - (NombreSortie * 2)).ToString
            Nombre = NombreSortie
 
        Loop Until Nombre = 0
 
        Return StrReverse(Binaire)
 
    End Function
 
    Function BinVal(ByVal Bin As String)
 
        Dim NombreSortie As BigInteger = 0
        Dim Bite As String = ""
 
        If Bin > "" Then
 
            For Index = 1 To Bin.Length
 
                Bite = Bin.Substring(Index - 1, 1)
 
                If Bite = "0" Then
                    NombreSortie *= 2
 
                ElseIf Bite = "1" Then
                    NombreSortie *= 2
                    NombreSortie += 1
                End If
 
            Next
 
            Return NombreSortie
        Else
 
            Return ""
        End If
 
    End Function
 
    Sub Main()
 
        Dim NombreOriginale As BigInteger = BigInteger.Parse("1234567890123456789012345678901234567890")
        Dim NombreVersBinaire As String = Bin(NombreOriginale)
        Dim BinaireVersNombre As BigInteger = BinVal(NombreVersBinaire)
 
        Debug.WriteLine(NombreOriginale.ToString & " En Binaire = " & NombreVersBinaire)
        Debug.WriteLine(NombreVersBinaire & " Vers Nombre = " & BinaireVersNombre.ToString)
 
    End Sub
 
End Module

N'oubliez pas d'ajouter la référence System.Numerics à votre projet pour que ceci fonctionne !

Edit : je reprend la forme de mon commentaire qui passais pour condescendant.

Félicitation pour ton programme, cela fait toujours plaisir de réussir quelque chose sur lequel on a passé du temps.

Tu peux faire tout simplement :
Code:

1 2 3 4 5 6 7 8 9 10 int a = 254; Console.WriteLine("Binaire : {0}", Convert.ToString(a,2)); Console.WriteLine("Octal : {0}", Convert.ToString(a, 8)); Console.WriteLine("Hexadécimal : {0}", Convert.ToString(a, 16)); Console.ReadLine();
et je sais aussi que l'on peut faire ceci :
Code:

1 2 3 BigInteger b = BigInteger.Parse("1234567890123456789012345678901234567890"); Console.WriteLine("Hexadécimal : {0}", b.ToString("X"));
Après une première recherche, on ne peut pas provider les BigInteger en binaire simplement en string. En revanche par une requête Linq qui prend les éléments hexa 4 par 4 et les transforme en base 2 tu doit pouvoir faire le taf en une ligne de code sans réaliser un seul calcul.

For fun :

Code:

1
2
3
4
 
BigInteger b = BigInteger.Parse("1234567890123456789012345678901234567890");
 
var arr = b.ToByteArray().Select(x =>Convert.ToString( Convert.ToInt32(string.Format("{0:X2}", x), 16),2)).Aggregate(new StringBuilder(), (sb,current)=> { return sb.Append(current);}).ToString();

Juste sur le code (pas sur la manière de procéder) il y a moyen de simplifier encore un peu :
Pas besoin de formater le byte en string hexa pour le convertir en entier en base 16 et reconvertir ça en base 2 il existe déjà une surcharge de Convert.ToString qui prend un directement byte et une base.
Du coup on peut se passer du Select et directement faire un Aggregate et tant qu'à faire laisser tomber le bloc "lambda" qui se contente de retourner une valeur et directement passer une lambda "inline" (ça évitera deux accolades et un return inutiles)
Sur un plan un peu plus personnel, je préfère utiliser la surcharge d'Aggregate qui prend en plus un "resultSelector" pour appliquer une transformation finale au dernier résultat accumulé et ainsi retourner le StringBuilder.ToString là plutôt que de faire le ToString à la fin

Ce qui donne :
Code:

1 2 3 4 5 6 7 var number = BigInteger.Parse ("1234567890123456789012345678901234567890"); var binaryString = number.ToByteArray () .Aggregate (new StringBuilder (), (builder, x) => builder.Append (Convert.ToString (x, 2)), builder => builder.ToString ());
Maintenant je ne suis pas certain qu'en l'état ça donne forcément les bons résultats, ToByteArray renvoie les bytes dans "l'ordre inverse" (Little Endian) il faudrait donc soit parcourir à l'envers (avec un Reverse) soit insérer en début de StringBuilder (avec Insert(0, valeur)) mais surtout parce qu'il y a potentiellement un élément en plus pour le bit de signe si nécessaire qui fausse les choses :)

Cordialement !

06/11/2014, 23h44
worm83

Oui ok, effectivement c'est mieux, j'avoue que j'ai pas forcément chercher à l'optimiser, j'aurais dû, c’était juste pour la faisabilité.

Merci pour le retour ^^.
07/11/2014, 19h06
Lord - Nelson

Bonjour, merci pour vos retour même si c'est en VB.Net que j'ai codé et pas en #C :aie:
08/11/2014, 11h25
worm83

C'est pas grave c'est de .Net, tu peux écrire la même chose en vb.

Sehnsucht, ton code ne fonctionne pas il me semble, après vérification, il semble erroné !
Convertie en VB.Net:
Code:

1 2 3 Dim Nombre = BigInteger.Parse("1234567890123456789012345678901234567890") Dim Binaire = Nombre.ToByteArray().Aggregate(New StringBuilder(), Function(builder, x) builder.Append(Convert.ToString(x, 2)), Function(builder) builder.ToString()) Debug.WriteLine(Binaire)
Ton code montre: 1234567890123456789012345678901234567890 = 1110100000110010010010000001110101110000001101101111110011101110001010110010111100010111111001011011001110001111110000101011010010
Mon code Montre: 1234567890123456789012345678901234567890 = 110100101010111111110011101001011010111111011110010101100101110001111001111011011110000001110101100000110010011010000011

Ou est l’erreur ?

worm83, ton code à toi bien qu’incompréhensible fonctionne très bien à première vue :)
Merci.

1 pièce(s) jointe(s)

Probablement parce que je n'ai jamais prétendu qu'il était fonctionnel :) car en l'état aucune des versions présentées n'est totalement fonctionnelle (pour différentes raisons, certaines en partie expliquées dans mon précédent post)
ci-joint un bout de code et un screen pour illustrer (note: le code n'est pas le plus propre du monde car ce n'était pas le but)

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
Imports System.Numerics
Imports System.Text
 
Module Module1
 
    Sub Main()
        Dim fromBinary = Function(str As String) As BigInteger
                             Dim result = BigInteger.Zero
                             Dim bit = ""
                             For i = 0 To str.Length - 1
                                 result *= 2
                                 If str(i) = "1"c Then result += 1
                             Next
                             Return result
                         End Function
 
        Dim fcts As New Dictionary(Of String, Func(Of BigInteger, String)) From {
            {"Lord - Nelson", Function(number As BigInteger) As String
                                  Dim result = ""
                                  Dim tmp = BigInteger.Zero
                                  Do
                                      tmp = number / 2
                                      result &= (number - (tmp * 2)).ToString
                                      number = tmp
                                  Loop Until number = 0
                                  Return StrReverse(result)
                              End Function},
            {"worm83", Function(number As BigInteger) number.ToByteArray.Select(Function(x) Convert.ToString(Convert.ToInt32(String.Format("{0:X2}", x), 16), 2)).Aggregate(New StringBuilder, Function(sb, current) sb.Append(current)).ToString},
            {"Sehnsucht", Function(number As BigInteger) number.ToByteArray.Aggregate(New StringBuilder, Function(builder, x) builder.Append(Convert.ToString(x, 2)), Function(builder) builder.ToString)}
        }
 
        For Each sample As BigInteger In {-255, -128, -127, 127, 128, 255}
            For Each fct In fcts
                Console.WriteLine("{0,-13} : {1,4} => {2,-16} => {3}", fct.Key, sample, fct.Value(sample), fromBinary(fct.Value(sample)))
            Next
            Console.Write(New String("-"c, Console.WindowWidth))
        Next
    End Sub
 
End Module

Pièce jointe 160967

10/11/2014, 00h13
Sehnsucht

Citation:

The individual bytes in the array returned by this method appear in little-endian order. That is, the lower-order bytes of the value precede the higher-order bytes.

(version "française" au besoin: )

Citation:

Les octets individuels du tableau retourné par cette méthode respectent l'ordre avec primauté des octets de poids faible (little-endian). Autrement dit, les octets d'ordre inférieur de la valeur précèdent les octets d'ordre supérieur.

Autrement dit par exemple pour le nombre 256 ToByteArray renverra un tableau contenant {0, 1} c'est à dire le bit de poid-fort à la fin (sans compter le bit de signe éventuel) alors qu'en représentation "base 256" (la plage d'un byte) on écrirait plutôt 256 comme égal à 10 c'est à dire le bit de poid-fort au début
C'est dans ce sens là que je parlais "d'inversé" ; en y mettant déjà des guillemets parce qu'il n'y a pas vraiment d'ordre plus légitime qu'un autre :)