Konwertuj liczbę całkowitą na binarną w C #

Jak przekonwertować liczbę całkowitą na jej reprezentację binarną?

Używam tego kodu:

String input = "8";
String output = Convert.ToInt32(input, 2).ToString();

Ale rzuca wyjątek:

Nie można znaleźć żadnych cyfr parsowalnych

Twój przykład ma liczbę całkowitą wyrażoną jako ciąg. Powiedzmy, że twoja liczba całkowita była w rzeczywistości liczbą całkowitą i chcesz wziąć liczbę całkowitą i przekonwertować ją na ciąg binarny.

int value = 8;
string binary = Convert.ToString(value, 2);

Który zwraca 1000.

Konwertuj z dowolnej klasycznej bazy na dowolną bazę w C #

String number = "100";
int fromBase = 16;
int toBase = 10;

String result = Convert.ToString(Convert.ToInt32(number, fromBase), toBase);

// result == "256"

Obsługiwane bazy to 2, 8, 10 i 16

Bardzo prosty, bez dodatkowego kodu, tylko wprowadzanie, konwersja i wyjście.

using System;

namespace _01.Decimal_to_Binary
{
    class DecimalToBinary
    {
        static void Main(string[] args)
        {
            Console.Write("Decimal: ");
            int decimalNumber = int.Parse(Console.ReadLine());

            int remainder;
            string result = string.Empty;
            while (decimalNumber > 0)
            {
                remainder = decimalNumber % 2;
                decimalNumber /= 2;
                result = remainder.ToString() + result;
            }
            Console.WriteLine("Binary:  {0}",result);
        }
    }
}

http://zamirsblog.blogspot.com/2011/10/convert-decimal-to-binary-in-c.html

    public string DecimalToBinary(string data)
    {
        string result = string.Empty;
        int rem = 0;
        try
        {
            if (!IsNumeric(data))
                error = "Invalid Value - This is not a numeric value";
            else
            {
                int num = int.Parse(data);
                while (num > 0)
                {
                    rem = num % 2;
                    num = num / 2;
                    result = rem.ToString() + result;
                }
            }
        }
        catch (Exception ex)
        {
            error = ex.Message;
        }
        return result;
    }

prymitywny sposób:

public string ToBinary(int n)
{
    if (n < 2) return n.ToString();

    var divisor = n / 2;
    var remainder = n % 2;

    return ToBinary(divisor) + remainder;
}

Convert.ToInt32(string, base)nie dokonuje konwersji bazy do bazy. Zakłada, że ​​ciąg zawiera poprawną liczbę we wskazanej bazie i konwertuje na bazę 10.

Otrzymujesz błąd, ponieważ „8” nie jest prawidłową cyfrą w bazie 2.

String str = "1111";
String Ans = Convert.ToInt32(str, 2).ToString();

Pokaże 15(1111 podstawa 2 = 15 podstawa 10)

String str = "f000";
String Ans = Convert.ToInt32(str, 16).ToString();

Pokaże 61440.

Wiem, że ta odpowiedź wyglądałaby podobnie do większości odpowiedzi już tutaj, ale zauważyłem, że prawie żadna z nich nie używa pętli for. Ten kod działa i można go uznać za prosty, w tym sensie, że będzie działał bez żadnych specjalnych funkcji, takich jak ToString () z parametrami, i nie jest zbyt długi. Może niektórzy wolą pętle for zamiast pętli while, może to być dla nich odpowiednie.

public static string ByteConvert (int num)
{
    int[] p = new int[8];
    string pa = "";
    for (int ii = 0; ii<= 7;ii = ii +1)
    {
        p[7-ii] = num%2;
        num = num/2;
    }
    for (int ii = 0;ii <= 7; ii = ii + 1)
    {
        pa += p[ii].ToString();
    }
    return pa;
}

using System;

class Program 
{
    static void Main(string[] args) {

        try {

            int i = (int) Convert.ToInt64(args[0]);
            Console.WriteLine("\n{0} converted to Binary is {1}\n", i, ToBinary(i));

        } catch(Exception e) {
            Console.WriteLine("\n{0}\n", e.Message);
        }
    }

    public static string ToBinary(Int64 Decimal) {
        // Declare a few variables we're going to need
        Int64 BinaryHolder;
        char[] BinaryArray;
        string BinaryResult = "";

        while (Decimal > 0) {
            BinaryHolder = Decimal % 2;
            BinaryResult += BinaryHolder;
            Decimal = Decimal / 2;
        }

        BinaryArray = BinaryResult.ToCharArray();
        Array.Reverse(BinaryArray);
        BinaryResult = new string(BinaryArray);

        return BinaryResult;
    }
}

Inną alternatywą, ale również wbudowanym rozwiązaniem wykorzystującym Enumerablei LINQjest:

int number = 25;

string binary = Enumerable.Range(0, (int) Math.Log(number, 2) + 1).Aggregate(string.Empty, (collected, bitshifts) => ((number >> bitshifts) & 1 )+ collected);

Ta funkcja konwertuje liczbę całkowitą na binarną w języku C #:

public static string ToBinary(int N)
{
    int d = N;
    int q = -1;
    int r = -1;

    string binNumber = string.Empty;
    while (q != 1)
    {
        r = d % 2;
        q = d / 2;
        d = q;
        binNumber = r.ToString() + binNumber;
    }
    binNumber = q.ToString() + binNumber;
    return binNumber;
}

class Program
{
    static void Main(string[] args)
    {
        var @decimal = 42;
        var binaryVal = ToBinary(@decimal, 2);

        var binary = "101010";
        var decimalVal = ToDecimal(binary, 2);

        Console.WriteLine("Binary value of decimal {0} is '{1}'", @decimal, binaryVal);
        Console.WriteLine("Decimal value of binary '{0}' is {1}", binary, decimalVal);
        Console.WriteLine();

        @decimal = 6;
        binaryVal = ToBinary(@decimal, 3);

        binary = "20";
        decimalVal = ToDecimal(binary, 3);

        Console.WriteLine("Base3 value of decimal {0} is '{1}'", @decimal, binaryVal);
        Console.WriteLine("Decimal value of base3 '{0}' is {1}", binary, decimalVal);
        Console.WriteLine();


        @decimal = 47;
        binaryVal = ToBinary(@decimal, 4);

        binary = "233";
        decimalVal = ToDecimal(binary, 4);

        Console.WriteLine("Base4 value of decimal {0} is '{1}'", @decimal, binaryVal);
        Console.WriteLine("Decimal value of base4 '{0}' is {1}", binary, decimalVal);
        Console.WriteLine();

        @decimal = 99;
        binaryVal = ToBinary(@decimal, 5);

        binary = "344";
        decimalVal = ToDecimal(binary, 5);

        Console.WriteLine("Base5 value of decimal {0} is '{1}'", @decimal, binaryVal);
        Console.WriteLine("Decimal value of base5 '{0}' is {1}", binary, decimalVal);
        Console.WriteLine();

        Console.WriteLine("And so forth.. excluding after base 10 (decimal) though :)");
        Console.WriteLine();


        @decimal = 16;
        binaryVal = ToBinary(@decimal, 11);

        binary = "b";
        decimalVal = ToDecimal(binary, 11);

        Console.WriteLine("Hexidecimal value of decimal {0} is '{1}'", @decimal, binaryVal);
        Console.WriteLine("Decimal value of Hexidecimal '{0}' is {1}", binary, decimalVal);
        Console.WriteLine();
        Console.WriteLine("Uh oh.. this aint right :( ... but let's cheat :P");
        Console.WriteLine();

        @decimal = 11;
        binaryVal = Convert.ToString(@decimal, 16);

        binary = "b";
        decimalVal = Convert.ToInt32(binary, 16);

        Console.WriteLine("Hexidecimal value of decimal {0} is '{1}'", @decimal, binaryVal);
        Console.WriteLine("Decimal value of Hexidecimal '{0}' is {1}", binary, decimalVal);

        Console.ReadLine();
    }


    static string ToBinary(decimal number, int @base)
    {
        var round = 0;
        var reverseBinary = string.Empty;

        while (number > 0)
        {
            var remainder = number % @base;
            reverseBinary += remainder;

            round = (int)(number / @base);
            number = round;
        }

        var binaryArray = reverseBinary.ToCharArray();
        Array.Reverse(binaryArray);

        var binary = new string(binaryArray);
        return binary;
    }

    static double ToDecimal(string binary, int @base)
    {
        var val = 0d;

        if (!binary.All(char.IsNumber))
            return 0d;

        for (int i = 0; i < binary.Length; i++)
        {
            var @char = Convert.ToDouble(binary[i].ToString());

            var pow = (binary.Length - 1) - i;
            val += Math.Pow(@base, pow) * @char;
        }

        return val;
    }
}

Źródła nauki:

Wszystko, co musisz wiedzieć o systemie binarnym

w tym algorytm do konwersji dziesiętnej na binarną

    static void convertToBinary(int n)
    {
        Stack<int> stack = new Stack<int>();
        stack.Push(n);
        // step 1 : Push the element on the stack
        while (n > 1)
        {
            n = n / 2;
            stack.Push(n);
        }

        // step 2 : Pop the element and print the value
        foreach(var val in stack)
        {
            Console.Write(val % 2);
        }
     }

class Program{

   static void Main(string[] args){

      try{

     int i = (int)Convert.ToInt64(args[0]);
         Console.WriteLine("\n{0} converted to Binary is {1}\n",i,ToBinary(i));

      }catch(Exception e){

         Console.WriteLine("\n{0}\n",e.Message);

      }

   }//end Main


        public static string ToBinary(Int64 Decimal)
        {
            // Declare a few variables we're going to need
            Int64 BinaryHolder;
            char[] BinaryArray;
            string BinaryResult = "";

            while (Decimal > 0)
            {
                BinaryHolder = Decimal % 2;
                BinaryResult += BinaryHolder;
                Decimal = Decimal / 2;
            }

            // The algoritm gives us the binary number in reverse order (mirrored)
            // We store it in an array so that we can reverse it back to normal
            BinaryArray = BinaryResult.ToCharArray();
            Array.Reverse(BinaryArray);
            BinaryResult = new string(BinaryArray);

            return BinaryResult;
        }


}//end class Program

BCL pod warunkiem Convert.ToString(n, 2) jest dobre, ale na wypadek, gdybyś potrzebował alternatywnej implementacji, która jest kilka tyknięć szybsza niż dostarczona przez BCL.

Po niestandardowej implementacji działa dla wszystkich liczb całkowitych (-ve i + ve). Oryginalne źródło pochodzi z https://davidsekar.com/algorithms/csharp-program-to-convert-decimal-to-binary

static string ToBinary(int n)
{
    int j = 0;
    char[] output = new char[32];

    if (n == 0)
        output[j++] = '0';
    else
    {
        int checkBit = 1 << 30;
        bool skipInitialZeros = true;
        // Check the sign bit separately, as 1<<31 will cause
        // +ve integer overflow
        if ((n & int.MinValue) == int.MinValue)
        {
            output[j++] = '1';
            skipInitialZeros = false;
        }

        for (int i = 0; i < 31; i++, checkBit >>= 1)
        {
            if ((n & checkBit) == 0)
            {
                if (skipInitialZeros)
                    continue;
                else
                    output[j++] = '0';
            }
            else
            {
                skipInitialZeros = false;
                output[j++] = '1';
            }
        }
    }

    return new string(output, 0, j);
}

Powyższy kod to moja implementacja. Z niecierpliwością czekam na wszelkie uwagi :)

    // I use this function
    public static string ToBinary(long number)
    {
        string digit = Convert.ToString(number % 2);
        if (number >= 2)
        {
            long remaining = number / 2;
            string remainingString = ToBinary(remaining);
            return remainingString + digit;
        }
        return digit;
     }

        static void Main(string[] args) 
        {
        Console.WriteLine("Enter number for converting to binary numerical system!");
        int num = Convert.ToInt32(Console.ReadLine());
        int[] arr = new int[16];

        //for positive integers
        if (num > 0)
        {

            for (int i = 0; i < 16; i++)
            {
                if (num > 0)
                {
                    if ((num % 2) == 0)
                    {
                        num = num / 2;
                        arr[16 - (i + 1)] = 0;
                    }
                    else if ((num % 2) != 0)
                    {
                        num = num / 2;
                        arr[16 - (i + 1)] = 1;
                    }
                }
            }
            for (int y = 0; y < 16; y++)
            {
                Console.Write(arr[y]);
            }
            Console.ReadLine();
        }

        //for negative integers
        else if (num < 0)
        {
            num = (num + 1) * -1;

            for (int i = 0; i < 16; i++)
            {
                if (num > 0)
                {
                    if ((num % 2) == 0)
                    {
                        num = num / 2;
                        arr[16 - (i + 1)] = 0;
                    }
                    else if ((num % 2) != 0)
                    {
                        num = num / 2;
                        arr[16 - (i + 1)] = 1;
                    }
                }
            }

            for (int y = 0; y < 16; y++)
            {
                if (arr[y] != 0)
                {
                    arr[y] = 0;
                }
                else
                {
                    arr[y] = 1;
                }
                Console.Write(arr[y]);
            }
            Console.ReadLine();
        }           
    }

Może to być pomocne, jeśli potrzebujesz zwięzłej funkcji, którą możesz wywołać z głównej metody w swojej klasie. Być może nadal będziesz musiał zadzwonić, int.Parse(toBinary(someint))jeśli potrzebujesz numeru zamiast ciągu, ale uważam, że ta metoda działa całkiem dobrze. Dodatkowo można to dostosować, aby użyć forpętli zamiast do- whilejeśli wolisz.

    public static string toBinary(int base10)
    {
        string binary = "";
        do {
            binary = (base10 % 2) + binary;
            base10 /= 2;
        }
        while (base10 > 0);

        return binary;
    }

toBinary(10)zwraca ciąg "1010".

Problem ten napotkałem podczas wyzwania kodowania, w którym musisz przekonwertować 32-cyfrowy dziesiętny na binarny i znaleźć możliwą kombinację podłańcucha.

using System;
using System.Collections.Generic;
using System.Globalization;
using System.Numerics;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApp2
{
    class Program
    {

        public static void Main()
        {
            int numberofinputs = int.Parse(Console.ReadLine());
            List<BigInteger> inputdecimal = new List<BigInteger>();
            List<string> outputBinary = new List<string>();


            for (int i = 0; i < numberofinputs; i++)
            {
                inputdecimal.Add(BigInteger.Parse(Console.ReadLine(), CultureInfo.InvariantCulture));
            }
            //processing begins 

            foreach (var n in inputdecimal)
            {
                string binary = (binaryconveter(n));
                subString(binary, binary.Length);
            }

            foreach (var item in outputBinary)
            {
                Console.WriteLine(item);
            }

            string binaryconveter(BigInteger n)
            {
                int i;
                StringBuilder output = new StringBuilder();

                for (i = 0; n > 0; i++)
                {
                    output = output.Append(n % 2);
                    n = n / 2;
                }

                return output.ToString();
            }

            void subString(string str, int n)
            {
                int zeroodds = 0;
                int oneodds = 0;

                for (int len = 1; len <= n; len++)
                {

                    for (int i = 0; i <= n - len; i++)
                    {
                        int j = i + len - 1;

                        string substring = "";
                        for (int k = i; k <= j; k++)
                        {
                            substring = String.Concat(substring, str[k]);

                        }
                        var resultofstringanalysis = stringanalysis(substring);
                        if (resultofstringanalysis.Equals("both are odd"))
                        {
                            ++zeroodds;
                            ++oneodds;
                        }
                        else if (resultofstringanalysis.Equals("zeroes are odd"))
                        {
                            ++zeroodds;
                        }
                        else if (resultofstringanalysis.Equals("ones are odd"))
                        {
                            ++oneodds;
                        }

                    }
                }
                string outputtest = String.Concat(zeroodds.ToString(), ' ', oneodds.ToString());
                outputBinary.Add(outputtest);
            }

            string stringanalysis(string str)
            {
                int n = str.Length;

                int nofZeros = 0;
                int nofOnes = 0;

                for (int i = 0; i < n; i++)
                {
                    if (str[i] == '0')
                    {
                        ++nofZeros;
                    }
                    if (str[i] == '1')
                    {
                        ++nofOnes;
                    }

                }
                if ((nofZeros != 0 && nofZeros % 2 != 0) && (nofOnes != 0 && nofOnes % 2 != 0))
                {
                    return "both are odd";
                }
                else if (nofZeros != 0 && nofZeros % 2 != 0)
                {
                    return "zeroes are odd";
                }
                else if (nofOnes != 0 && nofOnes % 2 != 0)
                {
                    return "ones are odd";
                }
                else
                {
                    return "nothing";
                }

            }
            Console.ReadKey();
        }

    }
}

    int x=550;
    string s=" ";
    string y=" ";

    while (x>0)
    {

        s += x%2;
        x=x/2;
    }


    Console.WriteLine(Reverse(s));
}

public static string Reverse( string s )
{
    char[] charArray = s.ToCharArray();
    Array.Reverse( charArray );
    return new string( charArray );
}