Question

我知道我可以通过实现以下内容从右到左提取数字：

function arrayToTree_eval(array $source, $defaultValue = null) {

    eval(sprintf('$tree%s = $defaultValue;', '["' . implode('"]["', $values) . '"]'));
    // will create a $tree['a']['b']['...'] = $defaultValue

    return $tree;
}

var_dump( arrayToTree_eval( explode('.', 'a.b.c.d') ) );

但是有没有办法从左到右进行类似于这个的工作，只需使用模数值之类的东西？

Answer 1

如果您对递归方法没有问题，那么这里是一个解决方案，您的代码几乎没有变化： -

def get_digit(num):
    if num < 10:
        print(num)
    else:
        get_digit(num // 10)
        print(num % 10)

用法

>>> get_digit(543267)
5
4
3
2
6
7

Answer 2

你可以这样做，

number = 2164524
for i in str(number)[::-1]:
     digit = int(i)
     print digit

将数字转换为字符串，反向并迭代它。

数学方式：

number = 2164524
while(number >= 10):
    digit = number % 10
    number = number / 10
    print digit
print number # Last element will be in number

使用divmod

的替代方法

while n:
    n, remainder = divmod(n, 10)
    print remainder

<强>结果：

Answer 3

你可以做到这一点＆＃34;数学方式＆＃34;。如果从数字的绝对值和舍入结果中获取log10，则获得数字中的位数（0和1的情况除外）。你可以向上或向下舍入，它只会改变指数的原点。请注意，它使用log10和其他数学函数，因此它可能比使用字符串慢。实际的时间表就是这样：

>>> print(timeit.timeit('list(digits_left_to_right_str(12345))', setup='from __main__ import digits_left_to_right_str', number=10000))
>>> print(timeit.timeit('list(digits_left_to_right(12345))', setup='from __main__ import digits_left_to_right', number=10000))

0.02799521596170962
0.05542760493699461

def digits_left_to_right(number):
    abs_value = abs(number)

    if abs_value <= 1:
        e = 1
    else:
        l10 = math.log10(abs_value)
        e = math.ceil(l10)

    while e > 0:
        e -= 1
        digit, abs_value = divmod(abs_value, 10 ** e)
        yield digit


def digits_left_to_right_str(number):
    for i in str(number)[::-1]:
        digit = int(i)
        yield digit

Answer 4

这是一个生成器，它以从左到右的方式返回正整数的数字：

from math import floor, log10

def digits(n):
    """generator which returns digits in left to right order"""
    k = floor(log10(n))
    for e in range(k,-1,-1):
        d,n = divmod(n,10**e)
        yield d

例如，

>>> list(digits(2016))
[2, 0, 1, 6]

Answer 5

以下是这样做的数学方法：

from math import log

number = 2164524

lenght = int(log(number, 10))

for i in range(lenght, -1, -1):
    print( (number//(10**i)) % 10 )

Answer 6

你可以这样做。

number = 122322
num_str = str(number)
for num in num_str:
  print num

Answer 7

我们n是我们想要从左到右计算其数字的数字。

首先想象一下，我们s给n < 10^s s（通常情况并非如此，但现在让我们假设我们知道这样的n = q 10^(s-1) + r）

这意味着

其中r < 10^(s-1)是商，n是10^(s-1)除以n < 10^s的剩余部分。

自q <= 9以来，我们推断出q > 0。如果q，则n必须是n = (q....)的最左边数字。换句话说

其中圆点代表右边的数字。

现在，让我们用这种理解编写一个算法，从左到右计算n > 0的数字。我们将假设s := 0。

[查找最大功率]

置p := 1和p（10^s代表权力n < p）
如果s := s + 1，请转到下面的 5 。
放p := p * 10和m := n。
转到2

[查找位数]

让a[s]和i := 1成为要计算的数字数组
放p := p / 10（索引从1开始）
放q（整数除法）
让r和m成为p除以a[i] := q
放置m := r和i < s
如果i := i + 1放a[]并转到 7

此时，数组n包含10从左到右的数字。

注意：通过将b替换为任何正整数n，您可以获得基数b中Logging = setTimout(function() { Alert("10 seconds passed"); }, 10 * 1000);的数字。

Answer 8

>>> import math
>>> def digitsLTR(num):
    assert num > 0
    start = int(math.log(num, 10))
    for i in range(start, -1, -1):
        power = 10 ** i
        dig = num / power
        yield dig
        num -= dig * power          
>>> list(digitsLTR(3567))
[3, 5, 6, 7]

Answer 9

递归是你的朋友：

def digits(n):
    if n < 10:
        print n
    else:
        q = n // 10
        r = n - 10 * q
        digits(q)
        print r

随着递归向下移动，数字从右向左提取，然后在递归展开时从左向右打印。当 n 只是一个数字时递归停止。

Answer 10

如果您严格要求模数 - 您将需要进入两个阶段：

找到最接近10的力量。
使用除法和余数。

进入代码将是：

# 1
n, p = number, 1
while n >= 10:
    n, p = n // 10, p * 10

# 2
while number >= 0:
    number, digit, p = number % p, number // p, p // 10

Answer 11

基于亲爱的用户@AlokThakur的回答，但改进和扩展。

def get_digits_from_left_to_right(number, lst=None):
    """Return digits of an integer excluding the sign."""

    if lst is None:
        lst = list()

    number = abs(number)

    if number < 10:
        lst.append(number)
        return tuple(lst)

    get_digits_from_left_to_right(number // 10, lst)
    lst.append(number % 10)

    return tuple(lst)

与CPython 3.5一起使用的示例

In [99]: get_digits_from_left_to_right(-64517643246567536423)
Out[99]: (6, 4, 5, 1, 7, 6, 4, 3, 2, 4, 6, 5, 6, 7, 5, 3, 6, 4, 2, 3)

In [100]: get_digits_from_left_to_right(-9999999999999)
Out[100]: (9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9)

In [101]: get_digits_from_left_to_right(-100000000000)
Out[101]: (1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)

In [102]: get_digits_from_left_to_right(-9)
Out[102]: (9,)

In [103]: get_digits_from_left_to_right(0)
Out[103]: (0,)

In [104]: get_digits_from_left_to_right(9)
Out[104]: (9,)

In [105]: get_digits_from_left_to_right(100000000000000)
Out[105]: (1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)

In [106]: get_digits_from_left_to_right(9999999999999999)
Out[106]: (9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9)

In [107]: get_digits_from_left_to_right(123012312312321312312312)
Out[107]: (1, 2, 3, 0, 1, 2, 3, 1, 2, 3, 1, 2, 3, 2, 1, 3, 1, 2, 3, 1, 2, 3, 1, 2)

Answer 12

def digits(n):
    if n == 0:    # To use 0 instead of 10 allows the code to finish 
                  # finish the extraction of digits
        return n  # Allows code re-utilization 
    else: 
        q = n // 10
        r = n - 10 * q
        digits(q)
        print(r)  # This is python 3

例如digits(546)印刷品

5
4
6

Answer 13

C ++解决方案。将数字存储在阵列中。

int num = 120340;
int digits[10];
int size = 0;

while (num != 0)
{
    int digit = num % 10;
    digits[size++] = digit;
    num = num / 10;
}

我们有一个数字数组和大小，从最后到第一个遍历。

Answer 14

您还可以使用将结果附加到列表中的函数式方法恢复@AlokThakur 的递归实现：

def get_digits(num): 
         if num < 10: 
             return [num] 
         else: 
             return [*get_digits(num // 10), num % 10]

如何从左到右从数字中提取数字？

14 个答案: