Coffee break #170. Nagsusulat kami ng isang Java program upang suriin kung may tamang tatsulok. Paglikha ng iyong sariling algorithm sa pag-uuri

Java program upang suriin ang kanang tatsulok

Pinagmulan: Mayankvikash Ang artikulong ito ay nagpapakita ng pagbuo ng isang Java program upang subukan ang isang tatsulok upang makita kung ito ay may tamang anggulo. Ang tamang tatsulok ay isang tatsulok na may isa sa mga panloob na anggulo nito na may sukat na 90 degrees. Mayroong ilang mga katangian ng isang tamang tatsulok; isa sa mga ito ay ang parisukat ng hypotenuse ay katumbas ng kabuuan ng parisukat ng mga binti (patayo at base ng tatsulok). Ito ay tinatawag na Pythagorean theorem. Ang hypotenuse ay ang pinakamahabang bahagi ng isang tatsulok.

Logic ng programa

Dahil ang parisukat ng hypotenuse ay katumbas ng kabuuan ng mga parisukat ng iba pang dalawang panig, kailangan nating kalkulahin ang kabuuan na ito. At kung ito ay katumbas ng parisukat ng hypotenuse, kung gayon ang tatsulok ay right-angled. Screenshot ng programa: Ngayon ay isulat natin ang programa. Narito ang pangunahing istraktura nito:

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

Deklarasyon ng mga variable:

int h, p, b;

Prompt ng user para sa 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();

Isang simpleng paraan upang suriin kung ang parisukat ng hypotenuse ay katumbas ng kabuuan ng mga parisukat ng patayo at ang base ay ang paggamit ng if-else . Kung-ibang kondisyon :

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

    }
}

Konklusyon

Hindi kanang tatsulok: Kanang tatsulok:

Paglikha ng iyong sariling algorithm sa pag-uuri

Source: Medium Gamit ang tutorial na ito, matututunan mo kung paano mag-uri-uriin hindi lamang sa pataas o pababang pagkakasunud-sunod, ngunit batay din sa iyong sariling mga parameter. Karaniwan sa Java o anumang iba pang programming language ay pinag-uuri namin sa pataas o pababang pagkakasunud-sunod. Ngunit maaari ba nating pag-uri-uriin batay sa sarili nating parameter? Upang malaman, ayusin muna natin sa karaniwang paraan - sa pataas o pababang pagkakasunud-sunod.

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

Lumabas: Ang Arrays.sort(array) ay isang paraan ng mga koleksyon sa Java upang pagbukud-bukurin ang isang array. Kung ito ay ginagamit nang walang pangalawang parameter, ang pag-uuri ay nangyayari sa pataas na pagkakasunud-sunod. Sa pangalawang parameter maaari naming tukuyin ang Collections.reverseOrder() upang pagbukud-bukurin sa pababang pagkakasunud-sunod. Ngunit kailangan nating lumikha ng sarili nating algorithm ng pag-uuri sa pangalawang parameter. Paano ito gagawin? Ipagpalagay na kailangan nating mag-order ng mga numero sa isang array sa paraang kapag pinagsama natin ang mga ito makakakuha tayo ng isang numero na pinakamalaki sa lahat ng mga numero, na may kondisyon na ang posisyon lamang ng mga numero ang maaaring baguhin, at hindi ang mga digit. sa bilang na iyon. Halimbawa: {1,2,3,4}=>{4321} {12,34}=>{3412} {30,3}=>{330} {8,89}=>{898} Mayroong class sa Java Comparator kung saan dapat nating i-overload ang function ng paghahambing. Ang paraan ng paggana nito ay kung ang dalawang elemento ay lilitaw sa pagkakasunud-sunod na {item1, item2} kung gayon sila ay tatanggapin ng comparator function na tulad nito:

public int compare(item 1, item2){

}

Kung ang function ay naglalabas ng isang positibong halaga, ang pag-uuri ng function ay magpapalitan ng mga elemento. Ibig sabihin, ang magiging output sa koleksyon ay {item2,item1} . Kung maglalabas ang function ng negatibo o zero na resulta, hindi magbabago ang order, mananatiling pareho ang output: {item1,item2} . Recursively nalalapat ang logic na ito sa lahat ng miyembro ng array. Kaya, babalik sa orihinal na tanong, tutukuyin namin ang aming lohika sa klase ng comparator sa pamamagitan ng labis na pagkarga ng compare() function na tulad nito:

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;

}

Dito ay pinagsama namin ang dalawang numero at nasuri kung alin ang mas malaki. Ang logic na ito ay recursively inilapat sa lahat ng iba pang mga numero sa array upang makabuo ng nais na resulta. Upang buod, gamitin ang klase ng Comparator upang i-overload ang compare() function . Makakatulong ito sa iyong lumikha ng sarili mong lohika sa pag-uuri at magbalik ng positibong halaga kapag binabago ang pagkakasunud-sunod ng hitsura sa array, at isang negatibong halaga o 0 kapag pinapanatili ang pagkakasunud-sunod.