파이썬에서 문자열이 대칭인지를 판별하는 가장 빠른 방법은 s[::-1] == s입니다.

def is_palindrome(n):
  s = str(n)
  return s == s[::-1]

def main():
  m = 0
  for i in range(999, 99, -1):
    for j in range(999, 99, -1):
      n = i * j
      if is_palindrome(n) and m < n:
        m = n
  print(m)

저장용

hub = []
for i in range(999,99,-1):
    for j in range(999,99,-1):
        if str(i*j) == str(i*j)[::-1]:
            hub.append(i*j)

print(max(hub))

i * j == j * i 이기 때문에 안쪽 루프를 i로 제어해서 중복을 없앴고

i, j가 999에서부터 감소하기 떄문에,

i*j가 M(현재까지 가장 큰 palindrome) 보다 같거나 작으면

M보다 큰 수가 나올 수 없고 안쪽 루프는 바로 중단할 수 있습니다.

i, j가 작아질수록 거의 한 번 만에 빠져나옵니다.

m = i * j <-- 이 부분 수행 횟수가 4050회로 나오네요.

M = 0
for i in range(999, 99, -1):
    for j in range(999, i-1, -1):
        m = i * j
        if m <= M:
            break
        elif str(m) == str(m)[::-1]:
            M = m

print(M) # 906609

한 줄로 코딩해 봤습니다. 96자네요.

print(max([i*j for i in range(100,1000) for j in range(100,1000) if str(i*j)==str(i*j)[::-1]]))

결과는 906609입니다.

파이썬입니다.

num = [str(i*j) for i in range(100, 1000) for j in range(100, 1000)]
max_palindrome = max([int(n) for n in num if n == n[::-1]])
print(max_palindrome)

R로 작성했습니다.

# 세자리수의 곱으로 나오는 모든 수를 행렬로 정리합니다.

aa <- matrix(ncol=900, nrow=900)
x <- 100:999
y <- 100:999
for(i in 1:900) { aa[i,] <- x*y[i] }

# 앞에서 읽을 때와 뒤에서 읽을 때가 같은 숫자를 구하는 함수를 정의합니다.

same <- function(n) {
x <-unlist(strsplit(as.character(n),""))
result <- numeric(round(length(x)))
for(i in 1:round(length(x))) { result[i] <- x[i] == x[length(x)-i+1] }
return(all(as.logical(result)))
}

# 세자리수의 곱 중 위의 경우에 해당하는 모든 수를 구하고 가장 큰 수를 구합니다.
aa1 <- aa[sapply(aa, same)==1]
max(aa1)


913*993=906609

d = []
for o in range(100, 999):
    for p in range(100, o-1):
        if str(o*p) == ''.join(reversed(str(o*p))):
            d.append(o*p)
print(max(d))

Ruby

pal = ->pair { n = pair.reduce(:*); n.to_s == n.to_s.reverse ? n : 0 }
max_pal = -> { [*100..999].repeated_combination(2).map(&pal).max }

Test

expect( max_pal.call ).to eq 906609

num=0
for i in range(100,1000):
    for j in range(100,1000):
        temp=int(str(i*j)[::-1])
        if i*j == temp:
            if num <= i*j:
                num = i*j
print(num)

이렇게 하면 906609로 딱 나옵니다!

palindrome_arr = []


def is_palindrome(n):
    n = str(n)
    if n == n[::-1]:
        return True
    else:
        return False

for x in range(999, 1):
    for y in range(999, 1):
        num = x * y
        if is_palindrome(num):
            palindrome_arr.append(num)


print(max(palindrome_arr))

# -*- coding: cp949 -*-
ans=None
for i in range(100,1000):
    for n in range(100,1000):
        num=str(n*i) #세자리수를 곱해서 나올 수 있는 값
        val=True
        for a in range(0,len(num)):
            if num[a]!=num[-1-a]:
                val=False #대칭수이면 True가 된다.
        if val==True and ans<int(num):
            ans=int(num) #대칭수 중 가장 큰 수
print ans 

print([x for x in [str(x) for x in range(100*100, 999*999)] if x == x[::-1]][-1:])

// golang 1.9
package main

import (
    "fmt"
    "math"
)

func main() {
    pVal := 3 // 자리수

    var maxMult int = 0 // 최대 대칭수
    for i := math.Pow10(pVal - 1); i < math.Pow10(pVal); i++ {
        for j := math.Pow10(pVal - 1); j < math.Pow10(pVal); j++ {
            calc := int(i * j)
            chkStr := fmt.Sprintf("%d", calc)
            if chkStr == rev(chkStr) && calc > maxMult { // 대칭 and 최대값
                maxMult = calc
            }
        }
    }
    fmt.Println(maxMult)
}

// reverse string
func rev(s string) string {
    retStr := ""
    for i := 0; i < len(s); i++ {
        retStr = s[i:i+1] + retStr
    }
    return retStr
}

// ans: 906609

public class Example144 {
    public static void main(String args[]) {
        Example144 ex = new Example144();

        int max = 0;
        for (int i = 100; i < 1000; i++) {
            for (int j = 100; j < 1000; j++) {
                if (ex.isPalindrome(String.valueOf(i * j))) {
                    max = max < (i * j) ? (i * j) : max;
                }
            }
        }
        System.out.println(max);
    }

    public boolean isPalindrome(String str) {
        if (str.length() % 2 == 0) {
            return str.equals(new StringBuilder(str).reverse().toString());
        } else {
            return false;
        }
    }
}

reverse 로 대칭 확인 체크 했고, 숫자 길이 % 2 해서 아얘 대칭이 성립되지 않는 수는 필터했습니다.

# python 3.6
# 풀이 1
sol1 = [x * y for x in range(100, 1000)
        for y in range(100, 1000) if str(x * y) == str(x * y)[::-1]]
print(max(sol1))
# 풀이 2
sol2 = filter(lambda s: str(s) == str(s)[::-1],
              [x * y for x in range(100, 1000) for y in range(100, 1000)])
print(max(sol2))
# ans: 906609

public class Calculate {

    public static void main(String[] args) {
        StringBuffer s = new StringBuffer();
        StringBuffer rs = new StringBuffer();
        boolean end = false;
        for(int i=900 ; i>=100 ; i--){
            for(int j=999 ; j>=100 ; j--){
                s.append(i*j);
                rs.append(s).reverse();
                if( s.toString().equals(rs.toString()) ){
                    System.out.println(i*j + "(= "+i+" x "+j+")");
                    end = true;
                }else{
                    s.setLength(0);
                    rs.setLength(0);
                }
                if(end) break;
            }
            if(end) break;
        }
    }
}

파이썬입니다

mirror = []

for i1 in range (100, 1000):
    for i2 in range (100, 1000):
        ii = i1 * i2
        if ii > 99999:
            list_ii = list(str(ii))
            if list_ii[0] == list_ii[5] and \
               list_ii[1] == list_ii[4] and \
               list_ii[2] == list_ii[3]:
               mirror.append(ii)
        else:
            list_ii = list(str(ii))
            if list_ii[0] == list_ii[4] and \
               list_ii[1] == list_ii[3]:
               mirror.append(ii)


print (max(mirror))

코드가 난잡한 것 같지만 그래도 정답을 안보고 풀어서 좋네요

package codingdojang;

import java.util.ArrayList;
import java.util.List;

public class ThreeDigitPalindrome {

    public static void main(String[] args) {
        System.out.println(isPalindrome());
    }

    public static int isPalindrome() {
        String palin = "";
        int palindrome = 0;
        int max = 0;
        // i * j 로 세자리수 곱을 구함
        for (int i = 100; i < 1000; i++) {
            for (int j = 100; j < 1000; j++) {
                // i * j 값을 int 값에 담고 String 으로 변환
                palindrome = i * j;
                palin = Integer.toString(palindrome);
                String temp = "";

                // String으로 받은 값을 거꾸로 하나씩 temp 에 담아줌.
                for (int k = palin.length() - 1; k >= 0; k--) {
                    temp += palin.charAt(k);
                        // palin 과 reverse가 같은 숫자를 걸러준다.
                        if (palin.equals(temp)) {
                            // palin을 int값에 넣어주고
                            palindrome = Integer.parseInt(palin);
                            // max과 비교해서 크다면 그 값을 max로 넣어준다.
                            if (palindrome > max) {
                                max = palindrome;
                            }
                        }
                }
            }
        }
        return max;
    }
}

# 한글 처리 in Atom 1.21.1 + Anaconda(Python 3.6.3)
import sys
import io

sys.stdout = io.TextIOWrapper(sys.stdout.detach(), encoding='utf-8')
sys.stderr = io.TextIOWrapper(sys.stderr.detach(), encoding='utf-8')

# 앞에서부터 읽을 때나 뒤에서부터 읽을 때나 모양이 같은 수를 대칭수(palindrome)라고 부릅니다.
# 두 자리 수를 곱해 만들 수 있는 대칭수 중 가장 큰 수는 9009 (= 91 × 99) 입니다.
# 세 자리 수를 곱해 만들 수 있는 가장 큰 대칭수는 얼마입니까?

stop = False
for i in range(999, 100, -1):
    for j in range(999, i - 1, -1):
        if str(i * j) == str(i * j)[::-1]:
            print("{0} * {1} = {2}".format(i, j, i * j))
            stop = True
            break
    if stop:
        break

pal = []
for i in range(999,100,-1):
    for j in range(999,100,-1):
        if str(i*j) == str(i*j)[::-1]:
            pal.append([i*j,i,j])

print(max(pal))

data = []
for a in range(100, 1000) :
    for b in range(100, 1000) :
        c = str(a * b)
        c = list(c)
        d = c[:]
        c.reverse()
        if c[0:len(c)] == d[0:len(d)] :
            c = ''.join(c)
            c = int(c)
            data.append([c])
print(max(data))

data = []
for a in range(100, 1000) :
    for b in range(100, 1000) :
        c = str(a * b)
        if c == c[::-1] :
            c = int(c)
            data.append(c)
print(max(data))

python 2.7

가장 기초적인 풀이입니다. 다른 분들의 s[::-1]이 제 방법의 list를 reverse list와 비교하는것 보다 훨씬 빠르군요. 그리고 loop 돌릴 때도 뒤 999에서부터 돌리는 것 등 매번 많이 배우고 갑니다.

def max_palindrom(nb_range):
    palindrome = []

    for i in nb_range:
        for j in nb_range:
            nb = i * j
            nb_lst = [x for x in str(nb)]
            nb_rvs_lst = list(reversed(nb_lst))

            if nb_lst == nb_rvs_lst:
                palindrome.append(nb)

    return max(palindrome)

nb_sample = range(100,1000)
print (max_palindrom(nb_sample))

906609 나오네요

const palindrom = () => {
    const arr = [];
    for (let i = 999; i >= 100; i--) {
            for (let j = 999; j >= 100; j--) {
                    let tmp = i * j;
                    if (tmp.toString() === tmp.toString().split('').reverse().join('')) {
                            arr.push(tmp);
                    }
            }
    }
    return arr.reduce((max, v) => max < v ? v : max, Number.MIN_SAFE_INTEGER);
};

console.log(palindrom());

python 입니다~ 906609 913*993

lis = []
lis_xy = []
for x in range(100, 1000):
    for y in range(100, 1000):
        multi_xy = str(x*y)
        if multi_xy == multi_xy[::-1]:
            lis.append(int(multi_xy))
            if int(multi_xy) == 906609:
                lis_xy.append(x)
print(max(lis), lis_xy)

result=[0]
for i in range(100, 1000):
    for j in range(100, 1000):
        tmp=str(i*j)
        if tmp==tmp[::-1] and int(tmp)>result[0]:
            result=[int(tmp), i, j]

print(result)

calc = lambda start, stop: max([*( max([*( (lambda k: k if str(k) == str(k)[::-1] else 0)(i*j) for j in range(start, i+1))]) for i in range(start, stop+1))])

if __name__ == '__main__':
    print(calc(100,999))

파이썬 3.6.2 64

#파이썬 초보입니다! 잘부탁드려요
best_number = 1 * 2

for i in range(99, 1000):
    for x in range(99,1000):
        total_number = i * x
        if str(total_number) == str(total_number)[::-1] and total_number > best_number:
            best_number = total_number
print(best_number)

파이썬 3.6

def symmetrynum(n):
    mul = ''
    symlist =[]
    for i in range(10**(n-1),10**n):
        for h in range(10**(n-1),10**n):
            mul = str(i * h)
            if mul == mul[::-1]:
                symlist.append(int(mul))
            else:
                pass
    print( "\n",">>> 가장 큰 대칭수 : ",max(symlist))

n = int(input(" ▶곱하는 수의 자리수를 입력하세요: "))
symmetrynum(n)

*결과값

 ▶곱하는 수의 자리수를 입력하세요: 3

 >>> 가장 큰 대칭수 :  906609

파이썬 입니다.

#v1 무식한 방법 
def isPalindrome(number):
    num_str = str(number)
    num_len = len(num_str)
    count = float(num_len / 2) 

    for i in range(int(count)):
        if num_str[i] != num_str[num_len -1 - i]:
            return False

    return True

def maxForPalindrome(startN, endN):
    res = 0
    ranges = range(startN, endN)
    for i in ranges:
        for j in ranges:
            num = i * j
            if isPalindrome(num) == True and num > res:
                res = num
    return res

res = maxForPalindrome(100,999)
print('result : ', res)

package codingstudio;

public class Q144 {

    public static void main(String[] args) {
        // TODO 자동 생성된 메소드 스텁

        int MaxPalindrome = 0;
        int chk;

        System.out.println("코딩도장 144번 문제 풀이");
        System.out.println("-----------------");

        for (int i = 100; i < 1000; i++) {

            for (int j = 100; j < 1000; j++) {
                chk = i * j;

                if (chkPalindrome(chk)) {
                    MaxPalindrome = compareMax(MaxPalindrome, chk);
                } else {
                }
            }
        }
        System.out.println("세자리 수끼리 곱하여 계산된 최대 대칭수는" + MaxPalindrome + " 입니다.");
    }

    public static boolean chkPalindrome(int a) {
        String str = Integer.toString(a);

        int rvs = Integer.parseInt(reverseString(str));

        if (a == rvs) {
            return true;
        } else {
            return false;
        }
    }

    public static int compareMax(int max, int comp) {
        System.out.println("현재 최대값 : " + max);
        System.out.println("비교할 값 : " + comp);

        if (max < comp) {
            System.out.println("현재 최대값보다 비교값이 커서, 최대값이 " + comp + " 로 교체되었습니다.");
            return comp;
        } else {
            System.out.println("현재 최대값보다 비교값이 같거나 작아, 최대값이 교체되지 않았습니다.");
            return max;
        }
    }

    public static String reverseString(String s) {
        return (new StringBuffer(s)).reverse().toString();
    }

}

max_pal = 0
cur_pal = 0

for i in range(100, 1000):
    for j in range(100, 1000):
        cur_pal = i * j
        if str(cur_pal) == str(cur_pal)[::-1] and cur_pal > max_pal:
            max_pal, cur_pal = cur_pal, max_pal
print(max_pal)

a = []
for i in range(100,1000):
    for j in range(i, 1000):
        b = i*j
        c = d = list(str(b))
        c.reverse()
        if c == d:
            a.append(b)
print(max(a))

max_num=-99

for i in range(100,1000):
    for g in range(100,1000):
        temp_num=i*g
        if str(temp_num)==str(temp_num)[::-1] and temp_num>max_num:
            max_num=temp_num

print(max_num)

public class palindrome {

    public static void main(String[] args) {
        int number = 0;
        int max = 0;
        String str = null;

        for(int i = 100; i <= 999; i++) {
            for(int j = 100; j <= 999; j++) {
                number = i * j;
                str = number + "";

                char[] array1 = new char[str.length()];
                char[] array2 = new char[str.length()];
                for(int k = 0; k < str.length(); k++) {
                    array1[k] = str.charAt(k);
                }
                int idx = 0;
                for(int k = str.length() - 1; k >= 0; k--) {
                    array2[idx] = str.charAt(k);
                    idx++;
                }
                if(Arrays.equals(array1, array2)) {
                    if(number > max) {
                        max = number;
                    }
                    System.out.println(i + " * " + j + " = " + max);
                    System.out.println(Arrays.toString(array1));
                    System.out.println(Arrays.toString(array2));
                }
            }
        }
        System.out.println("가장 튼 대칭수는 :" + max + "입니다");

    }

}

def palindrome():
    result = 0
    for a in range(100, 1000):
        for b in range(100, 1000):
            if str(a*b) == str(a*b)[::-1] and a*b > result:
                result = a*b
    return result

Pyhton 3입니다 문자열 뒤집는 코드([::-1])는 나무위키 Python 문서를 참고했습니다

def pal() :
    for i in range(999,100,-1) :
        for j in range(999,100,-1) :
            if str(i * j) == str(i * j)[::-1] :
                return i * j

Swift입니다.

import Foundation

var maxNumber = -1
for i in stride(from:999, to:99, by: -1) {
    for j in stride(from:999, to:99, by: -1) {
        let number = i * j
        if number > maxNumber {
            let numString = String(number)
            if numString == String(numString.reversed()) {
                if number > maxNumber {
                    maxNumber = number
                }
                break
            }
        } else {
            break
        }
    }
}
print(maxNumber)

python 입니다. 그닥 좋은 알고리즘은 아닌듯 하네요 ㅎ^^;

l = []
for n1 in reversed(range(100, 1000)):
    for n2 in reversed(range(100, 1000)):
        v = n1 * n2
        if str(v) == ''.join(reversed(str(v))):
            l.append(int(v))

print(max(l))

public class hello {
    public static void main(String args[]) {
        Example144 ex = new Example144();

        int max = 0;
        for (int i = 100; i < 1000; i++) {
            for (int j = 100; j < 1000; j++) {
                if (ex.isPalindrome(String.valueOf(i * j))) {
                    max = max < (i * j) ? (i * j) : max;
                }
            }
        }
        System.out.println(max);
    }

    public boolean isPalindrome(String str) {
        if (str.length() % 2 == 0) {
            return str.equals(new StringBuilder(str).reverse().toString());
        } else {
            return false;
        }
    }
}

// 자바
public static void main(String[] args) throws Exception {

        int ans = 0;
        for (int i=100; i<1000; i++) {
            for (int j=100; j<1000; j++) {
                if ((i*j+"").equals(new StringBuffer(i*j+"").reverse().toString()))
                    ans = Math.max(ans, i*j);
            }
        }
        System.out.println(ans);
    }

``````{.cpp}
// ConsoleApplication1.cpp: 콘솔 응용 프로그램의 진입점을 정의합니다.
//

#include "stdafx.h"
#include <iostream>

//앞에서부터 읽을 때나 뒤에서부터 읽을 때나 모양이 같은 수를 대칭수(palindrome)라고 부릅니다. 
//두 자리 수를 곱해 만들 수 있는 대칭수 중 가장 큰 수는 9009 (= 91 × 99) 입니다. 
//세 자리 수를 곱해 만들 수 있는 가장 큰 대칭수는 얼마입니까?

int palindrome(int num)
{
    int a1 = 0, a2 = 0;
    int a21=0, a22=0, a23=0;

    a1 = num / 1000;
    a2 = num % 1000;

    a21 = a2 / 100;
    a2 = a2 % 100;
    a22 = a2 / 10;
    a2 = a2 % 10;
    a23 = a2;

    a23 = a23 * 100;
    a22 = a22 * 10;

    a2 = a23 + a22 + a21;

    if (a1 == a2) return 1;
    else return 0;
}

int main()
{
    int num = 0, max=0;

    for (int i = 999; i > 99; i--)
    {
        for (int j = 999; j > 99; j--)
        {
            num = i * j;

            std::cout << i << "*" << j << "=" <<num << "\n";

            if (palindrome(num))
            {
                if (max < num) max = num;
            }
        }
    }

    std::cout << max << "은 세자리 수를 곱해 만들수있는 가장 큰 대칭수입니다.";
}

906609 나왔네요, c++힘듭니다..ㅠㅠ

def palindrome():
    final_palindrome = 0
    for k in range(10000, 999*999):
        num = str(k)

        if num == num[::-1]:
            num1 = int(num)
            for j in range(100, 1000):
                if num1 // j > 100 and num1 // j <1000 and num1 % j == 0:
                    final_palindrome = num1

    print(final_palindrome)

python 3입니다

def palindrome(number):
    tmp = str(number)
    tmp2 = "".join(reversed(tmp))
    if tmp == tmp2:
        return True

n = 0
max = 0
for i in range(999, 99, -1):
    for j in range(999,99,-1):
        n = i*j
        if (palindrome(n)) and max < n: max = n
print(max)

Python

n = 3
ans = 0
for i in range(10**n-1, 0, -1):
    for j in range(i, 0, -1):
        #print(i*j)
        if str(i*j) == str(i*j)[::-1]:
            ans = max(ans, i*j)
print(ans)

max = 0
for i in range(100,1000):
    for j in range(100, 1000):
        ij = i * j
        if str(ij) == str(ij)[::-1] and max < ij:
            max  = ij
print(max)

palin_list = []

for i in range(100, 1000):
    for j in range(100, 1000):
        mul = i * j
        if str(mul) == str(mul)[::-1]:
            palin_list.append(mul)

print(max(palin_list))

public class test {
    public static void main(String[] args) {
        int num = 0;
        for (int i = 999; i > 99; i--)
            for (int j = i; j > 99; j--)
                if ((i * j + "").equals(new StringBuffer(i * j + "").reverse().toString()))
                    num = Math.max(i * j, num);
        System.out.print(num);
    }
}

def ispalindrome(n):
    return ''.join(reversed(str(n))) == str(n)

print(max(i*j for i in range(999,99,-1) for j in range(999,i-1,-1) if ispalindrome(i*j)))

# 906609

a=0
lists=[]
for i in range(100,1000):#3자리
    for j in range(100,1000):
        a=i*j
        if str(a)[0] == str(a)[-1] and str(a)[1] == str(a)[-2] and str(a)[2] == str(a)[-3]:
            lists.append(a)
lists.sort(reverse=True)
print('3자리 대칭수중 가장 큰수:',lists[0])
#906609

lst=[]

for x in range(100,1000):
    for y in range(100,1000):
        a=list(str(x*y))
        a.reverse()
        if list(str(x*y))==a:
            lst.append(x*y)

print(max(lst))

l = []
for a in range(100, 1000):
    for b in range(100, 1000):
        number = a * b
        strnum = str(number)
        if strnum == strnum[::-1]:
            l.append(int(strnum))

print(max(l))

906609

biglist=[]

def palindrome(num):
    a = str(num)
    alist=[]
    rlist=[]

    for i in range(0,len(a),1):
        alist.append(a[i])

    for i in range(len(a)-1,-1,-1):
        rlist.append(a[i])

    if alist==rlist:
        return True
    else:
        return False


for i in range(100,1000,1):
    for j in range(100,1000,1):
        num = i*j
        if palindrome(num) == True:
            biglist.append(num)


print(max(biglist))

palindrome = []

for i in range(999*999):
    if len(str(i)) % 2 == 0:
        check = 0
        for ind in range(int(len(str(i)) / 2)):
            if str(i)[ind] == str(i)[-ind-1]:
                check += 1
        if check == (len(str(i)) / 2):
            palindrome.append(i)

print(max([f * s for f in range(100, 1000) for s in range(100, 1000) if f * s in palindrome]))

#include <stdio.h>

int palindrome(int num){
    int arr[6] = {0,0,0,0,0,0};
    int size;

    size = -1;

    for(int i = 0 ; i < 6 ; i++){
        arr[i] = num % 10;
        num /= 10;
        size++;

        if(num < 0)
            break;
    }


    if((size+1) % 2 != 0)
        return 0;

    for(int i = 0; i < ((size+1)/2)+1; i++){
        if(arr[i] != arr[size])
            return 0;
        size--;
    }

    return 1;
}

int main(void){
    int a,b,c,num,palin,temp;

    a = 999;
    b = 999;
    c = 0;

    while(a>99){
        while(b>99){
            num = a * b;
            if(palindrome(num) == 1){
                palin = num;
                c = 1;
                break;
            }
            b--;
        }

        if(c==1)
            if(palin > temp){
                temp = palin;
            }
        a--;
        b=999;
        c = 0;
    }

    printf("%d",temp);

    return 0;
}

box = []
for i in range(100,1000) :
    for j in range(100,1000) :
        if list(str(i*j))[0::1] == list(str(i*j))[-1::-1] :
            box.append((''.join(list(str(i*j)))))
print(max(map(int,box)))

ma = 0
for a in reversed(range(100,1001)):
    for b in reversed(range(100,1001)):
        if str(a*b) == str(a*b)[::-1] and ma < a*b:
            ma = a*b
print(ma)

def is_palindrome(num):
    numstr = str(num)
    if numstr[::-1] == numstr:
        return True

def biggest():
    temp = []
    for i in range(999,99,-1):
        for j in range(999,99,-1):
            num = i*j
            if is_palindrome(num):
                temp.append(num)
    temp.sort()
    return temp[-1]

print(biggest())

namespace codingdojang_test
{
    class Program
    {
        static void Main(string[] args)
        {
            int max = 0;

            for (int i = 999; i > 99; i--)
            {
                for (int e = 999; e > 99; e--)
                {
                    int temp = i * e;
                    int temp_reverse = int.Parse(new string(temp.ToString().ToCharArray().Reverse().ToArray()));


                    if (int.Parse(temp.ToString()) == temp_reverse)
                    {
                        if (temp > max)
                        {
                            max = temp;
                        }
                    }
                }
            }

            Console.WriteLine(max);
        }
    }
}

답 = 906609

#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>

bool isPalindrome(int num) {  // 정수 회문 판별을 위해 정수를 배열로 바꾸어서 비교합니다.
    int tmp = num;
    int base = 1;  // 최상위 자리로부터 숫자를 꺼내기 위해 입력한 수를 넘지 않는 최대의 10의 제수를 구합니다.
    int exp = 0;
    while (base <= tmp) {
        base *= 10;
        exp++;  // 몇자리수인지 구합니다.
    }
    base /= 10;
    int* arr = (int*)malloc(sizeof(int) * exp);  // 자릿수 만큼 배열을 동적으로 할당합니다.
    for (int i = 0; i < exp; i++) {
        arr[i] = tmp / base;  // 정수를 최상위 자리부터 배열에 넣습니다.
        tmp %= base;
        base /= 10;
    }
    for (int i = 0; i <= exp / 2; i++) {
        if (arr[i] != arr[exp - (i + 1)]) {  // 왼쪽은 배열의 0, 1, 2, ... 이고 오른쪽은 n-1, n-2, ... 두 수를 비교 
            free(arr); // 두 수가 다르면 회문이 아니므로, 배열 해제
            return false;  // false 반환
        }
    }
    free(arr); //for문을 빠져나왔으면 회문이므로 배열 해제
    return true;  // true 반환
}
int main() {
    int num;
    int max = 0;
    for (int i = 100; i < 1000; i++) {
        for (int j = 100; j < 1000; j++) {
            num = i * j;
            if (isPalindrome(num)) {
                if (num > max) max = num;
            }
        }
    }
    printf("%d\n", max);
    return 0;
}

public class Problem144 {

    public static void main(String[] args) {
        int temp,r1 = 0,r2 = 0;
        Loop:
        for(int i=999;i>=900;i--) {
            for(int j=999;j>=900;j--) {
                temp=i*j;
                String str = Integer.toString(temp);
                String reverse = new StringBuffer(str).reverse().toString();
                if(str.equals(reverse)) {
                    r1=i;
                    r2=j;
                    break Loop;
                }                   
            }
        }
        System.out.println(r1+"와 "+r2+"를 곱한 "+r1*r2);
    }
}

palin=[]
for i in range(100,1000):
    for j in range(i,1000):
        a=list(str(i*j))
        a.reverse()
        if a==list(str(i*j)):
            palin.append(i*j)
print(max(palin))

public static int Palindrome(int position){

        int startNumber = (int) Math.pow(10, position) - 1;
        int number = 0;
        int result = 0;


        for(int i = startNumber; i >= startNumber/2; i--) {


            for(int j = i; j >= i/2; j--) {


                number = i * j;


                if(isSymmetryNumber(number)) {
                    break;
                }


            }


            if(number>result)
                result = number;

        }


        return result;


    }


    public static boolean isSymmetryNumber(int number) {

        String str = Integer.toString(number);


        for(int i = 0; i < str.length()/2; i++) {

            if(str.charAt(i) != str.charAt(str.length() - 1 - i))
                return false;

        }

        return true;

    }

palin = list()

for i in range(100, 1000):
    for j in range(100, 1000):
        pstr = str(i * j)
        # check if i * j is palindrome
        if pstr[0:len(pstr)//2] == pstr[-1:-(len(pstr)//2+1):-1]:
            #print("i: ", i, "j: ", j)
            #print("palin: ", pstr)
            palin.append(i * j)

print("Maximun value: ", max(palin))

ans=0
for q1 in range(100,1000):
    for w2 in range(100,1000):
        s=str(q1*w2)
        if s==s[::-1]:
            ans=max(ans,q1*w2)

print(ans)

문자열대칭을 한번에 알 수 있는 조작이 있었다니, 몰랐었읍니다.

result = 0

for i in range(1,1000):
    for j in range(1,1000):
        a=list(str(i*j))
        b=a.copy()
        b.reverse()
        if a==b and i*j >result :
            result = i*j            
print(result)   #906609

max = 0
for i in range(100, 1000):
    for j in range(100, 1000):
        palindrome = str(i*j)
        a = list(palindrome)
        b = a.copy()
        b.reverse()
        if a == b:
            if int(''.join(a)) > max:
                max = int(''.join(a))
print(max)

result = []
for i in range(999,99,-1):
    for j in range(999,99,-1):
        t = list(str(i*j))
        # t[::-1]은 리스트를 역순으로 변환
        # t = [1,2,3,4]이면 t[::-1]은 [4,3,2,1]
        if t == t[::-1]:
            result.append(i*j)
            break
print(max(result))

Python

set_A = []
set_B = []
set_C = []
for i in range(100, 1000):
    A = i
    for k in range(100, 1000):
        B = k
        C = A * B
        str_C = str(C)
        if list(str_C) == list(reversed(str_C)):
            set_A.append(A)
            set_B.append(B)
            set_C.append(C)
ans_A = set_A[set_C.index(max(set_C))]
ans_B = set_B[set_C.index(max(set_C))]
ans_C = set_C[set_C.index(max(set_C))]
ans = dict(zip(['A', 'B', 'C'], [ans_A, ans_B, ans_C]))
print(ans)

a=[]
b=[]
c=[]
for i in range(100,1000):
    for j in range(100,1000):
        a.extend(list(str(i*j)))
        b.extend(list(str(i*j)))
        a.reverse()
        if b==a:
            c.append(i*j)
            a.clear()
            b.clear()
        else:
            a.clear()
            b.clear()
print(max(c))

list_2 = []
f_num = 0
for i in range(100, 1000):
    for j in range(100, 1000):
        list_1 = list(str(i * j))
        k = list(reversed(list_1))
        if k == list_1 and len(list_1)%2 == 0:
            f_num = ''.join(list_1)
            list_2.append(str(f_num))
print(max(list_2))

메모리 엄청 잡아먹는 쓰레기 같은 코드입니다ㅋㅋㅋ 어떻게 푸는지 잘 몰라서 그냥 다 돌리고 리스트에 넣었습니다..

result = []
for a in range(99,1000):
    for b in range(99,1000):
        data = str(a*b)
        if data == data[::-1]:
            result.append(int(data))

print(max(result))

sum = [] for i in range(100,1000): for j in range(100,1000): result = i * j reverse = int(str(result)[::-1]) if result == reverse : sum.append(result)

sum.sort() sum.reverse() print(sum[0])

def palinedrome(num):
    num=str(num)
    if num[:]==num[::-1]:
        return int(num)
    else:
        return 0

max_paline=0

for x in range(100,1000):
    for y in range(100,1000):
        m=x*y
        print(x,y,m)
        if palinedrome(m)>max_paline:
            max_paline=m



print(max_paline)

import java.util.*;
public class palindrome {

    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<Integer>(); 
        ArrayList<Integer> palindrome_list = new ArrayList<Integer>();
        for(int i=100; i<1000; i++) {
            for(int j=100; j<1000; j++) {
                String str = Integer.toString(i*j);
                int num = i*j;
                for(double k=0; k<str.length()-1; k++) {
                    list.add((num)%10);
                    num = num/10;
                }
                list.add(num);
                if(str.length()==5) {
                    if(list.get(str.length()-1)==list.get(0)) {
                        if(list.get(str.length()-2)==list.get(1)){
                            palindrome_list.add(i*j);
                        }
                    }
            }
                else {
                    if(list.get(str.length()-1)==list.get(0)) {
                        if(list.get(str.length()-2)==list.get(1)){
                            if(list.get(str.length()-3)==list.get(2)){
                                palindrome_list.add(i*j);
                            }
                        }
                }
                 list.clear();
        }
    }
}
        System.out.println(palindrome_list);
        int BiggestPalindrome = 0;
        for(int m = 0; m<palindrome_list.size()-1; m++) {
            if(BiggestPalindrome<palindrome_list.get(m)){
                BiggestPalindrome = palindrome_list.get(m);
            }
        }
        System.out.println(BiggestPalindrome);
}
}

파이썬 입니다.

circle=[]
for i in range(100,1000):
  for j in range(100,1000):
    if str(i*j)[:3] == str(i*j)[3:][::-1]:
      circle.append(i*j)
print(max(circle))     #906609

파이썬입니다.

result = []
for a in range(999,99,-1):
  for b in range(999,99,-1):
    if str(a*b) == str(a*b)[::-1]:
      result.append(a*b)
print(max(result))

elst=[]
for n in range(100,1000):
    for k in range(n,1000):
        if str(n*k)==str(n*k)[::-1]:
            elst.append(n*k)
print(max(elst))  #906609

res = [0]
for i in range(100, 999) :
    for k in range(i, 999) :
        if str(i*k) == str(i*k)[::-1] : res.append(i*k)
    res = [max(res)]
print(res[0])

룰루랄라님의 풀이를 보고 작성하였습니다.

결과

906609

a = set()
b = set()

for i in range(999*999):
    numstr = str(i)
    if numstr == numstr[::-1]:
        a.add(int(numstr))

for m in range(1000):
    for n in range(1000):
        num = m * n
        b.add(num)

print(max(a & b))

pal = []

for i in range (100,1000):

    for j in range(100,1000):

        gop1 = i*j

        gop_list=list(str(gop1))



        gop2 = i*j

        gop_list2=list(str(gop2))

        gop_list2.reverse()

        if gop_list == gop_list2:

            pal.append(gop1)


print(max(pal))

result = [] for i in range(100, 1000): for j in range(100, 1000): A = i*j if 99999<A<1000000: A = list(str(A)) if A[0] == A[5] and A[1] == A[4] and A[2] == A[3]: result.append(A)

print(max(result))

result=[]
m=0

for i in range(999,99,-1):
    for j in range(999,99,-1):
        s= str(i*j)
        if s == s[::-1] and int(s)>m:
            m=int(s)


print(m)

result = 0
for i in range(100, 1000):
    for j in range(100, 1000):
        if str(i*j) == str(i*j)[::-1] and i*j > result:
            result = i*j
print(result)

def cal_palindrome():
    result = []

    for i in range(10, 1000):
        for j in range(10, 1000):
            if str(i * j) == str(i * j)[::-1]:
                result.append(i * j)
    return max(result)


print(cal_palindrome())

s=c=d=0
for i in range(100,1000):
    for k in range(100,1000):
        c=i*k
        l=list(str(c))
        r=list(reversed(l))
        if l==r and c>s:
            s=c
            print('대칭수 발견: '+str(c))
            d+=1
        else:
            pass
print(s)
print(d)

대칭수는 총 107개라는 것을 알 수 있었습니다 ^^

from math import *
max=0

for i in range (100,1000):
    for j in range (100,1000):
        n,k=str(i*j),0
        while (k<ceil(len(n)/2)):
            if n[k] != n[len(n)-k-1]:
                break
            k+=1
        if k==ceil(len(n)/2) and max<int(n):
            max=int(n)

print (max)

추천 풀이를 참고 했습니다.

a = set([i * j for i in range(999, 99, -1) for j in range(999, 99, -1)]) a = sorted(list(a), reverse=True) for num in a: string = str(num) if string == string[::-1]: print(num) break ```

def all(N):
    k = ""
    for i in range(len(N)):
        k += N[i]
    return int(k)
def main(N):
    m = ""
    N = list(str(N))
    if len(N) % 2 == 0:
        for h in range(int(len(N)/2)):
            m = N.pop(h) + m
    elif len(N) % 2 == 1:
        for h in range(int(len(N)/2)):
            m = N.pop(h) + m
        N.pop(0)
    if int(m) == all(N):
        return 1
    else:
        return 0
final = 0
for i in range(100,1000):
    for j in range(100,1000):
        if final < (i * j):
            check = i*j
            if main(check) == 1:
                final = check
print(final)

def palindrome(num):
    pali=str(num)
    for i in range(len(pali)//2):
        if pali[i]!=pali[len(pali)-i-1]:
            return 0

    return 1


list=0
for i in range(100,1000):
    for j in range(100,1000):
        if palindrome(i*j):
            if list<i*j:
                list=i*j


print(list)

public class Q144 {

    public static void main(String[] args) {
        int num;
        int max=0;
        for(int i=999; i>99; i--) {
            for(int j=999; j>99; j--) {
                num = i*j;
                String pd = Integer.toString(num);
                String temp="";
                for(int k=pd.length()-1; k>=0; k--) {
                    temp += pd.charAt(k);

                    if(pd.equals(temp)&&num>max) {
                        max = num;
                        break;
                    }
                }
            }
        }
        System.out.println(max);
    }
}

def max_palind_num():
    return max([i * j for i in range(100, 1000) for j in range(100, 1000) if str(i * j) == str(i * j)[::-1]])

import math
list = []
for i in range(100,1000):
    for j in range(100,1000):
        a = int(str(i*j)[::-1])
        if a == i*j:
            list.append(a)
        else:
            continue
print(max(list))

for i in range (999,99,-1):
    for j in range(999,99,-1):
        if str(i*j)==str(i*j)[::-1]:
            x.append(i*j)
x.sort()
print(x[-1])

#include <iostream>
#include <vector>
using namespace std;
/* 
앞에서부터 읽을 때나 뒤에서부터 읽을 때나 모양이 같은 수를 대칭수(palindrome)라고 부릅니다. 
두 자리 수를 곱해 만들 수 있는 대칭수 중 가장 큰 수는 9009 (= 91 × 99) 입니다. 
세 자리 수를 곱해 만들 수 있는 가장 큰 대칭수는 얼마입니까?
*/


bool palindrome(int a) {
    int size = 1;
    int first = a;
    do {
        a = a / 10;
        size++;
    } while (a > 10);

    a = first;
    vector<int> vector(size);
    for (int i = 0; i < size; i++)
    {
        vector[i] = a % 10;
        a = a / 10;
    }
    int i = 0;
    while (i<vector.size()) 
    {
        if (vector[i] == vector.back())
        {
            vector.pop_back();
            i++;
        }
        else
            return false;
    }
    return true;

}

int main()
{
    int num = 0;
    int max = 0;
    int answer1 = 0;
    int answer2 = 0;
    for (int i = 999; i > 99; i--)
    {
        for (int y = 999; y > 99; y--)
        {
            num = i * y;
            if (palindrome(num))
                if (num > max)
                {
                    max = num;
                    answer1 = i;
                    answer2 = y;
                }
        }
    }
    cout << answer1 << " X " << answer2 << endl;
    cout << max;
    return 0;
}

package test;
import java.util.*;
//세 자리 수를 곱해 만들 수 있는 가장 큰 대칭수 구하기
public class Test{
    public static void main(String[] args) {
        ArrayList<Integer> arr = new ArrayList<>();
        StringBuffer str1 = new StringBuffer();
        StringBuffer str2 = new StringBuffer();
        int max = 0;
        for(int i = 100; i<1000;i++){
            for(int j = 100; j<1000; j++) {
                int num = i * j;
                String a = Integer.toString(num);  //두수의 곱을 string형 으로 전환
                str2.append(a.substring(3));  // str2에 뒷 3자리 문자열 추가
                str2.reverse();  //str2 거꾸로
                str1.append(a.substring(0,3));  //str1에 앞 3자리 문자열 추가
                if(str1.toString().equals(str2.toString())) {  //str1과 str2 문자열이 같다면 
                    arr.add(Integer.parseInt(str1.toString()+str2.toString()));  
                } // str1과 str2를 붙인 문자열을 int형으로 전환후 Integer형 arr 리스트에 추가
                str1.setLength(0);  //str1, str2 초기화
                str2.setLength(0);
            }
        }
        int arr2[] = new int [arr.size()];  //int형 arr2배열 생성
        for(int k=0;k<arr.size();k++) {     
            arr2[k] = Integer.valueOf(arr.get(k));  //Integer형 arr을 int형 arr2배열로 전환
        }
        for(int k=1; k<arr2.length; k++) {  //비교를 통해 가장 큰 대칭수 구하기
            if(arr2[k]<arr2[k-1])
                max = arr2[k-1];
        }
        StringBuffer max2 = new StringBuffer(Integer.toString(max)); //최댓값을 string 전환
        StringBuffer max3 = new StringBuffer(max2.substring(3));//최댓값의 뒷자리 3개 max3에 대입
        max3.reverse(); //뒷 세자리 거꾸로
        max2.delete(3, 6); //원본의 뒷 3자리 제거
        System.out.println(max2.append(max3)); //max뒤에 max 붙이기
    }
}

print(max([i*l for i in range(100, 1000) for l in range(100, 1000) if str(i*l) == str(i*l)[::-1]]))

파이썬입니다

print(max(x*y for x in range(100,1000) for y in range(100,1000) if str(x*y)==str(x*y)[::-1]))

#include <stdio.h>


int main()
{
    int i,j;

    int result,temp;

    for(i=999;i>=100;i--)
    {
        for(j=999;j>=i;j--)
        {
            result=i*j;
            if(result/100000==0 && result/10000==result%10 && (result/10)%10==(result/1000)%10)//만의 자리
            {
                if(result>temp)
                    temp=result;
            }
            else if(result/100000==result%10 && (result/10)%10==(result/10000)%10 && (result/100)%10==(result/1000)%10)//십만
            {
                if(result>temp)
                    temp=result;
            }
        }
    }

    printf("답은! %d",temp);

    return 0;
}

class FindPalindrome:
    def __init__(self):
        self.result = 0
    def findThree(self):
        for i in range(99,1000):
            for j in range(99,1000):
                b = str(i*j)
                if b==b[::-1]:
                    if int(b)>self.result:
                        self.result = int(b)
        print (self.result)

a = FindPalindrome()
a.findThree()

a=[x*y for y in range(100,1000) for x in range(100,1000) if str(x*y) == str(x*y)[::-1]]
print(max(a))

maximum=0
for x in range(100,1000):
    for y in range(100,1000):
        multiplied=x*y
        multiplied=str(multiplied)
        if multiplied[::]==multiplied[::-1] and int(multiplied)>maximum:
            maximum=int(multiplied)

print(maximum)

def pal(num):
    result=[]
    temp = []

    for i in range(10**(num-1),10**num):
        for j in range(10**(num-1),10**num):
            temp.append(str(i*j))

    for aa in temp:
        bb = aa[::-1]
        if aa == bb and len(aa)>1:
            result.append(int(aa))

    result = list(set(result))
    result.sort()

    return result

print(max(pal(3)))

result = []
for i in range(100,1000):
    for k in range(100,1000):
        temp = ""
        n=len(str(i*k))
        while n > 0:
            temp += str(i*k)[n-1]
            n -= 1
        if i*k == int(temp):
            result.append(i*k)
print(max(result))

이 코딩도장 페이지는 관리가 안되나보군요;; 등급이 갱신이 안되서 댓글도 못쓰네요;

palindrome_dict = {}
for first_num in range(999, 100, -1):
    for second_num in range(999, 100, -1):
        multiplied_num = str(first_num * second_num)
        if multiplied_num[::] == multiplied_num[::-1]:
            palindrome_dict[int(multiplied_num)] = [first_num, second_num]

print(max(palindrome_dict.keys()), palindrome_dict[max(palindrome_dict.keys())])
>>>906609 [913, 993]

s1=set()

for x in range(100,1000):
  for y in range(100,1000):
    number_str = str(x*y)
    k=0
    for i in range(0,len(number_str)//2,1):
      if number_str[i] != number_str[len(number_str)-(i+1)]:
        k+=1
        break

    if k==0:
      s1.add(int(number_str))


print(max(s1))

def pal(a):

  b=str(a)

  for i in range(0,len(b),1):

    if b[i]!=b[len(b)-1-i]:

      return False

      break

    if i==len(b)-1:

      return True

for_answer=[]

for i in range(100,1000,1):

  for j in range(100,1000,1):

    if pal(i*j)==True:

      for_answer.append(i*j)

for_answer.sort()

print(for_answer[len(for_answer)-1])

import java.util.Scanner;

public class pro8 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Scanner sc = new Scanner(System.in);
        int re =0;
        String sum;
        for(int i=100; i<1000; i++) {
            for(int j=100; j<1000; j++) {
                sum = i*j+"";
                StringBuffer st = new StringBuffer();
                st.append(sum);
                if((sum).equals(st.reverse().toString())){
                        re=Math.max(i*j,re);
                    }
            }
        }
        System.out.println(re);
    }

}

def Maxpalindrome():
    import math
    max_value = 0
    for i in range(100,1001):
        for j in range(i,1001):
            temp = str(i*j)

            if list(temp[:len(temp)//2])==list(reversed(temp[math.ceil(len(temp)/2):])) and max_value<i*j:
                (max_value,a,b) = (i*j,i,j)

    return '{} * {} = {}'.format(a,b,max_value)

result = 0

for a in range(100, 1000):
    for b in range(100, 1000):
        list = []
        for i in str(a * b):
            list.append(i)
        r_list = []
        for j in range(len(list) -1 , -1, -1):
            r_list.append(list[j])
        if list == r_list:
            if a * b > result:
                result = a * b

print(result)

906699

M = 0
for i in range(999,99,-1):
    for j in range(999,99,-1):
        m = i*j
        if m < M:
            break
        elif str(m)[::-1]==str(m):
            M=m
            break
print(M)

output = []
for i in range(999, 99, -1):
   for j in range(i, 99, -1):
       mul = str(i * j)
       if mul[::-1]==mul:
           output.append(int(mul))
       else:
           pass
output.sort()
print(output[-1])

def isPalindrome():
    m = 0
    for i in range(999,99,-1):
        for j in range(999,99,-1):
            result = str(i*j)
            if result == result[::-1] and m < int(result):
                m = int(result)

    return m

print(isPalindrome())

li = []
for i in range(100,1000):
    for k in range(100,1000):
        if len(str(i*k)) == 6:
            li.append(str(i*k))

li1 = []
for k in li:
    if k[0:3] == "".join(reversed(k[3:6])):
        li1.append(k)

print(max(li1))

num = []
for i in range(100, 1000):
    for j in range(100, 1000):
        if str(i*j) == str(i*j)[::-1]: # [::-1] 레게노 ~
            num.append(i*j)
print(max(num))

pal=[]

for x in range(100,1000):
    for y in range(100,1000):
            if str(x*y) == str(x*y)[::-1] :
                pal.append(x*y)

print(pal[-1])

s[ : : -1]을 통해 간단하게 문자열을 뒤집을 수 있단 것을 이 문제를 풀면서 알게 되었네요. 오늘도 배우고 갑니다.

def palindrome(num):
    if str(num) == str(num)[::-1]:
        return True
    return False

result = 0
for i in range(100, 1000):
    for j in range(100, 1000):
        if palindrome(i * j ) and result < i*j:
            result = i*j

print(result)

스크래치입니다

https://scratch.mit.edu/projects/514648519/

def is_palindrome(input_s):
    return str(input_s) == str(input_s)[::-1]

pal_list=[]

for i in range(999,99,-1):
    for j in range(999,99,-1):
        c = i * j
        if is_palindrome(c):
            pal_list.append(c)
print(max(pal_list))

for a in range(100,1000,1):
    for b in range(100,1000,1):
        n = a*b
        palin = []
        s = str(n)
        while 1:
         if len(s) == 6:
          s[0] == s[5]
          s[1] == s[4]
          s[2] == s[3]
          palin.append(int(s))

         elif len(s) == 5:
          s[0] == s[4]
          s[1] == s[3]
          palin.append(int(s))

print(max(palin))

[::-1]을 까먹어서 저런식으로 풀려고 했는데 안 풀려요..ㅜㅠ 뭐가 잘못된건지 모르겠어요

def func():
    n = 0
    list = []
    for i in range(100, 1000):
        for j in range(100, 1000):
            num = str(i * j)
            if num == num[::-1]:
                temp = int(num)
                if n <= temp:
                    n = temp

    return n
print(func())

#codingdojing_palindrome


#1차

win = 0

for i in range(100,1000):
    for j in range(100,1000):
        if str(i*j) == str(i*j)[::-1]:
            win = max(win, i*j)

print(win) #906609

파이썬 3.8.10으로 작성되었습니다.

import math


def is_palindrome(num):
    data = str(num)
    data_len = len(data)

    for i in range(math.floor(data_len / 2)):
        if data[i] == data[data_len - i - 1]:
            pass
        else:
            return False
    return True


def main():
    for i in range(901, 1000):
        a = 1000 - i
        for j in range(1, 1000):
            b = 1000 - j
            if is_palindrome(a*b):
                palindrome.append(a*b)

    return print(max(set(palindrome)))

if __name__ == '__main__':
    main()

Palindrome = []

for a in range(100,1000): for b in range(100,1000): N = a * b str_N = str(N) if len(str_N) == 5: pass elif str_N[0] == str_N[5] and str_N[1] == str_N[4] and str_N[2] == str_N[3]: Palindrome.append(N)

print(max(Palindrome))

result=0
for i in range(10,100):
    for j in range(10,100):
        number=int(str(i*j)[::-1])
        if i*j ==number:
            if result<=i*j:
                result=i*j
print(result)

def give():
    a = 0
    for i in range(100,1000):
        for r in range(100,1000):
            if str(i*r) == str(i*r)[::-1] and i*r > a:
                a = i*r
    return a

print(give())

def is_palindrome(num):
    s = str(num)
    return s == s[::-1]

result = 0

for i in range(999,99,-1):
    for j in range(999,99,-1):
        tmp = i * j
        if tmp < result:
            break
        if is_palindrome(tmp) and tmp > result:
            result = tmp

result=0
for i in range(100,1000):
    for j in range(100,1000):
        x=str(i*j)
        if x==x[::-1] and int(x)>result:
            result=int(x)
print(result)

static void palindrome(int x, int y) {
        int max = 0;
        for(int i = x; i <= y; i++) {
            for(int j = x; j <=y ; j++) {
                String str = (i*j)+"";
                boolean istrue = true;
                for(int k =0; k< str.length(); k++) {
                    if(str.charAt(k) != str.charAt(str.length() - k - 1)) {
                        istrue = false;
                    }
                }
                if(istrue) {
                    if(max < i*j) {
                        max = i*j;
                    }
                }
            }
        }
        System.out.println(max);
    }

    public static void main(String[] args) {
        palindrome(100, 999);
    }

maxNum = 0
for i in range(999, 99, -1):
  for j in range(999, 99, -1):
    pldr = str(i * j)
    if pldr == pldr[::-1] and int(pldr) > maxNum:
      maxNum = int(pldr)
print(maxNum)

m=[]

for k in range(100,1001) :
    for j in range(100,1001) :
        n = list("".join(str(k*j)))
        if n == list(reversed(n)) :  
            m.append(k*j)

print(max(m))

def pal(n):
    n_p = []
    for i in range (len(str(n))):
        n_p.append(str(n)[-i-1])
    return(n_p)

pal_list=[]

for a in range(100,1000):
    for b in range(100,1000):
        if a*b == int(''.join(pal(a*b))):
            pal_list.append(a*b)

print(max(pal_list))

993 * 913 = 906609 palindrome 검사 횟수를 최대한 줄여보려 loop를 최대한 빨리 빠져나오게 했고, 6,124회 검사하는 걸로 나왔습니다.

// Rust

use std::string::ToString;

fn main() {

let n = 3;
let mut m;
let mut max_p;
let mut max = (0, 0);
let mut count = 0;

// i는 999~100까지 루프
for i in (10u32.pow(n-1)..10u32.pow(n)).rev() {

    max_p = max.0 * max.1;
    // i * j의 최대값이 현재 저장된 최대값을 넘을 수 없으면 루프 중단, 결과 출력
    if i * i <= max_p { 
        break; }

    // b는 i~100까지 루프
    for j in (10u32.pow(n-1)..(i+1)).rev() {

        m = i * j;
        // i * j 값이 현재 저장된 최대값을 넘을 수 없으면 루프 중단
        if m < max_p { break; }

        // palindrome 검사 및 횟수 카운트
        count += 1;
        if is_palindrome(m.to_string()) {
            max = (i, j);
            break;
        }
    }
}
println!("{} x {} = {}, count:{}", max.0, max.1, max.0 * max.1, count);

}

fn is_palindrome(num: String) -> bool {

let l = num.len();
let num: Vec<char> = num.chars().collect();

for (i, d) in num[..=l/2].iter().enumerate() {
    if *d != num[l-1-i] { return false; }
}
true

}

result =dict()
for a in range(100,1000):
    for b in range(100,1000):
        r = str(a * b)
        if r == r[::-1]:
            result[int(r)] = a, b

print(max(zip(result.keys(),result.values())))

package org.javaturotials.ex;
import java.util.*;


public class test {
    public static void main(String[] args) {
        String num ="";
        int max=0;
        for(int i=100; i<1000; i++) {
            for(int j=100; j<1000; j++) {
                num=String.valueOf(i*j);
                StringBuilder rb = new StringBuilder(num);
                String rnum = rb.reverse().toString();
                    int a = Integer.valueOf(num);
                    int b = Integer.valueOf(rnum);
                    if(a==b) {
                        if(max<a) {
                            max=a;
                        }
                    }
            }
        }
        System.out.println(max);
        }
    }

result=[]
for a in range(100,1000):
    for b in range(100,1000):
        if str(a*b)[::-1]==str(a*b):
            result.append(a*b)
print(max(result))

first , second = 1, 1
for i in range(100, 1000):
    for j in range(100, 1000):
        x = i * j
        if str(x) == str(x)[::-1]:
            if x > first * second:
                first = i
                second = j
                result = x
print(str(first) + 'x' + str(second)+'=' + str(result))

package com.algorithm.algorithmpractice.dojang;

import java.util.ArrayList;
import java.util.List;

public class Palindrome {
    public static void main(String[] args) {
        List<Integer> palindrome = new ArrayList();
        for(int i = 900; i < 1000; i++){
            for(int j = 900; j < 1000; j++) {
                boolean flag = true;
                int temp = i * j;
                String tempStr = Integer.toString(temp);
                for(int k = 0; k < tempStr.length(); k++){
                    if(tempStr.charAt(k) != tempStr.charAt(tempStr.length()-1-k)){
                        flag = false;
                        break;
                    }
                }
                if(flag){
                    palindrome.add(temp);
                }
            }
        }
        int max = 0;
        for(int i = 0; i < palindrome.size(); i++){
            if(max < palindrome.get(i)){
                max = palindrome.get(i);
            }
        }
        System.out.println(max);
    }
}

파이썬입니다. [::-1] <== 이걸 모르는 상태로 해서 다소 억지일 수 있습니다 ...ㅋㅋ

# 세자리수 곱중 가장 작은 수 : 10000 = 100 * 100
# 세자리수 곱중 가장 큰 수   : 998001= 999 * 999
# 최소 5자리 최대 6자리 이므로 앞에서 셋 뒤집어서 뒤에서 셋을 비교

result = []
for i in [x*y for x in range(999,99,-1)
              for y in range(999,99,-1)]:
    if str(i)[:3] == str(i)[-1]+str(i)[-2]+str(i)[-3]:
        result.append(i)


max(result)
906609

pali = 0

for i in range(100, 1000):
    for j in range(100, 1000):
        num1 = str(i*j)
        num2 = str(i*j)[::-1]

        if num1 == num2:
            if pali <= int(num1):
                pali = int(num1)

print(pali)

파이썬으로 했고 앞에분들이랑 비슷하게 했네요

앞에 코드 작성하신 분 참고해서 i*j 중복 계산되는 부분은 건너뛰도록 작성했습니다`

max([ int(("").join(str(i*j))) for i in range(100,1000) for j in range(i,1000) if str(i*j)[:3] == str(i*j)[-1:-4:-1] ])

python

def find_palindrome():
    num = 0
    palindrome = []

    for x in range(100,1000):
        for y in range(100,1000):
            num = x*y
            if str(num) == str(num)[::-1]:
                palindrome.append(num)

    return max(palindrome)

print(find_palindrome())

정답: 906609

private static int palindrome() {
        ArrayList<Integer> arrayAns = new ArrayList<>(); //대칭값들 
        int ans; //최종답


        for(int i=100; i<1000; i++) {
            for(int j=100; j<1000; j++) {
                int number = i * j;
                int[] numArray = Stream.of(String.valueOf(number).split("")).mapToInt(Integer::parseInt).toArray();

                for(int k=0; k<Math.floor(numArray.length/2); k++) {
                    if(numArray[k] == numArray[numArray.length - k -1]) {
                        if(k == Math.floor(numArray.length/2) - 1){
                            arrayAns.add(number);
                        }
                    } else {
                        break;
                    }
                }
            }
        }

        ans = Collections.max(arrayAns);

        return ans;
    }

for i in range(100,1000):
    for j in range(100,1000):
        if i*j < 1000000 and i*j > 900000 and str(i*j)[:3] == str(i*j)[-1:-4:-1]:
            print(i*j,i,j)

출력: 906609 913 993

palindrome = 0
for i in range(100,1000,1):
   for j in range(100,1000,1):
      n = i * j
      n_digit = [int(k) for k in str(n)]
      if n_digit == n_digit[::-1] and palindrome < n:
         palindrome = n
      else:
         continue
print(palindrome)

palindrome=[] for i in range(100,1000): for j in range(100,1000): a = ij if a == int(str(ij)[::-1]):
palindrome.append(a)

result=max(palindrome) print(result)

def isPalindrome(num):
    strNum = str(num)
    l, r = 0, len(strNum)-1
    while l < r:
        if not strNum[l] == strNum[r]:
            return False
        l, r = l+1, r-1
    return True


maxP, l, r = 1, 1, 1
for i in range(100, 1000):
    for j in range(100, 1000):
        p = i * j
        if isPalindrome(p) and maxP < p:
            maxP = p
            l, r = i, j
print("{} X {} = {}".format(l, r, maxP))

def palindrom(n):
    if str(n)[::-1] == str(n):
        return True
def find_pal():
    i = 0
    for x in range(999,99,-1):
        for y in range(999,99,-1):
            a = x * y
            if palindrom(a) and i < a :
                i = a
    print(i)

def palin(n):
    numstr=str(n)
    if numstr==numstr[::-1]:
        return True

def insu(n):
    for i in range(999,100,-1):
        for j in range(999,100,-1):
            if i*j==n:
                return True
                break

for i in range(999999,10000,-1):
    if palin(i) :
        if insu(i) :
            print("maxpalin=",i)
            break

def solve():
    for i in range(999*999, 10000, -1):
            s = str(i)
            if s != s[::-1]:
                continue

            for j in range(100, 1000):
                if i % j == 0:
                    k = i // j
                    if 100 <= k <= 999:
                        print(i)
                        return

solve()