Question

想知道如何以反向填充零的方式将int转换为List，反之亦然？

有一个表示List（8）的字节，有时是List（16）的2个字节，List（64）的8个字节;所以寻找一个好的解决方案来处理转换为int列表，然后再操作。

e.g。输入3到1,1,0,0,0,0,0,0

的列表

或输入42到0,1,0,1,0,1,0,0

列表

反之亦然，取一个1,1,0,0,0,0,0,0的清单并返回3或0,1,0,1,0,1,0,0的清单并返回42

我目前所做的是构建一些功能来处理这两种情况，一切正常，只是想知道是否有一个更好/更优雅的解决方案，我完全忽略了？

    private List<int> IntToList(int _Input)
    {
        string _Binary = ReverseString(Convert.ToString(_Input, 2).PadLeft(8, '0'));
        List<int> _List = new List<int>(8);
        for (int i = 0; i < _Binary.Length; i++)
        {
            _List.Add(Convert.ToInt32(_Binary.Substring(i, 1)));
        }
        return _List;            
    }

    private int IntsToByte(List<int> _List)
    {
        string _Binary = "";
        for (int i = 7; i > -1; i--)
        {
            _Binary += _List[i];
        }
        return Convert.ToInt32(_Binary, 2);            
    }

Answer 1

您可以使用按位操作。他们可能很快。

警告：注意Little / Big Endian（More here）

以下代码有效：

  private List<int> IntToList(int _Input, int _MaxSize = 8)
  {
    int padding = 1;
    List<int> resultList = new List<int>(_MaxSize);
    while (padding < 1 << _MaxSize)
      {
        resultList.Add((_Input & padding) == padding ? 1 : 0);
        padding = padding << 1;
      }
    return resultList;            
  }

  private int IntsToByte(List<int> _List)
  {
    int result = 0, padding = 0;
    foreach (int i in _List)
    {
        result = result | (i << padding++);
    }
    return result;            
  }

Answer 2

这应该有效

int number = 42
char[] reverse = Convert.ToString(number, 2).PadLeft(8, '0').ToCharArray();
Array.Reverse(reverse);

Answer 3

试试这个

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            List<ulong> results = null;
            List<byte> output = null;
            List<byte> input1 = new List<byte>() { 1, 1, 0, 0, 0, 0, 0, 0 };
            results = ReadList(input1, 1);
            output = WriteList(results,1);
            List<byte> input2 = new List<byte>() { 0, 1, 0, 1, 0, 1, 0, 0 };
            results = ReadList(input2, 1);
            output = WriteList(results,1);

        }
        static List<ulong> ReadList(List<byte> input, int size)
        {
            List<ulong> results = new List<ulong>();
            input.Reverse();
            MemoryStream stream = new MemoryStream(input.ToArray());
            BinaryReader reader = new BinaryReader(stream);
            int count = 0;
            ulong newValue = 0;
            while (reader.PeekChar() != -1)
            {

                switch (size)
                {
                    case 1:
                        newValue = ((ulong)Math.Pow(2, size) * newValue) + (ulong)reader.ReadByte();
                        break;
                    case 2:
                        newValue = ((ulong)Math.Pow(2, size) * newValue) + (ulong)reader.ReadInt16();
                        break;
                }
                if (++count == size)
                {
                    results.Add(newValue);
                    newValue = 0;
                    count = 0;
                }
            }
            return results;
        }
        static List<byte> WriteList(List<ulong> input, int size)
        {
            List<byte> results = new List<byte>();
            foreach (ulong num in input)
            {
                ulong result = num;
                for (int count = 0; count < size; count++)
                {
                    if (result > 0)
                    {
                        byte bit = (byte)(result % Math.Pow(2, size));
                        results.Add(bit);
                        result = (ulong)(result / Math.Pow(2, size));
                    }
                    else
                    {
                        results.Add(0);
                    }
                }
            }
            results.Reverse();
            return results;
        }
    }
}

Answer 4

来自OP的

解决方案。

Jean Bob建议使用BitWise。

对于任何人都可以获益，这里是我修改后的版本，可以在列表中以8块为单位进行读/写。

private List<int> IntToList(List<int> _List, int _Input)
{
   int _Padding = 1;
   while (_Padding < 1 << 8)
    {
        _List.Add((_Input & _Padding) == _Padding ? 1 : 0);
        _Padding = _Padding << 1;
    }
    return _List;           
}

private int IntsToByte(List<int> _List, int l)
{
    int _Result = 0, _Padding = 0;
    for (int i = l; i < (l + 8); i++)
    {
        _Result = _Result | (_List[i] << _Padding++);
    }
    return _Result;
}

将byte / int转换为List <int> reverse，反之亦然

4 个答案: