Belajar dasar-dasar pemrograman dengan Java.

Pemrograman 1

Persiapan Belajar

Kontrak Perkuliahan


## Contoh kode

untuk semua pertemuan dapat diakses pada URL https://p1-2024.surge.sh/ diikuti dengan nama kelas dan nomor urut pertemuan.

Kelas A:\
https://p1-2024.surge.sh/A01 \
https://p1-2024.surge.sh/A02 \
https://p1-2024.surge.sh/A03 \
dst

Kelas B: \
https://p1-2024.surge.sh/B01 \
https://p1-2024.surge.sh/B02 \
https://p1-2024.surge.sh/B03 \
dst

## Daftar Referensi

- Think Java: How to Think Like a Computer Scientist. Version 6 by Allen Downey and Chris Mayfield (http://greenteapress.com/wp/think-java/)
- Java How to Program. 10/e, Book by Paul Deitel
- http://www.sololearn.com/Course/Java/
- https://www.udemy.com/java-tutorial/

## Evaluation

| Kategori     | Persentase |
| :----------- | :--------: |
| Partisipasi  |    10%     |
| Tugas & Quiz |    40%     |
| UTS          |    15%     |
| UAS          |    15%     |
| Proyek Akhir |    20%     |


Materi

Hello World

## [JDK (Java Development Kit)](http://www.oracle.com/technetwork/java/javase/downloads/index.html)

- The Java Compiler (javac)
- The Java Archiving Tool (jar)
- The Java Debugging Tool (jdb)
- A complete Java Runtime Environment (JRE), for running Java programs

## IDE (Integrated Development Environments)

- Visual Studio Code
- IntelliJ IDEA
- Eclipse
- NetBeans
- glot.io
- replit

## Contoh

### Say Hello to the World

```java Hello.java
public class Hello {
 public static void main(String[] args) {
 // generate some simple output
 System.out.println("Hello, World!");
 }
}
```

### Compile & Run

- Compile `javac Hello.java`
- Run `java Hello`
 ![Proses](https://i.ibb.co/cbjdzKy/Screenshot-2024-04-03-122738.png)

## Displaying Strings

<CodeGroup>

```java Hello1.java
public class Hello {
 public static void main(String[] args) {
 // generate some simple output
 System.out.println("Hello, World!"); // first line
 System.out.println("Hello, World!"); // 2nd line
 }
}
```

```java Hello2.java
public class Hello {
 public static void main(String[] args) {
 // generate some simple output
 System.out.print("Hello, "); // first line
 System.out.println("World!"); // first line
 }
}
```

```java Hello3.java
System.out.print("Text");
System.out.println("Text");
```

</CodeGroup>

## New Line

```java
System.out.println("Text");
System.out.print("Text\n");
```

## Special Characters

### escape sequence

| | |
| --- | ------------ |
| \n | new line |
| \t | tab |
| \" | double quote |
| \\ | backslash |

## Comments

<CodeGroup>

```java Hello1.java
public class Hello {
 public static void main(String[] args) {
 // generate some simple output
 System.out.print("Hello, "); // first line
 System.out.println("World!"); // first line
 }
}
```

```java Hello2.java
public class Hello {
 public static void main(String[] args) {
 // generate some simple output
 /*
 System.out.print("Hello, "); // first line
 System.out.println("World!"); // first line
 */
 }
}
```

</CodeGroup>

## Code Formatting

<CodeGroup>

```java Hello1.java
public class Hello {
 public static void main(String[] args) {
 System.out.println("Hello, World!");
 }
}
```

```java Hello2.java
public class Hello {
public static void main(String[] args) {
System.out.println("Hello, World!");
}
}
```

```java Hello3.java
public class Hello{public static void main(String[] args){System.out.printl
n("Hello, World!");}}
```

</CodeGroup>

Variables and Operators

# Variables

## Variables

![Variables](https://i.ibb.co/DzwtZ4n/Screenshot-2024-04-03-135211.png)

## Declarations

![Declarations](https://i.ibb.co/Gnsy6JT/Screenshot-2024-04-03-135220.png)

## Assignments

![Assignments](https://i.ibb.co/qntJkvh/Screenshot-2024-04-03-135231.png)

## Variable Naming

- Begin with a letter (a-z/A-Z)
- After the initial letter, may also contain letters, digits (0-9), underscore (\_), or dollar sign ($)
- Not a keyword or reserved word http://docs.oracle.com/javase/tutorial/java/nutsandbolts/_keywords.html
- Case sensitive
- Disarankan:

 - Tidak dimulai dengan huruf kapital
 - camelCase
 - Meaningful

 | | |
 | :--------- | :----------- |
 | sum | address2 |
 | first name | phone |
 | first_name | phone number |
 | firstName | double |
 | FirstName | static |
 | FIRSTNAME | e-mail |
 | 1stName | GradeTest#1 |
 | Address | homepageURL |
 | address | homepageUrl |
 | address1 | ... |

## Declaring Variables

![Declaring Variables](https://i.ibb.co/PY9XQPP/Screenshot-2024-04-03-140708.png)

## Data Types

| Type | Explanation | Min | Max |
| :------ | :------------------------------------- | :----------------------------: | :----------------------------: |
| int | 32-bit (4-byte) integers | -2,147,483,648 | 2,147,483,647 |
| short | 16-bit (2-byte) integers | -32,768 | 32,767 |
| long | 64-bit (8-byte) integers | -9,223,372,036,854,775,808 | 9,223,372,036,854,775,807 |
| byte | 8-bit (1-byte) integers | -128 | 127 |
| float | 32-bit (4-byte) floating point numbers | $\pm$1.40129846432481707e-45 | $\pm$3.40282346638528860e+38 |
| double | 64-bit (8-byte) floating point numbers | $\pm$4.94065645841246544e-324d | $\pm$1.79769313486231570e+308d |
| char | Unicode characters | 0 | 65,535 |
| boolean | true or false | - | - |
| String | Text | - | - |

## Printing Variables

```java
System.out.println(variable);
System.out.print(variable);
```

# Operators

```java
System.out.println(quantity * price);
sum = sum + 1;
System.out.println(10 - 2);
System.out.println(sum / 5);
System.out.println(-total);
```

## Arithmetic Operators

```java
int a = 10, b = 5;
```

<CodeGroup>

```java Addition
+ (Addition), e.g.: a + b equals 15
```

```java Subtraction
- (Subtraction), e.g.: a - b equals 5
```

```java Multiplication
* (Multiplication), e.g.: a * b equals 50
```

```java Division
/ (Division), e.g.: a / b equals 2
```

```java Modulus
% (Modulus), e.g.: a % b equals 0
```

```java Increment
++ (Increment), e.g.: a++ equals 11
```

```java Decrement
-- (Decrement), e.g.: a-- equals 9
```

</CodeGroup>

```java
int a = 10; // variable declaration
// addition (+)
System.out.println(a + 1);
System.out.println(a);
// increment
System.out.println(a++);
System.out.println(a);
// another increment
a++;
System.out.println(a);
```

## Operators for Strings

<CodeGroup>

```java Opsi 1
String message = "Welcome";
System.out.println(message);
```

```java Opsi 2
String message = "Welcome ";
String name = "Arif";
System.out.println(message + name);
```

```java Opsi 3
String message = "Welcome ";
String name = "Arif";
message = message + name;
System.out.println(message);
```

```java Opsi 4
String message = "Welcome ";
String name = "Arif";
message = message + name + "!";
System.out.println(message);
```

```java Opsi 5
String message = "Welcome ";
String name = "Arif";
message = message + name + "!";
System.out.println(message);
int date = 15;
int month = 9;
int year = 2016;
String message2 = "Today's date is " + date;
System.out.println(message2);
```

</CodeGroup>

Advanced Arithmetic Operation, Input, Output Formatting

# Advanced Arithmetic Operation

## Math class ([docs](https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Math.html))

`Math` is a class that provides common mathematical operations:

- Power and root
- Logarithm
- Max, Min
- Trigonometry
- Random
- ...

```java Program.java
public class Program {
 public static void main(String[] args) {
 double n = 5;
 double power = 4;
 double nPower = Math.pow(n, power);
 System.out.println(n + " to the " + power + "th power = " + nPower
 );
 }
}
```

# Data Type: Integer and Double

<AccordionGroup>
	<Accordion title="Integer [+,-,*,/] Integer = Integer">
		```java 
		double a = 3.75, b = 2.5; 
		int p = 13, q = 4; 
		System.out.println(p + q); 
		System.out.println(p - q); 
		System.out.println(p * q);
		System.out.println(p / q); 
		```
	</Accordion>

 <Accordion title="Double [+,-,*,/] Double = Double">
 ```java
 double a = 3.75, b = 2.5;
 int p = 13, q = 4;
 System.out.println(a + b);
 System.out.println(a - b);
 System.out.println(a * b);
 System.out.println(a / b);
 ```
 </Accordion>

 <Accordion title="Double [+,-,*,/] Integer = Double">
 ```java
 double a = 3.75, b = 2.5;
 int p = 13, q = 4;
 System.out.println(a + p);
 System.out.println(a - p);
 System.out.println(a * p);
 System.out.println(a / p);
 ```
 </Accordion>

 <Accordion title="Integer / Integer">
 	```java
 	System.out.println(1 / 2); // 0
 	System.out.println(3 / 2); // 1
 	System.out.println(14 / 3); // 4
 	System.out.println(-1 / 2); // 0
 	System.out.println(-3 / 2); // -1
 	System.out.println(-14 / 3); // -4
 	````
 </Accordion>

 <Accordion title="Integer → Double">
 	```java
 	double a = 3.75, b = 2.5;
 	int p = 13, q = 4;
 	double c = p / q;
 	double d = (double) p / q;
 	double e = (double) (p / q);
 	System.out.println(c);
 	System.out.println(d);
 	System.out.println(e);
 	````
 </Accordion>

 <Accordion title="Double → Integer">
 	```java
 	double a = 3.75, b = 2.5;
 	int p = 13, q = 4;
 	int r = a / b;
 	int s = (int) a / b;
 	int t = (int) (a / b);
 	System.out.println(r);
 	System.out.println(s);
 	System.out.println(t);
 	````
 </Accordion>

</AccordionGroup>

# Input

<CodeGroup>

```java Before
String name = "Arif";
String message = "Welcome " + name + "!";

System.out.println(message);
```

```java After
import java.util.Scanner;
public class Program {
 public static void main(String[] args) {
 Scanner input = new Scanner(System.in);
 String name = input.nextLine();
 String message = "Welcome " + name + "!";

 System.out.println(message);
 }
}
```

```java Code
Scanner input = new Scanner(System.in);
System.out.print("What is your name? ");
String name = input.nextLine();
String message = "Welcome " + name + "!";

System.out.println(message);
```

</CodeGroup>

## Basic Methods of Scanner

### Reading Strings

<Tabs>
 <Tab title="nextLine()">One line</Tab>
 <Tab title="next()">One word</Tab>
</Tabs>
### Reading Numners
<Tabs>
 <Tab title="nextInt()">Integer</Tab>
 <Tab title="nextDouble()">Double</Tab>
 <Tab title="nextLong()">Long</Tab>
</Tabs>

## Special Case

![Special Case](https://i.ibb.co/rdBybYH/Screenshot-2024-04-03-150910.png)

<CodeGroup>

```java Before
Scanner input = new Scanner(System.in);
System.out.print("What is your name? ");
String name = input.nextLine();
System.out.print("What is your age? ");
int age = input.nextInt();
System.out.println("Hello, " + name);
System.out.println("You are " + age + " years old");
```

```java After
Scanner input = new Scanner(System.in);
System.out.print("What is your age? ");
int age = input.nextInt(); // apa yang terjadi ketika nextInt digunakan sebelum NextLine?
System.out.print("What is your name? ");
String name = input.nextLine();
System.out.println("Hello, " + name);
System.out.println("You are " + age + " years old");
```

```java Solution
Scanner input = new Scanner(System.in);
System.out.print("What is your age? ");
int age = input.nextInt();
input.nextLine(); // tambahkan ini untuk mengatasi permasalahan nextInt sebelum nextLine
System.out.print("What is your name? ");
String name = input.nextLine();
System.out.println("Hello, " + name);
System.out.println("You are " + age + " years old");
```

</CodeGroup>

# Output Formatting

## Too Many Trailing Digits!

```java
double athird = 1.0 / 3;
System.out.println(athird);

//Output 0.3333333333333333 - Too Long
```

## Try use this!

### System.out.printf()

- System.out.format()
 ```java
 System.out.printf(format, param1, param2, ...);
 ```
- Example
 ```java
 double tax = 0.2 * price;
 System.out.printf("Price: %.2f, Tax: %.2f", price, tax);
 ```

## Format Works

![Format](https://i.ibb.co/44FYrBk/Screenshot-2024-04-03-151455.png)

## Converters & Flags

| Converters | Flag | Description |
| :--------: | :--: | :------------------------------------------------------------------------------- |
| d | | Integer |
| f | | Float/Double |
| n | | Newline |
| s | | String |
| | + | Includes sign, whether positive or negative. |
| | , | Includes locale-specific grouping characters (thousands) |
| | - | Left-justified. |
| | 8 | Eight characters in width, right justified |
| | 08 | Eight characters in width, with leading zeroes as necessary. |
| | .3 | Three places after decimal point. |
| | 10.3 | Ten characters in width, right justified, with three places after decimal point. |

```java
String name = "Ani";
int age = 6;
double saving = 1234567.89012345;

System.out.printf("Name: %s %n", name);
System.out.printf("Name: %10s %n", name);
System.out.printf("Name: %-10s %n", name);

System.out.printf("Age: %d years old %n", age);
System.out.printf("Age: %2d years old %n", age);
System.out.printf("Age: %02d years old %n", age);

System.out.printf("Saving: Rp %f %n", saving);
System.out.printf("Saving: Rp %.2f %n", saving);
System.out.printf("Saving: Rp %12.2f %n", saving);
System.out.printf("Saving: Rp %5.2f %n", saving);
System.out.printf("Saving: Rp %,.2f %n", saving);
```

## Saving Formatted String in Variables

```java
String.format(format, param1, param2, ...)
```

- Example:
 ```java
 String priceString = String.format("Rp %.2f", price);
 ```

Conditionals and Logic

# if

![if](https://i.ibb.co/VLfqB04/Screenshot-2024-04-03-154618.png)

# if ... else ...

![if else](https://i.ibb.co/BrJXs0T/Screenshot-2024-04-03-154629.png)

# Simple Example

<Tabs>
 <Tab title="Question">
 Write a program to determine whether the body temperature entered by the user can be categorized as a fever
 - Input: **body temperature in celcius (C)**
 - Output: **“Fever”, if body temperature is more than 37o C. If not, no outputs.**

 </Tab>
 <Tab title="Answer">
 ```java Program.java
 import java.util.*;
 public class Program {
 public static void main(String[] args) {
 Scanner in = new Scanner(System.in);
 double temperature = in.nextDouble();
 if (temperature > 37) { // condition
 System.out.println("Fever"); // Statements executed when the condition is true (fulfilled)
 }
 }
 }
 ```
 </Tab>
</Tabs>

# Relational Operators

| Operator | Description | Example |
| :------: | ------------------------ | :-----: |
| == | Equal to | x == y |
| != | Not equal to | x != y |
| > | Greater than | x > y |
| \< | Less than | x \< y |
| >= | Greater than or equal to | x >= y |
| \<= | Less than or equal to | x \<= y |

# Logical Operators

| Operator | Description | Example |
| :------: | ----------- | :------: |
| && | Logical AND | x && y |
| \|\| | Logical OR | x \|\| y |
| ! | Logical NOT | !x |

- Example
 ```java
 x < 0 && y >= 10
 number != 2 || number > 0
 !(temperature > 37)
 !(price < 10 || price > 100)
 (width > 0 && width < 10) || (length > 20)
 ```

# Chaining

```java
if (condition1) {
// executed when condition1 is true
} else if (condition2) {
// executed when condition1 is false and condition2 is true
} else if (condition3) {
// executed when condition1 & 2 are false, condition3 is true
} else {
// executed when all conditions are false
}
```

# Exercise

## Exercise 1

<Tabs>
 <Tab title="Question">
 Write a program to calculate the total user must pay for an imported item.
 - If the price of the item exceeds USD 100, then an import tax of 20% is imposed
 - Input: **price of items before tax in USD**
 - Output: **total paid (item price plus tax)**

 </Tab>
 <Tab title="Answer">
 ```java Program.java
 import java.util.*;
 public class Program {
 public static void main(String[] args) {
 Scanner in = new Scanner(System.in);
 double price = in.nextDouble();
 double tax = 0;
 if (price > 100) {
 tax = price * 0.2;
 }
 double total = price + tax;
 System.out.printf("The total paid is %.2f\n", total);
 }
 }
 ```
 </Tab>
</Tabs>

## Exercise 2

<Tabs>
 <Tab title="Question">
 Write a program to determine whether the value entered by the user is odd or even.
 - Input: **integer**
 - Output: **“Odd” or “Even”**

 </Tab>
 <Tab title="Answer">
 ```java Program.java
 import java.util.*;
 public class Program {
 public static void main(String[] args) {
 Scanner in = new Scanner(System.in);
 int number = in.nextInt();
 if (number % 2 == 0) {
 System.out.println("Even");
 } else {
 System.out.println("Odd");
 }
 }
 }
 ```
 </Tab>
</Tabs>

## Exercise 3

<Tabs>
 <Tab title="Question">
 Write a program to determine whether the size of the baby at birth is normal or not
 - Normal baby weight at birth ranges from 2.5 to 4.5 kg and lengths between 45 and 60 cm
 - Input: **baby's weight in kg and length in cm**
 - Output: **whether the baby's size is normal or not**

 </Tab>
 <Tab title="Answer">
 ```java Program.java
 import java.util.*;
 public class Program {
 public static void main(String[] args) {
 Scanner in = new Scanner(System.in);

 System.out.print("Enter the baby's weight: ");
 double weight = in.nextDouble();

 System.out.print("Enter the baby's length: ");
 double length = in.nextDouble();

 // Flag variables
 boolean normalWeight = (weight >= 2.5 && weight <= 4.5);
 boolean normalLength = (length >= 45 && length <= 60);

 if (normalWeight && normalLength) {
 System.out.println("Normal weight and length");
 } else if (normalWeight) {
 System.out.println("Normal weight, Abnormal length");
 } else if (normalLength) {
 System.out.println ("Abnormal weight, normal length");
 } else {
 System.out.println ("Abnormal weight and length");
 }
 }
 }
 ```

 </Tab>
</Tabs>

## Exercise 4

<Tabs>
 <Tab title="Question">
 Write a program to convert grade in numbers to letters.
 - Conversion table:
 | Number | Letter |
 | :----: | :----: |
 | < 41 | E |
 | 41 to < 56 | D |
 | 56 to < 61 | C |
 | 61 to < 66 | BC |
 | 66 to < 76 | B |
 | 76 to < 81 | AB |
 | >= 81 | A |

 - Input: **grade in number**
 - Output: **letter grade**

 </Tab>
 <Tab title="Answer">
 ```java Program.java
 import java.util.*;
 public class Program {
 public static void main(String[] args) {
 Scanner in = new Scanner(System.in);

 System.out.print("Berapa nilaimu: ");
 double nilai = in.nextDouble();
 String nilaiHuruf;

 if (nilai < 41) {
 nilaiHuruf = "E";
 } else if (nilai < 56) {
 nilaiHuruf = "D";
 } else if (nilai < 61) {
 nilaiHuruf = "C";
 } else if (nilai < 66) {
 nilaiHuruf = "BC";
 } else if (nilai < 76) {
 nilaiHuruf = "B";
 } else if (nilai < 81) {
 nilaiHuruf = "AB";
 } else {
 nilaiHuruf = "A";
 }

 System.out.println("Nilai Huruf = " + nilaiHuruf);
 }
 }
 ```

 </Tab>
</Tabs>

Conditions, Input Validation, Strings

# Introduction 1

<Tabs>
 <Tab title="Question">
 As part of promotion, a department store provides discounts for its customers.
 All products whose prices are above IDR 300,000 are given a discount of 40%. For example, a pair of shoes that cost IDR 499,000 are now sold for only IDR 299,400.
 However, the labels printed on the products are still showing prices before the discount, so the department store employee still needs to calculate in advance to get the final price.
 **Write a program to help department store employees to calculate the final price of the products.**
 </Tab>
 <Tab title="Answer">
 ```java 
 total = price;
 if (price > 300000 && date == 7) {
 total = total - 0.4 * total; // 40% discount
 total = total - 0.2 * total; // additional 20% discount
 } else if (price > 300000) {
 total = total - 0.4 * total; // 40% discount
 } else if (date == 7) {
 total = total - 0.2 * total; // additional 20% discount
 } 
 ```

 </Tab>
</Tabs>

# Introduction 2

<Tabs>
 <Tab title="Question">
 Because the strategy of providing discounts successfully attracted customers, department store management plans to hold additional events. On the 7th of each month, department stores will provide an additional discount of 20% for all products. For products with prices above IDR 300,000, of course the discounts obtained will double.
 For example, for a bag worth IDR 1,000,000, the initial discount obtained is 40% x IDR 1,000,000 = IDR 400,000 so the price of the item before the additional discount = IDR 600,000. 
 With an additional discount of 20%, the total to be paid is IDR 600,000 - (20% x IDR 600,000) = IDR 480,000. 
 **Update the program you have previously written.**
 </Tab>
 <Tab title="Answer">
 ```java 
 total = price;
 if (price > 300000) {
 total = total - 0.4 * total;
 }
 if (date == 7) {
 total = total - 0.2 * total;
 }
 ```

 </Tab>
</Tabs>

# Flag Variables

```java
boolean varFlag = condition;
```

<Tabs>
 <Tab title="Sample Case">
 Write a program to determine whether the size of the baby at birth is normal
or not
 - Normal baby weight at birth ranges from 2.5 to 4.5 kg and lengths between 45 and 60 cm
 - Input: **baby's weight in kg and length in cm**
 - Output: **whether the baby's weight and length are normal, its weight is normal, its length is normal, or both are not normal**
 </Tab>
 <Tab title="Sample Solution">
 ```java 
 if (weight >= 2.5 && weight <= 4.5 && length >= 45 && length <= 60) {
 // both weight & length are normal
 } else if (weight >= 2.5 && weight <= 4.5) {
 // weight is normal, length is not
 } else if (length >= 45 && length <= 60) {
 // length is normal, weight is not
 } else {
 // both weight & length are not normal
 }
 ```
 </Tab>
 <Tab title="Using Flag Variables">
 ```java 
 // Flag Variables
 boolean weightNormal = (weight >= 2.5 && weight <= 4.5);
 boolean lengthNormal = (length >= 45 && length <= 60);

 if (weightNormal && lengthNormal) {
 // both weight & length are normal
 } else if (weightNormal) {
 // weight is normal, length is not
 } else if (lengthNormal) {
 // length is normal, weight is not
 } else {
 // both weight & length are not normal
 }
 ```

 </Tab>
</Tabs>

# Nested Ifs

```java
if (condition1) {
 // do something
 if (condition2) {
 // do something
 } else {
 // do something
 }
 // do something
}
```

<Tabs>
 <Tab title="Sample Case">
 Write a program to calculate the total user must pay for an imported item.
 - If the price of the item exceeds USD 100, then an import tax of 20% is imposed
 - Input: **price of items before tax in USD**
 - Output: **total paid (item price plus tax)**
 </Tab>
 <Tab title="Negative price allowed?">
 ```java 
 Scanner in = new Scanner(System.in);
 
 double price = in.nextDouble();
 double total = price;

 if (price > 100) {
 total = price + 0.2 * price;
 }
 System.out.println(total);
 ```

 </Tab>
 <Tab title="Solution">
 ```java 
 Scanner in = new Scanner(System.in);
 double price = in.nextDouble();

 if (price > 0) {
 double total = price;
 if (price > 100) {
 total = price + 0.2 * price;
 }
 System.out.println(total);
 } else {
 System.out.println("The price must be positive");
 }
 ```

 </Tab>
</Tabs>

# Input Validation

<Tabs>
 <Tab title="Sample Case">
 Write a program to calculate the volume of the cube
 - Input: **the length of any edge of the cube**
 - Output: **volume of the cube**
 </Tab>
 <Tab title="Solution">
 ```java 
 Scanner in = new Scanner(System.in);

 System.out.print("Enter the length of the cube's edge: ");
 double edge = in.nextDouble();
 double volume = edge * edge * edge;
 System.out.println(volume);
 ```

 </Tab>
 <Tab title="Negative edge length allowed?">
 ```java 
 Scanner in = new Scanner(System.in);
 
 System.out.print("Enter the length of the cube's edge: ");
 double edge = in.nextDouble();
 if (edge > 0) {
 double volume = edge * edge * edge;
 System.out.println(volume);
 } else {
 System.out.println("The length of the cube's edge must be positive");
 }
 ```

 </Tab>
 <Tab title="User don't enter a number?">
 ```java 
 Scanner in = new Scanner(System.in);
 System.out.print("Enter the length of the cube's edge: ");
 if (in.hasNextDouble()) {
 double edge = in.nextDouble();
 ...
 } else {
 String word = in.next();
 System.out.println(word + " is not a number");
 }
 ```

 </Tab>
 <Tab title="Return Keyword">
 ```java 
 Scanner in = new Scanner(System.in);
 System.out.print("Enter the length of the cube's edge: ");
 if (! in.hasNextDouble()) {
 String word = in.next();
 System.out.println(word + " is not a number");
 return; // return keyword
 }
 double edge = in.nextDouble();
 ...
 ```

 </Tab>
</Tabs>

# String

## Strings in Conditionals

```java
Scanner in = new Scanner(System.in);
System.out.print("What is your name: ");
String name = in.next();
if (name == "Ani") {
 System.out.println("Your name is Ani");
} else {
 System.out.println("Your name is not Ani");
}
```

## String Comparison

<Tabs>
 <Tab title="equals">
 `.equals()` : digunakan untuk membandingkan isi dari dua buah string, dan mengembalikan true jika isi kedua string tersebut sama. 
 ```java 
 string.equals(anotherString)
 string.equalsIgnoreCase(anotherString)

 string1 = "text";
 string2 = "text";
 string3 = "Text";
 string4 = "txt";

 string1.equals(string2); // true
 string1.equals(string3); // false
 string1.equals(string4); // false

 string1.equalsIgnoreCase(string2); // true
 string1.equalsIgnoreCase(string3); // true
 string1.equalsIgnoreCase(string4); // false
 ```

 </Tab>

 <Tab title="contains">
 `.contains()` : digunakan untuk mengecek apakah suatu string mengandung karakter tertentu atau tidak. 
 ```java 
 string.contains(anotherString)

 string1 = "once upon a time";
 string2 = "time";
 string3 = "once upon a time";
 string4 = "a book";

 string1.contains(string2); // true
 string2.contains(string1); // false
 string1.contains(string3); // true
 string1.contains(string4); // false
 ```

 </Tab>

 <Tab title="startswith/endswith">
 `.startswith()` : digunakan untuk mengecek apakah suatu string diawali dengan karakter tertentu atau tidak.\
 `.endswith()` : digunakan untuk mengecek apakah suatu string diakhiri dengan karakter tertentu atau tidak.
 ```java 
 string.startsWith(anotherString)
 string.endsWith(anotherString)

 string1 = "once upon a time ";
 string2 = "once";
 string3 = "time";

 string1.startsWith(string2); // true
 string1.startsWith(string3); // false
 string1.endsWith(string2); // false
 string1.endsWith(string3); // true
 ```

 </Tab>

 <Tab title="compareTo/compareToIgnoreCase">
 `.compareTo()` : digunakan untuk membandingkan dua buah string berdasarkan urutan leksikografisnya.\
 `.compareToIgnoreCase()` : digunakan untuk membandingkan dua buah string berdasarkan urutan leksikografisnya tanpa memperdulikan huruf besar atau kecil.
 ```java 
 string.compareTo(anotherString)
 string.compareToIgnoreCase(anotherString)

 string1 = "budi";
 string2 = "ani";
 string3 = "chandra";
 string4 = "Budi";

 string1.compareTo(string2); // > 0
 string1.compareTo(string3); // < 0
 string1.compareTo(string1); // 0
 string1.compareTo(string4); // > 0
 string1.compareToIgnoreCase(string4); // 0
 ```

 </Tab>
</Tabs>

## String Manipulation

<Tabs>
 <Tab title="substring">
 `.substring()` : digunakan untuk mengambil sebagian karakter dari suatu string.
 ```java 
 string.substring(beginIndex)
 string.substring(beginIndex, endIndex)

 string = "abcdefghij";

 string.substring(3); // "defghij"
 string.substring(3, 5); // "de"
 ```

 </Tab>

 <Tab title="replaceAll/replaceFirst">
 `.replaceAll()` : digunakan untuk mengganti semua kemunculan suatu karakter atau string dengan karakter atau string lain.\
 `.replaceFirst()` : digunakan untuk mengganti kemunculan pertama suatu karakter atau string dengan karakter atau string lain.
 ```java 
 string.replaceAll(pattern, replacement)
 string.replaceFirst(pattern, replacement)

 string = "he's a doctor while she's a nurse";
 string.replaceAll("'s", " is");
 // "he is a doctor while she is a nurse"
 string.replaceFirst("'s", " is");
 // "he is a doctor while she's a nurse"
 ```

 </Tab>

 <Tab title="toUpperCase/toLowerCase">
 `.toUpperCase()` : digunakan untuk mengubah semua karakter dalam suatu string menjadi huruf besar.\
 `.toLowerCase()` : digunakan untuk mengubah semua karakter dalam suatu string menjadi huruf kecil.
 ```java 
 string.toUpperCase()
 string.toLowerCase()

 string = "My name is Ani";
 string.toUpperCase();
 // "MY NAME IS ANI"
 string.toLowerCase();
 // "my name is ani"
 ```

 </Tab>

 <Tab title="trim">
 `.trim()` : digunakan untuk menghapus spasi di awal dan di akhir suatu string.
 ```java 
 string.trim()

 string =" Ani ";
 string.trim();
 // "Ani"
 ```

 </Tab>
</Tabs>

## String → Number

`.parseInt()` : digunakan untuk mengubah string menjadi integer.\
`.parseDouble()` : digunakan untuk mengubah string menjadi double.

```java
Integer.parseInt(string)
Double.parseDouble(string)

String time = "18:49";
String h = time.substring(0, 2);
String m = time.substring(3);
int hour1 = Integer.parseInt(h);
int minute1 = Integer.parseInt(m);
double hour2 = Double.parseDouble(h);
double minute2 = Double.parseDouble(m);
```

Loops

Methods

- **Statement** = a line of code that performs a basic operation
- **Method** = a named sequence of statements

- Usage:
 - to do non-simple operations repeatedly
 - to break complex problems into smaller, simpler parts

## Types of Methods

| VOID Method | VALUE Method |
| -------------------------------- | ------------------------------- |
| Does not return a value | Returns a value |
| Often referred to as a procedure | Often referred to as a function |

### Void Method

```java
public static void sayHello() {
 System.out.println("Hello");
}

public static void sayHello(String name) {
 System.out.println("Hello " + name);
}

public static void main(String[] args) {
 sayHello();
 sayHello("Ani");
}
```

<Accordion title="Penjelasan">
- Method Names ![Method Names](https://i.ibb.co/1dGM5PQ/Screenshot-2024-04-03-191448.png)
- Parameters and Arguments ![Parameters and Arguments](https://i.ibb.co/tKWB3QY/Screenshot-2024-04-03-191459.png)
- Statements ![Statements](https://i.ibb.co/xXhLYZv/Screenshot-2024-04-03-191511.png)
- Overloading ![Overloading](https://i.ibb.co/SBZmkHQ/Screenshot-2024-04-03-191521.png)

</Accordion>

#### Exercise Void Method

<Tabs>
 <Tab title="Exercise 1">
 Write one or several methods to do the following
 1. Prints a String n times
 2. Display the message "Good Morning" in various languages
 3. Display an alphanumeric character as an ASCII art
 </Tab>

 <Tab title="Solution Exercise 1">
 ```java
 public static void printString(String str, int n) {
 for (int i = 0; i < n; i++) {
 System.out.println(str);
 }
 }
 ```
 </Tab>

</Tabs>

### Value Method

```java
public static double computeBMI(double weight, double height) {
 double bmi = weight / height / height;
 return bmi;
}

public static void main(String[] args) {
 double weight = 40;
 double height = 1.65;
 double bmi = computeBMI(weight, height);

 System.out.println("Ani's BMI is: " + bmi);
}
```

<Accordion title="Penjelasan">
- Return type and value ![Return type and value](https://i.ibb.co/Hq66kb0/Screenshot-2024-04-03-192156.png)
- ![2](https://i.ibb.co/n7LqLWC/Screenshot-2024-04-03-192204.png)

</Accordion>

#### Exercise Value Method

<Tabs>
 <Tab title="Exercise 1">
 Write one or several methods to do the following
 1. Calculates the distance between two coordinates
 2. Determines whether a number is prime or not
 3. Determines the number of days in a year
 </Tab>

 <Tab title="Solution Exercise 1">
 ```java
 public static double distance(double x1, double y1, double x2, double y2) {
 double dx = x2 - x1;
 double dy = y2 - y1;
 return Math.sqrt(dx * dx + dy * dy);
 }
 ```
 </Tab>

</Tabs>

# Method Composition

```java
public static double computeTax(double price) {
 double tax = 0;
 if (price > 100) {
 tax = 0.2 * price;
 }
 return tax;
}

public static double computePayment(double price) {
 return price + computeTax(price);
}

public static void main(String[] args) {
 double itemPrice = 600;
 double payment = computePayment(itemPrice);
}
```

# Recursive Methods

<Frame caption="https://keenformatics.blogspot.com/2013/08/how-to-solve-json-infinite-recursion.html">
 <img src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEglzxsfghEu3st1QOHLTdCUkcc9E6kX8tNtW2QkDC21AAcaOaS2HKDv5H7jKn_tDdmTrwiXRJSqNluSBB4hVYTVglPTpgRz4QOo_MCTx-T3AY8SR92yeQBFeSBiU994Yt1pktej5xAipoic/s320/recursion.jpg" />
</Frame>

- A method that invokes itself
- example:

<CodeGroup>

```java factorial
 0! = 1
 n! = n ∙ (n – 1)!

 factorial(5) = 5 _ factorial(4)
 factorial(4) = 4 _ factorial(3)
 factorial(3) = 3 _ factorial(2)
 factorial(2) = 2 _ factorial(1)
 factorial(1) = 1 * factorial(0)
 factorial(0) = 1

```

```java Code
public static int factorial(int n) {
 if (n == 0) {
 return 1;
 }
 return n * factorial(n - 1);
}

public static void main(String[] args) {
 System.out.println(factorial(5));
}
```

</CodeGroup>

- Write the **_base case_**:

```java
if (n == 0) {
 return 1;
}
```

- Write the **_reduction step_**. Ensure that the base case can be reached:

```java
return n * factorial(n - 1);
```

## Recursion vs Iteration

- Recursion is not always needed
- Everything that can be done with recursion can be done using iterations (loops)
- Recursion
 - consumes more memory and slower than iterations
 - elegant, shorter code

# Documentation

<Tabs>
 <Tab title="True">
 ![True](https://i.ibb.co/1dzQSFX/Screenshot-2024-04-03-193718.png)
 </Tab>
 <Tab title="False">
 ![False](https://i.ibb.co/c30vJXr/Screenshot-2024-04-03-193726.png)
 </Tab>
</Tabs>

Arrays 1

![Arrays](https://i.ibb.co/CVz5ZTS/Screenshot-2024-04-03-194447.png)

- An array is a sequence of values
- Used to store multiple values of the same type using a single variable
- The size of the array is fixed, determined when created
- The values in the array are called elements
- Elements in arrays are accessed using an index
- The index starts at 0, not 1

## Creating Arrays

```java
int[] data = new int[10];

double[] priceList;
priceList = new double[5];

String[] names = {"Ani", "Budi", "Cinta"};
```

## Accessing Elements

<Tabs>
<Tab title="Code">
```java
int[] counts = new int[4];
```
</Tab>
<Tab title="Ilustrasi">

![1](https://i.ibb.co/jRZg8Dn/Screenshot-2024-04-03-194726.png)

</Tab>
</Tabs>

<Tabs>
<Tab title="Code">
```java
counts[0] = 7;
counts[1] = counts[0] * 2;
counts[2]++;
counts[3] = counts[3] - 60;
```
</Tab>
<Tab title="Ilustrasi">

![2](https://i.ibb.co/ZmJjN1W/Screenshot-2024-04-03-194735.png)

</Tab>
</Tabs>

## Displaying Arrays

<Tabs>
<Tab title="False">
```java
int[] values = {89, 50, 77};
System.out.println(values); // [I@15db9742
```
</Tab>
<Tab title="True">
```java
int[] values = {89, 50, 77};
System.out.println(values[0]);
System.out.println(values[1]);
System.out.println(values[2]);
```
</Tab>
<Tab title="True">
```java
int[] values = {89, 50, 77};
for (int i = 0; i < 3; i++) {
 System.out.println(values[i]);
}
```

</Tab>
</Tabs>

## Array length

`.length` : digunakan untuk mengetahui panjang array yang dimiliki oleh suatu array

```java
int[] values = {89, 50, 77};
for (int i = 0; i < 3; i++) {
 System.out.println(values[i]);
}
for (int i = 0; i < values.length; i++) {
 System.out.println(values[i]);
}
```

## Copying Arrays

<Tabs>
<Tab title="False">
```java
int[] a = {89, 50, 77};
int[] b = a;
b[0] = b[0] - 20;
System.out.println(a[0]);
System.out.println(b[0]);
```
</Tab>
<Tab title="True">
```java
int[] a = {89, 50, 77};
int[] b = new int[a.length];
for (int i = 0; i < a.length; i++) {
 b[i] = a[i]; 
}
int[] a = {89, 50, 77};
int[] b = Arrays.copyOf(a, a.length);
int[] c = Arrays.copyOf(a, 2);
```
</Tab>
</Tabs>

## Array Traversal

<Tabs>
<Tab title="True">
```java
int[] values = {89, 50, 77};
for (int i = 0; i < values.length; i++) {
 System.out.println(values[i]);
}
for (int i = 0; i < values.length; i++) {
 values[i] = values[i] * 2;
}
````
</Tab>
<Tab title="True">
```java
int[] values = {89, 50, 77};
for (int v : values) {
 System.out.println(v);
}
````

</Tab>
</Tabs>

## String $\Leftrightarrow$ char Array

```java
String word = "lemon";
char[] characters = word.toCharArray();

characters[0] = 'm';
characters[2] = 'l';

String word2 = String.valueOf(characters);

System.out.println(word2);
```

## Exercise

<Tabs>
 <Tab title="Question 1">
 - Create an array that can hold 15 integers
 - Fill up each element of the array with the number 123
 - Then display the contents of the array
 ![Question 1](https://i.ibb.co/B4zgRnC/Screenshot-2024-04-03-200449.png)
 </Tab>
 <Tab title="Answer 1">
 ```java
 int[] numbers = new int[15];
 for (int i = 0; i < numbers.length; i++) {
 numbers[i] = 123;
 }
 for (int i = 0; i < numbers.length; i++) {
 System.out.println("Element-" + i + " = " + numbers[i]);
 }
 ````
 </Tab>
</Tabs>

<Tabs>
 <Tab title="Question 2">
 - Create an array that can hold 5 integers
 - Fill up the array with user inputs
 - Then display the contents of the array
 ![Question 2](https://i.ibb.co/fnb86bX/Screenshot-2024-04-03-200456.png)
 </Tab>
 <Tab title="Answer 2">
 ```java
 Scanner scanner = new Scanner(System.in);
 int[] numbers = new int[5];
 for (int i = 0; i < numbers.length; i++) {
 System.out.print("Enter the value of Element-" + i + ": ");
 numbers[i] = scanner.nextInt();
 }
 for (int i = 0; i < numbers.length; i++) {
 System.out.println("Element-" + i + " = " + numbers[i]);
 }
 ````
 </Tab>
</Tabs>

<Tabs>
 <Tab title="Question 3">
 - Create an array that can hold $n$ integers
 - $n$ is user input
 - Fill up the array with user inputs
 - Then display the contents of the array
 ![Question 3](https://i.ibb.co/rKjtjjh/Screenshot-2024-04-03-200503.png)
 </Tab>
 <Tab title="Answer 3">
 ```java
 Scanner scanner = new Scanner(System.in);
 System.out.print("Enter the Length of array: ");
 int n = scanner.nextInt();
 int[] numbers = new int[n];
 for (int i = 0; i < numbers.length; i++) {
 System.out.print("Enter the value of Element-" + i + ": ");
 numbers[i] = scanner.nextInt();
 }
 for (int i = 0; i < numbers.length; i++) {
 System.out.println("Element-" + i + " = " + numbers[i]);
 }
 ````
 </Tab>
</Tabs>

<Tabs>
 <Tab title="Question 4">
 - Create an array that can hold $n$ integers
 - $n$ is user input
 - Fill up the array with user inputs
 - Then display the contents of the array starting from the last element to the first
 ![Question 4](https://i.ibb.co/tLXqy91/Screenshot-2024-04-03-200512.png)
 </Tab>
 <Tab title="Answer 4">
 ```java
 Scanner scanner = new Scanner(System.in);
 System.out.print("Enter the Length of array: ");
 int n = scanner.nextInt();
 int[] numbers = new int[n];
 for (int i = 0; i < numbers.length; i++) {
 System.out.print("Enter the value of Element-" + i + ": ");
 numbers[i] = scanner.nextInt();
 }
 for (int i = numbers.length - 1; i >= 0; i--) {
 System.out.println("Element-" + i + " = " + numbers[i]);
 }
 ````
 </Tab>
</Tabs>

<Tabs>
 <Tab title="Question 5">
 - Create an array that can hold $n$ integers
 - $n$ is user input
 - Fill up the array with user inputs
 - Then display the contents of the array starting from the last element to the first
 ![Question 5](https://i.ibb.co/sspZY5r/Screenshot-2024-04-03-200525.png)
 ![Question 5](https://i.ibb.co/YQY9sM0/Screenshot-2024-04-03-200518.png)
 </Tab>
 <Tab title="Answer 5">
 ```java
 Scanner scanner = new Scanner(System.in);
 System.out.print("How many values: ");
 int n = scanner.nextInt();
 int[] numbers = new int[n];
 for (int i = 0; i < numbers.length; i++) {
 System.out.print("Enter the value-" + i + ": ");
 numbers[i] = scanner.nextInt();
 }
 double sum = 0;
 for (int i = 0; i < numbers.length; i++) {
 sum += numbers[i];
 }
 double mean = sum / numbers.length;
 double sumOfSquares = 0;
 for (int i = 0; i < numbers.length; i++) {
 sumOfSquares += Math.pow(numbers[i] - mean, 2);
 }
 double standardDeviation = Math.sqrt(sumOfSquares / numbers.length);
 System.out.println("Standard Deviation = " + standardDeviation);
 ````
 </Tab>
</Tabs>

<Tabs>
 <Tab title="Question 6">
 - Make a program to check whether a word entered by a user is palindrome or not
 - A palindrome is a word, number, phrase, or other sequence of characters which reads the same backward as forward
 - Examples:
 - eye
 - level
 - radar
 - madam
 - refer
 - ...
 ![Question 6](https://i.ibb.co/hLK8Xb0/Screenshot-2024-04-03-200531.png)
 </Tab>
 <Tab title="Answer 6">
 ```java
 Scanner scanner = new Scanner(System.in);
 System.out.print("Enter a word: ");
 String word = scanner.next();
 char[] characters = word.toCharArray();
 boolean isPalindrome = true;
 for (int i = 0; i < characters.length / 2; i++) {
 if (characters[i] != characters[characters.length - 1 - i]) {
 isPalindrome = false;
 break;
 }
 }
 if (isPalindrome) {
 System.out.println("Palindrome");
 } else {
 System.out.println("Not a palindrome");
 }
 ````
 </Tab>
</Tabs>

<Tabs>
 <Tab title="Question 7">
 - Write a program that asks the user to enter the student's name and grade n times.
 - After all data is entered, the user can search for the grade of a student by entering his name.
 - The program stops when the user enters “-” when asked for the name
 ![Question 7](https://i.ibb.co/W542npv/Screenshot-2024-04-03-200544.png)
 </Tab>
 <Tab title="Answer 7">
 ```java
 Scanner scanner = new Scanner(System.in);
 System.out.print("How many students? ");
 int n = scanner.nextInt();
 String[] names = new String[n];
 int[] grades = new int[n];
 for (int i = 0; i < n; i++) {
 System.out.print("Name of student-" + i + ": ");
 names[i] = scanner.next();
 System.out.print("Grade of student-" + i + ": ");
 grades[i] = scanner.nextInt();
 }
 while (true) {
 System.out.print("Searching the grade of: ");
 String name = scanner.next();
 if (name.equals("-")) {
 break;
 }
 boolean found = false;
 for (int i = 0; i < n; i++) {
 if (names[i].equals(name)) {
 System.out.println(name + "\'s grade is " + grades[i]);
 found = true;
 break;
 }
 }
 if (!found) {
 System.out.println("Student not found");
 }
 }
 ````
 </Tab>
</Tabs>

Arrays 2

## Multidimensional Arrays

<Tabs>
 <Tab title="Ex-1">
 ```java
 int[][] a = new int[3][4];
 ```
 ![1](https://i.ibb.co/HtzHWtC/Screenshot-2024-04-03-210547.png)

 </Tab>

 <Tab title="Ex-2">
 ```java
 int n = 5;
 int[][] distance = new int[n][n];
 distance[0][1] = distance[1][0] = 10;
 distance[1][3] = distance[3][1] = 5;
 ```
 </Tab>

 <Tab title="Ex-3">
 ```java
 int[][] a = {
 {1, 2, 3},
 {4, 5, 6, 9},
 {7},
 };
 ```

 ![2](https://i.ibb.co/T1rk18d/Screenshot-2024-04-03-210554.png)
 </Tab>

 <Tab title="Ex-4">
 ```java
 int[][] data = new int[4][];
 data[0] = new int[3];
 data[1] = new int[10];
 data[2] = new int[2];
 data[3] = new int[6];
 ```
 </Tab>

</Tabs>

## Array Traversal

<CodeGroup>

```java Ex-1
int[][] data = {
 { 1, 2, 3 },
 { 4, 5 },
 { 6, 7, 8, 9 }
};

for (int i = 0; i < data.length; i++) {
 for (int j = 0; j < data[i].length; j++) {
 System.out.print(data[i][j] + "\t");
 }
 System.out.println();
}
```

```java Ex-2
int[][] array2D = {
 { 1, 2, 3 },
 { 4, 5 },
 { 6, 7, 8, 9 }
};

for (int[] array1D : array2D) {
 for (int elem : array1D) {
 System.out.print(elem + "\t");
 }
 System.out.println();
}
```

</CodeGroup>

## Exercise

### Exercise 1

<Tabs>
 <Tab title="Question">
	- Create an array that can hold $n$ integers 
	- Fill up the array with user inputs 
	- Ask the user to enter a value that they want to find 
	- Show if the value is in the array
	
	![1](https://i.ibb.co/8cZ9TYR/Screenshot-2024-04-03-215551.png)
 </Tab>
 
 <Tab title="Answer">
 ```java
	import java.util.Scanner;
	public class Main {
		public static void main(String[] args) {
			Scanner sc = new Scanner(System.in);
			System.out.print("Enter the length of array: ");
			int n = sc.nextInt();
			int[] arr = new int[n];
			System.out.println("Enter the elements of the array: ");
			for (int i = 0; i < n; i++) {
				arr[i] = sc.nextInt();
			}
			System.out.print("Enter the lookup value: ");
			int lookup = sc.nextInt();
			for (int i = 0; i < n; i++) {
				if (arr[i] == lookup) {
					System.out.println(lookup + " is in the array.");
				}
			}
 	}
 }

````

</Tab>

</Tabs>

### Exercise 2


<Tabs>
 <Tab title="Question">
	- Create an array that can hold $n$ integers
	- Fill up the array with user inputs
	- Ask the user to enter a value that they want to find
	- Show how many times the value appears in the array

	![2](https://i.ibb.co/Jrp44Fz/Screenshot-2024-04-03-215557.png)
 </Tab>

 <Tab title="Answer">
 ```java
	import java.util.Scanner;
	public class Main {
		public static void main(String[] args) {
			Scanner sc = new Scanner(System.in);
			System.out.print("Enter the length of array: ");
			int n = sc.nextInt();
			int[] arr = new int[n];
			System.out.println("Enter the elements of the array: ");
			for (int i = 0; i < n; i++) {
				arr[i] = sc.nextInt();
			}
			System.out.print("Enter the lookup value: ");
			int lookup = sc.nextInt();
			int count = 0;
			for (int i = 0; i < n; i++) {
				if (arr[i] == lookup) {
					count++;
				}
			}
			System.out.println(lookup + " appears " + count + " time(s) in the array.");
 	}
 }

````

</Tab>

</Tabs>

### Exercise 3

<Tabs>
 <Tab title="Question">
	- Create an array that can hold $n$ integers
	- Fill up the array with user inputs
	- Ask the user to enter a value that they want to find
	- Show whether the value is in the array or not

 ![3](https://i.ibb.co/JrjFGp5/Screenshot-2024-04-03-215602.png)

 </Tab>

 <Tab title="Answer">
 ```java
	import java.util.Scanner;
	public class Main {
		public static void main(String[] args) {
			Scanner sc = new Scanner(System.in);
			System.out.print("Enter the length of array: ");
			int n = sc.nextInt();
			int[] arr = new int[n];
			System.out.println("Enter the elements of the array: ");
			for (int i = 0; i < n; i++) {
				arr[i] = sc.nextInt();
			}
			System.out.print("Enter the lookup value: ");
			int lookup = sc.nextInt();
			boolean found = false;
			for (int i = 0; i < n; i++) {
				if (arr[i] == lookup) {
					found = true;
					break;
				}
			}
			if (found) {
				System.out.println(lookup + " is in the array.");
			} else {
				System.out.println(lookup + " is not in the array.");
			}
 	}
 }

````

</Tab>

</Tabs>

### Exercise 4

<Tabs>
 <Tab title="Question">
	- Create an array that can hold $n$ integers
	- Fill up the array with user inputs
	- Ask the user to enter a value that they want to find
	- Show on which index the value appears in the array

 ![4](https://i.ibb.co/Csf13Gs/Screenshot-2024-04-03-215608.png)

 </Tab>

 <Tab title="Answer">
 ```java
	import java.util.Scanner;
	public class Main {
		public static void main(String[] args) {
			Scanner sc = new Scanner(System.in);
			System.out.print("Enter the length of array: ");
			int n = sc.nextInt();
			int[] arr = new int[n];
			System.out.println("Enter the elements of the array: ");
			for (int i = 0; i < n; i++) {
				arr[i] = sc.nextInt();
			}
			System.out.print("Enter the lookup value: ");
			int lookup = sc.nextInt();
			boolean found = false;
			for (int i = 0; i < n; i++) {
				if (arr[i] == lookup) {
					found = true;
					System.out.println(lookup + " is at index " + i + ".");
				}
			}
			if (!found) {
				System.out.println(lookup + " is not in the array.");
			}
 	}
 }

````

</Tab>

</Tabs>

### Exercise 5

<Tabs>
 <Tab title="Question">
	- Create an array that can hold $n$ integers
	- Fill up the array with user inputs
	- Find the largest value in the array
	- Also display on which index the maximum value appears in the array

 ![5](https://i.ibb.co/S0k5562/Screenshot-2024-04-03-215613.png)

 </Tab>

 <Tab title="Answer">
 ```java
	import java.util.Scanner;
	public class Main {
		public static void main(String[] args) {
			Scanner sc = new Scanner(System.in);
			System.out.print("Enter the length of array: ");
			int n = sc.nextInt();
			int[] arr = new int[n];
			System.out.println("Enter the elements of the array: ");
			for (int i = 0; i < n; i++) {
				arr[i] = sc.nextInt();
			}
			int max = arr[0];
			int index = 0;
			for (int i = 1; i < n; i++) {
				if (arr[i] > max) {
					max = arr[i];
					index = i;
				}
			}
			System.out.printf("Maximum value: %d", max);
			System.out.printf("\nIndex: %d", index);
 	}
 }

````

</Tab>

</Tabs>

### Exercise 6

<Tabs>
 <Tab title="Question">
	- Create a 2-dimensional array that can hold m x n integers
	- Fill up the array with user inputs
	- Display the contents of the array

 ![6](https://i.ibb.co/b6xmh7B/Screenshot-2024-04-03-210601.png)

 </Tab>

 <Tab title="Answer">
 ```java
	import java.util.Scanner;
	public class Main {
		public static void main(String[] args) {
			Scanner sc = new Scanner(System.in);
			System.out.print("m: ");
			int m = sc.nextInt();
			System.out.print("n: ");
			int n = sc.nextInt();
			int[][] arr = new int[m][n];
			System.out.println("Enter the elements of the array: ");
			for (int i = 0; i < m; i++) {
				for (int j = 0; j < n; j++) {
					arr[i][j] = sc.nextInt();
				}
			}
			System.out.println("Contents of the array:");
			for (int i = 0; i < m; i++) {
				for (int j = 0; j < n; j++) {
					System.out.print(arr[i][j] + "\t");
				}
				System.out.println();
			}
 	}
 }

````

</Tab>

</Tabs>

### Exercise 7

<Tabs>
 <Tab title="Question">
	- Create a 2-dimensional array that can hold m x n integers
	- Fill up the array with user inputs
	- Ask the user to enter a value that they want to find
	- Show how many times the value appears in the array

 ![7](https://i.ibb.co/vz4TYJM/Screenshot-2024-04-03-210607.png)

 </Tab>

 <Tab title="Answer">
 ```java
	import java.util.Scanner;
	public class Main {
		public static void main(String[] args) {
			Scanner sc = new Scanner(System.in);
			System.out.print("m: ");
			int m = sc.nextInt();
			System.out.print("n: ");
			int n = sc.nextInt();
			int[][] arr = new int[m][n];
			System.out.println("Enter the elements of the array: ");
			for (int i = 0; i < m; i++) {
				for (int j = 0; j < n; j++) {
					arr[i][j] = sc.nextInt();
				}
			}
			System.out.print("Enter the lookup value: ");
			int lookup = sc.nextInt();
			int count = 0;
			for (int i = 0; i < m; i++) {
				for (int j = 0; j < n; j++) {
					if (arr[i][j] == lookup) {
						count++;
					}
				}
			}
			System.out.println(lookup + " appears " + count + " time(s) in the array.");
 	}
 }

````

</Tab>

</Tabs>

### Exercise 8

<Tabs>
 <Tab title="Question">
	- Create a 2-dimensional array that can hold m x n integers
	- Fill up the array with user inputs
	- Find the largest value in the array
	- Also display on which index the maximum value appears in the array

 ![8](https://i.ibb.co/DRFGHt9/Screenshot-2024-04-03-210615.png)

 </Tab>

 <Tab title="Answer">
 ```java
	import java.util.Scanner;
	public class Main {
		public static void main(String[] args) {
			Scanner sc = new Scanner(System.in);
			System.out.print("m: ");
			int m = sc.nextInt();
			System.out.print("n: ");
			int n = sc.nextInt();
			int[][] arr = new int[m][n];
			System.out.println("Enter the elements of the array: ");
			for (int i = 0; i < m; i++) {
				for (int j = 0; j < n; j++) {
					arr[i][j] = sc.nextInt();
				}
			}
			int max = arr[0][0];
			int maxI = 0;
			int maxJ = 0;
			for (int i = 0; i < m; i++) {
				for (int j = 0; j < n; j++) {
					if (arr[i][j] > max) {
						max = arr[i][j];
						maxI = i;
						maxJ = j;
					}
				}
			}
			System.out.printf("Maximum value: %d\n", max);
			System.out.printf("Index: (%d, %d)\n", maxI, maxJ);
 	}
 }

````

</Tab>

</Tabs>

Task

# Soal 1

<Tabs>
 <Tab title="Question">
 Buatlah sebuah program untuk menampilkan ascii art dari teks **IF2A-023** sesuai dengan output di bawah.

 ```plaintext
 @@@ @@@@@@@@@ @@
 @@@ @@@ @@@@@@ @@@@ @@@ @@@@@@ @@@@@@
 @@@ @@@ @@ @@@ @@ @@@ @@@ @@@ @@ @@@ @@@
 @@@ @@@@@@@ @@@ @@@ @@@ @@@@@@ @@@ @@@ @@@ @@@
 @@@ @@@ @@@ @@@@@@@@@@@ @@@ @@@ @@@ @@@
 @@@ @@@ @@@ @@@ @@@ @@@ @@@ @@@ @@@
 @@@ @@@ @@@@@@@@ @@@ @@@ @@@@ @@@@@@@@ @@@@@@
 ```

 Simpan program dalam sebuah file dengan nama **IF2A023.java** (nama class = **IF2A023**)

 </Tab>
 <Tab title="Answer">
 ```java IF2A023.java
 public class IF2A023 {
 public static void main(String[] args) {
 System.out.println("@@@ @@@@@@@@@ @@");
 System.out.println("@@@ @@@ @@@@@@ @@@@ @@@ @@@@@@ @@@@@@");
 System.out.println("@@@ @@@ @@ @@@ @@ @@@ @@@ @@@ @@ @@@ @@@");
 System.out.println("@@@ @@@@@@@ @@@ @@@ @@@ @@@@@@ @@@ @@@ @@@ @@@");
 System.out.println("@@@ @@@ @@@ @@@@@@@@@@@ @@@ @@@ @@@ @@@");
 System.out.println("@@@ @@@ @@@ @@@ @@@ @@@ @@@ @@@ @@@");
 System.out.println("@@@ @@@ @@@@@@@@ @@@ @@@ @@@@ @@@@@@@@ @@@@@@");
 }
 }
 ```
 </Tab>
</Tabs>

# Soal 2

<Tabs>
 <Tab title="Question">
 Buatlah sebuah program untuk menampilkan biodata sesuai dengan output berikut:

 ```plaintext
 Nama saya Muhammad Muqoffin Nuha.
 Usia saya sekarang 21 tahun.
 Saat ini saya sedang belajar di UISI.
 Indeks prestasi saya semester lalu sebesar 3.75.
 Semester ini, target saya bisa meraih IP 4.00.
 Artinya saya harus meningkatkan IP saya sebesar 0.25.
 Semoga saya bisa lulus dari UISI tepat waktu 1 tahun lagi.
 Saat itu saya akan genap berusia 22 tahun.
 ```

 Gunakan variabel dengan tipe data yang sesuai untuk menyimpan informasi-informasi yang terlibat di dalamnya.

 Jika ada nilai yang bisa dihitung dari sebuah variabel, gunakan juga operasi aritmatika untuk menghitungnya.

 Simpan program dalam sebuah file dengan nama **Biodata023.java** (nama class = **Biodata023**)

 </Tab>
 <Tab title="Answer">
 ```java Biodata023.java
 public class Biodata023 {
 public static void main(String[] args) {
 String nama = "Muhammad Muqoffin Nuha", kampus = "UISI";
 int usia = 21, tahunLulus = 1;
 double ipLalu = 3.75, targetIp = 4.00, selisihIp = targetIp - ipLalu;

 System.out.printf("Nama saya %s.\n", nama);
 System.out.printf("Usia saya sekarang %d tahun.\n", usia);
 System.out.printf("Saat ini saya sedang belajar di %s.\n", kampus);
 System.out.printf("Indeks prestasi saya semester lalu sebesar %.2f.\n", ipLalu);
 System.out.printf("Semester ini, target saya bisa meraih IP %.2f.\n", targetIp);
 System.out.printf("Artinya saya harus meningkatkan IP saya sebesar %.2f.\n", selisihIp);
 System.out.printf("Semoga saya bisa lulus dari %s tepat waktu %d tahun lagi.\n", kampus, tahunLulus);
 System.out.printf("Saat itu saya akan genap berusia %d tahun.\n", usia + tahunLulus);
 }
 }
 ```

 </Tab>
</Tabs>

# Soal 3

<Tabs>
 <Tab title="Question">
 Keluarga

 ![Family](/images/pemrograman-1/uts/soal3.png)

 *Sebuah keluarga memiliki 3 orang anak yang usia ketiganya membentuk barisan geometri.
 Diketahui usia dari anak termuda dan anak kedua, berapa usia anak tertua?*

 Buatlah sebuah program yang meminta input berupa usia anak termuda dan anak kedua dari keluarga tersebut.

 Program selanjutnya menghitung dan menampilkan usia anak tertua.

 Simpan program dalam sebuah file dengan nama **Keluarga023.java** (nama class = **Keluarga023**)

 </Tab>
 <Tab title="Answer">
 ```java Keluarga023.java
 import java.util.Scanner;
 public class Keluarga023 {
 public static void main(String[] args) {
 Scanner input = new Scanner(System.in);
 
 System.out.print("Masukkan usia anak termuda: ");
 int usiaAnakTermuda = input.nextInt();

 System.out.print("Masukkan usia anak kedua: ");
 int usiaAnakKedua = input.nextInt();

 int rasio = usiaAnakKedua / usiaAnakTermuda;
 int usiaAnakTertua = usiaAnakKedua * rasio;

 System.out.printf("Usia anak tertua adalah %d tahun.\n", usiaAnakTertua);
 }
 }
 ```

 </Tab>
</Tabs>

# Soal 4

<Tabs>
 <Tab title="Question">
 Kuliah

 ![Family](/images/pemrograman-1/uts/soal4.png)

 Pada suatu hari, Budi akan berangkat ke kampus untuk kuliah.

 Jarak rumah Budi ke kampus adalah $d$ km.

 Budi berangkat dari rumah pukul $pp : qq$.

 Kuliah Budi akan dimulai pukul $cc : yy$.

 Buatlah program untuk membantu Budi menentukan kecepatan rata-rata minimalnya agar sampai ke kampus tepat waktu untuk kuliah.

 Program menerima 5 input, yaitu jarak rumah Budi ke kampus, jam dan menit Budi berangkat, serta jam dan menit kuliah Budi dimulai.

 Output program adalah kecepatan rata-rata minimal perjalanan Budi agar Budi tidak terlambat kuliah.

 Simpan program dalam sebuah file dengan nama **Kuliah023.java** (nama class = **Kuliah023**)

 </Tab>
 <Tab title="Answer">
 ```java Kuliah023.java
 import java.util.Scanner;
 public class Kuliah023 {
 public static void main(String[] args) {
 Scanner input = new Scanner(System.in);
 
 System.out.print("Masukkan jarak rumah ke kampus (km): ");
 double jarak = input.nextDouble();

 System.out.print("\nMasukkan jam berangkat (0-23): ");
 int jamBerangkat = input.nextInt();
 System.out.print("Masukkan menit berangkat (0-59): ");
 int menitBerangkat = input.nextInt();

 System.out.print("\nMasukkan jam kuliah dimulai (0-23): ");
 int jamKuliah = input.nextInt();
 System.out.print("Masukkan menit kuliah dimulai (0-59): ");
 int menitKuliah = input.nextInt();

 int waktuBerangkat = jamBerangkat * 60 + menitBerangkat;
 int waktuKuliah = jamKuliah * 60 + menitKuliah;
 int waktuTempuh = waktuKuliah - waktuBerangkat;

 double kecepatan = jarak / (waktuTempuh / 60.0);
 System.out.printf("Kecepatan rata-rata minimal yang harus dicapai adalah %.2f km/jam.", kecepatan);
 }
 }
 ```

 </Tab>
</Tabs>

# Soal 5

<Tabs>
 <Tab title="Question">
 Zona Waktu

 ![Family](/images/pemrograman-1/uts/soal5.png)

 Zona Waktu Indonesia Tengah (WITA) satu jam lebih cepat daripada Waktu Indonesia Barat (WIB) dan 1 jam lebih lambat dari Waktu Indonesia Timur (WIT).

 Jadi jika di Bali yang berada pada zona WITA saat ini menunjukkan pukul 20:15, maka di Gresik yang termasuk zona WIB akan menunjukkan pukul 19:15 dan di Jayapura sudah pukul 21:15 WIT.

 Buatlah program yang menerima input berupa waktu di zona WITA (jam dan menit) kemudian menampilkan waktu di zona WIB dan WIT.

 Simpan program dalam sebuah file dengan nama **ZonaWaktu023.java** (nama class = **ZonaWaktu023**)

 **Contoh Input dan Output Sebagai Berikut**

 | Jarak Rumah-Kampus | Waktu Berangkat | Waktu Kuliah | Kecepatan Minimal (km/jam) |
 | ------------------ | --------------- | ------------ | -------------------------- |
 | 1 | 7:30 | 8:00 | 2 |
 | 1 | 7:45 | 8:00 | 4 |
 | 1 | 7:50 | 8:00 | 6 |
 | 5 | 7:30 | 8:00 | 10 |
 | 5 | 7:45 | 8:00 | 20 |
 | 5 | 7:50 | 8:00 | 30 |
 | 12 | 7:30 | 8:00 | 24 |
 | 12 | 7:45 | 8:00 | 48 |
 | 12 | 7:50 | 8:00 | 72 |

 </Tab>
 <Tab title="Answer">
 ```java ZonaWaktu023.java
 import java.util.Scanner;
 public class ZonaWaktu023 {
 public static void main(String[] args) {
 Scanner input = new Scanner(System.in);
 
 System.out.print("Masukkan jam di zona WITA (1-23): ");
 int jamWITA = input.nextInt();
 System.out.print("Masukkan menit di zona WITA (0-59): ");
 int menitWITA = input.nextInt();

 int jamWIB = 0;
 if (jamWITA == 1) {
 jamWIB = 23;
 } else {
 jamWIB = jamWITA - 1;
 }

 int jamWIT = 0;
 if (jamWITA == 23) {
 jamWIT = 1;
 } else {
 jamWIT = jamWITA + 1;
 }

 System.out.printf("Waktu di zona WIB adalah %02d:%02d\n", jamWIB, menitWITA);
 System.out.printf("Waktu di zona WIT adalah %02d:%02d\n", jamWIT, menitWITA);
 }
 }
 ```

 </Tab>
</Tabs>

# Soal 6

<Tabs>
 <Tab title="Question">
 2 Juli

 2 Juli adalah hari yang spesial.

 Buatlah program yang menerima input berupa digit bulan dan tanggal, kemudian menampilkan output apakah input tersebut sebelum 2 Juli, setelah 2 Juli, atau hari yang spesial ( 2 Juli).

 Simpan program dalam sebuah file dengan nama **TanggalSpesia1023.java** (nama class = **TanggalSpesia1023**)

 </Tab>
 <Tab title="Answer">
 ```java TanggalSpesia1023.java
 import java.util.Scanner;
 public class TanggalSpesia1023 {
 public static void main(String[] args) {
 Scanner input = new Scanner(System.in);
 
 System.out.print("Masukkan digit bulan (1-12): ");
 int bulan = input.nextInt();

 System.out.print("Masukkan digit tanggal (1-31): ");
 int tanggal = input.nextInt();

 if (bulan < 7 || (bulan == 7 && tanggal < 2)) {
 System.out.println("Sebelum 2 Juli");
 } else if (bulan > 7 || (bulan == 7 && tanggal > 2)) {
 System.out.println("Setelah 2 Juli");
 } else {
 System.out.println("Hari yang spesial");
 }
 }
 }
 ```

 </Tab>
</Tabs>

# Soal 7

<Tabs>
 <Tab title="Question">
 Sepak Bola

 ![Soal 7](/images/pemrograman-1/uts/soal7.png)

 Pada sebuah liga sepak bola, sebuah tim mendapat 3 poin Saat menang, 1 poin Saat pertandingan berakhir imbang (Seri), dan O poin Saat kalah.

 Pada tahun 2099, Liga Sepak Bola UIS' diikuti oleh 4 tim, yaitu **Arsenal, Barcelona, Chelsea**, dan **Dortmund**.

 Buatlah sebuah program yang meminta pengguna untuk memasukkan berapa kali masing-masing tim tersebut menang, Seri, dan kalah, menghitung dan menampilkan total poin masing-masing tim, dan menampilkan pemenang dari Liga UISI 2099.

 Simpan program dalam sebuah file dengan nama **Klasemen023.java** (nama class = **Klasemen023**)

 </Tab>
 <Tab title="Answer">
 ```java Klasemen023.java
 import java.util.Scanner;
 public class Klasemen023 {
 public static void main(String[] args) {
 Scanner input = new Scanner(System.in);
 
 System.out.println("Masukkan jumlah kemenangan, seri, dan kekalahan untuk setiap tim.");
 
 System.out.print("Arsenal\nKemenangan: ");
 int arsenalWin = input.nextInt();
 System.out.print("Seri: ");
 int arsenalDraw = input.nextInt();
 System.out.print("Kekalahan: ");
 int arsenalLose = input.nextInt();

 System.out.print("\nBarcelona\nKemenangan: ");
 int barcelonaWin = input.nextInt();
 System.out.print("Seri: ");
 int barcelonaDraw = input.nextInt();
 System.out.print("Kekalahan: ");
 int barcelonaLose = input.nextInt();

 System.out.print("\nChelsea\nKemenangan: ");
 int chelseaWin = input.nextInt();
 System.out.print("Seri: ");
 int chelseaDraw = input.nextInt();
 System.out.print("Kekalahan: ");
 int chelseaLose = input.nextInt();

 System.out.print("\nDortmund\nKemenangan: ");
 int dortmundWin = input.nextInt();
 System.out.print("Seri: ");
 int dortmundDraw = input.nextInt();
 System.out.print("Kekalahan: ");
 int dortmundLose = input.nextInt();

 int arsenalPoint = arsenalWin * 3 + arsenalDraw;
 int barcelonaPoint = barcelonaWin * 3 + barcelonaDraw;
 int chelseaPoint = chelseaWin * 3 + chelseaDraw;
 int dortmundPoint = dortmundWin * 3 + dortmundDraw;

 System.out.printf("\nArsenal: %d poin\n", arsenalPoint);
 System.out.printf("Barcelona: %d poin\n", barcelonaPoint);
 System.out.printf("Chelsea: %d poin\n", chelseaPoint);
 System.out.printf("Dortmund: %d poin\n", dortmundPoint);

 if (arsenalPoint > barcelonaPoint && arsenalPoint > chelseaPoint && arsenalPoint > dortmundPoint) {
 System.out.println("\nJuara: Arsenal");
 } else if (barcelonaPoint > chelseaPoint && barcelonaPoint > dortmundPoint) {
 System.out.println("\nJuara: Barcelona");
 } else if (chelseaPoint > dortmundPoint) {
 System.out.println("\nJuara: Chelsea");
 } else {
 System.out.println("\nJuara: Dortmund");
 }
 }
 }
 ```

 </Tab>
</Tabs>

# Soal 8

<Tabs>
 <Tab title="Question">
 nuhanuhanuha...

 Buatlah sebuah program menggunakan `loop` (perulangan) yang meminta pengguna untuk menampilkan $n$ karakter pertama dari String `nuhanuhanuha...` (kata `nuha` yang berulang terus menerus).

 **Contoh Input-Output**

 | Input (Banyak karakter) | Output |
 |--------------------------|--------|
 | 1 | n |
 | 3 | nuh |
 | 10 | nuhanuhanu |
 | 20 | nuhanuhanuhanuhanuha |
 | 37 | nuhanuhanuhanuhanuhanuhanuhanuhanuha |

 Simpan program dalam sebuah file dengan nama **Nuha023.java** (nama class = **Nuha023**)

 </Tab>
 <Tab title="Answer">
 ```java Nuha023.java
 import java.util.Scanner;
 public class Nuha023 {
 public static void main(String[] args) {
 Scanner input = new Scanner(System.in);
 
 System.out.print("Masukkan banyak karakter: ");
 int n = input.nextInt();

 String nuha = "nuha";
 for (int i = 0; i < n; i++) {
 System.out.print(nuha.charAt(i % 4));
 }
 System.out.println();
 }
 }
 ```

 </Tab>
</Tabs>

# Soal 9

<Tabs>
 <Tab title="Question">
 Voting

 ![Soal 9](/images/pemrograman-1/uts/soal9.jpg)

 Sebuah kelas terdiri atas $n$ orang siswa akan mengadakan voting untuk memilih ketua kelas.

 Ada 2 orang calon ketua kelas: Ani dan Budi.

 Masing-masing siswa (termasuk Ani dan Budi) menuliskan calon yang dipilihnya untuk menjadi ketua kelas.

 Untuk membantu proses pemilihan ketua kelas tersebut, buatlah sebuah program yang meminta pengguna untuk memasukkan banyak siswa di kelas tersebut ($n$).

 Program kemudian meminta masing-masing siswa (total sebanyak $n$ kali) untuk memasukkan calon pilihannya (Ani/Budi).

 Selanjutnya, program menghitung perolehan suara Ani dan Budi dan menampilkan pemenangnya.

 Simpan program dalam sebuah file dengan nama **Voting023.java** (nama class = **Voting023**)

 </Tab>
 <Tab title="Answer">
 ```java Voting023.java
 import java.util.Scanner;
 public class Voting023 {
 public static void main(String[] args) {
 Scanner input = new Scanner(System.in);
 
 String pemenang = "";
 System.out.print("Masukkan banyak siswa: ");
 int n = input.nextInt();

 int ani = 0, budi = 0;
 for (int i = 0; i < n; i++) {
 System.out.print("Siswa ke-" + (i + 1) + " memilih: ");
 String pilihan = input.next();

 if (pilihan.equalsIgnoreCase("ani")) {
 ani++;
 } else if (pilihan.equalsIgnoreCase("budi")) {
 budi++;
 }
 }

 if (ani > budi) {
 pemenang = "Ani";
 } else if (budi > ani) {
 pemenang = "Budi";
 } else {
 pemenang = "Tidak Ada (Seri)";
 }

 System.out.printf("\nAni = %d", ani);
 System.out.printf("\nBudi = %d", budi);
 System.out.printf("\nPemenang = %s", pemenang);
 }
 }
 ```

 </Tab>
</Tabs>

# Soal 10

<Tabs>
 <Tab title="Question">
 Descending

 ![Soal 10](/images/pemrograman-1/uts/soal10.jpg)

 Buatlah sebuah program yang meminta pengguna memasukkan 3 bilangan bułat berbeda.

 Program harus memastikan 3 bilangan yang dimasukkan pengguna berbeda satu sama lain.
 Jika ada input yang sama, program meminta pengguna untuk kembali memasukkan bilangan bułat tersebut hingga tidak ada input yang sama.

 Selanjutnya, program mengurutkan ketiga bilangan tersebut dari yang terbesar hingga terkecil dan menampilkan hasilnya

 Simpan program dalam sebuah file dengan nama **Urut023.java** (nama class = **Urut023**)

 </Tab>
 <Tab title="Answer">
 ```java Urut023.java
 import java.util.Scanner;
 public class Urut023 {
 public static void main(String[] args) {
 Scanner input = new Scanner(System.in);
 
 int a, b, c;
 System.out.print("Masukkan bilangan pertama: ");
 a = input.nextInt();

 System.out.print("Masukkan bilangan kedua: ");
 b = input.nextInt();

 while (b == a) {
 System.out.println("Bilangan kedua harus berbeda dengan bilangan pertama.");
 System.out.print("Masukkan bilangan kedua: ");
 b = input.nextInt();
 }

 System.out.print("Masukkan bilangan ketiga: ");
 c = input.nextInt();

 while (c == a || c == b) {
 System.out.println("Bilangan ketiga harus berbeda dengan bilangan pertama dan kedua.");
 System.out.print("Masukkan bilangan ketiga: ");
 c = input.nextInt();
 }

 int max = Math.max(a, Math.max(b, c));
 int min = Math.min(a, Math.min(b, c));
 int mid = a + b + c - max - min;

 System.out.printf("\nUrutan bilangan dari yang terbesar hingga terkecil: %d %d %d", max, mid, min);
 }
 }
 ```

 </Tab>
</Tabs>

# Soal 1 - Modified fibonacci Sequence

<Tabs>
 <Tab title="Question">
 Diketahui sebuah barisan fibonacci yang dimodifikasi sebagai berikut:

 $~~~~~~~~~~1, 1, 3, 5, 9, 15, 25, 41, ...$

 dimana
 - $f(n) = f(n-1)+f(n-2)+1$
 - $f(1) = 1$
 - $f(2) = 2$

 Buatlah sebuah program yang meminta input berupa satu buah bilangan bulat positif $n$. Program selanjutnya menampilkan $n$ suku pertama dari barisan tersebut.

 Simpan program tersebut dalam sebuah file dengan nama **OddFibonacci023.java** (nama class = **OddFibonacci023**)

 </Tab>
 <Tab title="Answer">
 ```java OddFibonacci023.java
 import java.util.Scanner;
 
 public class OddFibonacci023 {
 public static void main(String[] args) {
 Scanner input = new Scanner(System.in);

 System.out.print("Masukkan nilai n: ");
 int n = input.nextInt();

 for (int i = 1; i <= n; i++) {
 System.out.print(fibonacci(i) + " ");
 }
 }

 public static int fibonacci(int n) {
 if (n == 1 || n == 2) {
 return 1;
 } else {
 return fibonacci(n - 1) + fibonacci(n - 2) + 1;
 }
 }
 }
 ```

 </Tab>
</Tabs>

# Soal 2 - Largest Prime Factor

<Tabs>
 <Tab title="Question">
 Buatlah sebuah program yang meminta input berupa satu buah bilangan bulat postitif $n$. Program selanjutnya menampilkan faktor prima terbesar dari $n$.

 Simpan program tersebut dalam sebuah file dengan nama **LargestPrimeFactor023.java** (nama class = **LargestPrimeFactor023**)

 </Tab>
 <Tab title="Answer">
 ```java LargestPrimeFactor023.java
 import java.util.Scanner;

 public class LargestPrimeFactor023 {
 public static void main(String[] args) {
 Scanner input = new Scanner(System.in);

 System.out.print("Masukkan nilai n: ");
 int n = input.nextInt();

 factor(n);
 }

 public static void factor(int n) {
 int max = 0;
 for (int i = 1; i <= n; i++) {
 if (n % i == 0 && isPrime(i)) {
 max = Math.max(max, i);
 }
 }
 System.out.println("Faktor prima terbesar dari " + n + " adalah " + max);
 }

 public static boolean isPrime(int n) {
 for (int i = 2; i <= Math.sqrt(n); i++) {
 if (n % i == 0) {
 return false;
 }
 }
 return true;
 }
 }
 ```

 </Tab>
</Tabs>

# Soal 3 - Menabung

<Tabs>
 <Tab title="Question">
 ![Soal 3](/images/pemrograman-1/uas/soal3.png)
 *Budi ingin membeli barang diinginkannya, hanya saja uangnya tidak cukup. Untuk itu, dia mencoba menabung satiap hari hingga uangnya cukup untuk membeli barang tersebut. Bantulah Budi dalam merekap dan mengingatkan saat uangnya sudah cukup untuk membeli barang yang diinginkannya.*

 Buatlah sebuah program untuk membantu Budi.

 Program pertama-tama menanyakan barang apa yang Budi inginkan beserta harganya. Setelah itu, program secara berulang meminta Budi untuk memasukkan berapa uang yang ditabungnya pada hari tersebut (anggap 1 kali menabung/hari). Input berhenti saat uang Budi sudah cukup untuk membeli barang yang diinginkannya. Setelah itu program menampilkan berapa total tabungan Budi dan berapa hari waktu yang dibutuhkan Budi untuk menabung hingga tabungannya cukup untuk membeli barang impiannya.

 Simpan program tersebut dalam sebuah file dengan nama **Tabungan023.java** (nama class = **Tabungan023**)

 </Tab>
 <Tab title="Answer">
 ```java Tabungan023.java
 import java.util.Scanner;

 public class Tabungan023 {
 public static void main(String[] args) {
 Scanner input = new Scanner(System.in);

 System.out.print("Masukkan nama barang yang ingin dibeli: ");
 String barang = input.nextLine();
 System.out.print("Masukkan harga barang: ");
 int harga = input.nextInt();

 int total = 0;
 int hari = 0;
 while (total < harga) {
 System.out.print("Masukkan uang yang ditabung hari ini: ");
 int tabungan = input.nextInt();
 total += tabungan;
 hari++;
 }

 System.out.println("Total tabungan: " + total);
 System.out.println("Hari yang dibutuhkan: " + hari);
 }
 }
 ```

 </Tab>
</Tabs>

# Soal 4 - Persegi Nama

<Tabs>
 <Tab title="Question">
 ![Soal 4](/images/pemrograman-1/uas/soal4.png)
 Buatlah sebuah program yang meminta input berupa satu buah bilangan bulat positif $n$. Program selanjutnya menampilkan pola persegi dengan menggunakan karakter-karakter dari string `nuha` seperti contoh berikut:

 | Input (n) | Output |
 |-----------|--------|
 | 1 | n |
 | 2 | n u h a |
 | 3 | n u h a n u h a n |
 | 5 | n u h a n u h a n u h a n u h a n u h a n u h a n |
 | 10 | n u h a n u h a n u h a n u h a n u h a n u h a n u h a n u h a n u h a n u h a n u h a n u h a n u h a n u h a n u h a n u h a n u h a n u h a n u h a n u h a n u h a n u h a n u h a n u h a n u h a |

 Simpan program tersebut dalam sebuah file dengan nama **PersegiNama023.java** (nama class = **PersegiNama023**)

 </Tab>
 <Tab title="Answer">
 ```java PersegiNama023.java
 import java.util.Scanner;

 public class PersegiNama023 {
 public static void main(String[] args) {
 Scanner input = new Scanner(System.in);

 System.out.print("Masukkan nilai n: ");
 int n = input.nextInt();

 String nama = "nuha";
 int index = 0;
 for (int i = 0; i < n; i++) {
 for (int j = 0; j < n; j++) {
 System.out.print(nama.charAt(line % 4) + " ");
 }
 System.out.println();
 }
 }
 }
 ```

 </Tab>
 <Tab title="Answer Array">
 ```java PersegiNama023.java
 import java.util.Scanner;

 public class PersegiNama023 {
 public static void main(String[] args) {
 Scanner input = new Scanner(System.in);

 System.out.print("Masukkan nilai n: ");
 int n = input.nextInt();

 String[] nama = {"n", "u", "h", "a"};
 int index = 0;
 for (int i = 0; i < n; i++) {
 for (int j = 0; j < n; j++) {
 System.out.print(nama[index] + " ");
 index = (index + 1) % 4;
 }
 System.out.println();
 }
 }
 }
 ```

 </Tab>
</Tabs>

# Soal 5 - Segitiga Nama

<Tabs>
 <Tab title="Question">
 ![Soal 5](/images/pemrograman-1/uas/soal5.png)
 Buatlah sebuah program yang meminta input berupa satu buah bilangan bulat positif $n$. Program selanjutnya menampilkan pola segitiga dengan menggunakan karakter-karakter dari string `nuha` seperti contoh berikut:

 | Input (n) | Output |
 |-----------|--------|
 | 1 | n |
 | 2 | n n u |
 | 3 | n n u n u h |
 | 5 | n n u n u h n u h a n u h a n |
 | 10 | n n u n u h n u h a n u h a n n u h a n u n u h a n u h n u h a n u h a n u h a n u h a n n u h a n u h a n u |

 Simpan program tersebut dalam sebuah file dengan nama **SegitigaNama023.java** (nama class = **SegitigaNama023**)

 </Tab>
 <Tab title="Answer">
 ```java SegitigaNama023.java
 import java.util.Scanner;

 public class SegitigaNama023 {
 public static void main(String[] args) {
 Scanner input = new Scanner(System.in);

 System.out.print("Masukkan nilai n: ");
 int n = input.nextInt();

 String nama = "nuha";
 for (int i = 0; i < n; i++) {
 for (int j = 0; j <= i; j++) {
 System.out.print(nama.charAt(j % 4) + " ");
 }
 System.out.println();
 }
 }
 }
 ```

 </Tab>
 <Tab title="Answer Array">
 ```java SegitigaNama023.java
 import java.util.Scanner;

 public class SegitigaNama023 {
 public static void main(String[] args) {
 Scanner input = new Scanner(System.in);

 System.out.print("Masukkan nilai n: ");
 int n = input.nextInt();

 String[] nama = {"n", "u", "h", "a"};
 for (int i = 0; i < n; i++) {
 for (int j = 0; j <= i; j++) {
 System.out.print(nama[j % 4] + " ");
 }
 System.out.println();
 }
 }
 }
 ```

 </Tab>
</Tabs>

# Soal 6 - Unique Elements

<Tabs>
 <Tab title="Question">
 Buatlah sebuah program yang menampilkan elemen-elemen unik dari daftar bilangan yang dimasukkan oleh pengguna. Program pertama-tama meminta pengguna untuk memasukkan $n$, banyak bilangan yang akan dimasukkan. Kemudian, program meminta pengguna untuk memasukkan $n$ buah bilangan bulat. Setelah itu, program menampilkan elemen-elemen unik dari daftar bilangan tersebut. Elemen-elemen unik adalah bilangan-bilangan yang hanya muncul sekali dalam daftar bilangan tersebut.

 Simpan program tersebut dalam sebuah file dengan nama **UniqueElement023.java** (nama class = **UniqueElement023**)

 </Tab>
 <Tab title="Answer">
 ```java UniqueElement023.java
 import java.util.Scanner;

 public class UniqueElement023 {
 public static void main(String[] args) {
 Scanner input = new Scanner(System.in);

 System.out.print("Masukkan nilai n: ");
 int n = input.nextInt();

 int[] data = new int[n];
 for (int i = 0; i < n; i++) {
 			System.out.print("Masukkan bilangan ke-" + (i + 1) + ": ");
 			data[i] = input.nextInt();
 			System.out.println();
 }
 uniqueElement(data);
 	}

 	public static void uniqueElement(int[] data) {
 		for (int i = 0; i < data.length; i++) {
 			boolean unique = true;
 			for (int j = 0; j < data.length; j++) {
 				if (i != j && data[i] == data[j]) {
 					unique = false;
 					break;
 				}
 			}
 			if (unique) {
 				System.out.println("Bilangan unik: " + data[i]);
 			}
 		}
 	}
 }
 ```

 </Tab>
</Tabs>

# Soal 7 - Banyak Hari

<Tabs>
 <Tab title="Question">
 	Diberikan potongan kode program berikut:

 ```java KalkulatorBanyakHari023.java
 public class KalkulatorBanyakHari023 {
 	public static void main(String[] args) {
 		System.out.println("Banyak hari pada bulan Februari 2024 adalah: " + banyakHari(2024, 2));
 		System.out.println("Banyak hari pada bulan Februari 2025 adalah: " + banyakHari(2025, 2));
 		System.out.println("Banyak hari pada bulan Maret 2024 adalah: " + banyakHari(2024, 3));
 		System.out.println("Banyak hari pada bulan Juni 2024 adalah: " + banyakHari(2024, 6));
 	}
 }
 ```

 Kode di atas belum lengkap sehingga tidak dapat dicompile dan dijalankan.

 Implementasikan method yang dibutuhkan untuk memperbaiki kode program di atas. Anda **TIDAK DIPERBOLEHKAN** mengubah isi dari method `main`.

 Simpan program tersebut dalam sebuah file dengan nama **KalkulatorBanyakHari023.java** (nama class = **KalkulatorBanyakHari023**)

 </Tab>
 <Tab title="Answer">
 ```java KalkulatorBanyakHari023.java
 import java.util.Scanner;

 public class KalkulatorBanyakHari023 {
 public static void main(String[] args) {
 		System.out.println("Banyak hari pada bulan Februari 2024 adalah: " + banyakHari(2024, 2));
 		System.out.println("Banyak hari pada bulan Februari 2025 adalah: " + banyakHari(2025, 2));
 		System.out.println("Banyak hari pada bulan Maret 2024 adalah: " + banyakHari(2024, 3));
 		System.out.println("Banyak hari pada bulan Juni 2024 adalah: " + banyakHari(2024, 6));
 	}

 	public static int banyakHari(int tahun, int bulan) {
 		int hari = 0;
 		switch (bulan) {
 			case 1:
 			case 3:
 			case 5:
 			case 7:
 			case 8:
 			case 10:
 			case 12:
 				hari = 31;
 				break;
 			case 4:
 			case 6:
 			case 9:
 			case 11:
 				hari = 30;
 				break;
 			case 2:
 				if (tahun % 4 == 0 && (tahun % 100 != 0 || tahun % 400 == 0)) {
 					hari = 29;
 				} else {
 					hari = 28;
 				}
 				break;
 		}
 		return hari;
 	}
 }
 ```

 </Tab>
</Tabs>

# Soal 8 - 8

<Tabs>
 <Tab title="Question">
 	Faktor-faktor dari 24 ada 8, yaitu 1, 2, 3, 4, 6, 8, 12, 24. Bilangan lain yang banyak faktornya 8 antara lain 30, 40, 42, ...

 Buat sebuah program untuk menampilkan semua bilangan antara 1 sampai 1.000.000.000 yang banyak faktornya 8.

 Simpan program tersebut dalam sebuah file dengan nama **Delapan023.java** (nama class = **Delapan023**)

 </Tab>
 <Tab title="Answer">
 ```java Delapan023.java
 public class Delapan023 {
		public static void main(String[] args) {
			for (int i = 1; i <= 1_000_000_000; i++) {
				if (faktor(i) == 8) {
					System.out.println(i);
				}
			}
		}

 	public static int faktor(int n) {
 		int count = 0;
 		for (int i = 1; i <= n; i++) {
 			if (n % i == 0) {
 				count++;
 			}
 		}
 		return count;
 	}
 }
 ```

 </Tab>
</Tabs>

# Soal 9 - Magic Square Validator

<Tabs>
 <Tab title="Question">
 	Magic Square adalah sebuah matriks persegi yang isinya bilangan bulat positif tanpa ada bilangan yang sama. Bilangan-bilangan tersebut harus memenuhi syarat bahwa jumlah bilangan pada setiap baris, kolom, dan diagonal harus sama.

 Diberikan potongan kode program berikut:

 ```java MagicSquareValidator023.java
 public class MagicSquareValidator023 {
 	public static void main(String[] args) {
 		int[][] square1 = {
 			{4, 9, 2},
 			{3, 5, 7},
 			{8, 1, 6}
 		};

 		int[][] square2 = {
 			{4, 9, 2},
 			{3, 5, 6},
 			{8, 1, 7}
 		};

 		int[][] square3 = {
 			{8, 11, 14, 1},
 			{13, 2, 7, 12},
 			{3, 16, 9, 6},
 			{10, 5, 4, 15}
 		};

 		System.out.println("Is square1 a valid magic square? " + validate(square1)); // should be true
 		System.out.println("Is square2 a valid magic square? " + validate(square2)); // should be false
 		System.out.println("Is square3 a valid magic square? " + validate(square3)); // should be true
 	}
 }
 ```

 Simpan program tersebut dalam sebuah file dengan nama **MagicSquareValidator023.java** (nama class = **MagicSquareValidator023**)

 </Tab>
 <Tab title="Answer">
 ```java MagicSquareValidator023.java
 public class MagicSquareValidator023 {
		public static void main(String[] args) {
			int[][] square1 = {
				{4, 9, 2},
				{3, 5, 7},
				{8, 1, 6}
			};

 		int[][] square2 = {
 			{4, 9, 2},
 			{3, 5, 6},
 			{8, 1, 7}
 		};

 		int[][] square3 = {
 			{8, 11, 14, 1},
 			{13, 2, 7, 12},
 			{3, 16, 9, 6},
 			{10, 5, 4, 15}
 		};

 		System.out.println("Is square1 a valid magic square? " + validate(square1)); // should be true
 		System.out.println("Is square2 a valid magic square? " + validate(square2)); // should be false
 		System.out.println("Is square3 a valid magic square? " + validate(square3)); // should be true
 	}

 	public static boolean validate(int[][] square) {
 		int n = square.length;
 		int sum = 0;
 		for (int i = 0; i < n; i++) {
 			sum += square[0][i];
 		}

 		for (int i = 1; i < n; i++) {
 			int temp = 0;
 			for (int j = 0; j < n; j++) {
 				temp += square[i][j];
 			}
 			if (temp != sum) {
 				return false;
 			}
 		}

 		for (int i = 0; i < n; i++) {
 			int temp = 0;
 			for (int j = 0; j < n; j++) {
 				temp += square[j][i];
 			}
 			if (temp != sum) {
 				return false;
 			}
 		}

 		int temp = 0;
 		for (int i = 0; i < n; i++) {
 			temp += square[i][i];
 		}
 		if (temp != sum) {
 			return false;
 		}

 		temp = 0;
 		for (int i = 0; i < n; i++) {
 			temp += square[i][n - i - 1];
 		}
 		if (temp != sum) {
 			return false;
 		}

 		return true;
 	}
 }
 ```

 </Tab>
</Tabs>

# Soal 10 - Teman yang Sama

<Tabs>
 <Tab title="Question">
 	![Soal 10](/images/pemrograman-1/uas/soal10.png)

 *Ani memiliki $m$ orang teman, sedangkan Budi memiliki $n$ orang teman.*

 *Carilah teman Ani yang juga merupakan teman Budi.*

 Buatlah sebuah program yang meminta input sebagai berikut:
 - banyak teman Ani ($m$)
 - nama masing-masing teman Ani ($m$ nama berbeda)
 - banyak teman Budi ($n$)
 - nama masing-masing teman Budi ($n$ nama berbeda)

 Program selanjutnya menampilkan nama-nama teman Ani yang juga merupakan teman dari Budi. Jika tidak ada, program menampilkan pesan bahwa Ani dan Budi tidak memiliki teman yang sama.

 **Contoh Input/Output**

 | Banyak Teman Ani | Nama Teman Ani | Banyak Teman Budi | Nama Teman Budi | Teman Ani yang juga Teman Budi |
 |------------------|----------------|-------------------|-----------------|---------------------------------|
 | 1				 | Deni | 1 | Chandra | Ani dan Budi tidak memiliki teman yang sama |
 | 2 			 | Chandra Deni | 3 | Chandra Deni Edi | Chandra Deni |
 | 3 			 | Chandra Deni Edi | 2 | Chandra Edi | Chandra Edi |

 Simpan program tersebut dalam sebuah file dengan nama **Teman023.java** (nama class = **Teman023**)

 </Tab>
 <Tab title="Answer">
 ```java Teman023.java
 import java.util.Scanner;

 public class Teman023 {
 	public static void main(String[] args) {
 		Scanner input = new Scanner(System.in);

 		System.out.print("Masukkan banyak teman Ani: ");
 		int m = input.nextInt();
 		String[] temanAni = new String[m];
 		for (int i = 0; i < m; i++) {
 			System.out.print("Masukkan nama teman Ani ke-" + (i + 1) + ": ");
 			temanAni[i] = input.next();
 		}

 		System.out.print("Masukkan banyak teman Budi: ");
 		int n = input.nextInt();
 		String[] temanBudi = new String[n];
 		for (int i = 0; i < n; i++) {
 			System.out.print("Masukkan nama teman Budi ke-" + (i + 1) + ": ");
 			temanBudi[i] = input.next();
 		}

 		boolean sama = false;
 		for (int i = 0; i < m; i++) {
 			for (int j = 0; j < n; j++) {
 				if (temanAni[i].equals(temanBudi[j])) {
 					System.out.println(temanAni[i]);
 					sama = true;
 				}
 			}
 		}

 		if (!sama) {
 			System.out.println("Ani dan Budi tidak memiliki teman yang sama");
 		}
 	}
 }
 ```

 </Tab>
</Tabs>