回文字符串

import java.util.*;
public class Main {
    public static void main(String args[]){
        Scanner sc = new Scanner(System.in);
        String s = sc.next();
        int i=0,j=s.length()-1;
        String res = "";
        //此题必须要删除一个字符
        //本身是回文字符串的要输出删除一个字符的结果
        if(isValid(s,0,s.length()-1)==true){
             res = s.substring(1,s.length());
             System.out.print(res);
             return;
        }
        while(i < j){
            if(s.charAt(i) != s.charAt(j)){
                if(isValid(s,i+1,j)){
                    res += s.substring(0,i);
                    res += s.substring(i+1,s.length());
                    System.out.print(res);
                    return;
                }
                else if(isValid(s,i,j-1)){
                    res += s.substring(0,j);
                    res += s.substring(j+1,s.length());
                    System.out.print(res);
                    return;
                }
                else{
                    System.out.print("false");
                    return;
                }
            }
            
            i++;
            j--;
            
        }
    }
    public static boolean isValid(String s,int i,int j){
        while(i < j){
            if(s.charAt(i) != s.charAt(j))
                return false;
            i++;
            j--;
        }
        return true;
    }
}

def isHuiWen(word):
    left,right = 0,len(word)-1
    while left<right:
        if word[left] != word[right]:
            return False
        left += 1
        right -= 1
    return True


if __name__ == "__main__":
    word = input()
    wordNum = len(word)
    flag = False
    wordCopy = word[1:]
    if isHuiWen(word):
        print(wordCopy)
        flag = True
    else:
        for i in range(1,wordNum):
            wordCopy = word[:i] + word[i+1 :]
            if isHuiWen(wordCopy):
                print(wordCopy)
                flag = True
                break
    if not flag:
        print("false")

#include<string>
#include<iostream>
#include<algorithm>
#include<math.h>
using namespace std;
bool judge(string a){
    int i=0;
    while(i<floor(a.length()/2)){
        if(a[i]!=a[a.length()-1-i])return false;
        i++;
    }
     return true;   
}
int main(){
    string input;
    cin>>input;

    for (int i=0;i<input.length();i++){
        string temp_input(input);
        temp_input.erase(i,1);
        if (judge(temp_input)){
            cout<<temp_input<<endl;
            return 0;
        }
    }
    cout<<"false"<<endl;
    return 0;
}

def func(a):
    le, ri = 0, len(a) - 1
    loc = 0
    flag = 0
    while le < ri:
        if a[le] == a[ri]:
            le += 1
            ri -= 1
        else:
            flag += 1
            if flag > 1:
                return "false"
            if a[le+1] == a[ri]:
                loc = le
                le += 1
            elif a[le] == a[ri-1]:
                loc = ri
                ri -= 1
            else:
                return "false"
    if loc == 0:
        return a[1:]
    else:
        return a[:loc] + a[loc+1:]

#include "bits/stdc++.h"

using namespace std;

string del(string input, int x) {
    string ans;
    for (int i = 0; i < input.size(); i++) {
        if (i != x) {
            ans.push_back(input[i]);
        }
    }
    return ans;
}

bool f(string input) {
    int n = input.size();
    if (input.size() % 2 == 0) {
        for (int i = 0; i < n / 2; i++) {
            if (input[i] != input[n - 1 - i]) {
                return false;
            }
        }
    } else {
        for (int i = 0; i < n / 2; i++) {
            if (input[i] != input[n - 1 - i]) {
                return false;
            }
        }
    }
    return true;
}

int main() {
    string input;
    cin >> input;
    int n = input.size();
    for (int i = 0; i < n; i++) {
        string tmp = del(input, i);
        if (f(tmp)) {
            cout << tmp << endl;
            return 0;
        }
    }
    cout<<"false"<<endl;
    return 0;
}
//
//if (input.size() == 1 || f(input)) {
//cout << input << endl;
//return 0;
//} else {
//
//}
//cout << false << endl;

#include<iostream>
using namespace std;
#include<vector>
bool ishuiwen(string str,int low,int high){
    for(int i=low,j=high;i<j;i++,j--){
        if(str[i]!=str[j]) return false;
    }
    return true;
}
int main(){
     string str;cin>>str;
     int n=str.size();
     int left=0;int right=n-1;
     while(left<right){
         if(str[left]==str[right]){
             left++;right--;
         }
         else{  // 遇到不相等的
             bool deleteleft=ishuiwen(str, left+1, right);
             bool deleteright=ishuiwen(str, left, right-1);
             if(deleteleft==false&&deleteright==false) {
                 std::cout<<"false";
                 return 0;
             }
             if(deleteleft){
                 str.erase(left,1);std::cout<<str;
                 return 0;
             }
             else if(deleteright){
                 str.erase(right,1);std::cout<<str;
                 return 0;
             }
             else if(deleteleft&&deleteright){
                 str.erase(left,1);std::cout<<str;
                 return 0;
             }
         }
     }
     str.erase(left,1);std::cout<<str;  // 按题意 必须要删除一个
    
    return 0;
 }

import java.util.*;

public class Main{
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String str = sc.nextLine();
        int l = str.length();
        int i = 0;
        while(i < l) {
            String newStr = removeCharAt(str, i);
            //System.out.println(newStr);
            String reverse = new StringBuffer(newStr).reverse().toString();
            //System.out.println(reverse);
            if(newStr.equals(reverse)) {
                System.out.println(newStr);
                break;
            }
            else {
                i++;
                if(i >= l) {
                    System.out.println("false");
                }
            }
            }
    }
    
    public static String removeCharAt(String s, int pos) {
        return s.substring(0, pos) + s.substring(pos + 1);
     }

import java.util.*;
public class Main {
	public static void main(String args[]){
        Scanner in = new Scanner(System.in);
        StringBuffer S = new StringBuffer(in.nextLine());
        int n = S.length();
        for(int i=0;i<n;i++) {
            // 根据JAVA字符串的特性，不能直接StringBuffer t = S;
            StringBuffer t = new StringBuffer(S);
            String s = t.deleteCharAt(i).toString(); // 删掉当前字符
            if(Judge(s)) {                           // 判断删掉一个字符后的字符串是否为回文串
                System.out.println(s);
                return;
            }
        }
        // 题目要求的是以“删除一个字符后能构成回文串”为优先条件，所以原字符串要在后面判断
                                    // 当删掉一个字符的所有情况都不符合回文串时
        if(Judge(S.toString())) {   // 判断最开始输入的字符串是否符合回文串
        	System.out.println(S);
        	return;
        }
        System.out.println(false);  // 以上两种情况都不符合，输出false
	}
    // ---------------------------------------------------------------------------------
	public static boolean Judge(String s) { // 判断当前字符串是否为回文串
		int n = s.length();
		int mid = n%2==0 ? n/2:n/2+1;       // 根据长度的奇偶性，得到中间值
		int end = n%2==0 ? mid:mid-1;       // 左边字符串的终点
		String l = s.substring(0,end);                        // 左半部分字符串
		StringBuffer r = new StringBuffer(s.substring(mid));  // 右半部分
		if(l.equals(r.reverse().toString())) {                // 翻转右半部分与左半部分对比
			return true;
		}
		return false;
	}
}

while 1:
    try:
        s = input()
        flag = 0
        if s[1:] == s[1:][::-1]:
            flag =1
            print(s[1:][::-1])
        elif s[:-1] == s[:-1][::-1]:
            flag =1
            print(s[:-1][::-1])
        else:
            for i in range(1,len(s)-1):
                new = s[0:i]+s[i+1:]
                if new == new[::-1]:
                    print(new)
                    flag = 1
                    break
        if flag == 0:
            print("false")
    except:
        break

s = input()  # 获得输入


def judge(s):
    for i in range(0, int(len(s) / 2)):  # 左右元素比较
        if s[i] == s[len(s) - 1 - i]:
            continue
        else:
            return 'false'
    return 'true'


def test(s):
    if len(s) == 0:  # 长度为0
        return 'false'
    for i in range(0, len(s)):
        str1 = s[:i] + s[i + 1:]  # 删除一位后得到str1
        if judge(str1) == 'true':  # str1 判断是否回文
            return str1
        else:
            continue
    return 'false'


print(test(s))

#include<iostream>
#include<string>
using namespace std;

class Solution {
public:
	string validPalindrome(string str) {
		string s = str;
		int i = 0, j = s.size() - 1, erase_num = 0;		// i,j分别指向字符串头和尾
		while (i < j) {
			if (s[i] != s[j]) {
				erase_num++;		// 检测到字符不等，说明需要进行删除操作，操作数自加1
				break;				// 同时跳出while循环，进行下一步删除操作
			}
			i++;
			j--;
		}
		if (erase_num == 0) {
			str.erase(str.begin() + i);
		}
		if(erase_num== 1) {
			erase_num = 0;		// 重置删除操作次数
			int m = i + 1, n = j;
			// 将i指针向后移动一位
			while (m < n) {
				if (s[m] != s[n]) {
					erase_num++;		// 字符再次不相等，说明i指针向后移动1次，并不能使s成为回文串
					break;				// 跳出循环后，复原i,j指针
				}
				m++;
				n--;
			}
			if (!erase_num) {
				str.erase(str.begin() + i);
				return str;
			}
			m = i, n = j - 1;	// 将j指针向前移动一位
			while (m < n) {
				if (s[m] != s[n]) {
					erase_num++;
					break;	
				}
				m++;
				n--;
			}
			str.erase(str.begin() + j);
		}
		if(erase_num== 2) {
			// 删除一个字符并不能满足条件
			return "false";
		}
		return str;
	}
};

int main() {
	string s;
	cin >> s;
	Solution sol;
	string res = sol.validPalindrome(s);
	cout << res << endl;
}