[Java] Scanner, ternärer Operator, Array-Betrieb (AOJ ① große und kleine Ausrichtung)

Ich werde mit den Unterrichtsmaterialien von AIZU ONLINE JUDGE lernen

Was ist AIZU ONLINE JUDGE?

• AOJ (Aizu Online Judge: onlinejudge.u-aizu.ac.jp) ist ein Online-Bewertungssystem zum Programmieren von Fragen, das jeder kostenlos verwenden kann.
• http://judge.u-aizu.ac.jp/onlinejudge/
• Erklärung der Funktionen und Verwendung durch Entwickler Aritaka Watanabe
  https://book.mynavi.jp/manatee/series/detail/id=88273
• Beachten Sie, dass Javad nur erfolgreich ist, wenn der Klassenname auf Main gesetzt ist.

Online Judge ist ein Dienst, mit dem Sie viele Übungen herausfordern und Ihren Code online bewerten können. Für jede Frage werden Testdaten erstellt, die sofort die Richtigkeit des eingereichten Codes und seine Effizienz beurteilen.

So empfangen Sie Eingaben (Scanner)

• ** nextLine-Methode **: Liefert die Eingabe für eine Zeile bis zum Zeilenumbruch
• Lesen Sie Eingaben mit Leerzeichen zwischen Wörtern (bis zum Ende der Zeile \ n).
• Bewegt den Cursor beim Laden der Eingabe in die nächste Zeile
• ** nächste Methode **: Lesen Sie die Eingabe bis zum Leerzeichen
• Platzieren Sie den Cursor nach dem Lesen der Eingabe in derselben Zeile
• • ** nextInt-Methode **: Eingabe als int bis zum Leerzeichen abrufen
• Lesen Sie nicht die Escape-Sequenz "\ n"

import java.util.Scanner;

public class Main {
    public static void main(String[] args) throws Exception {
        Scanner scan = new Scanner(System.in);
        // String str = scan.nextLine();
        // System.out.println(str); //neko inu
        String str1 = scan.next(); 
        String str2 = scan.next(); 
        System.out.println(str1); //neko
        System.out.println(str2); //inu
        
        scan.close();
    }
}

Rechteckfläche und Umfang

Erstellen Sie ein Programm, um die Fläche und den Umfang eines a cm langen und b cm breiten Rechtecks zu ermitteln.

import java.util.Scanner;
public class Main {
    public static void main(String[] args){
        Scanner scan = new Scanner(System.in);
        int a = scan.nextInt();
        int b = scan.nextInt();
        System.out.println( (a*b) + " " + (a*2+b*2) );
	//System.out.printf("%d %d\n",a*b,2*(a+b));
    }
}

Uhr

Da die Zeit S in Sekunden angegeben ist, konvertieren Sie sie in das Format h: m: s und geben Sie sie aus. Wo h Stunden ist, ist m weniger als 60 Minuten und s ist weniger als 60 Sekunden. Geben Sie H, m und s in einer Zeile aus, die durch Folgendes getrennt ist: (Doppelpunkt).

import java.util.Scanner;
public class Main {
    public static void main(String[] args){
	Scanner sc = new Scanner(System.in);
        int sec, min, hour;
        sec = sc.nextInt();
        hour = sec / 3600;
        min = (sec%3600) / 60;
        sec = sec % 60;
        System.out.println(hour+":"+min+":"+sec);
    }
}

Bedingter Operator (ternärer Operator)

• (Bedingter Ausdruck)? Ausdruck A: Ausdruck B
• Prozessausdruck 1, wenn der Wert des bedingten Ausdrucks wahr ist, Prozessausdruck 2, wenn er falsch ist
• Beim Vergleich von A und B (Gleichung A: Ausdruck B) müssen die Ausdrücke A und B einen Wert zurückgeben

public class Main {
    public static void main(String[] args) throws Exception{
    var age = 20;
    System.out.println(age >= 20 ? "aufgewachsen" : "Kinder"); //aufgewachsen
    }
}

• Referenz [[Java] Operator Summary (Operator)](https://qiita.com/suema0331/items/7045e3ce3e2f5faa9acf#%E9%96%A2%E4%BF%82%E6%BC%94%E7%AE% 97% E5% AD% 90% E6% AF% 94% E8% BC% 83% E6% BC% 94% E7% AE% 97% E5% AD% 90)

Große und kleine Beziehung

Erstellen Sie ein Programm, das zwei Ganzzahlen a und b liest und die Größenbeziehung zwischen a und b ausgibt.

import java.util.Scanner;

public class Main{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        int a = sc.nextInt();
        int b = sc.nextInt();
        String result = (a == b) ? "a == b" : (a > b) ? "a > b" : "a < b";
        System.out.println(result);
    }
}

Array-Manipulation

• ** Arrays Klasse **
• Die Größe des Arrays kann später nicht geändert werden
• → ** copyOf-Methode ** zum Duplizieren von Werten in Arrays unterschiedlicher Größe
• copyOf und copyOfRange sind ** flache Kopie **
• Wenn es sich bei der flachen Kopie um einen Referenztyp handelt, ändert sich das Kopierziel, wenn sich die Kopierquelle ändert.
• → ** Tiefe Kopie **
• var list2 = new StringBuilder[list1.length];

//Shallow copy
import java.util.Arrays;

public class Main {
  public static void main(String[] args) {
    var  array1 = new String[] { "dog", "cat", "mouse", "fox", "lion" };
    //Sortieren Sie das Array
    Arrays.sort(array1);
    //Stringisieren Sie ein Array
    System.out.println(Arrays.toString(array1)); //[cat, dog, fox, lion, mouse]
    //Suchen Sie Werte in einem sortierten Array
    System.out.println(Arrays.binarySearch(array1, "mouse")); //4

    var array2 = new String[] { "Ah", "ich", "U.", "e", "Oh" };   
    //Array-Kopie, Länge im Argument, 0 Mangel/Füllen Sie mit null
    var array3 = Arrays.copyOf(array2, 2);
    System.out.println(Arrays.toString(array3)); //[Ah,ich]

    //Kopieren Sie das Array, indem Sie den Bereich mit dem Argument angeben
    var array4 = Arrays.copyOfRange(array2, 1, 7);
    System.out.println(Arrays.toString(array4)); //[ich,U.,e,Oh, null, null]

    //Legen Sie Werte in einem Array fest
    Arrays.fill(array4, 4, 6, "―");
    System.out.println(Arrays.toString(array4)); //[ich,U.,e,Oh, ―, ―]
  }
}

//Deep copy
import java.util.Arrays;

public class Main {
  public static void main(String[] args) {
    var list1 = new StringBuilder[] {
        new StringBuilder("Doremifa Donuts"),
        new StringBuilder("ARAMA"),
        new StringBuilder("Hanihoheto")
      };

    var list2 = new StringBuilder[list1.length];
    for (var i = 0; i < list1.length; i++) {
      list2[i] = new StringBuilder(list1[i].toString());
    }

    list1[2].append("Hallo");
    System.out.println(Arrays.toString(list1)); //[Doremifa Donuts, ARAMA,Hanihoheto Hallo]
    System.out.println(Arrays.toString(list2)); //[Doremifa Donuts, ARAMA,Hanihoheto]
  }
}

Ausrichtung von drei Zahlen

Erstellen Sie ein Programm, das drei Ganzzahlen liest und diese in aufsteigender Reihenfolge des Werts ausgibt.

import java.util.Arrays;
import java.util.Scanner;

public class Main {
	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		int num1 = scanner.nextInt();
		int num2 = scanner.nextInt();
		int num3 = scanner.nextInt();
		int[] nums = {num1,num2,num3};
		Arrays.sort(nums);
		
		System.out.println(String.format("%s %s %s", nums[0],nums[1],nums[2])); //46 50 80
		
	}
}