C# trouver le plus grand commun diviseur

"Le plus grand commun diviseur de deux nombres entiers est le plus grand entier qui uniformément divise chacun des deux nombres. La méthode d'écriture Pgcd qui renvoie le plus grand commun diviseur de deux nombres entiers. Incorporer la méthode dans une application qui lit deux valeurs de l'utilisateur et affiche le résultat."

(ce n'est pas de devoirs, juste un exercice dans le livre que je suis en utilisant)

pouvez-vous m'aider à résoudre ce problème? Voici ce que j'ai obtenu jusqu'à présent. Grâce

(modifier - je peux envoyer les deux chiffres, mais il ne sera pas calculer le Pgcd pour moi)

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Greatest_Common_Divisor
{
class Program
{

    static int GetNum(string text)
    {
        bool IsItANumber = false;
        int x = 0;
        Console.WriteLine(text);

        do
        {
            IsItANumber = int.TryParse(Console.ReadLine(), out x);

        } while (!IsItANumber);

        return x;
    }
    static void Main(string[] args)
    {
        string text = "enter a number";
        int x = GetNum(text);
        text = "enter a second number";
        int y = GetNum(text);


        int z = GCD(x, y);
        Console.WriteLine(z);
    }

    private static int GCD(int x, int y)
    {
        int v = 0;
        int n = 0;

        v = GetGreatestDivisor(x, y);


        return v;

    }

    static int GetGreatestDivisor(int m, int h)
        {

            do
            {
                for (int i = m; i <= 1; i--)



                    if (m%i == 0 && h%i == 0)
                    {
                        int x = 0;
                        x = i;

                        return x;
                    }
            } while (true);
            return m;
        }

  }
}

Votre code ne fonctionne pas ou tout simplement incomplète?
Quel est le problème ici?
Je peux envoyer les deux chiffres, mais il ne sera pas calculer le Pgcd pour moi
Vous devriez vérifier le algorithme d'Euclide.
for (int i = m; i <= 1; i--) ne sera pas exécuté lorsque m > 1, vous signifiait i >= 1.

OriginalL'auteur user2723261 | 2013-08-30

c#math

27

Voici une implémentation de la Algorithme d'euclide qui renvoie le plus grand commun diviseur sans effectuer aucune allocation de tas.

Vous pouvez remplacer ulong pour uint si nécessaire. Un type non signé est utilisé, car la technique ne fonctionne pas pour les valeurs signées. Si vous savez que votre a et b les valeurs ne sont pas négatifs, vous pouvez utiliser long ou int à la place.
```
private static ulong GCD(ulong a, ulong b)
{
    while (a != 0 && b != 0)
    {
        if (a > b)
            a %= b;
        else
            b %= a;
    }

    return a == 0 ? b : a;
}
```
Cette méthode est utilisée dans mon métadonnées-extracteur de la bibliothèque, où il est associé à des les tests unitaires.

C'est la meilleure réponse sur la page; il ne fait pas du tout coûteux et superflu d'appels récursifs, et répond vraiment aux OP de la question spécifique (à la différence de quelques autres réponses qui, pour une raison quelconque une digression sur le PGCD d'un jeu).
Ils calculer le PGCD d'un ensemble parce qu'ils sont de copier et de coller le code qu'ils ne comprennent pas d'une réponse à une question distincte.
Agréable et propre - pas de LINQ-soupe mixte. Et avec ça, exactement ce que je cherchais pour mon propre petit "dilemme". 😀
Oh, cela fonctionne très bien avec entrée négative(s): il suffit de retourner le signe des valeurs négatives avant d'entrer en boucle... if(a<0)a=-a; si(b<0)b=-b;

OriginalL'auteur Drew Noakes
14

À l'aide de LINQ Globale de la méthode:
```
static int GCD(int[] numbers)
{
    return numbers.Aggregate(GCD);
}

static int GCD(int a, int b)
{
    return b == 0 ? a : GCD(b, a % b);
}
```
Remarque: la réponse ci-dessus emprunté à accepté de répondre à Plus grand Diviseur Commun à partir d'un ensemble de plus de 2 entiers.

Ceci est incorrect. Vous ne pouvez pas diviser cette réponse en LINQ et non-LINQ, la solution est les 2 méthodes de travail ensemble. La première méthode est l'appel de la deuxième méthode dans l'ensemble, ce est un peu déroutant parce que les noms sont les mêmes.
il serait très agréable de répondre à cela, Karl. Votre réponse est en effet incorrect.

OriginalL'auteur Karl Anderson

Vous pouvez essayer d'utiliser cette:-

static int GreatestCommonDivisor(int[] numbers)
{
    return numbers.Aggregate(GCD);
}

static int GreatestCommonDivisor(int x, int y)
{
return y == 0 ? x : GCD(y, x % y);
}

OriginalL'auteur Rahul Tripathi

Essayez ceci:

public static int GCD(int p, int q)
{
    if(q == 0)
    {
         return p;
    }

    int r = p % q;

    return GCD(q, r);
}

OriginalL'auteur user2623931

By using this, you can pass multiple values as well in the form of array:-


//pass all the values in array and call findGCD function
    int findGCD(int arr[], int n) 
    { 
        int gcd = arr[0]; 
        for (int i = 1; i < n; i++) {
            gcd = getGcd(arr[i], gcd); 
}

        return gcd; 
    } 

//check for gcd
int getGcd(int x, int y) 
    { 
        if (x == 0) 
            return y; 
        return gcd(y % x, x); 
    }

OriginalL'auteur Chang

-2

    int a=789456;


    int b=97845645;
    if(a>b)     
    {

    }
    else
    {
        int temp=0;
        temp=a;
        a=b;
        b=temp;
    }
    int x=1;
    int y=0 ;

    for (int i =1 ; i < (b/2)+1 ; i++ )
    {

        if(a%i==0)
        {
             x=i;
        }
        if(b%i==0)
        {
             y=i;
        }
        if ((x==y)& x==i & y==i & i < a)
        {
            Console.WriteLine(i);
        }

    }

OriginalL'auteur seyed

Vous devez vous connecter pour publier un commentaire.