48.

Scrieți un program Java pentru a aranja elementele unei matrice date de

numere întregi în care toate numerele întregi negative apar înaintea tuturor
numerelor întregi positive

Programul în JAVA :
import java.util.Arrays;

public class Main {

public static void main(String[] args) {

int[] nums = {-4, 8, 6, -5, 6, -2, 1, 2, 3, -11};
System.out.println("Original Array:
"+Arrays.toString(nums));
sort_nums(nums);
System.out.println("New Array:
"+Arrays.toString(nums));
}
public static void sort_nums(int[] nums){
int pos_num = 0;
int neg_num = 0;
int i,j;
int max = Integer.MIN_VALUE;
for(i=0; i<nums.length; i++){
if(nums[i]<0) neg_num++;
else pos_num++;
if(nums[i]>max) max = nums[i];
}
max++;
if(neg_num==0 || pos_num == 0) return;
i=0;
j=1;
while(true){
while(i<=neg_num && nums[i]<0) i++;
while(j<nums.length && nums[j]>=0) j++;

1
 if(i>neg_num || j>=nums.length) break;
nums[i]+= max*(i+1);
swap_nums(nums,i,j);
}

i = nums.length-1;
while(i>=neg_num){
int div = nums[i]/max;
if(div == 0) i--;
else{
nums[i]%=max;
swap_nums(nums,i,neg_num+div-2);
}
}

}
private static void swap_nums(int[] nums, int i , int
j){
int t = nums[i];
nums[i] = nums[j];
nums[j] = t;
}
}

Rezultatul rulării programului :

49. Scrieți un program Java pentru a aranja elementele unui tablou dat de
numere întregi în care toate numerele întregi pozitive apar înaintea tuturor
numerelor întregi negative

2
 Programul în JAVA :
import java.util.Arrays;
public class Main {

public static void main(String[] args) {

int arra_nums[] = {-4, 8, 6, -5, 6, -2, 1, 2, 3, -
11};
System.out.println("Original array :
"+Arrays.toString(arra_nums));
int j,temp,arr_size;

arr_size = arra_nums.length;
for (int i = 0; i <arr_size; i++){
j = i;

//Shift positive numbers left, negative

numbers right

while ((j > 0) && (arra_nums[j] >0) &&

(arra_nums[j-1] < 0)){
temp = arra_nums[j];
arra_nums[j] = arra_nums[j-1];
arra_nums[j-1] = temp;
j--;
}
}
System.out.println("New array :
"+Arrays.toString(arra_nums));
}
}
Rezultatul rulării programului :

50.Scrieți un program Java pentru a sorta un tablou de numere întregi pozitive

dintr-un tablou dat, în tabloul sortat valoarea primului element ar trebui să
fie maximă, a doua valoare ar trebui să fie valoarea minimă, a treia ar trebui
să fie a doua maximă, a patra ar trebui să fie a doua minimă și așa mai
departe

Programul în JAVA :
import java.util.Arrays;

public class Main

3
 {
static int[] rearrange(int[] new_arra, int n)
{
int temp[] = new int[n];

int small_num = 0, large_num = n-1;

boolean flag = true;

for (int i=0; i < n; i++)

{
if (flag)
temp[i] = new_arra[large_num--];
else
temp[i] = new_arra[small_num++];

flag = !flag;
}

return temp;
}

public static void main(String[] args)

{
int nums[] = new int[]{10, 20, 30, 40, 50, 60,
70, 80, 90, 100};
int result[];

System.out.println("Original Array ");

System.out.println(Arrays.toString(nums));

result = rearrange(nums,nums.length);

System.out.println("New Array ");

System.out.println(Arrays.toString(result));

}
}

Rezultatul rulării programului :

4
51.Scrieți un program Java pentru a separa 0-uri în partea stângă și 1-uri în
partea dreaptă a unei matrice de 0-uri și 1-uri în ordine aleatorie.

Programul în JAVA :
import java.util.Arrays;

public class Main {

public static void main(String[] args)
{
int arr[] = new int[]{ 0, 0, 1, 1, 0, 1, 1, 1,0
};
int result[];
System.out.println("Original Array ");
System.out.println(Arrays.toString(arr));

int n = arr.length;

result = separate_0_1(arr, n);

System.out.println("New Array ");
System.out.println(Arrays.toString(result));
}

static int [] separate_0_1(int arr[], int n)

{
int count = 0;

for (int i = 0; i < n; i++) {

if (arr[i] == 0)
count++;
}

for (int i = 0; i < count; i++)

arr[i] = 0;

for (int i = count; i < n; i++)

arr[i] = 1;

5
 return arr;
}
}

Rezultatul rulării programului :

52.Scrieți un program Java pentru a separa numerele pare și impare dintr-o

matrice de numere întregi dată. Puneți mai întâi toate numerele pare și apoi
numerele impare.

Programul în JAVA :
import java.util.Arrays;
public class Main
{

public static void main (String[] args)

{
int nums[] = {20, 12, 23, 17, 7, 8, 10, 2, 1, 0};
int result[];
System.out.println("Original Array ");
System.out.println(Arrays.toString(nums));

result = separate_odd_even(nums);

System.out.print("Array after separation ");

System.out.println(Arrays.toString(result));
}

static int [] separate_odd_even(int arr[])

{
int left_side = 0, right_side = arr.length - 1;
while (left_side < right_side)
{
while (arr[left_side]%2 == 0 && left_side <

6
 right_side)
left_side++;

while (arr[right_side]%2 == 1 && left_side <

right_side)
right_side--;

if (left_side < right_side)

{
int temp = arr[left_side];
arr[left_side] = arr[right_side];
arr[right_side] = temp;
left_side++;
right_side--;
}
}
return arr;
}
}

Rezultatul rulării programului :

53.Scrieți un program Java care să înlocuiască fiecare element cu următorul cel

mai mare element (din partea dreaptă) dintr-o matrice dată de numere întregi.
Nu există niciun element lângă ultimul element, prin urmare, înlocuiți-l cu
-1.

Programul în JAVA :
import java.io.*;
import java.util.Arrays;
public class Main
{
public static void main (String[] args)
{
int nums[] = {45, 20, 100, 23, -5, 2, -6};
int result[];
System.out.println("Original Array ");
System.out.println(Arrays.toString(nums));

result = next_greatest_num(nums);
System.out.println("The modified array:");
System.out.println(Arrays.toString(result));

7
 }

static int [] next_greatest_num(int arr_nums[])

{
int size = arr_nums.length;
int max_from_right_num = arr_nums[size-1];
arr_nums[size-1] = -1;

for (int i = size-2; i >= 0; i--)

{
int temp = arr_nums[i];
arr_nums[i] = max_from_right_num;
if(max_from_right_num < temp)
max_from_right_num = temp;
}
return arr_nums;
}
}

Rezultatul rulării programului :

54. Scrieți un program Java care să verifice dacă un array dat conține un
subarray cu suma 0.
Exemplu:
Input :
nums1= { 1, 2, -2, 3, 4, 5, 6 }
nums2 = { 1, 2, 3, 4, 5, 6 }
nums3 = { 1, 2, -3, 4, 5, 6 }
Output:
Does the said array contain a subarray with 0 sum: true
Does the said array contain a subarray with 0 sum: false
Does the said array contain a subarray with 0 sum: true

Programul în JAVA :
import java.util.Set;
import java.util.HashSet;
import java.util.Arrays;

public class Main

{
public static Boolean
find_subarray_sum_zero(int[] nums)

8
 {
Set<Integer> set = new HashSet<>();
set.add(0);
int suba_sum = 0;
for (int i = 0; i < nums.length; i++)
{
suba_sum += nums[i];

if (set.contains(suba_sum)) {
return true;
}
set.add(suba_sum);
}

return false;
}

public static void main (String[] args)

{
int[] nums1= { 1, 2, -2, 3, 4, 5, 6 };
System.out.println("Original array:
"+Arrays.toString(nums1));
System.out.println("Does the said array
contain a subarray with 0 sum:
"+find_subarray_sum_zero(nums1));
int[] nums2 = { 1, 2, 3, 4, 5, 6 };
System.out.println("\nOriginal array:
"+Arrays.toString(nums2));
System.out.println("Does the said array
contain a subarray with 0 sum:
"+find_subarray_sum_zero(nums2));
int[] nums3 = { 1, 2, -3, 4, 5, 6 };
System.out.println("\nOriginal array:
"+Arrays.toString(nums3));
System.out.println("Does the said array
contain a subarray with 0 sum:
"+find_subarray_sum_zero(nums3));
}
}

Rezultatul rulării programului :

9
55. Scrieți un program Java care să tipărească toate sub-rețelele cu suma 0
prezente într-o anumită matrice de numere întregi.
Exemplu:
Input :
nums1 = { 1, 3, -7, 3, 2, 3, 1, -3, -2, -2 }
nums2 = { 1, 2, -3, 4, 5, 6 }
nums3= { 1, 2, -2, 3, 4, 5, 6 }
Output:
Sub-arrays with 0 sum : [1, 3, -7, 3]
Sub-arrays with 0 sum : [3, -7, 3, 2, 3, 1, -3, -2]
Sub-arrays with 0 sum : [1, 2, -3]
Sub-arrays with 0 sum : [2, -2]

Programul în JAVA :
import java.util.*;
import java.lang.*;
public class Main
{
public static void print_all_Subarrays(int[] A)
{

List<Integer> llist = new ArrayList<Integer>();

for (int i = 0; i < A.length; i++)
{
int sum = 0;
llist.removeAll(llist);
for (int j = i; j < A.length; j++)
{
sum += A[j];
llist.add(A[j]);
if (sum == 0) {
System.out.println("Sub-arrays
with 0 sum : " + llist.toString());

}
}
}

10
 }

public static void main (String[] args)

{
int[] nums1 = { 1, 3, -7, 3, 2, 3, 1, -3, -2, -
2 };
System.out.println("\nOriginal array:
"+Arrays.toString(nums1));
print_all_Subarrays(nums1);

int[] nums2 = { 1, 2, -3, 4, 5, 6 };

System.out.println("\nOriginal array:
"+Arrays.toString(nums2));
print_all_Subarrays(nums2);

int[] nums3= { 1, 2, -2, 3, 4, 5, 6 };

System.out.println("\nOriginal array:
"+Arrays.toString(nums3));
print_all_Subarrays(nums3);
}
}

Rezultatul rulării programului :

56. Scrieți un program Java pentru a sorta un anumit tablou binar în timpi
liniari.
Timp liniar: se spune că un algoritm ia timp liniar, sau timp O(n),
dacă complexitatea sa în timp este O(n). Informal, aceasta înseamnă că
timpul de rulare crește cel mult liniar cu dimensiunea intrării. Mai precis,
aceasta înseamnă că există o constantă c astfel încât timpul de rulare să
fie de cel mult cn pentru fiecare intrare de dimensiune n. De exemplu, o
procedură care adună toate elementele unei liste necesită timp
proporțional cu lungimea listei, dacă timpul de adăugare este constant
sau, cel puțin, este limitat de o constantă.

11
 Timpul liniar este cea mai bună complexitate de timp posibilă în
situațiile în care algoritmul trebuie să citească secvenţial întreaga intrare.
Prin urmare, multe cercetări au fost investite în descoperirea algoritmilor
care prezintă timp liniar sau, cel puțin, timp aproape liniar. Această
cercetare include atât metode software, cât și metode hardware. Există
mai multe tehnologii hardware care exploatează paralelismul pentru a
oferi acest lucru. Un exemplu este memoria adresabilă conținutului.
Acest concept de timp liniar este utilizat în algoritmii de potrivire a
șirurilor, cum ar fi algoritmul Boyer-Moore și algoritmul lui Ukkonen.
Exemplu:
Input : b_nums[] = { 0, 1, 1, 0, 1, 1, 0, 1, 0, 0 }
Output: After sorting: [0, 0, 0, 0, 0, 1, 1, 1, 1, 1]

Programul în JAVA :
import java.util.Arrays;
public class Main
{

public static void sort_binary_nums(int[] b_nums)

{
int k = 0;

for (int i = 0; i < b_nums.length; i++)

{
if (b_nums[i] == 0) {
b_nums[k++] = 0;
}
}

for (int i = k; i < b_nums.length; i++) {

b_nums[k++] = 1;
}
}

public static void main (String[] args)

{
int b_nums[] = { 0, 1, 1, 0, 1, 1, 0, 1, 0,
0 };
System.out.println("Original array:
"+Arrays.toString(b_nums));
sort_binary_nums(b_nums);
System.out.println("After sorting:
"+Arrays.toString(b_nums));

}
}

12
 Rezultatul rulării programului :

57.Verificați dacă o sub-matrice este formată din numere întregi consecutive

dintr-o matrice dată de numere întregi
Exemplu:
Input :
nums = { 2, 5, 0, 2, 1, 4, 3, 6, 1, 0 }
Output:
The largest sub-array is [1, 7]
Elements of the sub-array: 5 0 2 1 4 3 6

Programul în JAVA :
import java.lang.Math;
import java.util.Arrays;
public class Main
{
static boolean is_consecutive(int nums[], int i, int
j, int min, int max)
{
if (max - min != j - i) {
return false;
}

boolean check[] = new boolean[j - i + 1];

for (int k = i; k <= j; k++)

{
if (check[nums[k] - min]) {
return false;
}

check[nums[k] - min] = true;

}

return true;
}

public static void find_Max_SubArray(int[] nums)

{
int len = 1;
int start = 0, end = 0;

for (int i = 0; i < nums.length - 1; i++)

{
int min_val = nums[i], max_val = nums[i];

13
 for (int j = i + 1; j < nums.length; j++)
{
min_val = Math.min(min_val, nums[j]);
max_val = Math.max(max_val, nums[j]);

if (is_consecutive(nums, i, j,
min_val, max_val))
{
if (len < max_val - min_val + 1)
{
len = max_val - min_val +
1;
start = i;
end = j;
}
}
}
}

System.out.println("The largest sub-array is ["

+ start + ", "
+ end + "]");
System.out.print("Elements of the sub-array:
");
for (int x = start; x <= end; x++)
{

System.out.print(nums[x]+" ");
}
}

public static void main (String[] args)

{
int[] nums = { 2, 5, 0, 2, 1, 4, 3, 6, 1, 0 };
System.out.println("Original array:
"+Arrays.toString(nums));
find_Max_SubArray(nums);
}
}

Rezultatul rulării programului :

14
58. Având în vedere două tablouri sortate A și B de dimensiunea p și q, scrieți
un program Java pentru a îmbina elementele lui A cu B, menținând ordinea
sortată, adică umpleți A cu primele p elemente cele mai mici și umpleți B cu
elementele rămase.
Exemplu:
Input :
int[] A = { 1, 5, 6, 7, 8, 10 }
int[] B = { 2, 4, 9 }
Output:
Sorted Arrays:
A: [1, 2, 4, 5, 6, 7]
B: [8, 9, 10]

Programul în JAVA :
import java.util.Arrays;

public class Main

{
public static void merge_sorted_arrays(int[] A,
int p, int[] B, int q)
{

for (int i = 0; i < p; i++)

{
if (A[i] > B[0])
{
int temp = A[i];
A[i] = B[0];
B[0] = temp;

int first_arr = B[0];

int k;
for (k = 1; k < q && B[k] <
first_arr; k++) {
B[k - 1] = B[k];
}

B[k - 1] = first_arr;
}
}
}

public static void main (String[] args)

{
int[] A = { 1, 5, 6, 7, 8, 10 };
int[] B = { 2, 4, 9 };
int p = A.length;

15
 int q = B.length;

System.out.println("Original Arrays:");
System.out.println("A: " +
Arrays.toString(A));
System.out.println("B: " +
Arrays.toString(B));

merge_sorted_arrays(A, p, B, q);

System.out.println("\nSorted Arrays:");
System.out.println("A: " +
Arrays.toString(A));
System.out.println("B: " +
Arrays.toString(B));
}
}

Rezultatul rulării programului :

59. Scrieți un program Java pentru a găsi produsul maxim a două numere întregi
într-o matrice dată de numere întregi.
Exemplu:
Input :
nums = { 2, 3, 5, 7, -7, 5, 8, -5 }
Output:
Pair is (7, 8), Maximum Product: 56

Programul în JAVA :
import java.util.*;
public class Main
{
public static void find_max_product(int[] nums)
{
int max_pair_product = Integer.MIN_VALUE;
int max_i = -1, max_j = -1;

for (int i = 0; i < nums.length - 1; i++)

{
for (int j = i + 1; j < nums.length; j+

16
 +)
{
if (max_pair_product < nums[i] *
nums[j])
{
max_pair_product = nums[i] *
nums[j];
max_i = i;
max_j = j;
}
}
}
System.out.println("\n");
System.out.println("Pair is (" + nums[max_i]
+ ", " + nums[max_j] + "), Maximum Product: " +
(nums[max_i]*nums[max_j]));
}

public static void main (String[] args)

{
int[] nums = { 2, 3, 5, 7, -7, 5, 8, -5 };
System.out.println("\n Original array:
"+Arrays.toString(nums));

find_max_product(nums);
}
}
Rezultatul rulării programului :

60. Scrieți un program Java pentru a amesteca o serie dată de numere întregi.
Exemplu:
Input :
nums = { 1, 2, 3, 4, 5, 6 }
Output:
Shuffle Array: [4, 2, 6, 5, 1, 3]

Programul în JAVA :
import java.util.Arrays;
import java.util.Random;

class solution
{
public static void shuffle(int nums[])
{

17
 for (int i = nums.length - 1; i >= 1; i--)
{
Random rand = new Random();

int j = rand.nextInt(i + 1);

swap_elements(nums, i, j);
}
}
private static void swap_elements(int[] nums, int i,
int j) {
int temp = nums[i];
nums[i] = nums[j];
nums[j] = temp;
}
public static void main (String[] args)
{
int[] nums = { 1, 2, 3, 4, 5, 6 };
System.out.println("Original Array:
"+Arrays.toString(nums));
shuffle(nums);
System.out.println("Shuffle Array:
"+Arrays.toString(nums));
}
}

Rezultatul rulării programului :

61.Scrieți un program Java pentru a rearanja o matrice dată de elemente unice,

astfel încât fiecare al doilea element al matricei să fie mai mare decât
elementele din stânga și din dreapta.
Exemplu:
Input :
nums= { 1, 2, 4, 9, 5, 3, 8, 7, 10, 12, 14 }
Output:
Array with every second element is greater than its left and right elements:
[1, 4, 2, 9, 3, 8, 5, 10, 7, 14, 12]

Programul în JAVA :
import java.util.Arrays;

public class Main

{
private static void swap_nums(int[] nums, int i, int j) {
int t_nums = nums[i];

18
 nums[i] = nums[j];
nums[j] = t_nums;
}

public static void rearrange_Array_nums(int[] nums)

{
for (int i = 1; i < nums.length; i += 2)
{
if (nums[i - 1] > nums[i]) {
swap_nums(nums, i - 1, i);
}

if (i + 1 < nums.length && nums[i + 1] >

nums[i]) {
swap_nums(nums, i + 1, i);
}
}
}

public static void main (String[] args)

{
int[] nums= { 1, 2, 4, 9, 5, 3, 8, 7, 10, 12, 14 };
System.out.println("Original array:\
n"+Arrays.toString(nums));
rearrange_Array_nums(nums);
System.out.println("\nArray with every second
element is greater than its left and right elements:\
n"+Arrays.toString(nums));
}
}

Rezultatul rulării programului :

62.Scrieți un program Java pentru a găsi indicii de echilibru dintr-o matrice dată
de numere întregi.
Un indice de echilibru al unei secvențe este un indice al secvenței astfel
încât suma elementelor la indici mai mici este egală cu suma elementelor la
indici mai mari.
De exemplu, într-o secvență A:
A0 = -7
A1 = 1

19
 A2 = 5
A3 = 2
A4 = -4
A5 = 3
A6 = 0
3 este un indice de echilibru, deoarece:
A0 + A1 + A2 = A4 + A5 + A6

6 este, de asemenea, un indice de echilibru, deoarece:

A0 + A1 + A2 + A3 + A4 + A5 = 0

(suma zero elemente este zero)

7 nu este un indice de echilibru, deoarece nu este un indice valid al
secvenței A.

Exemplu:
Input :
nums = {-7, 1, 5, 2, -4, 3, 0}
Output:
Equilibrium indices found at : 3
Equilibrium indices found at : 6

Programul în JAVA :
import java.util.Arrays;
public class Main {
public static void main(String[] args) {
int[] nums = {-7, 1, 5, 2, -4, 3, 0};
System.out.println("Original array:
"+Arrays.toString(nums));
equlibrium_indices(nums);
}

public static void equlibrium_indices(int[] nums){

//find total sum
int totalSum = 0;
for (int n : nums) {
totalSum += n;
}
//compare running sum to remaining sum to find
equlibrium indices
int runningSum = 0;
for (int i = 0; i < nums.length; i++) {
int n = nums[i];
if (totalSum - runningSum - n == runningSum) {

20
 System.out.println("Equilibrium indices
found at : "+i);
}
runningSum += n;
}
}
}

Rezultatul rulării programului :

63.Scrieți un program Java pentru a înlocui fiecare element al matricei cu

produsul fiecărui alt element dintr-o matrice dată de numere întregi.
Exemplu:
Input :
nums1 = { 1, 2, 3, 4, 5, 6, 7}
nums2 = {0, 1, 2, 3, 4, 5, 6, 7}
Output:
Array with product of every other element:
[5040, 2520, 1680, 1260, 1008, 840, 720]
Array with product of every other element:
[5040, 0, 0, 0, 0, 0, 0, 0]

Programul în JAVA :
import java.util.Arrays;

public class Main

{
public static int[] find_Product_in_array(int[] nums)
{
int n = nums.length;

int[] left_element = new int[n];

int[] right_element = new int[n];

left_element[0] = 1;
for (int i = 1; i < n; i++) {
left_element[i] = nums[i - 1] * left_element[i
- 1];
}

right_element[n - 1] = 1;

21
 for (int j = n - 2; j >= 0; j--) {
right_element[j] = nums[j + 1] *
right_element[j + 1];
}

for (int i = 0; i < n; i++) {

nums[i] = left_element[i] * right_element[i];
}
return nums;
}

public static void main(String[] args)

{
int[] nums1 = { 1, 2, 3, 4, 5, 6, 7};
System.out.println("Original array:\
n"+Arrays.toString(nums1));
int[] result1 = find_Product_in_array(nums1);
System.out.println("Array with product of every
other element:\n" + Arrays.toString(result1));

int[] nums2 = {0, 1, 2, 3, 4, 5, 6, 7};

System.out.println("\nOriginal array:\
n"+Arrays.toString(nums2));
int[] result2 = find_Product_in_array(nums2);
System.out.println("Array with product of every
other element:\n" + Arrays.toString(result2));

}
}

Rezultatul rulării programului :

22