小易爱回文

def ss_ss(ss,reversed_s):
    ss1 = []
    len_reversed_s = len(reversed_s) for i in range(len_reversed_s):
        str1 = reversed_s[i+1: len(reversed_s)+1] if s + str1 == ''.join(reversed(s + str1)):
            ss = s + str1
            ss1.append(ss) print(min(ss1,key = len)) return True if __name__ == '__main__':
    s = input()
    reversed_s = s[::-1] if s == reversed_s: print(s) else:
        ss = s + reversed_s if ss_ss(ss,reversed_s) is not True: print(ss)

str = input().strip()
str1 = ''
str2 = ''
n = len(str)
list1, list2 = [], []
for i in str[::-1]:
    str1 += i
if str1 == str:
    print(str)
else:
    for i in range(n):
        list1.append(str[i])
        if str[i+1:] == str1[:(-i-1)]:

            break

    list1.reverse()
    for i in range(len(list1)):
        str += list1[i]
    print(str)

#include<iostream>
#include<stdio.h>
#include<string.h>
using namespace std;
 
bool judge(string& s, int l, int r)
{
    bool ret = true;
    while(l<r)
    {
        if(s[l]!=s[r])
        {
            ret = false;
            break;
        }
        l++;
        r--;
    }
    return ret;
}
 
int main()
{
    string s;
    int n,t;
    cin>>s;
    n=s.size();
    t=n-1;
    for(int i=n-1;i>=0;i--)
    {
        if(judge(s,i,n-1))
        {
            t=i;
        }
    }
    for(int i=t-1;i>=0;i--)
        s+=s[i];
    cout<<s<<endl;
    return 0;
}

str_or=input()
n=len(str_or)
if str_or==str_or[::-1]:
    print(str_or)
else:
    for i in range(1,n):
        if str_or[i:]==str_or[i:][::-1]:
            print(str_or+str_or[:i][::-1])
            break

#include<iostream>
using namespace std;

// 判断s[index:]是否回文
bool isPalindrome(string& s, int index, int size){
    for(int i = index, j = size-1; i <= j; i++, j--){
        if(s[i] != s[j]) return false;
    }
    return true;
}

int main(){
    string s;
    cin >> s;
    int size = s.size();
    for(int i = 0; i < size; i++){
        if(isPalindrome(s, i, size)){
            cout << s;
            break;
        }
        s.insert(s.begin() + size, s[i]);
    }
    return 0;
}

s=input()
revs=s[::-1]  #helol的最后两位  loleh首两位   相等 则拼接它们
for i in range(len(s)):
    if s[i:]==revs[:len(s)-i]:
        print(s+revs[len(s)-i:])
        break
    

import java.util.*;
 
public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String str = sc.nextLine();
        
        StringBuffer sf = new StringBuffer(str);
        StringBuffer tmp = new StringBuffer(str);
        tmp = tmp.reverse();
        //先判断 本身是否是一个回文串
        if(tmp.toString().equals(sf.toString())) {
            System.out.println(str);
            return;
        }
        //遍历字符串 每次在len下标添加str.charAt[i] 建议画图 一画图就会了
        //值得注意的是StringBuffer和SringBuilder都没有equals()方法 要转化为字符串
        //并且要使用tmp来逆置字符串  因为使用sf来逆置字符串 那么sf本身也被逆置了
        int len = str.length();
        for(int i = 0;i < str.length();i++) {
            sf.insert(len,str.charAt(i));
            tmp = new StringBuffer(sf);
            tmp = tmp.reverse();
            if(tmp.toString().equals(sf.toString())) {
                break;
            }
        }
        System.out.println(tmp);
    }
}

# Python3
s = str(input().strip())
# 左右边界
start = 0
end = len(s)-1
while(start<end):
    if(s[start]==s[end]):
        start += 1
        end -= 1
    else:
        # 记录需要进行重复的字符串
        adds = list(s[:start+1])
        start += 1
        end = len(s)-1
adds.reverse()
print(s+''.join(adds))

写个暴力解 (go语言)
O(n2)
优解LC  214
package main
import "fmt"
func isPalind(s string) bool {
    for i, j := 0, len(s) - 1; i < j; i, j = i + 1, j - 1 {
        if (s[i] != s[j]) {
            return false;
        }
    }
    return true;
}
func reverse(t string) string {
    s := []byte(t)
    for i, j := 0, len(s) - 1; i < j; i, j = i + 1, j - 1 {
        s[i], s[j] = s[j], s[i]
    }
    return string(s)
}
func main() {
    var s string
    fmt.Scanln(&s)
    n := len(s)
    for i := 0; i < n; i++ {
        if (isPalind(s[i:n])) {
            s += reverse(s[:i])
            fmt.Println(s)
            break;
        }
    }
}

// C++字符串哈希（O(n))
#include<iostream>
#include<string>
#include<algorithm>
using namespace std;

using ull = unsigned long long;
ull mod = 1e9 + 7;

int main() {
    string s;
    cin >> s;
    int pos = s.size() - 1;
    if (s.empty())    cout << " " << endl;
    ull base = 131, buff = 1;
    ull left = 0, right = 0; 
    for (int i = s.size() - 1; i >= 0; --i) {
        (left = left * base + s[i]) %= mod;
        (right = right + buff * s[i]) %= mod;
        if (left == right)     pos = i;
        (buff *= base) %= mod;
    }
    string str = s.substr(0, pos);
    reverse(str.begin(), str.end());
    s += str;
    cout << s << endl;

    return 0;
}

import java.util.Scanner;
public class Main {
    public static void main(String args[]) {
        Scanner sc = new Scanner(System.in);
        StringBuffer sb = new StringBuffer();
        sb.append(sc.nextLine());
        int le = sb.length();
        if (le <= 2) {
            System.out.println(le==2?(sb.charAt(0)==sb.charAt(1)?sb:sb+String.valueOf(sb.charAt(0))):sb);
        } else {
            int max = 0;
            int start = 0;
            int end = 0;
            int[][] dp = new int[le][le];
            for (int i = 0; i < le; i++) {
                for (int j = 0; j < i; j++) {
                    if (sb.charAt(j) == sb.charAt(i) && (i - j < 2 || dp[j + 1][i - 1] > 0)) {
                        dp[j][i] = i - j + 1;
                        if (dp[j][i] > max) {
                            start = j;
                            end = i;
                        }
                    }
                }
            }
            if (start == 0 && end == le - 1) {
                System.out.println(sb);
            } else if (end == le - 1) {
                System.out.println(sb + sb.reverse().substring(le - start));
            } else {
                System.out.println(sb + sb.reverse().substring(1));
            }
        }
    }
}

• 逆序 原串，寻找 前缀，简单易懂

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String s = sc.nextLine();
        // 逆序原字符串
        String reverse = new StringBuffer(s).reverse().toString();
        String ans = "";
        int len = Integer.MAX_VALUE;

        if(judge(s)) {
            System.out.println(s);
        } else {
            for(int i=0;i<reverse.length();i++){
                // 寻找r对应s的前缀
                /**
                   i s(YCiC) r(CiCY)的前缀
                   0 YCiC    no
                   1 CiC     yes:CiC
                               CiC后追加(Y)
                               Y的index=r.length()-i
                 */
                if(reverse.startsWith(s.substring(i))){
                    String tmp = s+reverse.substring(reverse.length()-i);
                    if (tmp.length() < len) {
                        len = tmp.length();
                        ans = tmp;
                    }
                    // 为什么不直接输出呢？因为可能会有多个输出，我要输出最短的那个
                    // System.out.println(s+reverse.substring(reverse.length()-i));
                }
            }
             System.out.println(ans);
        }

    }

    public static boolean judge(String s) {
        int left = 0, right = s.length() - 1;
        while(left <= right) {
            if(s.charAt(left) == s.charAt(right)) {
                left++;
                right--;
            } else {
                return false;
            }
        }
        return true;
    }
}

# 读取输入字符串并去除首尾空白（如空格、换行符）
s = input().strip()

# 生成原始字符串的反转版本（[::-1]是Python中反转字符串的简洁写法）
reversed_s = s[::-1]

# 若原始字符串本身就是回文串（与反转字符串相等），直接输出
if s == reversed_s:
    print(s)
else:
    # 获取字符串长度，用于控制循环范围
    n = len(s)

    # 循环寻找最长的匹配片段：原字符串的后缀与反转字符串的前缀匹配
    # 关键在于用原始字符串和翻转后的字符串同时使用当前位置以后的部分查看是否是回文串
    # 如果是则说明当前位置及以前的部分是缺少的，我们需要将这部分倒序追加到原始字符串末尾
    for i in range(n):
        # 核心判断：
        # s[i+1:] 表示原字符串从第i+1个字符到结尾的部分（后缀）
        # reversed_s[:-i-1] 表示反转字符串从开头到第-(i+1)个字符的部分（前缀）
        # 当两者相等时，说明找到了可以对称的最长片段
        if s[i + 1 :] == reversed_s[: -i - 1]:
            # 构造最短回文串：
            # s[:i+1] 是原字符串中需要对称补充的前缀部分
            # [::-1] 将这部分反转，添加到原字符串尾部即可形成回文
            result = s + s[: i + 1][::-1]
            print(result)
            # 找到匹配后立即退出循环，避免多余计算
            break

s = input()
l = 0
r = len(s) - 1
k = 0
 
# 找到 最小的 子回文串并记录下位置
# 例：     hallowordro
#最大的子回文串是  ordro   将剩余的翻转即可
while l < r :
    if s[l] != s[r]:
        l += 1
        r = len(s) -1
        k = l
    else:
        l += 1
        r -= 1
 
#字符串切片 得到 s[:k:-1] 的倒序  然后跟 s进行拼接
s = s + s[:k][::-1]
 
print(s)