Added tasks 3270-3277

Author: javadev

src/main/java/g3201_3300/s3270_find_the_key_of_the_numbers/Solution.java

@@ -0,0 +1,18 @@
+package g3201_3300.s3270_find_the_key_of_the_numbers;
+
+// #Easy #2024_09_02_Time_0_ms_(100.00%)_Space_40.5_MB_(100.00%)
+
+public class Solution {
+    public int generateKey(int num1, int num2, int num3) {
+        int s1 =
+                Math.min(((num1 / 1000) % 10), Math.min(((num2 / 1000) % 10), ((num3 / 1000) % 10)))
+                        * 1000;
+        int s2 =
+                Math.min(((num1 / 100) % 10), Math.min(((num2 / 100) % 10), ((num3 / 100) % 10)))
+                        * 100;
+        int s3 =
+                Math.min(((num1 / 10) % 10), Math.min(((num2 / 10) % 10), ((num3 / 10) % 10))) * 10;
+        int s4 = Math.min((num1 % 10), Math.min((num2 % 10), (num3 % 10)));
+        return s1 + s2 + s3 + s4;
+    }
+}

src/main/java/g3201_3300/s3270_find_the_key_of_the_numbers/readme.md

@@ -0,0 +1,45 @@
+3270\. Find the Key of the Numbers
+
+Easy
+
+You are given three **positive** integers `num1`, `num2`, and `num3`.
+
+The `key` of `num1`, `num2`, and `num3` is defined as a four-digit number such that:
+
+*   Initially, if any number has **less than** four digits, it is padded with **leading zeros**.
+*   The <code>i<sup>th</sup></code> digit (`1 <= i <= 4`) of the `key` is generated by taking the **smallest** digit among the <code>i<sup>th</sup></code> digits of `num1`, `num2`, and `num3`.
+
+Return the `key` of the three numbers **without** leading zeros (_if any_).
+
+**Example 1:**
+
+**Input:** num1 = 1, num2 = 10, num3 = 1000
+
+**Output:** 0
+
+**Explanation:**
+
+On padding, `num1` becomes `"0001"`, `num2` becomes `"0010"`, and `num3` remains `"1000"`.
+
+*   The <code>1<sup>st</sup></code> digit of the `key` is `min(0, 0, 1)`.
+*   The <code>2<sup>nd</sup></code> digit of the `key` is `min(0, 0, 0)`.
+*   The <code>3<sup>rd</sup></code> digit of the `key` is `min(0, 1, 0)`.
+*   The <code>4<sup>th</sup></code> digit of the `key` is `min(1, 0, 0)`.
+
+Hence, the `key` is `"0000"`, i.e. 0.
+
+**Example 2:**
+
+**Input:** num1 = 987, num2 = 879, num3 = 798
+
+**Output:** 777
+
+**Example 3:**
+
+**Input:** num1 = 1, num2 = 2, num3 = 3
+
+**Output:** 1
+
+**Constraints:**
+
+*   `1 <= num1, num2, num3 <= 9999`

src/main/java/g3201_3300/s3271_hash_divided_string/Solution.java

@@ -0,0 +1,17 @@
+package g3201_3300.s3271_hash_divided_string;
+
+// #Medium #2024_09_02_Time_2_ms_(100.00%)_Space_44.7_MB_(100.00%)
+
+public class Solution {
+    public String stringHash(String s, int k) {
+        var result = new StringBuilder();
+        for (int i = 0, sum = 0; i < s.length(); i++) {
+            sum += s.charAt(i) - 'a';
+            if ((i + 1) % k == 0) {
+                result.append((char) ('a' + sum % 26));
+                sum = 0;
+            }
+        }
+        return result.toString();
+    }
+}

src/main/java/g3201_3300/s3271_hash_divided_string/readme.md

@@ -0,0 +1,46 @@
+3271\. Hash Divided String
+
+Medium
+
+You are given a string `s` of length `n` and an integer `k`, where `n` is a **multiple** of `k`. Your task is to hash the string `s` into a new string called `result`, which has a length of `n / k`.
+
+First, divide `s` into `n / k` **substrings**, each with a length of `k`. Then, initialize `result` as an **empty** string.
+
+For each **substring** in order from the beginning:
+
+*   The **hash value** of a character is the index of that character in the **English alphabet** (e.g., `'a' → 0`, `'b' → 1`, ..., `'z' → 25`).
+*   Calculate the _sum_ of all the **hash values** of the characters in the substring.
+*   Find the remainder of this sum when divided by 26, which is called `hashedChar`.
+*   Identify the character in the English lowercase alphabet that corresponds to `hashedChar`.
+*   Append that character to the end of `result`.
+
+Return `result`.
+
+**Example 1:**
+
+**Input:** s = "abcd", k = 2
+
+**Output:** "bf"
+
+**Explanation:**
+
+First substring: `"ab"`, `0 + 1 = 1`, `1 % 26 = 1`, `result[0] = 'b'`.
+
+Second substring: `"cd"`, `2 + 3 = 5`, `5 % 26 = 5`, `result[1] = 'f'`.
+
+**Example 2:**
+
+**Input:** s = "mxz", k = 3
+
+**Output:** "i"
+
+**Explanation:**
+
+The only substring: `"mxz"`, `12 + 23 + 25 = 60`, `60 % 26 = 8`, `result[0] = 'i'`.
+
+**Constraints:**
+
+*   `1 <= k <= 100`
+*   `k <= s.length <= 1000`
+*   `s.length` is divisible by `k`.
+*   `s` consists only of lowercase English letters.

src/main/java/g3201_3300/s3272_find_the_count_of_good_integers/Solution.java

@@ -0,0 +1,107 @@
+package g3201_3300.s3272_find_the_count_of_good_integers;
+
+// #Hard #2024_09_02_Time_167_ms_(100.00%)_Space_54.5_MB_(100.00%)
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+public class Solution {
+    private List<String> palindromes = new ArrayList<>();
+
+    private long factorial(int n) {
+        long res = 1;
+        for (int i = 2; i <= n; i++) {
+            res *= i;
+        }
+        return res;
+    }
+
+    private Map<Character, Integer> countDigits(String s) {
+        Map<Character, Integer> freq = new HashMap<>();
+        for (char c : s.toCharArray()) {
+            freq.put(c, freq.getOrDefault(c, 0) + 1);
+        }
+        return freq;
+    }
+
+    private long calculatePermutations(Map<Character, Integer> freq, int length) {
+        long totalPermutations = factorial(length);
+        for (int count : freq.values()) {
+            totalPermutations /= factorial(count);
+        }
+        return totalPermutations;
+    }
+
+    private long calculateValidPermutations(String s) {
+        Map<Character, Integer> freq = countDigits(s);
+        int n = s.length();
+        long totalPermutations = calculatePermutations(freq, n);
+        if (freq.getOrDefault('0', 0) > 0) {
+            freq.put('0', freq.get('0') - 1);
+            long invalidPermutations = calculatePermutations(freq, n - 1);
+            totalPermutations -= invalidPermutations;
+        }
+
+        return totalPermutations;
+    }
+
+    private void generatePalindromes(
+            int f, int r, int k, int lb, int sum, StringBuilder ans, int[] rem) {
+        if (f > r) {
+            if (sum == 0) {
+                palindromes.add(ans.toString());
+            }
+            return;
+        }
+        for (int i = lb; i <= 9; i++) {
+            ans.setCharAt(f, (char) ('0' + i));
+            ans.setCharAt(r, (char) ('0' + i));
+            int chk = sum;
+            chk = (chk + rem[f] * i) % k;
+            if (f != r) {
+                chk = (chk + rem[r] * i) % k;
+            }
+            generatePalindromes(f + 1, r - 1, k, 0, chk, ans, rem);
+        }
+    }
+
+    private List<String> allKPalindromes(int n, int k) {
+        StringBuilder ans = new StringBuilder(n);
+        for (int i = 0; i < n; i++) {
+            ans.append('0');
+        }
+        int[] rem = new int[n];
+        rem[0] = 1;
+        for (int i = 1; i < n; i++) {
+            rem[i] = (rem[i - 1] * 10) % k;
+        }
+
+        palindromes.clear();
+        generatePalindromes(0, n - 1, k, 1, 0, ans, rem);
+
+        return palindromes;
+    }
+
+    public long countGoodIntegers(int n, int k) {
+        List<String> ans = allKPalindromes(n, k);
+        Set<String> st = new HashSet<>();
+        for (String str : ans) {
+            char[] arr = str.toCharArray();
+            Arrays.sort(arr);
+            st.add(new String(arr));
+        }
+
+        List<String> v = new ArrayList<>(st);
+        long chk = 0;
+        for (String str : v) {
+            long cc = calculateValidPermutations(str);
+            chk += cc;
+        }
+        return chk;
+    }
+}

src/main/java/g3201_3300/s3272_find_the_count_of_good_integers/readme.md

@@ -0,0 +1,50 @@
+3272\. Find the Count of Good Integers
+
+Hard
+
+You are given two **positive** integers `n` and `k`.
+
+An integer `x` is called **k-palindromic** if:
+
+*   `x` is a palindrome.
+*   `x` is divisible by `k`.
+
+An integer is called **good** if its digits can be _rearranged_ to form a **k-palindromic** integer. For example, for `k = 2`, 2020 can be rearranged to form the _k-palindromic_ integer 2002, whereas 1010 cannot be rearranged to form a _k-palindromic_ integer.
+
+Return the count of **good** integers containing `n` digits.
+
+**Note** that _any_ integer must **not** have leading zeros, **neither** before **nor** after rearrangement. For example, 1010 _cannot_ be rearranged to form 101.
+
+**Example 1:**
+
+**Input:** n = 3, k = 5
+
+**Output:** 27
+
+**Explanation:**
+
+_Some_ of the good integers are:
+
+*   551 because it can be rearranged to form 515.
+*   525 because it is already k-palindromic.
+
+**Example 2:**
+
+**Input:** n = 1, k = 4
+
+**Output:** 2
+
+**Explanation:**
+
+The two good integers are 4 and 8.
+
+**Example 3:**
+
+**Input:** n = 5, k = 6
+
+**Output:** 2468
+
+**Constraints:**
+
+*   `1 <= n <= 10`
+*   `1 <= k <= 9`

src/main/java/g3201_3300/s3273_minimum_amount_of_damage_dealt_to_bob/Solution.java

@@ -0,0 +1,51 @@
+package g3201_3300.s3273_minimum_amount_of_damage_dealt_to_bob;
+
+// #Hard #2024_09_02_Time_221_ms_(100.00%)_Space_59.9_MB_(100.00%)
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+public class Solution {
+    int total;
+    int power;
+
+    private class Pair implements Comparable<Pair> {
+        int health;
+        int damage;
+
+        Pair(int health, int damage) {
+            this.health = health;
+            this.damage = damage;
+        }
+
+        @Override
+        public int compareTo(Pair p) {
+
+            int thisHits = (int) Math.ceil((double) this.health / power);
+            int otherHits = (int) Math.ceil((double) p.health / power);
+
+            double thisTotalDamage = this.damage * 1.0 / thisHits;
+            double otherTotalDamage = p.damage * 1.0 / otherHits;
+
+            return Double.compare(otherTotalDamage, thisTotalDamage);
+        }
+    }
+
+    public long minDamage(int power, int[] damage, int[] health) {
+        this.power = power;
+        total = 0;
+        List<Pair> pairs = new ArrayList<>();
+        for (int i = 0; i < damage.length; i++) {
+            pairs.add(new Pair(health[i], damage[i]));
+        }
+        Collections.sort(pairs);
+        long totalDamage = 0;
+        int hitsRequired = 0;
+        for (Pair pair : pairs) {
+            hitsRequired += (int) Math.ceil((double) pair.health / power);
+            totalDamage += (long) hitsRequired * pair.damage;
+        }
+        return totalDamage;
+    }
+}

src/main/java/g3201_3300/s3273_minimum_amount_of_damage_dealt_to_bob/readme.md

@@ -0,0 +1,49 @@
+3273\. Minimum Amount of Damage Dealt to Bob
+
+Hard
+
+You are given an integer `power` and two integer arrays `damage` and `health`, both having length `n`.
+
+Bob has `n` enemies, where enemy `i` will deal Bob `damage[i]` **points** of damage per second while they are _alive_ (i.e. `health[i] > 0`).
+
+Every second, **after** the enemies deal damage to Bob, he chooses **one** of the enemies that is still _alive_ and deals `power` points of damage to them.
+
+Determine the **minimum** total amount of damage points that will be dealt to Bob before **all** `n` enemies are _dead_.
+
+**Example 1:**
+
+**Input:** power = 4, damage = [1,2,3,4], health = [4,5,6,8]
+
+**Output:** 39
+
+**Explanation:**
+
+*   Attack enemy 3 in the first two seconds, after which enemy 3 will go down, the number of damage points dealt to Bob is `10 + 10 = 20` points.
+*   Attack enemy 2 in the next two seconds, after which enemy 2 will go down, the number of damage points dealt to Bob is `6 + 6 = 12` points.
+*   Attack enemy 0 in the next second, after which enemy 0 will go down, the number of damage points dealt to Bob is `3` points.
+*   Attack enemy 1 in the next two seconds, after which enemy 1 will go down, the number of damage points dealt to Bob is `2 + 2 = 4` points.
+
+**Example 2:**
+
+**Input:** power = 1, damage = [1,1,1,1], health = [1,2,3,4]
+
+**Output:** 20
+
+**Explanation:**
+
+*   Attack enemy 0 in the first second, after which enemy 0 will go down, the number of damage points dealt to Bob is `4` points.
+*   Attack enemy 1 in the next two seconds, after which enemy 1 will go down, the number of damage points dealt to Bob is `3 + 3 = 6` points.
+*   Attack enemy 2 in the next three seconds, after which enemy 2 will go down, the number of damage points dealt to Bob is `2 + 2 + 2 = 6` points.
+*   Attack enemy 3 in the next four seconds, after which enemy 3 will go down, the number of damage points dealt to Bob is `1 + 1 + 1 + 1 = 4` points.
+
+**Example 3:**
+
+**Input:** power = 8, damage = [40], health = [59]
+
+**Output:** 320
+
+**Constraints:**
+
+*   <code>1 <= power <= 10<sup>4</sup></code>
+*   <code>1 <= n == damage.length == health.length <= 10<sup>5</sup></code>
+*   <code>1 <= damage[i], health[i] <= 10<sup>4</sup></code>