C++ 返回数字中的数字的函数

我想创建一个函数，它将显示一个数字和我要检索的数字的位置

int getDigit(int value, int positionFromLeft)

比如说，getDigit（534，2）将返回3

---

编写此函数最简单/有效的方法是什么？

最简单但不一定是最好的：

int getDigit(int value, int positionFromLeft)
{
    char buf[sizeof(int)*3+2];
    if (sprintf(buf, "%d", value)-1U < positionFromLeft-1U) return -1;
    return buf[positionFromLeft-1U]-'0';
}

int getDigit（int值，int位置从左开始）
{
字符buf[sizeof（int）*3+2]；
if（sprintf（buf，“%d”，value）-1U

<强>注释：编辑，因为有人反对（显然）对<代码> SNPrTNF不在C++中，并考虑到超出边界和基于一个位置。现在它稍微不那么简单了

function getDigit(original,nonZeroIndexedIndex)
{
    return ((int)floor(original / pow(10, nonZeroIndexedIndex))) % 10;
}

根据@R..的建议：

function getDigit(original,nonZeroIndexedIndex)
{
    int tens [5] = { 1, 10, 100, 1000, 10000 };
    return ((int)floor(original / tens[nonZeroIndexedIndex - 1])) % 10;
}

希望这有帮助！对于我来说，这是一个很好的C++ C++复习程序：

如果您要求数字RHS以外的数字，则返回零。求反技巧确保值始终为负（并且在求反INT_MIN时不会遇到问题），然后有一个减号，因此

位置from left

是正确的，无需调整1。此代码假定C99或C++（小号警告，代码> SNPrtff（））/C>不是由C++ 98强制的，但可能是可扩展的；纯C++ 98和C99解决方案将不得不使用<代码> SpRtff（）/<代码>，而上下文中的安全性足够。 抗议曾经被选为正确的解决方案！ 考虑测试线束：

#include <stdio.h>

int getDigit1(int value, int positionFromLeft)
{
    while (--positionFromLeft)
        value /= 10;
    return value % 10;
}

int getDigit2(int value, int positionFromLeft)
{
    char buffer[20];
    if (value > 0)
        value = -value;
    int len = snprintf(buffer, sizeof(buffer), "%d", value);
    int digit = 0;
    if (len > positionFromLeft && positionFromLeft > 0)
        digit = buffer[positionFromLeft] - '0';
    return digit;
}

int main(void)
{
    int values[] = { 534, 1234567, -1234567 };
    for (int i = 0; i < 3; i++)
    {
        for (int j = 1; j <= 7; j++)
            printf("getDigit(%d, %d) = (v1) %d, (v2) %d\n", values[i], j,
                   getDigit1(values[i], j), getDigit2(values[i], j));
        putchar('\n');
    }
    return 0;
}

---

这个问题特别要求从数字左边的第n位开始，从1开始计数。

最简单的方法就是转换为字符串并进行查找。这个例子使用C++，但是这个想法可以很容易地翻译成C.<

int getDigit(int value, int positionFromLeft) {
    if (value < 0) positionFromLeft++;

    std::stringstream ss;
    ss << value;

    std::string s = ss.str();
    if (positionFromLeft >= 1 && positionFromLeft <= s.length())
        return s[positionFromLeft-1] - '0';
    else
        throw std::runtime_error("invalid digit position");
}

int getDigit（int值，int位置从左开始）{
如果（值<0）位置从左++；
std：：stringstream-ss；
ss=1&&positionfrom left首先，如果您愿意为右侧而不是左侧工作（即，从最低有效位开始），这会容易得多

给定输入N，
N%10
将给出最低有效位。X/10将X向右移动一位，X/100将其向右移动两位，以此类推

如果您真的需要从左边开始计算，
log10
应该可以得到总位数。
如果您真的需要从左边开始计算，您可以这样做：

uint8_t getDigitR(uint16_t value, uint8_t i) {
  uint32_t digit = 1;
  while (digit <= value)
    digit *= 10;
  while (i--) // if you start counting at 1
    digit /= 10;
  return (value / digit) % 10;
}

uint8\u t getDigitR（uint16\u t值，uint8\u t i）{
uint32_t位=1；
而（digit所有这些基于字符串的解决方案都让我害怕…真的吗？：-/

int getDigit(int value, int positionFromLeft)
{
    int posFromRight = 1;
    {
        int v = value;
        while (v /= 10)
            ++posFromRight;
    }
    posFromRight -= positionFromLeft - 1;
    while (--posFromRight)
        value /= 10;
    value %= 10;
    return value > 0 ? value : -value;
}

请注意，从左到右传递
位置的越界值不会返回任何感官值。
只是为了不同，没有
#include
的值是必需的

int getDigit(unsigned int original, unsigned int positionFromLeft)
{
    if (original==0 && positionFromLeft==1) {
        /* In a more mathematical world, zero has no digits. */
        return 0;
    }
    unsigned int expon=0;
    unsigned int power=1;
    for (unsigned int quotient=original; quotient; quotient/=10, ++expon) {
        if (expon >= positionFromLeft) {
            power *= 10;
        }
    }
    if (positionFromLeft > expon) {
        /* Not enough digits in number. */
        return -1;
    }
    return (original / power) % 10;
}

如果我错了，请纠正我

您可以尝试使用sprintf将int转换为字符串表示形式。
然后让一个指针（比如*ptr）指向第一个位置

positionFromLeft是要提取的字符的位置

使用

*（ptr+位置从左起）

将为您提供所需的数字。
希望有帮助。
我认为这是最简单的解决方案：

   int valuePosition(int value, int position) {
     int r;
     for(int i=0; i<=position; i++){
       r = value % 10;
       value = value / 10;
     }
     return r;
   }

int-valuePosition（int-value，int-position）{
INTR；
对于（int i=0；i此旧问题的不同递归解决方案（我将
位置的类型从left
更改为
unsigned
）

请参见向Number类添加一个名为getDigit的实例方法，该方法具有以下签名：
int getDigit（int digitNum）
当digitNum变量指定unity系列的位数（0）时，1表示十位数
依此类推。如果存在相应的数字，则该方法将返回相应的数字。否则，该方法将返回
.-1
-1将返回digitNum=6，对于4，将digitn=3方法返回：value=124571，如果

<>列表项
但注意这不是有效的C++。@ askpuld:为什么要声明它？因为它使用了代码> SNPROTFF（）<代码> >不是标准C++吗？还是因为其他原因？如果代码< >左> /COD>位置为负，或者如果数字短到没有第N位，则存在少量的缓冲管理问题。此外，对于示例，返回4而不是3（逐个），但您得到正确的答案：<代码> GigDigy（-534，2）。
我还不知道。但是（int）*3+2的大小很整洁：）哎呀，没关系。我的大脑不知怎么地认为数组中有一个变量绑定为
buf
。在向量中逐位推送，并在需要时索引。我认为@Cameron的意思是“向我们展示代码”。如果你设法获得一个多语言源文件，请发布它。无论如何，我建议你坚持每个文件使用一种语言：要么<代码>C
或
C++
：）这是我试过的，但是我用了一个向量。这个SS不是双语解决方案，问题是双语的。乔纳森：啊，我错过了C标签。我加了一个关于它是C++的注释。@ Jonathan Leffler C和C++不应该被标记在同一个问题中。所以谁在乎。最后一个简单的解决方案。干杯！你的代码> GE。tDigit（1234567，2）
返回5而不是3。正好534的3是从左到右的第二个。是的，除了你的解决方案是错误的。左到右的错误不等于右！问题指定了从左到右的
位置，也就是说，如果你通过1，你想要的是最高有效数字，但你返回的是最低有效数字。-1基于字符串的解决方案是因为你解决了一个比OP的问题更简单的问题，而没有回答OP的问题。在这种情况下，你问错了问题，浪费了我们的时间……因为这个答案肯定不能解决你的问题。哦！哦！谢谢你打电话给我。我已经有一段时间没有写一行文章了“C++”：“代码> POW对于整数使用是不可靠的。只使用10的幂的<代码>静态const <代码>数组。没有很多。不管事实是这样，你不需要发言权。
int getDigit(unsigned int original, unsigned int positionFromLeft)
{
    if (original==0 && positionFromLeft==1) {
        /* In a more mathematical world, zero has no digits. */
        return 0;
    }
    unsigned int expon=0;
    unsigned int power=1;
    for (unsigned int quotient=original; quotient; quotient/=10, ++expon) {
        if (expon >= positionFromLeft) {
            power *= 10;
        }
    }
    if (positionFromLeft > expon) {
        /* Not enough digits in number. */
        return -1;
    }
    return (original / power) % 10;
}

   int valuePosition(int value, int position) {
     int r;
     for(int i=0; i<=position; i++){
       r = value % 10;
       value = value / 10;
     }
     return r;
   }

int getDigit(int value, unsigned positionFromLeft) {
    assert(positionFromLeft > 0);
    if (positionFromLeft == 1) return abs(value) % 10;
    if (value == 0) return 0; // optimization: break out of recursion if 0 is reached
    return getDigit(value / 10, positionFromLeft - 1);
}