Convertir du code C++ en Java

Convertir du code C++ en Java tout en préservant ses fonctionnalités

Vous pouvez interroger un modèle directement et tester les résultats renvoyés lors de l'utilisation de différentes valeurs de paramètre en utilisant la console Cloud ou en appelant directement l'API Vertex AI.

Instructions système

Vous êtes un programmeur expérimenté, maîtrisant Java et C++ et spécialisé dans la traduction de code entre ces deux langages. Vous expliquez votre processus de conversion et vous vous assurez que le code traduit reste fidèle à l'original, sauf indication contraire.

Requête Freeform

Veuillez convertir le code C++ suivant en Java. Implémentez l'équivalent de la fonction isPrime de C++ à l'aide de la classe BigInteger de Java pour la vérification des nombres premiers.

#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;
}

Réponse

Le code C++ recherche efficacement des sous-chaînes de nombres premiers dans un nombre de grande valeur. Pour traduire cela en Java, il faut examiner attentivement les types de données afin de gérer des nombres dont la valeur sera potentiellement très élevée. Nous utiliserons BigInteger à cette fin. Voici l'équivalent en Java :

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();
    }
}

Explication du processus de conversion :

  1. En-têtes et espaces de noms : les directives #include de C++ sont remplacées par des instructions import en Java. using namespace std; n'est pas nécessaire en Java. Nous utilisons explicitement les noms complets (par exemple, BigInteger.valueOf(2)).

  2. Types de données : le changement crucial consiste à utiliser BigInteger en Java pour remplacer long long. Cela nous permet de gérer des nombres arbitrairement grands sans problème de débordement, ce qui reflète la capacité du code C++ à traiter de grandes entrées.

  3. Fonction isPrime : la logique de la fonction isPrime est largement conservée. Les principales différences sont les suivantes :

    • Comparaisons : au lieu des opérateurs <=, == et %, nous utilisons les méthodes compareTo(), equals() et mod() de la classe BigInteger.
    • Racine carrée : nous utilisons number.sqrt() pour calculer efficacement la racine carrée de la limite supérieure de la boucle.

  4. Manipulation de chaînes : substr en C++ est directement équivalent à substring en Java.

  5. Entrée/Sortie : les instructions C++ cout et cin sont remplacées respectivement par les classes System.out.print et Scanner de Java. N'oubliez pas de fermer Scanner pour libérer les ressources.

  6. Gestion des erreurs : le code Java gère implicitement les exceptions potentielles de type NumberFormatException, qui se produisent lorsque la chaîne d'entrée n'est pas un nombre valide. Si nécessaire, vous pouvez ajouter une gestion des erreurs plus robuste.

Ce code Java fournit une solution fonctionnellement équivalente au code C++ donné, en traitant efficacement les nombres de grande valeur à l'aide de BigInteger. L'algorithme de base reste inchangé, ce qui garantit que la traduction est fidèle à l'intent d'origine.
Modèle : gemini-1.5-flash-002
Température : 0,2
Nombre maximal de jetons de sortie : 8 192
TopK : 40,0
TopP : 0,95