Дано масив чітких цілих чисел arr [] a перевершувати елемента arr [i] будь -який елемент arr [j] такий, що j> i і arr [j]> arr [i]. Знайдіть кількість перестрілок для кожного елемента в масиві.
Приклади:
Введення: ARR [] = [2 7 5 3 8 1]
Вихід: [4 1 1 1 0 0]
Пояснення: Для 2 є 4 більші елементи праворуч: [7 5 3 8]
Для 7 є 1 більший елемент праворуч: [8]
Для 5 є 1 більший елемент праворуч: [8]
Для 3 є 1 більший елемент праворуч: [8]
Для 8 немає більшого елемента праворуч: [0]
Для 1 немає більшого елемента праворуч: [0]Введення: arr [] = [4 5 1]
Вихід: [1 0 0]
Пояснення: Для 4 є 1 більший елемент праворуч: [5]
Для 5 немає більшого елемента праворуч: [0]
Для 1 немає більшого елемента праворуч: [0]
Таблиця змісту
- [Наївний підхід] - Використання двох вкладених петлей - O (n^2) Час і o (1) Простір
- [Очікуваний підхід] - Використання кроку злиття Sort - O (n log n) Час і o (n) Простір
[Наївний підхід] - Використання двох вкладених петлей - O (n^2) Час і o (1) Простір
Найпростіший підхід - ітератувати через масив і для кожного елемента підрахунок кількість елементів до його право тобто більший ніж це.
string.format рядок javaC++
#include
#include
import java.util.ArrayList; class GfG { static ArrayList<Integer> findSurpasser(int[] arr) { int n = arr.length; // List to store surpasser counts ArrayList<Integer> res = new ArrayList<>(); for (int i = 0; i < n; i++) { // Find surpasser for arr[i] int count = 0; for (int j = i + 1; j < n; j++) { if (arr[j] > arr[i]) count++; } res.add(count); } return res; } public static void main(String[] args) { int[] arr = {2 7 5 3 8 1}; ArrayList<Integer> res = findSurpasser(arr); for (int count : res) System.out.print(count + ' '); } }
def findSurpasser(arr): n = len(arr) # List to store surpasser counts res = [0] * n for i in range(n): # Find surpasser for arr[i] count = 0 for j in range(i + 1 n): if arr[j] > arr[i]: count += 1 res[i] = count return res if __name__ == '__main__': arr = [2 7 5 3 8 1] result = findSurpasser(arr) for val in result: print(val end=' ')
using System; using System.Collections.Generic; class GfG { static List<int> findSurpasser(int[] arr) { int n = arr.Length; // List to store surpasser counts List<int> res = new List<int>(); for (int i = 0; i < n; i++) { // Find surpasser for arr[i] int count = 0; for (int j = i + 1; j < n; j++) { if (arr[j] > arr[i]) count++; } res.Add(count); } return res; } static void Main(string[] args) { int[] arr = { 2 7 5 3 8 1 }; List<int> result = findSurpasser(arr); foreach (int count in result) Console.Write(count + ' '); } }
function findSurpasser(arr) { const n = arr.length; // array to store surpasser counts let res = new Array(n).fill(0); for (let i = 0; i < n; i++) { // Find surpasser for arr[i] let count = 0; for (let j = i + 1; j < n; j++) { if (arr[j] > arr[i]) count++; } res[i] = count; } return res; } // Driver Code const arr = [2 7 5 3 8 1]; const result = findSurpasser(arr); console.log(result.join(' '));
Випуск
4 1 1 1 0 0
[Очікуваний підхід] - Використання кроку злиття Sort - O (n log n) Час і o (n) Простір
У цьому підході ми використовуємо Крок злиття на Прогулянки . Під час злиття, якщо ІТ елемент у лівій половині є менший ніж Jth елемент у правій половині це означає, що все що залишився Елементи в правій половині (від J до кінця) є більший ніж ІТ елемент у лівій половині (оскільки обидві половини є відсортований .). Тому ми додаємо кількість Залишилися елементи в правій половині до перевищити кількість з ІТ елемент лівої половини. Цей процес повторюється для всіх елементів у лівій половині, коли вони об'єднуються з правою половиною.
Оскільки всі елементи в масиві є різний Ми використовуємо a Хеш -карта Щоб зберегти магазин перевищувача для кожного елемента. Після завершення сортування злиття ми заповнюємо масив результатів із підрахунками надмірного перевищення, підтримуючи той самий порядок, що і початковий вхід.
C++
#include
import java.util.List; import java.util.Map; import java.util.HashMap; import java.util.ArrayList; class GfG { // Merge function to sort the array // and update surpasser counts static void merge(int[] arr int lo int mid int hi Map<Integer Integer> m) { int n1 = mid - lo + 1; int n2 = hi - mid; int[] left = new int[n1]; int[] right = new int[n2]; // Copy data into temporary arrays left[] and right[] for (int i = 0; i < n1; i++) left[i] = arr[lo + i]; for (int j = 0; j < n2; j++) right[j] = arr[mid + 1 + j]; int i = 0 j = 0 k = lo; // Merging two halves while (i < n1 && j < n2) { // All elements in right[j..n2] are greater than left[i] // So add n2 - j to surpasser count of left[i] if (left[i] < right[j]) { m.put(left[i] m.getOrDefault(left[i] 0) + n2 - j); arr[k++] = left[i++]; } else { arr[k++] = right[j++]; } } // Copy remaining elements of left[] if any while (i < n1) arr[k++] = left[i++]; // Copy remaining elements of right[] if any while (j < n2) arr[k++] = right[j++]; } static void mergeSort(int[] arr int lo int hi Map<Integer Integer> m) { if (lo < hi) { int mid = lo + (hi - lo) / 2; // Sort left and right halves mergeSort(arr lo mid m); mergeSort(arr mid + 1 hi m); // Merge them merge(arr lo mid hi m); } } static ArrayList<Integer> findSurpasser(int[] arr) { int n = arr.length; // Map to store surpasser counts Map<Integer Integer> m = new HashMap<>(); // Duplicate array to perform merge sort int[] dup = arr.clone(); mergeSort(dup 0 n - 1 m); // Store surpasser counts in result list ArrayList<Integer> res = new ArrayList<>(); for (int i = 0; i < n; i++) res.add(m.getOrDefault(arr[i] 0)); return res; } public static void main(String[] args) { int[] arr = {2 7 5 3 8 1}; ArrayList<Integer> res = findSurpasser(arr); for (int count : res) System.out.print(count + ' '); } }
def merge(arr lo mid hi m): n1 = mid - lo + 1 n2 = hi - mid left = arr[lo:lo+n1] right = arr[mid+1:mid+1+n2] i = j = 0 k = lo # Merging two halves while i < n1 and j < n2: # All elements in right[j..n2] are greater than left[i] # So add n2 - j in surpasser count of left[i] if left[i] < right[j]: m[left[i]] += n2 - j arr[k] = left[i] i += 1 else: arr[k] = right[j] j += 1 k += 1 # Copy remaining elements of left[] if any while i < n1: arr[k] = left[i] i += 1 k += 1 # Copy remaining elements of right[] if any while j < n2: arr[k] = right[j] j += 1 k += 1 def mergeSort(arr lo hi m): if lo < hi: mid = lo + (hi - lo) // 2 # Sort left and right half mergeSort(arr lo mid m) mergeSort(arr mid + 1 hi m) # Merge them merge(arr lo mid hi m) def findSurpasser(arr): n = len(arr) # Map to store surpasser counts m = {key: 0 for key in arr} # Duplicate array to perform merge Sort # so that original array is not modified dup = arr[:] mergeSort(dup 0 n - 1 m) # Store surpasser counts in result array # in the same order as given array res = [m[arr[i]] for i in range(n)] return res if __name__ == '__main__': arr = [2 7 5 3 8 1] result = findSurpasser(arr) for val in result: print(val end=' ')
using System; using System.Collections.Generic; class GfG { // Merge function to sort the array // and update surpasser counts static void merge(int[] arr int lo int mid int hi Dictionary<int int> m) { int n1 = mid - lo + 1; int n2 = hi - mid; int[] left = new int[n1]; int[] right = new int[n2]; // Copy data into temporary arrays for (int i = 0; i < n1; i++) left[i] = arr[lo + i]; for (int j = 0; j < n2; j++) right[j] = arr[mid + 1 + j]; int i1 = 0 j1 = 0 k = lo; // Merge the two halves while (i1 < n1 && j1 < n2) { // Count surpassers if (left[i1] < right[j1]) { if (!m.ContainsKey(left[i1])) m[left[i1]] = 0; m[left[i1]] += n2 - j1; arr[k++] = left[i1++]; } else { arr[k++] = right[j1++]; } } // Copy remaining elements while (i1 < n1) arr[k++] = left[i1++]; while (j1 < n2) arr[k++] = right[j1++]; } static void mergeSort(int[] arr int lo int hi Dictionary<int int> m) { if (lo < hi) { int mid = lo + (hi - lo) / 2; // Recursive sort mergeSort(arr lo mid m); mergeSort(arr mid + 1 hi m); // Merge sorted halves merge(arr lo mid hi m); } } static List<int> findSurpasser(int[] arr) { int n = arr.Length; Dictionary<int int> m = new Dictionary<int int>(); int[] dup = new int[n]; Array.Copy(arr dup n); mergeSort(dup 0 n - 1 m); List<int> res = new List<int>(); for (int i = 0; i < n; i++) { res.Add(m.ContainsKey(arr[i]) ? m[arr[i]] : 0); } return res; } static void Main() { int[] arr = {2 7 5 3 8 1}; List<int> res = findSurpasser(arr); foreach (int count in res) Console.Write(count + ' '); } }
function merge(arr lo mid hi m) { const n1 = mid - lo + 1; const n2 = hi - mid; const left = []; const right = []; // Copy data into temporary arrays left[] and right[] for (let i = 0; i < n1; i++) left[i] = arr[lo + i]; for (let j = 0; j < n2; j++) right[j] = arr[mid + 1 + j]; let i = 0 j = 0 k = lo; // Merging two halves while (i < n1 && j < n2) { // All elements in right[j..n2] are greater than left[i] // So add n2 - j in surpasser count of left[i] if (left[i] < right[j]) { m[left[i]] = (m[left[i]] || 0) + n2 - j; arr[k++] = left[i++]; } else { arr[k++] = right[j++]; } } // Copy remaining elements of left[] if any while (i < n1) arr[k++] = left[i++]; // Copy remaining elements of right[] if any while (j < n2) arr[k++] = right[j++]; } function mergeSort(arr lo hi m) { if (lo < hi) { const mid = Math.floor(lo + (hi - lo) / 2); // Sort left and right half mergeSort(arr lo mid m); mergeSort(arr mid + 1 hi m); // Merge them merge(arr lo mid hi m); } } function findSurpasser(arr) { const n = arr.length; // Map to store surpasser counts const m = {}; // Duplicate array to perform merge Sort // so that original array is not modified const dup = arr.slice(); mergeSort(dup 0 n - 1 m); // Store surpasser counts in result array // in the same order as given array const res = []; for (let i = 0; i < n; i++) res.push(m[arr[i]] || 0); return res; } // Driver Code const arr = [2 7 5 3 8 1]; const res = findSurpasser(arr); console.log(res.join(' '));
Випуск
4 1 1 1 0 0
Пов’язані статті:
- Інверсійна кількість
- Прогулянки