Rehat kopi #170. Kami sedang menulis program Java untuk memeriksa segi tiga tepat. Mencipta algoritma pengisihan anda sendiri

Program Java untuk menyemak segi tiga tepat

Sumber: Mayankvikash Artikel ini menunjukkan pembangunan program Java untuk menguji segitiga untuk melihat sama ada ia mempunyai sudut tepat. Segitiga tegak ialah segi tiga dengan salah satu sudut dalamannya berukuran 90 darjah. Terdapat beberapa sifat bagi segi tiga tepat; salah satunya ialah kuasa dua hipotenus adalah sama dengan jumlah kuasa dua kaki (serenjang dan tapak segi tiga). Ini dipanggil teorem Pythagoras. Hipotenus ialah sisi terpanjang bagi segitiga.

Logik program

Oleh kerana kuasa dua hipotenus adalah sama dengan jumlah kuasa dua dua sisi yang lain, kita perlu mengira jumlah ini. Dan jika ia sama dengan segi empat sama hipotenus, maka segitiga itu bersudut tegak. Tangkapan skrin program: Sekarang mari tulis atur cara. Berikut adalah struktur asasnya:

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

Pengisytiharan pembolehubah:

int h, p, b;

Gesaan pengguna untuk input:

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

Satu cara mudah untuk memeriksa sama ada kuasa dua hipotenus adalah sama dengan hasil tambah kuasa dua serenjang dan tapaknya ialah menggunakan if-else . Keadaan jika-lain :

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

Kod

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

    }
}

Kesimpulan

Segitiga bukan kanan: Segitiga kanan:

Mencipta algoritma pengisihan anda sendiri

Sumber: Sederhana Dengan tutorial ini, anda akan belajar cara mengisih bukan sahaja dalam tertib menaik atau menurun, tetapi juga berdasarkan parameter anda sendiri. Biasanya dalam Java atau mana-mana bahasa pengaturcaraan lain kami menyusun mengikut tertib menaik atau menurun. Tetapi bolehkah kita mengisih berdasarkan parameter kita sendiri? Untuk mengetahuinya, mari kita susun dahulu mengikut cara biasa - dalam tertib menaik atau menurun.

//Например, у нас есть массив
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));

Keluar: Arrays.sort(array) ialah kaedah koleksi dalam Java untuk mengisih tatasusunan. Jika ia digunakan tanpa parameter kedua, maka pengisihan berlaku dalam tertib menaik. Dalam parameter kedua kita boleh mentakrifkan Collections.reverseOrder() untuk mengisih dalam tertib menurun. Tetapi kita perlu mencipta algoritma pengisihan kita sendiri dalam parameter kedua. Bagaimana hendak melakukannya? Katakan kita perlu menyusun nombor dalam tatasusunan sedemikian rupa sehingga apabila kita menggabungkannya kita mendapat nombor yang terbesar daripada semua nombor, dengan syarat hanya kedudukan nombor boleh diubah, dan bukan digit. dalam bilangan itu. Contohnya: {1,2,3,4}=>{4321} {12,34}=>{3412} {30,3}=>{330} {8,89}=>{898} Terdapat kelas dalam Java Comparator di mana kita mesti membebankan fungsi perbandingan. Cara ia berfungsi ialah jika dua elemen muncul dalam susunan {item1, item2} maka ia akan diterima oleh fungsi pembanding seperti ini:

public int compare(item 1, item2){

}

Jika fungsi mengeluarkan nilai positif, fungsi isihan akan menukar elemen. Iaitu, output dalam koleksi ialah {item2,item1} . Jika fungsi mengeluarkan hasil negatif atau sifar, maka tertib tidak akan berubah, output akan kekal sama: {item1,item2} . Logik ini digunakan secara rekursif kepada semua ahli tatasusunan. Jadi, kembali kepada soalan asal, kami akan menentukan logik kami dalam kelas pembanding dengan melebihkan fungsi compare() seperti ini:

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;

}

Di sini kami telah menggabungkan dua nombor dan menyemak yang mana satu lebih besar. Logik ini digunakan secara rekursif pada semua nombor lain dalam tatasusunan untuk menghasilkan hasil yang diingini. Untuk meringkaskan, gunakan kelas Comparator untuk membebankan fungsi compare() . Ini akan membantu anda mencipta logik pengisihan anda sendiri dan mengembalikan nilai positif apabila menukar susunan penampilan dalam tatasusunan, dan nilai negatif atau 0 apabila mengekalkan susunan itu.