Question

我目前正在使用下面的代码，从整数中删除所有等于零的数字。

JTable jt=new JTable(rowsArray,columnNames);  
jt.setBounds(30,40,200,300);   // you can put dimension as per your wish...

JScrollPane sp=new JScrollPane(jt);  
jPanel2.add(sp);
// code fore set visible true to jpanel2...

例如预期的输出102304将是1234.

直接 处理整数 是否有更紧凑的方法，即 不是字符串表示 < / STRONG>？它实际上会更快吗？

Answer 1

这是一种没有字符串和缓冲区的方法。

我只用正数来测试这个。使用负数进行此操作是一项由您完成的练习。

int removeZeros(int x)
{
    int result = 0;
    int multiplier = 1;
    while (x > 0)
    {
        int digit = x % 10;
        if (digit != 0)
        {
            int val = digit * multiplier;
            result += val;
            multiplier *= 10;
        }
        x = x / 10;
    }

    return result;
}

Answer 2

为了可维护性，我建议不直接在数值上工作。您可以使用字符串操作以非常简单的方式表达您的要求，虽然它确实可能比数字操作执行速度慢，但我希望它足够快，您不必担心性能，除非它在一个非常严密的循环。

int removeZeros(int n) {
  auto s = std::to_string(n);
  s.erase(std::remove(s.begin(), s.end(), '0'), s.end());
  return std::stoi(s);
}

作为奖励，这个更简单的实现正确处理负数。对于零，它会抛出std::invalid_argument，因为从0中删除所有零不会产生数字。

Answer 3

您可以尝试这样的事情：

template<typename T> T nozeros( T const & z )
{
  return z==0 ? 0 : (z%10?10:1)*nozeros(z/10)+(z%10);
}

如果你想让你的处理更进一步，你可以做一个漂亮的尾递归，不需要辅助函数：

template<typename T> inline T pow10(T p, T res=1)
{
  return p==0 ? res : pow10(--p,res*10);
}

template<typename T> T nozeros( T const & z , T const & r=0, T const & zp =0)
{
  static int digit =-1;
  return not ( z ^ r ) ? digit=-1, zp : nozeros(z/10,z%10, r ? r*pow10(++digit)+zp : zp);
}

这是如何使用输入32040

Ret，z，r，zp，digits

- ，32040,0,0，-1

- ，3204,0,0，-1

- ，320,4,0,0，-1

- ，32,0,4,4,0

- ，3,2,4,0

- ，0,3,24,1

- ，0,0,324,2

324， - ， - ， - ， - 1

整数计算总是比实际将整数转换为字符串更快，对字符串进行比较，查找字符串以将它们转换回整数。

很酷的是，如果你尝试传递浮点数，你会得到很好的编译时错误。

我声称这比其他解决方案略快，因为它使得条件评估更少，这将使其在CPU分支预测方面表现更好。

Answer 4

此处未使用字符串表示形式。我不能说速度。

int removezeroes(int candid)
{
    int x, y = 0, n = 0;

    // I did this to reverse the number as my next loop 
    // reverses the number while removing zeroes.
    while (candid>0)
    {
        x = candid%10;
        n = n *10 + x;
        candid /=10;
    }
    candid = n;
    while (candid>0)
    {
        x = candid%10;
        if (x != 0)
            y = y*10 + x;
        candid /=10;
    }
    return y;
}

Answer 5

如果C++11可用，我喜欢使用lambda函数：

int removeZeros(int candid){
    std::string s=std::to_string(candid);
    std::string output;
    std::for_each(s.begin(), s.end(), [&](char& c){ if (c != '0') output += c;});
    return std::stoi(output);
}

Answer 6

int number = 9042100;
stringstream strm;
strm << number;
string str = strm.str();
str.erase(remove(str.begin(), str.end(), '0'), str.end());
number = atoi(str.c_str());

Answer 7

g24l递归解决方案的固定实现：

template<typename T> T nozeros(T const & z)
{   
  if (z == 0) return 0;
  if (z % 10 == 0) return nozeros(z / 10);
  else return (z % 10) + ( nozeros(z / 10) * 10);
}

如何只保留整数的非零数字？

7 个答案: