int a = 17, b = 5;

System.out.println(a + b);   // 22  — addition
System.out.println(a - b);   // 12  — subtraction
System.out.println(a * b);   // 85  — multiplication
System.out.println(a / b);   // 3   — INTEGER division (truncated!)
System.out.println(a % b);   // 2   — modulus (remainder: 17 = 5×3 + 2)

// Result type follows the "larger" operand type:
System.out.println(10 + 3.5);  // 13.5 (double — int widened)
System.out.println(7 + 3);     // 10   (int)
System.out.println(7.0 + 3);   // 10.0 (double)

// int / int = int  (decimal silently dropped)
System.out.println(7 / 2);      // 3  (NOT 3.5!)
System.out.println(1 / 4);      // 0  (NOT 0.25!)
System.out.println(9 / 10);     // 0  (NOT 0.9!)

// FIX 1: make one operand a double literal
System.out.println(7.0 / 2);    // 3.5 ✓
System.out.println(7 / 2.0);    // 3.5 ✓

// FIX 2: cast one operand to double
int x = 7, y = 2;
double result = (double) x / y;  // 3.5 ✓  — cast BEFORE dividing
double wrong  = (double)(x / y); // 3.0 ✗  — divides first, THEN casts!

System.out.println(17 % 5);   // 2  (17 = 5×3 + 2)
System.out.println(10 % 3);   // 1  (10 = 3×3 + 1)
System.out.println(8  % 4);   // 0  (8 = 4×2 + 0, exactly divisible)
System.out.println(3  % 7);   // 3  (3 < 7, so remainder IS 3)

// Real-world uses of %:
int n = 42;
boolean isEven = (n % 2 == 0);     // true — even/odd check
int lastDigit = n % 10;             // 2 — extract last digit
int secondLastDigit = (n / 10) % 10; // 4 — extract 2nd last digit

// Cycling / wrapping around (e.g., 7 days of week):
int day = 9;
int dayOfWeek = day % 7;  // 2 (day 9 → day 2 in the week cycle)

// Negative modulus (Java keeps sign of dividend):
System.out.println(-7 % 3);  // -1 (not 2!) — sign follows -7
System.out.println(7 % -3);  // 1  — sign follows 7

int a = 10, b = 20;

System.out.println(a == b);  // false — equal to (NOTE: == not =)
System.out.println(a != b);  // true  — not equal to
System.out.println(a >  b);  // false — greater than
System.out.println(a <  b);  // true  — less than
System.out.println(a >= b);  // false — greater than or equal
System.out.println(a <= b);  // true  — less than or equal
System.out.println(a == 10); // true  — a equals 10

// Store result in boolean variable:
boolean isAdult = (a >= 18);  // false (10 is not >= 18)
boolean passed  = (a > 5);    // true  (10 > 5)

boolean p = true, q = false;

// && (AND) — BOTH must be true
System.out.println(p && q);   // false (true AND false = false)
System.out.println(p && p);   // true  (true AND true  = true)

// || (OR) — AT LEAST ONE must be true
System.out.println(p || q);   // true  (true OR false = true)
System.out.println(q || q);   // false (false OR false = false)

// ! (NOT) — reverses the boolean
System.out.println(!p);       // false (!true = false)
System.out.println(!q);       // true  (!false = true)

// Real-world combined conditions:
int age = 25;
double income = 40000;
boolean loanEligible = (age >= 18) && (income >= 30000);  // true

int marks = 75;
boolean distinction = (marks >= 80) || (marks == 75);  // true (second part)

boolean notPassed = !(marks >= 50);  // false (marks IS >= 50)

// && SHORT-CIRCUIT: if LEFT is FALSE, RIGHT is NEVER evaluated
int n = 0;
if (n != 0 && 10/n > 1) {  // SAFE! 10/n never runs (n != 0 is false)
    System.out.println("safe");
}
// Without short-circuit: 10/0 would throw ArithmeticException

// || SHORT-CIRCUIT: if LEFT is TRUE, RIGHT is NEVER evaluated
int x = 5;
if (x > 0 || ++x > 0) {  // x > 0 is TRUE, so ++x is NEVER executed
    System.out.println(x);  // prints 5, NOT 6!
}

// Non-short-circuit versions: & and | (evaluate BOTH sides always)
if (n != 0 & 10/n > 1) { }  // DANGEROUS — evaluates both, throws exception

int x = 10;   // simple assignment: x = 10

// Compound assignment operators:
x += 5;    // x = x + 5  → x = 15
x -= 3;    // x = x - 3  → x = 12
x *= 2;    // x = x * 2  → x = 24
x /= 4;    // x = x / 4  → x = 6
x %= 4;    // x = x % 4  → x = 2

// Also works for strings:
String s = "Hello";
s += " World";  // s = "Hello World"

// Chained assignment (right to left):
int a, b, c;
a = b = c = 5;  // c=5 first, then b=5, then a=5 — all equal 5

// Compound with implicit narrowing cast:
byte byt = 10;
byt += 5;    // ✓ implicit cast: equivalent to byt = (byte)(byt + 5)
// byt = byt + 5  would cause error (int result, needs explicit cast)

int x = 5;

// Unary plus and minus:
int pos = +x;   // +5 — no change (unary plus rarely used)
int neg = -x;   // -5 — negates the value

// Logical NOT:
boolean t = true;
boolean f = !t;  // false

// Standalone — pre and post produce IDENTICAL results:
int a = 5;
a++;    // a = 6 (post-increment standalone)
++a;    // a = 7 (pre-increment standalone)
a--;    // a = 6 (post-decrement)
--a;    // a = 5 (pre-decrement)

// In an expression — CRITICAL DIFFERENCE:
int x = 5;
int y = x++;  // POST: y gets old value (5), then x increments → y=5, x=6

int p = 5;
int q = ++p;  // PRE: p increments first (6), then q gets new value → q=6, p=6

// Tricky example frequently in exams:
int a2 = 5;
System.out.println(a2++);  // prints 5 (old value), then a2 becomes 6
System.out.println(a2);    // prints 6
System.out.println(++a2);  // a2 becomes 7 first, then prints 7
System.out.println(a2);    // prints 7

// Complex expression (exam trap!):
int n = 5;
int result = n++ + ++n;
// Step 1: n++ uses 5 (old n), n becomes 6
// Step 2: ++n increments 6 to 7, uses 7
// result = 5 + 7 = 12,  n = 7

// 5 = 0101,  3 = 0011
System.out.println(5 & 3);   // 1  (0101 & 0011 = 0001)
System.out.println(5 | 3);   // 7  (0101 | 0011 = 0111)
System.out.println(5 ^ 3);   // 6  (0101 ^ 0011 = 0110)
System.out.println(~5);      // -6 (flip all bits of 5)

// Bit shifting (fast multiply/divide by powers of 2):
System.out.println(5 << 1);  // 10  (5 × 2¹)
System.out.println(5 << 2);  // 20  (5 × 2²)
System.out.println(20 >> 2); // 5   (20 ÷ 2²)

// Practical use: check if number is even (fast even/odd):
int n = 42;
boolean isEven = (n & 1) == 0;  // true — faster than n%2==0

// Basic ternary:
int a = 10, b = 20;
int max = (a > b) ? a : b;      // max = 20
int min = (a < b) ? a : b;      // min = 10
String result = (a % 2 == 0) ? "Even" : "Odd";  // "Even"

// Equivalent if-else:
int max2;
if (a > b) { max2 = a; } else { max2 = b; }

// Ternary inside println:
System.out.println("Pass or Fail: " + (a > 50 ? "Pass" : "Fail"));

// Nested ternary (use sparingly — hurts readability):
int score = 75;
String grade = score >= 90 ? "A"
              : score >= 80 ? "B"
              : score >= 70 ? "C"
              : "F";
System.out.println(grade);  // "C"

// Max of three numbers using nested ternary:
int x = 5, y = 9, z = 3;
int maxThree = (x > y) ? ((x > z) ? x : z) : ((y > z) ? y : z);
// maxThree = 9

// String + anything = String (left to right evaluation)
System.out.println("Hello" + " World");  // "Hello World"
System.out.println("Age: " + 20);        // "Age: 20" (int→String)
System.out.println("Pi: " + 3.14);      // "Pi: 3.14"

// TRICKY: + is evaluated LEFT TO RIGHT
System.out.println(1 + 2 + "3");   // "33"  (1+2=3, then "3"+"3"="33")
System.out.println("1" + 2 + 3);   // "123" ("1"+2="12", "12"+3="123")
System.out.println(1 + 2 + 3);    // 6     (all ints: 1+2+3=6)

// Use () to force desired evaluation order:
System.out.println("Sum: " + (1 + 2 + 3));  // "Sum: 6" (brackets first)

// Char concatenation — VERY tricky:
System.out.println('A' + 'B');    // 131  (char + char = int! 65+66)
System.out.println("" + 'A' + 'B'); // "AB"  (empty String forces concatenation)

// Example 1:
int r = 2 + 3 * 4 - 8 / 2;
// Step 1: * and / (same level, left to right): 3*4=12, 8/2=4
// Step 2: + and - (left to right): 2+12=14, 14-4=10
// r = 10

// Example 2:
boolean b = 5 + 3 > 6 && 10 - 4 == 6;
// Step 1: + and -: 5+3=8, 10-4=6
// Step 2: > and ==: 8>6 is true, 6==6 is true
// Step 3: &&: true && true = true
// b = true

// Example 3:
int x = 5;
int r2 = x++ * 2 + ++x;
// Step 1: x++ uses 5 (post), x becomes 6
// Step 2: 5 * 2 = 10
// Step 3: ++x increments 6 to 7, uses 7
// Step 4: 10 + 7 = 17
// r2 = 17, x = 7

// Example 4 — mixing + and String:
System.out.println(2 + 3 + " apples");   // "5 apples"
System.out.println("apples: " + 2 + 3); // "apples: 23" (NOT "apples: 5"!)
System.out.println("sum: " + (2+3));    // "sum: 5" (brackets force addition first)