题目145：10亿以下有多少可反数？

欧拉计划

How many reversible numbers are there below one-billion?

Some positive integers n have the property that the sum [ n + reverse(n) ] consists entirely of odd (decimal) digits. For instance, 36 + 63 = 99 and 409 + 904 = 1313. We will call such numbers reversible; so 36, 63, 409, and 904 are reversible. Leading zeroes are not allowed in either n or reverse(n).

There are 120 reversible numbers below one-thousand.

How many reversible numbers are there below one-billion (10⁹)?

题目：

一些正整数 n 有这样一个性质：n 与 n取“相反”之和的所有位皆为奇数。例如： 36 + 63 = 99 以及 409 + 904 = 1313。我们将这样的数成为可反数；所以，36，63，409，904 都是可反数。在 n 和 n 取相反的最前面都不允许有 0。

一千以下共有 120 个可反数。

10 亿（10⁹）以下共有多少个可反数？

迷雾少年

608720个吧
跑了我好久的说

#include <myLib/myLib.h>
 

//判断是否为可反数
bool isz(int z)
{
        char buf[10]={0};
        char b[10]={0},c[10]={0};
        itoa(z,buf,10);
        int len = strlen(buf);
         memcpy(b,buf,len);
         memcpy(c,buf,len);
         ;//c是反过来的数  b是没反的
        reverse(c,c+len);
        if(c[0]=='0') return false;
        
        //2个数字的和
        int value = atoi(b) + atoi(c);

    while (value)
    {
                if((value%10)%2==0)
                        return false;
                value/=10;
    }

        return true;///*******************
}
int main()
{
        int m = 0;
         
        //10亿 干 2^31 = 2147483648
        //10Y          = 1000000000
        for (int z = 1;z<=1000000000;z++)
        {
                if(isz(z))
                {
                        m++;
                        //std::cout<<z<<endl;
                }
        }
        std::cout<<m;
        return 0;
}

jerryxjr1220

from numba import jit, autojit
from math import log10
from time import process_time

@jit("int32(int32)")
def reverse_add(n):
        m = n
        l = int(log10(n))
        s = 0
        for i in range(l+1):
                s = s*10 + n%10
                n //= 10
        return s+m

@jit("boolean(int32)")
def judge_odd(n):
        while n > 0:
                if n % 2 == 0:
                        return False
                n //= 10
        return True

@jit("int32(int32)")
def solve(limit):
        c, i = 0, 11
        while i < limit:
                if (i // (10**int(log10(i)))) % 2:
                        i += 10**int(log10(i))
                if judge_odd(reverse_add(i)):
                        c += 2
                i += 2
        return c

print(solve(1000000000))
print(process_time())

608720

永恒的蓝色梦想

#include<stdio.h>


bool isreversible(int n) {
    if (!(n % 10)) {
        return false;
    }

    int temp = n, res = 0;

    while (temp) {
        res = res * 10 + temp % 10;
        temp /= 10;
    }

    res += n;

    while (res) {
        if (!(res & 1)) {
            return false;
        }
        res /= 10;
    }

    return true;
}


int main() {
    int sum = 0;
    for (int i = 1000000000; --i; sum += isreversible(i));
    printf("%d", sum);
    return 0;
}

guosl

/*
608720
1.48196秒 (AMD R5 5600G)
*/
#include <iostream>
#include <omp.h>
using namespace std;

int main(void)
{
  double t = omp_get_wtime();
  int nCount = 0;
#pragma omp parallel for reduction(+:nCount)
  for (long long i = 11; i < 1000000000ll; ++i)
  {
    if (i % 10 == 0)
      continue;
    long long k = i, j = 0;
    while (k != 0)
    {
      j = 10 * j + k % 10;
      k /= 10;
    }
    k = i + j;
    bool bFlag = true;
    while (k != 0)
    {
      if (((k % 10) & 1) == 0)
      {
        bFlag = false;
        break;
      }
      k /= 10;
    }
    if (bFlag)
      ++nCount;
  }
  t = omp_get_wtime() - t;
  cout << nCount << endl << t << endl;
  return 0;
}