在c#中，哪种方法更好？

我想做点什么：

  Input  <=  3432

  Output =>  List contains 7 items i.e. (3, 1000, 4, 100, 3, 10, 2) 

输入列表包含7项，即（3、1000、4、100、3、10、2）

为此，我用c#编写了一个函数：

public biginger from decimal（）
{
列表编号=新列表（）；
biginger number=biginger.Parse（NumberString）；
而（数量>0）
{
如果（数量>=100000000）
{
编号。添加（编号/100000000）；
数字=数字%100000000；
数字。添加（100000000）；
}
否则，如果（数量>=100000000）
{
编号。添加（编号/100000000）；
编号=编号%100000000；
增加（100000000）；
}
否则，如果（数量>=10000000）
{
编号。添加（编号/10000000）；
编号=编号%10000000；
增加（10000000）；
}
否则，如果（数量>=1000000）
{
数量。添加（数量/1000000）；
编号=编号%1000000；
增加（1000000）；
}
否则，如果（数量>=100000）
{
数量。添加（数量/100000）；
数量=数量%100000；
增加（100000）；
}
否则，如果（数量>=10000）
{
数量。添加（数量/10000）；
数量=数量%10000；
增加（10000）；
}
否则，如果（数字>=1000）
{
编号。添加（编号/1000）；
数字=数字%1000；
数字。加上（1000）；
}
否则，如果（数字>=100）
{
编号。添加（编号/100）；
数字=数字%100；
增加（100）；
}
否则，如果（数字>=10）
{
编号。添加（编号/10）；
数字=数字%10；
增加（10）；
}
其他的
{
数字。添加（数字）；
数字=0；
}
}
返回号码；
}

---

现在我觉得这段代码太大了，那么有没有更好的方法来实现这一点呢？

创建一个十次幂的表，或者边走边计算。这将允许您使用常规循环将数字拆分为成对的数字及其位置值，而不是使用向上延伸到固定数字的展开循环

以下是一种方法：

var ten = new BigInteger(10);
var res = new List<BigInteger>();
var number = BigInteger.Parse(NumberString);
int pow = 0;
while (!BigInteger.Zero.Equals(number)) {
    var lastDigit = BigInteger.Remainder(number, ten);
    var placeValue = BigInteger.Pow(ten, pow++);
    res.Add(placeValue);
    res.Add(lastDigit);
    number = BigInteger.Divide(number, ten);
}

var-ten=新的大整数（10）；
var res=新列表（）；
var number=BigInteger.Parse（NumberString）；
int-pow=0；
而（！BigInteger.Zero.Equals（number））{
var lastDigit=BigInteger.余数（数字，十）；
var placeValue=biginger.Pow（十，Pow++）；
res.Add（placeValue）；
res.Add（最后一位）；
数字=大整数。除法（数字，十）；
}

公共列表ParseIntoList（字符串initialNumber，列表currentArray）
{
如果（initialNumber.Length==0）{
返回电流阵列；
} 
变量数字=初始数字[0]；
initialNumber=initialNumber.子字符串（1）；
var功率=数学功率（10，初始值。长度）；
currentArray.Add（数字）；
currentArray.Add（电源）；
返回ParseIntoList（initialNumber，currentArray）；
}

用下一种方式调用它：

ParseIntoList（“3432”，newlist（））。

---

您可能希望将其包装在调用中，或者执行算法的编写版本

您可以只对字符串进行操作：

static void Main(string[] args)
{
    var input = "3432";
    var result = Foo(input);
}

private static string[] Foo(string input)
{
    var output = new List<string>();
    var power = input.Length;

    for (int i = 0; i < input.Length; i++)
    {
        output.Add(input[i].ToString());
        if (i < input.Length-1)
            output.Add(Math.Pow(10, power).ToString());

        power--;
    }

    return output.ToArray();
}

static void Main（字符串[]args）
{
var input=“3432”；
var结果=Foo（输入）；
}
私有静态字符串[]Foo（字符串输入）
{
var输出=新列表（）；
无功功率=输入长度；
for（int i=0；i

LINQ one liners救援

string inputString = "3432";
var result = Enumerable.Range(0, inputString.Length)
                     .SelectMany(
                           i => new[]
                                {
                                   Convert.ToInt32(inputString[i] - '0'),
                                   (int) Math.Pow(10, inputString.Length - i - 1)
                                }, (i, g) => g).ToList();

输出：

3
1000
4
100
3
10
2

---

一个更好的方法是在你的列表中加一个1。保持一致——每一个都有乘数乘以单位对，一直保持到最后。当你这样做的时候，你会发现做一个循环更容易。或者更好的是，根本不列出单位。必要时使用0，然后使用一些模运算。最好的方法是递归。这个问题似乎离题了，因为它是关于按原样工作的代码，没有错误。对于改进您的代码的批评或建议，请询问感谢回复，您能给我一个示例代码吗？@user1740381这应该可以工作-我没有尝试过，但它应该足够简单，可以做到这一点。请注意，此代码以相反的顺序生成输出，并为最后一位数字的位置值添加

1

。是否反转两次？似乎unnecessary@YuriiHohan你是对的，这正是我思考问题的方式。我更新了我的答案。

string inputString = "3432";
var result = Enumerable.Range(0, inputString.Length)
                     .SelectMany(
                           i => new[]
                                {
                                   Convert.ToInt32(inputString[i] - '0'),
                                   (int) Math.Pow(10, inputString.Length - i - 1)
                                }, (i, g) => g).ToList();

    static IEnumerable<long> GetDigitsAndMultiplesOfTen(long value)
    {
        var powerOfTen = (long)Math.Ceiling(Math.Log10(value));
        var divisor = (long)Math.Pow(10, powerOfTen);

        while (divisor > 0)
        {
            var quotient = value / divisor;

            if (quotient > 0)
            {
                yield return quotient;

                if (divisor > 1)
                    yield return divisor;
            }

            value %= divisor;
            divisor /= 10;
        }
    }

       long value = 3432;

        var list = GetDigitsAndMultiplesOfTen(value).ToList();

        foreach (var item in list)
            Console.WriteLine(item);

3
1000
4
100
3
10
2