Java 基本测试用例情书通过

情书密码问题：詹姆斯发现了一封他的朋友哈里给他女朋友写的情书。詹姆斯是个恶作剧者，所以他决定干预这封信。他把信中的所有单词都改成了回文

为此，他遵循两条规则：

（a） 他可以降低字母的值，例如，他可以将“d”改为“c”，但他不能将“c”改为“d”。 （b） 为了形成回文，如果他必须反复降低字母的值，他可以这样做，直到字母变成“a”。一旦一个字母被更改为“a”，它就不能再被更改

任何字母值的每次减少都作为单个操作计算。查找将给定字符串转换为回文所需的最小操作数

import java.io.*;
import java.util.*;
import java.text.*;
import java.math.*;
import java.util.regex.*;

public class Solution {

    static int getAscii(char letter)
    {
        return (int)letter;
    }

    static boolean checkPalindrome(String str, int strLen)
    {
        String revStr ="";
        for(int i=strLen;i >= 0;i--)
        {
            revStr = revStr + str.charAt(i);
        }

        if(str.equals(revStr))
        {
            return true;
        }
        return false;
    }

    static void reduceAscii(String str)
    {
        StringBuilder sb = new StringBuilder(str);
        str = str.toString();
        int strLen = str.length()-1;
        int numOfOperations=0;
        char letter;

        for(int j=strLen; j >= 0; j--)
        {
            letter = str.charAt(j);
            while(getAscii(letter) > 97 && getAscii(letter) <= 122)
               {
                   if(checkPalindrome(str, strLen))
                   {
                       break;
                   }
                   else
                   {
                       int asciiValofLetter = (char)getAscii(letter);
                       char charToreplace = (char)(asciiValofLetter-1);
                       sb.setCharAt(j, charToreplace);
                       str = sb.toString();
                       letter = charToreplace;
                       numOfOperations++;
                   }
               }
        }
        System.out.println(numOfOperations);
    }

    public static void main(String[] args) {

        Scanner sc = new Scanner(System.in);
        int numOfTestCases;
        String str;
        numOfTestCases = sc.nextInt();
        for(int i=0; i < numOfTestCases; i++)
        {
            str = sc.next();
            Solution.reduceAscii(str);
        }
    }
}

---

您的解决方案看起来过于复杂。要求您查找所需的操作数，而不是实际结果

Java不是我的专长，所以这里有一些伪代码：

Number of letters to change = int(length of string/2) (for a seven letter string we change three letters)
Total operations = 0

for n=0 to number of letters to change
    take nth letter and (string length-n)th letter

    (number of operations on each letter is difference of ASCII values so...)
    subtract ASCII value of first letter from ASCII value of second
    add absolute value of this to your total

next letter

print total.

导入java.io.BufferedReader；
导入java.io.IOException；
导入java.io.InputStreamReader；
导入java.util.InputMismatchException；
公共类转换程序{
公共ConvertToPal（）{
//TODO自动生成的构造函数存根
}
公共静态void main（字符串[]args）引发IOException{
BufferedReader br=新的BufferedReader（新的InputStreamReader（System.in））；
System.out.println（“请输入要回文的字符串！”）；
字符串str=br.readLine（）；
char[]strArr=str.toCharArray（）；
int size=strArr.length；
int numOfOperations=0；
对于（int i=0；i<（大小/2）；i++）{
int dif=（getAscii（strArr[i]）-getAscii（strArr[size-1-i]）；
如果（dif>0）{
strArr[i]=strArr[size-1-i]；
numOfOperations+=Math.abs（dif）；
}
if（dif<0）{
strArr[size-1-i]=strArr[i]；
numOfOperations+=Math.abs（dif）；
}
}
System.out.println（新字符串（strArr））；
System.out.println（“操作数：+numOfOperations”）；
}
静态int getAscii（字符字母）{
回信；
}
}

这里有一个用Java实现的方法

public int palindromeCount(String s) {
    int count = 0;
    int i = 0, j = s.length() - 1;
    while (i < j) {
        int front = (int) s.charAt(i);
        int back = (int) s.charAt(j);
        count += (Math.abs(front - back));
        i++;
        j--;
    }
    return count;
}

public int-palindromeCount（字符串s）{
整数计数=0；
int i=0，j=s.length（）-1；
而（i

您是说当输入已经是回文，但在所有其他情况下都失败时，您的代码通过了吗？您是否尝试过在IDE调试器中单步执行它？这是开始的地方。很好，谢谢你给了我其他的解决方案，但我的主要问题是用上面提到的测试用例来修复我的解决方案，而不是给我一个新的解决方案/伪代码。一旦我知道我做错了什么，我就可以使用其他更好的解决方案。OP中提供的解决方案不起作用，因为它一次只考虑从字符串末尾开始的1个字符。这里的摘录是，你必须在算法的字符约简部分中考虑字符串的“两半”。这部分不是一个替代方案，而是一个要求。请添加一个解释，说明此代码如何帮助OP解决他们的问题。

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.InputMismatchException;


public class ConvertToPal {

    public ConvertToPal() {
        // TODO Auto-generated constructor stub
    }

    public static void main(String[] args) throws IOException{
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        System.out.println("Please enter a string to be palindromized! ");
        String str = br.readLine();
        char[] strArr = str.toCharArray();
        int size = strArr.length;
        int numOfOperations = 0;
        for (int i = 0; i < (size/2) ; i++){
            int dif = (getAscii(strArr[i])-getAscii(strArr[size-1-i]));
            if (dif > 0){
                strArr[i] = strArr[size-1-i];
                numOfOperations += Math.abs(dif);
            }
            if(dif < 0){
                strArr[size-1-i] = strArr[i];
                numOfOperations += Math.abs(dif);
            }
        }
        System.out.println(new String(strArr));
        System.out.println("num of ops: "+ numOfOperations);
    }
    static int getAscii(char letter){
        return (int)letter;
    }
}

public int palindromeCount(String s) {
    int count = 0;
    int i = 0, j = s.length() - 1;
    while (i < j) {
        int front = (int) s.charAt(i);
        int back = (int) s.charAt(j);
        count += (Math.abs(front - back));
        i++;
        j--;
    }
    return count;
}