Pause café #170. Nous écrivons un programme Java pour rechercher un triangle rectangle. Créer votre propre algorithme de tri

Programme Java pour vérifier le triangle rectangle

Source : Mayankvikash Cet article démontre le développement d'un programme Java pour tester un triangle pour voir s'il a un angle droit. Un triangle rectangle est un triangle dont l'un de ses angles intérieurs mesure 90 degrés. Il existe plusieurs propriétés d’un triangle rectangle ; l'un d'eux est que le carré de l'hypoténuse est égal à la somme du carré des jambes (perpendiculaire et base du triangle). C'est ce qu'on appelle le théorème de Pythagore. L'hypoténuse est le côté le plus long d'un triangle.

Logique du programme

Puisque le carré de l’hypoténuse est égal à la somme des carrés des deux autres côtés, il faut calculer cette somme. Et s’il est égal au carré de l’hypoténuse, alors le triangle est rectangle. Capture d'écran du programme : Écrivons maintenant le programme. Voici sa structure de base :

import java.util*;
public class RightAngledTriangle{
  public static void main(String args[]){
    Scanner in = new Scanner(System.in);
    // code
  }
}

Déclaration des variables :

int h, p, b;

Invite de l'utilisateur à saisir :

System.out.println("Enter the Hypotenuse");
h = in.nextInt();
System.out.println("Enter the Perpendicular");
p = in.nextInt();
System.out.println("Enter the Base");
b = in.nextInt();

Un moyen simple de vérifier si le carré de l’hypoténuse est égal à la somme des carrés de la perpendiculaire et de la base est d’utiliser if-else . Condition si-sinon :

if (h*h==(p*p)+(b*b)){
    System.out.println("Right Angled Triangle");
}
else{
    System.out.println("Not a right angled Traingle");
}

Code

import java.util.*;
public class RightAngledTriangle {

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int h, p, b;
        System.out.println("Enter the Hypotenuse");
        h = in.nextInt();
        System.out.println("Enter the Perpendicular");
        p = in.nextInt();
        System.out.println("Enter the Base");
        b = in.nextInt();

        if (h*h==(p*p)+(b*b)){
            System.out.println("Right Angled Triangle");
        }
        else{
            System.out.println("Not a right angled Traingle");
        }

    }
}

Conclusion

Triangle non rectangle : Triangle rectangle :

Créer votre propre algorithme de tri

Source : Medium Avec ce tutoriel, vous apprendrez à trier non seulement par ordre croissant ou décroissant, mais également en fonction de vos propres paramètres. Habituellement, en Java ou dans tout autre langage de programmation, nous trions par ordre croissant ou décroissant. Mais pouvons-nous trier en fonction de notre propre paramètre ? Pour le savoir, commençons par trier de la manière habituelle – par ordre croissant ou décroissant.

//Например, у нас есть массив
Integer array[]={9,4,8,5,7,6,1,2,3};

//Сортируем по возрастанию
Arrays.sort(array);

//печатаем отсортированный массив
System.out.println(Arrays.toString(array));

//Сортируем по убыванию
Arrays.sort(array, Collections.reverseOrder());

//печатаем отсортированный массив
System.out.println(Arrays.toString(array));

Sortie: Arrays.sort(array) est une méthode de collections en Java pour trier un tableau. S'il est utilisé sans deuxième paramètre, le tri s'effectue par ordre croissant. Dans le deuxième paramètre, nous pouvons définir Collections.reverseOrder() pour trier par ordre décroissant. Mais nous devons créer notre propre algorithme de tri dans le deuxième paramètre. Comment faire? Supposons que nous devions ordonner les nombres dans un tableau de telle manière que lorsque nous les combinons, nous obtenions un nombre qui soit le plus grand de tous les nombres, à condition que seule la position des nombres puisse être modifiée, et non les chiffres. dans ce numéro. Par exemple : {1,2,3,4}=>{4321} {12,34}=>{3412} {30,3}=>{330} {8,89}=>{898} Il existe un classe dans Java Comparator dans laquelle nous devons surcharger la fonction de comparaison. La façon dont cela fonctionne est que si deux éléments apparaissent dans l'ordre {item1, item2} alors ils seront acceptés par la fonction de comparaison comme ceci :

public int compare(item 1, item2){

}

Si la fonction génère une valeur positive, la fonction de tri échangera les éléments. Autrement dit, la sortie de la collection sera {item2,item1} . Si la fonction génère un résultat négatif ou nul, alors l'ordre ne changera pas, la sortie restera la même : {item1,item2} . Cette logique s'applique de manière récursive à tous les membres du tableau. Donc, pour revenir à la question initiale, nous allons définir notre logique dans la classe comparateur en surchargeant la fonction compare() comme ceci :

Collections.sort(A,new Comparator<Integer>(){

public int compare(Integer a,Integer b){
String a1=Integer.toString(a)+Integer.toString(b);
String a2=Integer.toString(b)+Integer.toString(a);
int l =a1.length();
for(int i=0;i<l;i++){

if(a1.charAt(i)>a2.charAt(i)){
return -1;
}

else if(a1.charAt(i)<a2.charAt(i)){
return 1;

}

else continue;

}

return 0;

}

Ici, nous avons combiné deux nombres et vérifié lequel est le plus grand. Cette logique est appliquée de manière récursive à tous les autres nombres du tableau pour produire le résultat souhaité. Pour résumer, utilisez la classe Comparator pour surcharger la fonction compare() . Cela vous aidera à créer votre propre logique de tri et à renvoyer une valeur positive lors de la modification de l'ordre d'apparition dans le tableau, et une valeur négative ou 0 lors du maintien de l'ordre.