tema

Inserte la descripción de la imagen aquí
La imagen de arriba es de Sina Weibo.

Esta pregunta requiere que implementes un programa de preguntas y respuestas en inglés de IA un poco más valioso. Las reglas son:

No importa lo que dijo el usuario, primero imprima lo que dijo la otra parte en una línea;
Elimine espacios adicionales en el texto original: reemplace múltiples espacios entre palabras adyacentes con 1 espacio, elimine todos los espacios al principio y al final de la línea y elimine los espacios antes de la puntuación;
Cambie todas las letras mayúsculas en inglés del texto original a minúsculas, excepto I ;
Reemplace todos los independientes can you y could you en el texto original con I can and I could correspondientemente -donde "independiente" se refiere a palabras separadas por espacios o signos de puntuación;
El original todo independiente de mí y de mí en ti ;
Toda marca de la pregunta original ? Reemplaza con un signo de exclamación ! ;
Imprima la oración reemplazada en una línea como respuesta de AI.

Formato de entrada:

Ingrese un número entero positivo N que no exceda de 10 en la primera línea, y luego N líneas. Cada línea proporciona un diálogo de usuario con no más de 1000 caracteres y termina con un retorno de carro. El diálogo es una cadena no vacía y solo incluye Letras, números, espacios, signos de puntuación visibles de medio ancho.

Formato de salida:

Salida de acuerdo con los requisitos de la superficie de la pregunta, agregue AI: y un espacio antes de cada respuesta de AI .

Muestra de entrada:

6
¿Hola?
Es bueno charlar contigo
¿puedes hablar chino?
De Verdad?
¿Podrías mostrarme 5
¿Qué es esto principal? No lo sé

Salida de muestra:

Hola ?
AI: ¡hola!
Es bueno charlar contigo
AI: bueno charlar contigo
¿puedes hablar chino?
AI: ¡Puedo hablar chino!
De Verdad?
AI: ¡de verdad!
¿Podrías mostrarme 5
IA: podría mostrarte 5
¿Qué es esto principal? Yo, no sé
IA: ¡qué es esto principal! tu, no sabes

análisis

Usar expresiones regulares para resolver este problema será mucho más fácil.

Ideas de resolución de problemas:

1. Primero convierta mayúsculas y minúsculas, convierta todas las letras mayúsculas a minúsculas, excepto la I mayúscula.
2. Use expresiones regulares para reemplazar las palabras correspondientes
3. Nota : Al final, necesitamos convertir podría usted y puede usted a yo podría y yo puedo, y luego convertir yo y yo en usted. De lo contrario, se producirá la siguiente situación.
Entrada:

1
¿Puedo hacerlo?

Salida:

Puedo hacerlo ?
AI: ¡Puedo hacerlo!

Y la salida correcta debería ser:

Puedo hacerlo ?
AI: ¡puedes hacerlo!

Por lo tanto, primero deberíamos convertir a usted podría y puede en yo podría y yo puedo, y luego convertir yo y yo en usted. Pero en este caso, nuestro yo también se convertirá a ti, para que podamos marcar yo, por ejemplo, convertir podría y puedes a _ yo podría y _ yo puedo, y finalmente convertimos _ yo a yo .

responder

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 *
 * @author 梓叶枫林
 * @date 2020/10/30
 */
public class Main {
    
    

    public static void main (String [] args) {
    
    

        Scanner scanner = new Scanner(System.in);
        
        int n = scanner.nextInt();
        List<String> whatUserSaysStr = new ArrayList<>(n);

        //读取回车符
        scanner.nextLine();
        //把用户说的话存起来
        for (int i = 0; i < n; i++) {
    
    
            whatUserSaysStr.add(scanner.nextLine());
        }
        scanner.close();

        /*
        * 33-66行都是在写正则表达式
        * */
  
        //删除多余的空格
        String removeDuplicateSpaceRegex = "\\s+";
        Pattern dupPattern = Pattern.compile(removeDuplicateSpaceRegex);
        //删除,前的空格
        String removeSpaceBeforeDommaRegex = " ,";
        Pattern dommaPattern = Pattern.compile(removeSpaceBeforeDommaRegex);
        //删除.前的空格
        String removeSpaceBeforePeriodRegex = " \\.";
        Pattern periodPattern = Pattern.compile(removeSpaceBeforePeriodRegex);
        //删除!前的空格
        String removeSpaceBeforeExcRegex = " !";
        Pattern excPattern = Pattern.compile(removeSpaceBeforeExcRegex);
        //删除?前的空格
        String removeSpaceBeforeQuesRegex = " \\?";
        Pattern quesPattern = Pattern.compile(removeSpaceBeforeQuesRegex);
        //删除'前的空格
        String removeSpaceBeforeQuotRegex = " '";
        Pattern quotPattern = Pattern.compile(removeSpaceBeforeQuotRegex);

        //替换?成!
        String replaceQuesRegex = "\\?";
        Pattern replaceQuesPattern = Pattern.compile(replaceQuesRegex);
        //替换I成you
        String replaceIRegex = "\\bI\\b";
        Pattern replaceIPattern = Pattern.compile(replaceIRegex);
        //替换me成you
        String replaceMeRegex = "\\bme\\b";
        Pattern replaceMePattern = Pattern.compile(replaceMeRegex);
        //替换can you成I can
        String replaceCanRegex = "\\bcan you\\b";
        Pattern replaceCanPattern = Pattern.compile(replaceCanRegex);
        //替换could you成I could
        String replaceCouldRegex = "\\bcould you\\b";
        Pattern replaceCouldPattern = Pattern.compile(replaceCouldRegex);


        for (int i = 0; i < whatUserSaysStr.size(); i++) {
    
    

            //输出原话
            System.out.println(whatUserSaysStr.get(i));

            //去掉首尾的空格
            StringBuilder ansStr = new StringBuilder(whatUserSaysStr.get(i).trim());

            //字母转小写，除了I
            for (int j = 0; j < ansStr.length(); j++) {
    
    
                char currentChar = ansStr.charAt(j);
                if ( (currentChar >= 'A' && currentChar < 'I') || (currentChar > 'I' && currentChar <= 'Z') ) {
    
    
                    currentChar += 32;
                    ansStr.setCharAt(j, currentChar);
                }
            }
            
            /*
            * 90-128行都是在使用前面的正则表达式来进行匹配替换
            * */

            Matcher matcher1 = dupPattern.matcher(ansStr);
            String s1 = matcher1.replaceAll(" ");

            Matcher matcher2 = dommaPattern.matcher(s1);
            String s2 = matcher2.replaceAll(",");

            Matcher matcher3 = periodPattern.matcher(s2);
            String s3 = matcher3.replaceAll(".");

            Matcher matcher4 = excPattern.matcher(s3);
            String s4 = matcher4.replaceAll("!");

            Matcher matcher5 = quesPattern.matcher(s4);
            String s5 = matcher5.replaceAll("?");

            Matcher matcher6 = quotPattern.matcher(s5);
            String s6 = matcher6.replaceAll("'");


            Matcher matcher7 = replaceQuesPattern.matcher(s6);
            String s7 = matcher7.replaceAll("!");

            Matcher matcher8 = replaceCanPattern.matcher(s7);
            String s8 = matcher8.replaceAll("_I can");

            Matcher matcher9 = replaceCouldPattern.matcher(s8);
            String s9 = matcher9.replaceAll("_I could");
            
            Matcher matcher10 = replaceIPattern.matcher(s9);
            String s10 = matcher10.replaceAll("you");

            Matcher matcher11 = replaceMePattern.matcher(s10);
            String s11 = matcher11.replaceAll("you");


            String replaceIIRegex = "\\b_I\\b";
            Pattern replaceIIPattern = Pattern.compile(replaceIIRegex);
            Matcher matcher12 = replaceIIPattern.matcher(s11);
            String ans = matcher12.replaceAll("I");

            System.out.println("AI: " + ans);
        }
    }
}

Código de núcleo de AI PTA valorado en 100 millones