Question

我试图取一个整数，删除整数内的所有奇数位，然后返回这个新整数。没有内置。我到目前为止的方式使它成为一个列表，但我需要它输出一个整数。

def rem_odd(integer):
    x = []
    while integer > 0:
        if integer % 2 == 0:
            x = [(integer % 10)] + x
            integer = integer / 10
        else:
            integer = integer / 10
    return x

Answer 1

假设您使用203作为参数调用您的函数：

x = rem_odd(203)

你得到x = [2, 0]

这就是你所做的：

>>> x = [2, 0]
>>> x = [str(a) for a in x]
>>> x
['2', '0']
>>> int(''.join(x))
20
>>>

以上是字符串操作解决方案。算术上（而不使用内置函数），解决方案是：

>>> x = rem_odd(203)
>>> p = y = 0
>>> for i in x[::-1]:
...     y += i * (10 ** p)
...     p += 1
...
>>> y
20

您从右到左遍历列表，即从单位放置到最高幂10，然后将每个数字乘以10乘以索引。

Answer 2

对“内置词”的宽松解释：

def rem_odd(integer):
    return int(''.join(x for x in str(integer) if not x in '13579'))

应用更严格的内置定义：

def rem_odd(integer):
    r = 0
    mult = 1
    while integer > 0:
        if integer % 2 == 0:
            r = r + mult * (integer % 10)
        integer = integer // 10
        mult *= 10
    return r

〜

Answer 3

由于这里的其他答案都没有按照最严格意义上的“NO BUILT-INS”设法做到这一点，因此我将以下扩展名提交给Python用于OP的用例：

/* rem_odd.c */
#include <Python.h>                                                         
#include <math.h>                                                           

static PyObject *                                                           
rem_odd(PyObject *self, PyObject *args)                                     
{ 
    int digit, ix, n, num, result;                                          
    int digits[20];  /* handles up to 2^64 (20 digits) */                   
    if (!PyArg_ParseTuple(args, "i", &num))                                 
        return NULL;                                                        
    n = num;                                                                
    ix = 0;                                                                 
    while (n > 0) {                                                         
        digit = n % 10;                                                     
        n /= 10;                                                            
        if (digit % 2 == 0)                                                 
            digits[ix++] = digit;                                           
    }
    result = 0;                                                             
    while (ix-- >= 0) {                                                     
        result += (int)(pow(10., ix)) * digits[ix];                         
    }                                                                       
    return Py_BuildValue("i", result);                                      
}                                                                           


static PyMethodDef RemOddMethods[] = {                                      
    {"rem_odd", rem_odd, METH_VARARGS,                                      
    "Remove odd digits from an integer and return another integer."},       
    {NULL, NULL, 0, NULL}                                                   
};


PyMODINIT_FUNC                                                              
initrem_odd(void)                                                           
{                                                                           
    (void) Py_InitModule("rem_odd", RemOddMethods);                         
}

然后使用distutils：

from distutils.core import setup, Extension                                 

rem_odd_module = Extension('rem_odd',                                       
                            sources = ['rem_odd.c'])                        

setup(name='rem_odd', version='1.0',                                        
    description='Remove odd digits from integers -- NO BUILTINS',           
    ext_modules = [rem_odd_module])

示例用法（在运行setup.py build和setup.py install之后）：

Python 2.7.6 (default, Feb 26 2014, 12:01:28) 
[GCC 4.8.2 20140206 (prerelease)] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> from rem_odd import rem_odd
>>> rem_odd(203)
20
>>> rem_odd(9684684)
684684
>>> rem_odd(123456789)
2468

Answer 4

如果你不能使用像int（）或join（）这样的内置函数，你可以这样做：

def rem_odd(integer):
    x = []
    while integer > 0:
        if integer % 2 == 0:
            x = [(integer % 10)] + x
            integer = integer / 10
        else:
            integer = integer / 10
    res = 0
    digits = len(x)
    for i in range(digits):
        res += x[i] * (10**(digits-i-1))

    return res

Answer 5

整数可以分成数字，增加到10的幂。

例如：

24 = 2 * 10 + 4
256 = 2 * 100 + 5 * 10 + 6

您可以利用列表中的位置来确定当前的10的力量：

def getInt(lst):
    res = 0
    pow = len(lst) - 1

    for el in lst:
        res += el * (10 ** pow)
        pow -= 1

return res

现在调用>>> getInt([2,4,8])返回：248

在没有内置len的情况下获取列表的长度是相当简单的，因为你可以递归地执行它。

将数字列表转换为一个整数

5 个答案: