C++ in Java übersetzen

C++-Code in Java konvertieren und dabei die Funktionalität beibehalten

Sie können ein Modell direkt abfragen und die zurückgegebenen Ergebnisse testen, wenn Sie verschiedene Parameterwerte mit der Cloud Console oder durch direkten Aufruf der Vertex AI API verwenden.

Systemanweisungen

Sie sind ein erfahrener Programmierer mit Kenntnissen in Java und C++ und haben sich auf die Codeübersetzung zwischen diesen beiden Sprachen spezialisiert. Sie erläutern Ihren Conversion-Prozess und achten darauf, dass der übersetzte Code dem Original entspricht, sofern nicht anders angegeben.

Freiform-Prompt

Konvertiere den folgenden C++-Code in Java. Implementiere das Äquivalent der isPrime-Funktion von C++ mit der BigInteger-Klasse von Java für die Primzahlprüfung.

#include <iostream>
#include <string>
#include <cmath>

using namespace std;

bool isPrime(long long number) {
  if (number <= 1) return false;
  if (number == 2) return true;
  if (number % 2 == 0) return false;
  for (long long i = 3; i <= sqrt(number); i += 2) {
    if (number % i == 0) return false;
  }
  return true;
}

int main() {
  string largeNumber;
  cout << "Enter a large number: ";
  cin >> largeNumber;

  int primeSubstringCount = 0;

  for (size_t i = 0; i < largeNumber.length(); ++i) {
    for (size_t j = i + 1; j <= largeNumber.length(); ++j) {
      string substring = largeNumber.substr(i, j - i);
      long long number = stoll(substring);

      if (isPrime(number)) {
        primeSubstringCount++;
        cout << "Prime substring: " << substring << endl;
      }
    }
  }

  cout << "Total number of prime substrings: " << primeSubstringCount << endl;

  return 0;
}

Antwort

Der C++-Code sucht effizient nach Primzahlunterstrings in einer großen Zahl. Bei der Übersetzung in Java müssen die Datentypen sorgfältig ausgewählt werden, um potenziell sehr große Zahlen zu verarbeiten. Wir verwenden dazu BigInteger. Hier ist das Java-Äquivalent:

import java.math.BigInteger;
import java.util.Scanner;

public class PrimeSubstrings {

    public static boolean isPrime(BigInteger number) {
        if (number.compareTo(BigInteger.ONE) <= 0) return false;
        if (number.equals(BigInteger.valueOf(2))) return true;
        if (number.mod(BigInteger.valueOf(2)).equals(BigInteger.ZERO)) return false;
        for (BigInteger i = BigInteger.valueOf(3); i.compareTo(number.sqrt()) <= 0; i = i.add(BigInteger.valueOf(2))) {
            if (number.mod(i).equals(BigInteger.ZERO)) return false;
        }
        return true;
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.print("Enter a large number: ");
        String largeNumber = scanner.nextLine();

        int primeSubstringCount = 0;

        for (int i = 0; i < largeNumber.length(); ++i) {
            for (int j = i + 1; j <= largeNumber.length(); ++j) {
                String substring = largeNumber.substring(i, j);
                BigInteger number = new BigInteger(substring);

                if (isPrime(number)) {
                    primeSubstringCount++;
                    System.out.println("Prime substring: " << substring);
                }
            }
        }

        System.out.println("Total number of prime substrings: " + primeSubstringCount);
        scanner.close();
    }
}

Erläuterung des Conversion-Prozesses

  1. Header und Namespaces: Die C++-#include-Direktive wird durch die Java-import-Anweisung ersetzt. Der using namespace std; ist in Java nicht erforderlich. Wir verwenden explizit die vollständig qualifizierten Namen (z. B. BigInteger.valueOf(2).

  2. Datentypen: Die entscheidende Änderung besteht darin, dass BigInteger in Java anstelle von long long verwendet wird. So können wir beliebig große Zahlen ohne Überlaufprobleme verarbeiten, was der Fähigkeit des C++-Codes entspricht, große Eingaben zu verarbeiten.

  3. isPrime-Funktion: Die Logik der Funktion isPrime bleibt weitgehend erhalten. Die hauptsächlichen Unterschiede lauten:

    • Vergleiche: Anstelle von <=, == und % verwenden wir die Methoden compareTo(), equals() und mod() der Klasse BigInteger.
    • Quadratwurzel: Mit number.sqrt() wird die Quadratwurzel der Obergrenze der Schleife effizient berechnet.

  4. String-Manipulation: substr in C++ entspricht direkt substring in Java.

  5. Eingabe/Ausgabe: cout und cin in C++ werden durch die Klassen System.out.print und Scanner in Java ersetzt. Denken Sie daran, den Scanner zu schließen, um Ressourcen freizugeben.

  6. Fehlerbehandlung: Der Java-Code behandelt implizit mögliche NumberFormatException, wenn der Eingabestring keine gültige Zahl ist. Bei Bedarf kann eine robustere Fehlerbehandlung hinzugefügt werden.

Dieser Java-Code bietet eine funktional äquivalente Lösung für den angegebenen C++-Code und verarbeitet große Zahlen effektiv mit BigInteger. Der Kernalgorithmus bleibt unverändert, damit die Übersetzung der ursprünglichen Absicht entspricht.
Modell: gemini-1.5-flash-002
Temperatur: 0,2
Max. Ausgabetokens: 8.192
TopK: 40,0
TopP: 0,95