Codice per la ricerca di triplette pitagoriche

Question

Attualmente sto tentando questa domanda:

Una tripletta di Pitagora è un insieme di tre numeri naturali, a, b, c, per i quali un + b = c .

Ad esempio, 3 + 4 = 9 + 16 = 25 = 5 .

Esiste esattamente una tripletta pitagorica per cui a + b + c = 1000. Trova il prodotto abc.

Il mio codice è come segue, penso che dovrebbe essere corretto, ma il sito mi sta dicendo che la mia risposta è sbagliata? Qualcuno può aiutarmi a vedere i difetti nella mia logica per favore?

public class Pythagoras { 
    public static void main(String[] args) { 
      int sum = 1000; 
      int a; 
      int product=0; 
      for (a = 1; a <= sum/3; a++) 
      { 
       int b; 
       for (b = a + 1; b <= sum/2; b++) 
       { 
        int c = sum - a - b; 
        if (c > 0 && (a*a + b*b == c*c)) 
         System.out.printf("a=%d, b=%d, c=%d\n",a,b,c); 
         product = a * b * c; 
       } 
      } 
      System.out.println(product); 
     } 
    } 

Answer 1

Penso che manchi una serie di parentesi graffe. L'indentazione mi porta a credere che le due affermazioni più interne vadano d'accordo ma tu hai bisogno di parentesi graffe perché ciò sia corretto.

if (c > 0 && (a*a + b*b == c*c)) 
{ 
    System.out.printf("a=%d, b=%d, c=%d\n",a,b,c); 
    product = a * b * c; 
} 

Senza le parentesi product sarà sempre contenere il prodotto degli ultimi valori di a, b e c. (333 * 500 * 167 == 27805500).

Answer 2

Si può provare in questo modo,

public class Pythagoras { 

    public static void main(String[] args) { 

     int m = 1, n = 0, a = 0, b = 0, c = 0, sum = 0; 
     int product = 0; 

     for (m = 2; m < 100; m++) { 
      for (n = 1; n < 100; n++) { 

       while (m > n) { 

        a = (m * m) - (n * n); 
        b = (2 * m) * n; 
        c = (m * m) + (n * n); 

        sum = a + b + c; 


        if (sum == 1000) { 
         product = a * b * c; 

         System.out.print("a :" + a + "b :" + b + "c : " + c); 
         System.out.println("Product is" + product); 
         break; 
        } 
        break; 
       } 
      } 
     } 
    } 
} 

Questo implementa la formula di Euclide per la generazione tripletta pitagorica come spiegato here

Si noti che in questo metodo facciamo solo triplette ripetizioni quindi indesiderati sono ridotti.

e l'uscita è a: 375 b: 200 c: 425 Product è 31875000

Answer 3

Anche se altri hanno già dato correzioni specifiche per voi il codice, ecco un suggerimento più generale che sarà utile su altri problemi. Prova il tuo codice su una versione più semplice del problema.

Ad esempio, vedere se il programma può trovare 6,8,10 come una terzina con una somma di 24. Con un test più piccolo è possibile effettivamente scorrere il codice per vedere dove sta andando male.

Answer 4

//

import java.awt.*; 
import java.awt.event.*; 
import javax.swing.*; 
public javax.swingx.event.*; 

public class Triplet extends JApplet implements ActionListener 
{ 
JLabel l1, l2, l3; 
JButton b1; 
JTextFiel t1, t2; 
public void init() 
{ 
    Container c = getContentPane(); 
    c.setLayout(new FlowLayout()); 
    l1=new JLabel("Enter the value of a: "); 
    l2=new JLabel("Enter the value of b: "); 
    t1 = new JTextField(20); 
    t2 = new JTextField(20); 
    b1=new JButton("Ok"); 
    l2=new JLabel("  "); 
    add(l1); 
    add(t1); 
    add(l2); 
    add(t2); 
    add(b1); 
    add(l3); 
    b1.addActionListener(this); 

    public void ActionPerformed(ActionEvent e) 
    { 
     int a = Integer.parseInt(t1.getText()); 
     int b = Integer.parseInt(t2.getText()); 
     long c = Math.sqrt(a*a + b*b); 
     l3.setText(" " +c); 
    } 
    } 
} 

Answer 5

Ecco 5 soluzioni (da lento a veloce):

1) implementazione Trivial - 732.857 microsecondi (0.7 secondi)

private static void p1(int sum) { 
    for (int a = 0; a <= sum; a++) { 
     for (int b = 0; b <= sum; b++) { 
      for (int c = 0; c <= sum; c++) { 
       if (a < b && b < c && a + b + c == sum 
         && (c * c == a * a + b * b)) { 
        System.out.print(a * b * c); 
        return; 
       } 
      } 
     } 
    } 
} 

2) limitano il limite inferiore per b & c (stabilire la relazione d'ordine) - 251091 microsecondi (0,2 secondi)

private static void p2(int sum) { 
    for (int a = 0; a <= sum; a++) { 
     for (int b = a + 1; b <= sum; b++) { 
      for (int c = b + 1; c <= sum; c++) { 
       if (a + b + c == sum && (c * c == a * a + b * b)) { 
        System.out.print(a * b * c); 
        return; 
       } 
      } 
     } 
    } 
} 

3) limitare il & limiti superiori inferiori b per & c - 111220 microsecondi (0,1 secondi)

private static void p3(int sum) { 
    for (int a = 0; a <= sum; a++) { 
     for (int b = a + 1; b <= sum - a; b++) { 
      for (int c = b + 1; c <= sum - a - b; c++) { 
       if (a + b + c == sum && (c * c == a * a + b * b)) { 
        System.out.print(a * b * c); 
        return; 
       } 
      } 
     } 
    } 
} 

4) limite inferiore & limiti superiori per b e correzione rapporto c - 2625 microsecondi

private static void p4(int sum) { 
    for (int a = 0; a <= sum; a++) { 
     for (int b = a + 1; b <= sum - a; b++) { 
      int c = sum - a - b; 
      if (c > b && c * c == a * a + b * b) { 
       System.out.print(a * b * c); 
       return; 
      } 
     } 
    } 
} 

5) Usare formula Euclide s' - 213 microsecondi

private static void p5(int sum) { 
    // a = m^2 - n^2 
    // b = 2mn 
    // c = m^2 + n^2 
    int a, b, c; 
    int sqrt = (int)Math.sqrt(sum); 
    for (int n = 1; n <= sqrt; n++) { 
     for (int m = n+1; m <= sqrt; m++) { 
      a = m*m - n*n; 
      b = 2*m*n; 
      c = m*m + n*n; 
      if (a + b + c == 1000) { 
       System.out.print(a * b * c); 
       return; 
      } 
     } 
    } 
} 

Answer 6

public class Pythagorean_Triplets 
{ 
public static void main(long n) 
{ 
long h=1,p=1,b1; 
double b; 
while(h<=n) 
{ 
    while(p<h) 
    { 
    b=Math.sqrt((h*h)-(p*p)); 
    if(b%1==0) 
    { 
    b1=(long)b; 
    System.out.println(b1+","+p+","+h); 
    break; 
    }   
    p++; 
    }  
    h++;   
    p=1; 
    } 
    } 
}