C# 在C中连接整数#

在csharp中是否有一种连接整数的廉价方法

---

示例：1039&7056=10397056

如果您能找到这样一种情况，它的成本足以引起任何关注，我会非常感动：

int a = 1039;
int b = 7056;

int newNumber = int.Parse(a.ToString() + b.ToString())

或者，如果您想让它更像“.NET ish”：

解析不是一个昂贵的操作。花时间担心网络I/O和O^N正则表达式

其他注意事项：实例化StringBuilder的开销意味着，如果只进行几个连接，那么就没有意义了。非常重要的是，如果您打算将其转换为整数，请记住其限制为~2000000000。串联数字很快变得非常大，可能远远超过32位整数的容量（当然是有符号的）

编辑说明：修复了一些错误类型。还有更多类型问题。我只是给你一个大概的答案

第二种方法实际上应该是：

static int ConcatInt2(int x, int y) {
   return (int)(x * Math.Pow(10, y.ToString().Length)) + y;
}

---

如果我们想要整数结果，那么：

int result = int.Parse(input1.ToString() + input2.ToString());

对于字符串结果，请执行以下操作：

string result = input1.ToString() + input2.ToString();

“Mathy”和“No String”方法如下：

    int a = 1039;
    int b = 7056;

    int bLen = (int)Math.Ceiling(Math.Log10(b));
    int ab = (a * ((int)Math.Pow(10, bLen))) + b;

---

请注意，由于Log10调用，它可能仍然很慢。

便宜吗？字符串连接或格式化字符串可能会快得多

否则，您可以执行以下操作：

Math.Pow(10,Math.Ceiling(Math.Log10(second)))*first+second

---

假设第一个和第二个是整数。这是不需要转换为字符串并返回的唯一方法，但我非常怀疑它是否会更快。

如果要将多个int连接到一个字符串

StringBuilder sb = new StringBuilder(1039);
sb.Append(7056);
sb.Append(1234);
sb.Append(1235);
....
sb.Append(9999);
sb.ToString();

---

不是很贵，但是：

string con = string.Format("{0}{1}",int1,int2);

或

如果在循环中使用它，我想我会使用选项1，它在内部使用StringBuilder

public int ConcatInts(int int1, int int2)
{
    return (int)(int1 * Math.Pow(10, int2.ToString().Length)) + int2;
}

---

编辑：我猜我不是第一个使用这个解决方案的人

我认为你没有比这更简单的了：

static uint Concat (uint a, uint b)
{
  uint
    pow = 1;

  while (pow < b)
  {
    pow = ((pow << 2) + pow) << 1;
    a = ((a << 2) + a) << 1;
  }

  return a + b;
}

静态单元混凝土（单元a、单元b）
{
无符号整型
功率=1；
while（功率
int c = b;
while(c > 0) {
   a *= 10;
   c /= 10;
}
a += b;

我在聚会上迟到了一点，但最近我不得不连接整数。
当0
static ulong concat(uint a, uint b)
{
    if (b < 10U) return 10UL * a + b;
    if (b < 100U) return 100UL * a + b;
    if (b < 1000U) return 1000UL * a + b;
    if (b < 10000U) return 10000UL * a + b;
    if (b < 100000U) return 100000UL * a + b;
    if (b < 1000000U) return 1000000UL * a + b;
    if (b < 10000000U) return 10000000UL * a + b;
    if (b < 100000000U) return 100000000UL * a + b;
    return 1000000000UL * a + b;
}

静态乌龙混凝土（单元a、单元b）
{
如果（b<10U）返回10UL*a+b；
如果（b<100U）返回100UL*a+b；
如果（b<1000U）返回1000UL*a+b；
如果（b<10000U）返回10000UL*a+b；
如果（b<100000U）返回100000UL*a+b；
如果（b<1000000U）返回1000000UL*a+b；
如果（b<10000000U）返回10000000UL*a+b；
如果（b<100000000 U）返回100000000 ul*a+b；
返回1000000000UL*a+b；
}

编辑：下面的版本可能很有趣（平台目标：x64）

静态乌龙混凝土（乌龙a、乌龙b）
{
常数c0=10，c1=100，c2=1000，c3=10000，c4=100000，
c5=1000000，c6=10000000，c7=100000000，c8=100000000；
a*=b
//连接两个数字的程序//

        Console.WriteLine("Enter a number for a");
        int a = int.Parse(Console.ReadLine());

        Console.WriteLine("Enter a number for b");
        int b = int.Parse(Console.ReadLine());

        int Concatenating = Convert.ToInt32(string.Format("{0}{1}", a, b));
        Console.WriteLine(Concatenating);
        Console.ReadKey();

您只需调用.ToString（）即可在其中一个整数上。我同意。这应该可以。如果在代码的这一部分中性能真的很重要，我会尝试分析解决这个问题的不同解决方案。@Brandon技术上是正确的，但编译器以任何一种方式进行相同的字符串转换，因此最多只需保存几个击键。+1：有多少人经常让我感到惊讶在这样的代码上寻找微优化，而不是只做有效的事情。如果使用字符串插值，效果会更好。例如：Convert.ToInt32（$“{a}{b}”）；#2似乎比解析字符串要快。不确定第二个方法的实际速度有多快，因为您已经在解析一个int到字符串了（只是为了得到它的长度）.我认为，为了使这比连接两个字符串更快，您应该使用“旧方式”确定数字长度的方法。+1虽然我不是100%相信这在实践中比字符串连接更快，但老实说，我也不相信它是。但是它很有效，可能值得一试。请注意——其中很多（字符串解析）如果组合字符串大于最大整数值（或小于最小整数值），则解决方案可能存在OverflowException.因为你没有给出任何动机为什么你想要串联数字？什么是-1039和7056的串联？1039和-7056的串联？-1039和-7056？串联对整数没有太大意义。我永远不会有负数。这些整数代表id，id是递增的，永远不会是负数。然后我跳你正在使用UINT。这个问题得到了一些很好的答案，但是使用了INT（甚至UINT）因为id有点代码味道。所有id的位数都是一样的吗？如果不是的话，你就有可能在1&11、11和1与111之间发生冲突。不能变得更简单吗？我相信这是最快的方法，而且转换是聪明的，但我不确定它是否值得被贴上“简单”的标签。另外，对于一个非常紧密的循环，你会想要配置文件（或至少反汇编）以查看JIT是否将强度常数乘以10，以达到您这里的移位模式。可能是“pow*=10”的结果与“pow=”（pow在IA32上使用“*10”版本，编译器/JIT可能会使用以下指令：lea eax，[eax*4+eax]；添加eax，eax。这是一个很长的机会。我同意，这是一个很好的机会，我相信这是唯一比将int值解析为字符串并将其连接起来更快的方法。这应该是答案（op要求提供一种便宜的方法），我在这里对一些答案进行了基准测试，这一个答案以36毫秒（接受答案的546毫秒和.NET ish方式的718毫秒）位居榜首。我通过生成多达20000个（无溢出）的一百万个随机整数来测试它们，并将每个整数与前一个整数连接起来。
static uint Concat (uint a, uint b)
{
  uint
    pow = 1;

  while (pow < b)
  {
    pow = ((pow << 2) + pow) << 1;
    a = ((a << 2) + a) << 1;
  }

  return a + b;
}

static uint Concat (uint a, uint b)
{
  uint
    pow = 1;

  while (pow < b)
  {
    pow = ((pow << 2) + pow) << 1;
  }

  return a * pow + b;
}

static uint Concat (uint a, uint b)
{
  uint
    mask = uint.MaxValue;

  while ((mask & b) != 0)
  {
    mask <<= 1;
    a <<= 1;
  }

  return a | b;
}

int c = b;
while(c > 0) {
   a *= 10;
   c /= 10;
}
a += b;

static ulong concat(uint a, uint b)
{
    if (b < 10U) return 10UL * a + b;
    if (b < 100U) return 100UL * a + b;
    if (b < 1000U) return 1000UL * a + b;
    if (b < 10000U) return 10000UL * a + b;
    if (b < 100000U) return 100000UL * a + b;
    if (b < 1000000U) return 1000000UL * a + b;
    if (b < 10000000U) return 10000000UL * a + b;
    if (b < 100000000U) return 100000000UL * a + b;
    return 1000000000UL * a + b;
}

static ulong concat(ulong a, uint b)
{
    const uint c0 = 10, c1 = 100, c2 = 1000, c3 = 10000, c4 = 100000,
        c5 = 1000000, c6 = 10000000, c7 = 100000000, c8 = 1000000000;
    a *= b < c0 ? c0 : b < c1 ? c1 : b < c2 ? c2 : b < c3 ? c3 :
         b < c4 ? c4 : b < c5 ? c5 : b < c6 ? c6 : b < c7 ? c7 : c8;
    return a + b;
}

        Console.WriteLine("Enter a number for a");
        int a = int.Parse(Console.ReadLine());

        Console.WriteLine("Enter a number for b");
        int b = int.Parse(Console.ReadLine());

        int Concatenating = Convert.ToInt32(string.Format("{0}{1}", a, b));
        Console.WriteLine(Concatenating);
        Console.ReadKey();