题目4：找出由两个三位数乘积构成的回文

jerryxjr1220

AArdio编译：

import console;
import time.timer
 
console.setTitle("test");

time.timer.start();

var is_reversed = function(n){
        s_n = tostring(n);
        r_n = string.reverse(s_n);
        return s_n == r_n
}

var max_n = 0
for(j=999;100;-1){
        for(i=999;100;-1){
                if is_reversed(i*j){
                        if(i*j>max_n){
                                max_n = i*j;
                                break;
                        };
                }
                if i*j<max_n{
                        break;
                }
        }
}

console.print(max_n);
console.print(time.timer.endTick());
console.pause();
console.close()

906609
26.249376773834 （毫秒）
请按任意键继续 ...

编程新血

python3:

n=999
while n>100:
    a=str(n*n)
    b=str(n*n-n)
    if a==a[::-1]:
        print('回文数为',a,'由',n,'和',n,'组成')
        break
    if b==b[::-1]:
        print('回文数为',b,'由',n,'和',n-1,'组成')
        break
    n-=1

'回文数为 698896 由 836 和 836 组成'
如果考虑不同数字的话，只用考虑变量b.

zjhnz

答案 993*913=906609 时间 0.2983 秒

#include <stdio.h>

int ispalindromic(int n)
{
        int xn=0,xn1;
        int temp=n;
        while (n/10)
        {
                xn1=n%10;
                xn=xn*10+xn1;
                n=n/10;
        }
        xn=xn*10+n;
        if (temp==xn)
        {
                return 1;
                
        }
        else 
        {
                return 0;
        }
}

int isthree(int n)
{
        for (int i=999; i>=100; i--)
        {
                if(n%i==0 && n/i>100 && n/i<999 )
                
                {
                        printf("%d * %d =",i,n/i);
                        return 1;
                }
        }
        
        return 0;
}

int main(void)
{


                for(int i=998001; i>100000; i--)
                {
                        if( ispalindromic(i) && isthree(i))
                        {
                                printf("%d",i);
                                break;
                        }
                }
        
}

artistlu

#include <stdio.h>

int isPalindrome(int);

int isPalindrome(int num)
{
    int revNum = 0;
    int tmp = num;
    while(tmp != 0)
    {
        revNum = revNum * 10 + tmp % 10;
        tmp /= 10;
    }

    return num == revNum;
}

int main(void)
{    
    int multi, result, a, b;
    for (int i = 100; i <= 999; i++)
    {
        for (int j = i + 1; j <= 999; j++)
        {
            multi = i * j;
            if (isPalindrome(multi) && result < multi) 
            {
                result = multi;
                a = i;
                b = j;
            }
        }
    }
    printf("%d * %d = %d\n", a, b, result);
    return 0;
}

//913 * 993 = 906609

由我们主宰

#include<stdio.h>
int CheckPalindrome(int m)
{
        int n=0,quotient=m,remainder;
        while(0!=quotient)
        {
                remainder=quotient%10;
                n=10*n+remainder;
                quotient=quotient/10;                                
        }
        if(n==m)
        {
                return 1;
        }
        else
        {
                return 0;
        }
}
int main()
{
        int m,p,q;
        for(p=999;p>100;p--)
        {
                for(q=999;q>100;q--)
                {
                        m=p*q;
                        if(CheckPalindrome(m))
                        {
                                printf("%d=%d*%d\n",m,p,q);
                                goto END;
                        }
                }
        }
END:
        return 0;
}

由我们主宰

之前的代码没考虑好最大值，这里进行修改用MAX将最大的记录下来

#include<stdio.h>
struct MAX
{
        int m;
        int p;
        int q;
}MAX;

int CheckPalindrome(int m)
{
        int n=0,quotient=m,remainder;
        while(0!=quotient)
        {
                remainder=quotient%10;
                n=10*n+remainder;
                quotient=quotient/10;                                
        }
        if(n==m)
        {
                return 1;
        }
        else
        {
                return 0;
        }
}

int main()
{
        int m,p,q;
        MAX.m=0;
        for(p=999;p>99;p--)
        {
                for(q=999;q>99;q--)
                {
                        m=p*q;
                        if(CheckPalindrome(m))
                        {
                                if(m>MAX.m)
                                {
                                        MAX.m=m;
                                        MAX.p=p;
                                        MAX.q=q;
                                }
                        }
                }
        }
        printf("%d=%d*%d\n",MAX.m,MAX.p,MAX.q);
        return 0;

阿bang

def isPalindrome(num):
    l = []
    while num:
        l.append(num % 10)
        num /= 10
    k = l[:]
    l.reverse()
    if k == l:
        return True
    else:
        return False


temp = 0
for i in range(999, 100, -1):
    for j in range(i, 100, -1):
        if isPalindrome(i * j):
            temp = max(temp, i * j)
print temp

refracted_ray

import copy

# 判断n是否回文数
def if_pr_num(n):
        str_n=str(n) # 把整数n转换为字符串
        list_n=list(str_n) # 把字符串转换为列表
        list_n_copy=copy.deepcopy(list_n) # 对list_n进行一次深复制（在本题中浅复制是没用的）
        list_n_copy.reverse() # 倒转list_n_copy
        
        # 若倒转后依然和原列表相同，说明n是回文数
        if list_n==list_n_copy:                
                return True

pa_num=[] #所有三位数乘积的回文数，每一项都是回文数及其因子的元组

for i in range(999,99,-1):
        for j in range(999,99,-1):
                n=i*j
                if if_pr_num(n):
                        pa_num.append((n,i,j))

pa_num.sort(reverse=True) # 以n为第一优先级，把pa_num按从大到小排列
print ('三位数乘积最大的回文数是：%d=%d*%d'%pa_num[0])

结果是906609=993*913。不过运行速度比较慢，大概五六秒钟才出结果

zzzgod

#include <iostream>
using namespace std;
int main()
{
        int i=999,j=999,hui;
        for(i;i>0;--i)
        {
                j=i%10*100+(i%100-i%10)+(i-i%100)/100;
                hui=i*1000+j;
                for(int i=999;hui/i<1000;--i)
                {
                        if(hui%i==0)
                        {
                                cout<<i<<' '<<hui/i;
                                return 0;
                        }
                }
        }
}

名字有点夸张

#include <cstdio>
#include <cstring>
#include <ctime>
#include <cstdlib>

//交换字符串
void swap(char * s, char * f, int len)
{
        for (int i = len; i > 0; i--)
        {
                f[len - i] = s[i - 1];
        }
        f[len] = '\0';
}
int main(int argc, char * argv[])
{
        time_t clock = time(0);
        long int sum;
        char str[7], fstr[7];
        int temp = 0;  //标记使循环退出
        for (long int s = 998001; s > 10000; s--)
        {
                sprintf(str, "%lu", s);
                swap(str, fstr, strlen(str));
                if (!strcmp(str, fstr))
                {
                        for (long int i = 999; i > 100; i--)
                        {
                                for (long int j = 999; j > 100; j--)
                                {
                                        if (i * j == s)
                                        {
                                                printf("%lu * %lu = %lu\n", i, j, s);
                                                temp = 1;
                                                if (temp)
                                                        break;
                                        }
                                }
                                if (temp)
                                        break;
                        }
                }
                if (temp)
                        break;
        }
        printf("time = %d", time(0) - clock);
        fputc('\n', stdout);
        system("pause");
        return 0;
}

结果为 993 * 913 = 906609

塔利班

def fun():
    L=[]
    for i in range(999,99,-1):
        for j in range(999,99,-1):
            a=str(i*j)
            if a==a[::-1]:
                L.append(i*j)
    return max(L)

DetConan

用python3写的，耗时3毫秒，其实代码是用带你学c带你飞里面c语言写的程序改过来的，外加了python特性的翻转字符串
仅供参考，如有改进意见望指出

# 找出最大的有由个三位数乘积构成的回文数。
import time

start = time.clock()
n = 1998
maxnum = 0
while (n >= 200):
    i = (n + 1) // 2
    j = n - i
    while (i <= 999 and i * j > maxnum):
        x = i * j
        y = int(str(x)[::-1])
        if y == x:
            maxnum = x
            p = i
            q = j
        i += 1
        j -= 1
    n -= 1
print("找到最大回文数：%d=%d*%d" % (maxnum, p, q))
end = time.clock()
print("read:%f s" % (end - start))

shanczp

。。写的有点烂，一个判断回文，一个从最大回文开始判断2个3位数的乘积数。。一开始的想法是从小开始往大搜索,最后换成直接判断最大位。。

int num=998001;//999*999最大值
        while (true)
        {
                if (huiwen(num))
                {
                        zhishu(num);
                        if(zhishu(num)==1)
                        {
                                return;
                        }
                        //printf("%d\n",num);
                        //return;
                }
                num--;
        }
//判断回文
int huiwen(int a)
{
        int m;
        int sum=0;
        m=a;
        while(m)
        {
                sum=sum*10+m%10;
                m/=10;
        }
        if (sum==a)
        {
                return true;
        }
        else
        {
                return false;
        }
}


int zhishu(int num)
{
        
        int n=1;
        int sum=num;
        int j=0;
        while (true)
        {
                int i=999;
                for(;i>=100;i--)
                {
                        if(num%i==0)
                        {
                                n=i;
                                break;
                        }
                        if(i==100)
                        {return 0;}
                }
                num=num/n;
                if(num==1)
                {
                        printf("%d\n",sum);
                        return 1 ;
                }
                
        }
}

cupbbboom

list_1 = []
for i in range(101,1000):
        for n in range(i,1000):
                list_2 = [i * n]  
                for each in list_2:       # for each in [i * n for n in range(i,1000)]:  不过这样子写：n就取不到
                        if str(each) == str(each)[::-1]:
                                print(each,end=",")
                                list_1.append({'x1':i,'x2':n,'result':each})
print("\n"+'*'*50)
my_result = max(list_1,key=lambda x:x['result'])
print('输出最大回文结果：%s * %s = %s' %(str(my_result['x1']),str(my_result["x2"]),str(my_result['result'])))

最大结果是：913 * 993 = 906609

yuc_mi

#一个回文数指的是从左向右和从右向左读都一样的数字。

#最大的由两个两位数乘积构成的回文数是 9009 = 91 * 99。

#找出最大的有由个三位数乘积构成的回文数。

def product(begin, end):
    list1 = []
    for x in range(begin, end):
        for y in range(begin, end):
            num = x * y
            flag = huiwen(num)
            if flag:
                #可以输出你所设置区间的所有回文数
                #print('%d = %d * %d 是回文数'% (num, x, y))
               list1.append({'result': num,'x':x,'y':y})

    larger = max(list1,key = lambda x: x['result'] )
    print(larger)
    print('%d = %d * %d 是区间{%d, %d}最大回文数' \
          % (larger['result'], larger['x'], larger['y'], begin, end))
                
def huiwen(number):
    string = str(number)
    length = len(string)
    for i in range(length//2):
        if string[i] == string[length - i - 1]:
            continue
        else:
            return False
    return True
        
        

print('please inout digital range')
begin = int(input('begin：'))        
end = int(input('end:'))         

product(begin, end)

result

please inout digital range
begin：100
end:1000
{'result': 906609, 'x': 913, 'y': 993}
906609 = 913 * 993 是区间{100, 1000}最大回文数

何小胖胖

回文数不难判断，有很多方法，但是总觉得能找出一种方法就是只要判断到最大就break，但是不知道怎么去判断。一开始就是从100++到999，后来发现倒着来只判断前900个可以大大减少运行时间，改进回文的判断方法还能提高速度

#include<iostream>
#include<time.h>
using namespace std;
int main() {
        clock_t start,end;
        int value=0,number[7],k,n,test,max=0;
        int a,b;
        start=clock();
        for(int i=999;i>900;i--){
                for(int j=i;j>900;j--){
                        n=0;
                        test=1;
                        value=i*j;
                        //将一个数分解到数组中，方便把每一位拿出来作比较 
                        while(value>0){
                                k=value%10;
                                number[n]=k;
                                n++;
                                value/=10;
                        }
                        k=0;
                        //判断回文 
                        for(n=n-1,k;n>0,n>k;n--,k++){
                                if(number[n]!=number[k]){
                                        test=0;
                                        break;
                                }
                        }
                        //找出最大的回文数 
                        if(test==1) {
                                if(i*j>max){
                                        max=i*j;
                                        a=i;
                                        b=j;
                                } 
                        }
                }
        }
        cout<<"最大的回文数是："<<a<<"*"<<b<<"="<<max<<endl; 
        end=clock();
        cout<<endl<<"费时：        "<<end-start;
        return 0;
} 

996982937

#include<stdio.h>
void main()
{
        int a,b,n;
        int max=0,i=0,j=0;
        
        for(a=999;a>100;a--)
        {
                for(b=999;b>100;b--)
                {
                        n=a*b;
                        if(n>100000&&n<=999999)
                        {
                                if((n/100000==n%10)&&((n/10000)%10==(n%10)/10)&&((n/1000)%10==(n/100)%10))
                                {
                                        if (n>max)
                                        {
                                                max=n;
                                                i=a;
                                                j=b;
                                        }
                                        
                                }
                        }
                        else if(n<100000&&n>10000)
                        {
                                        if((n/10000==n%10)&&((n/1000)%10==(n%100)/10))
                                {
                                        if (n>max)
                                        {
                                                max=n;
                                                i=a;
                                                j=b;
                                        }
                                }
                        }
                        
                }
        }
        printf("%d*%d=%d\n",i,j,max);
}

输出结果：
993*913=906609
用时0.56s

zs86787

wyc1gg 发表于 2015-10-8 17:38
def int_reverse(x):
    '求一个数的反转：1234得到4321'
    x1 = str(x)

def dight(a):
    str_a = str(a)
    len_a = len(str_a)//2
    a1 = list(str_a[:len_a])
    a2 = list(reversed(str_a[len_a:]))
    if a1 == a2:
        return True
ls = []
for i in range(100,1000):
    for j in range(100,1000):
        if dight(i*j):
            ls.append(i*j)
print(max(ls))

王小召

运行结果：906609
运行时间：1.2636081

import time

def get_huiwen():
    x_l = []
    y_l = []
    z_l = []
    for x in range(0, 900):
        for y in range(0, 900):
            z = (999 - x) * (999 - y)
            if judge_huiwen(z):
                x_l.append(999 - x)
                y_l.append(999 - y)
                z_l.append(z)
    return max(z_l)

def easy_way():
    for i in range(0, 999*999 - 1000):
        t = 999*999 - i
        if judge_huiwen(t):
            return t    

def judge_huiwen(target):
    num_list = []
    if target < 10:
        print("当前值过小！")
    while target:
        num_list.append(target % 10)
        target = target//10
    lenth = len(num_list)
    if lenth % 2:
        return False
    else:
        for i in range(lenth//2):
            if num_list[i] != num_list[lenth - i - 1]:
                return False
        return True

print(get_huiwen())
print(time.process_time())

ietar

python

>>> p4()
[906609, 993, 913]
>>> timef(p4(),number=1000)
8.076700000003711e-05

from timef import timef
def p4():
    l1=[]
    result=[0,0,0]
    for i in range(999,99,-1):
        if 999*i < result[0]:
            return result
        for j in range(999,99,-1):
            if str(i*j)==str(i*j)[::-1]:
                if i*j > result[0]:
                    result = [i*j,i,j]
    return result