伪代码转Java遇类型错误：String无法转换为String[]，求解决

Let's break down what's causing your "Incompatible types : String Cannot be converted to String []" error and fix this step by step:

• Your pseudocode uses single string values (e.g., function g(string str)), but you incorrectly defined your Java methods to accept String[] (string arrays) instead of String. This mismatch is why the compiler throws type errors when you pass a String to methods expecting an array.
• Additionally, pseudocode's str[i] syntax for accessing a character doesn't translate directly to Java strings—you need to use str.charAt(i) instead.

Corrected Full Java Code #

public class TestLogic {
    // Fixed: accepts String instead of String[], uses charAt for character access
    public static String g(String str) {
        int i = 0;
        String new_str = "";
        while (i < str.length() - 1) {
            new_str += str.charAt(i + 1);
            i++;
        }
        return new_str;
    }

    // Fixed: accepts String instead of String[], fixes recursive call syntax
    public static String f(String str) {
        if (str.length() == 0) {
            return "";
        } else if (str.length() == 1) {
            return str;
        } else {
            // Added missing closing parenthesis, uses charAt(0) for first character
            return f(g(str) + str.charAt(0));
        }
    }

    // Fixed: calls static f() method, no type mismatch
    public static String h(long n, String str) {
        while (n != 1) {
            if (n % 2 == 0) {
                n = n / 2;
            } else {
                n = 3 * n + 1;
            }
            str = f(str);
        }
        return str;
    }

    // Fixed recursive logic, uses long to handle large exponents without overflow
    public static long pow(long x, long y) {
        if (y == 0) {
            return 1;
        } else {
            return x * pow(x, y - 1);
        }
    }

    public static void main(String[] args) {
        // Test cases matching your pseudocode
        System.out.println(h(1, "fruits"));
        System.out.println(h(2, "fruits"));
        System.out.println(h(5, "fruits"));
        
        // Note: pow(2, 1000000000000000) will cause stack overflow with recursive pow
        // For extremely large exponents, use iterative pow or BigInteger instead
        // System.out.println(h(pow(2, 1000000000000000L), "fruits"));
        
        // Fixed broken pow call (you missed the second argument)
        // System.out.println(h(pow(9831050005000007L, 1), "fruits"));
    }
}

Key Fixes Explained #

1. Type Mismatch Resolution:

   • Changed all method parameters from String[] to String to match the pseudocode's string input. This eliminates the core type error immediately.

2. String Character Access:

   • Replaced array-style str[i] with Java's str.charAt(i) to correctly access individual characters in a string.

3. Static Method Consistency:

   • Marked g() and f() as static since they're called from the static h() method. Static methods can't invoke non-static methods directly without an instance of the class.

4. Recursive Call Fix:

   • Added a missing closing parenthesis in f()'s return statement to fix the broken recursive call.

5. Handling Large Numbers:

   • Changed h()'s n parameter and pow()'s return/parameter types to long to avoid integer overflow with large values like 1000000000000000. Note that the recursive pow() will still hit a stack overflow for extremely large exponents—consider using an iterative implementation or BigInteger for those cases.

6. Test Case Corrections:

   • Fixed the broken pow() call in your last test case (you missed the second required argument for pow()).

内容的提问来源于stack exchange，提问作者Arie Wijaya