We Keep Coding

Power of the Set

I generated all the subsequences of the array using recursion, but I can't figure out why my pow
(last line print statement) is printing null arraylist, while the powset print statement always prints the subsequence fine.
Is there a concept of pass by value / pass by reference ?
import java.util.ArrayList;
public class recursion {
static ArrayList<ArrayList<Integer>> pow;
public static void main(String[] args) {
int arr[] = {2, 3, 5};
int sum = 10;
ArrayList<Integer> ans = new ArrayList<>();
pow = new ArrayList<ArrayList<Integer>>();
powset(arr, 0, ans);
System.out.println(pow); // Prints empty arraylist everytime
}
private static void powset(int[] arr, int i, ArrayList<Integer> ans) {
if(i >= arr.length){
System.out.println(ans); // prints the correct arraylist as expected
pow.add(ans);
return;
}
ans.add(arr[i]);
powset(arr,i+1,ans);
ans.remove(ans.size()-1);
powset(arr,i+1,ans);
}
}
I was expecting the pow arraylist to print all the arraylist inside it, but It is printing empty arraylists.

Count the new. I count exactly 2 new statements executed for the entire run: ans = new ArrayList<>() and pow = new ArrayList<ArrayList<Integer>>().
That means there are 2 lists and only 2, total.
Is there a concept of pass by value / pass by reference ?
All non-primitives are references in java. When you write ans = new ArrayList<>(), that is not stating that ans is the list. It is short for:
Find a place on the beach (the heap).
Conjure a new arraylist and bury it here, in this place on the beach.
Draw a map to this place on the piece of paper named ans.
When you pass 'ans' to another method, it's pass by value, i.e., a copy, but you're copying the treasuremap. Not the treasure. So if the called method uses = (that's java-ese for: Wipe out the treasure map and draw a new map), the caller doesn't notice anything (their copy of the map isn't being wiped, after all). But if the called method uses ., such as .add or .remove, well, . is java-ese for: Follow the map and dig down. Even though you have a copy of the treasure map, given that it leads to the same treasure, if someone else digs down and messes with the treasure, you'd notice.
Thus, count the new. If you expect your code to produce 15 arraylists, then throughout its total execution, exactly 15 new statements need to be executed.
new ArrayList<>(someList) makes a clone.

Array contains element in Java

I've got a task of writing a function that returns integers which are in both two arrays.
For example: nums1 [1,2,3] and nums2 [2,3,5] and answer should be [2,3].
I came with this solution:
public static void main(String[] args) {
System.out.println(arraysIntersection(new int[] {1,2,3}, new int[] {2,3,5}));
}
public static List<Integer> arraysIntersection(int[] nums1, int[] nums2) {
List<Integer> answer = new ArrayList<>();
for (int i = 0; i < nums1.length; i++) {
if (Arrays.asList(nums2).contains(nums1[i])) {
answer.add(nums1[i]);
}
}
return answer;
}
however it seems this condition doesn't work as intended:
if (Arrays.asList(nums2).contains(nums1[i]))
It says it doesn't contain the value altough it clearly contains 2 and 3. Any ideas?
I know I could just iterate each i over the second array but I thought this solution would be faster. Does anyone knows why it's not working?

You can do it in O(NlogN) time complexity and O(n) memory. Just sort arrays and use two pointers technique.
List<Integer> answer = new ArrayList<>();
int j = 0;
Arrays.sort(nums1);
Arrays.sort(nums2);
for(int i = 0; i < nums1.length; i++) {
if(i > 0 && nums1[i] == nums1[i - 1]) //we have already processed this number
continue;
while(j < nums2.length && nums2[j] < nums1[i])
j++;
if(j < nums2.length && nums1[i] == nums2[j])
answer.add(nums1[i]);
}
return answer;
You can do it in O(N) time complexity and O(n) memory (but constant is higher). Just add all elements of nums1 in first HashSet and all elements of nums2 if another HashSet. Then you can for each element in first set check if another set contains this element using O(1)* time.
List<Integer> answer = new ArrayList<>();
Set<Integer> set1 = new HashSet<>(), set2 = new HashSet<>();
set1.addAll(nums1);
set2.addAll(nums2);
for(var el : set1) {
if(set2.contains(el)) {
answer.add(el);
}
}
return answer;
*O(1) is middle time of operations with hashset

If Arrays is a static object already initialized, or declared at global scope, it may be OK, I don't know for sure. Can't call asList() on an uninitialized object, it must be allocated first.
Now I know, Arrays is a member of the utils package, can be OK.
But not anything that looks fine in code, actually works also.
As a matter of fact, I don't like the way in which Java calls a function. But it would be more easier and handy like this.
I don't know, if you had included the util package in your code.
util, or utils ? Can be 2 different packages, this is important.
You can try another way:
import java.util.*;
public static List<Integer> arraysIntersection(int[] nums1, int[] nums2){
List<Integer> answer = new ArrayList<>();
for (int i = 0; i < nums1.length; i++) {
int u = nums1[i];
for (int j = 0; j < nums2.length; j++) {
if (u == nums2[j]) {
answer.add(u);
break;
}
}
}
return answer;
}
A break could be necessary, if the values must be added only once.
( a number can be found more times into an array )
The break was meant just for ending the inner loop.
The outer loop should continue up to the end of the search.
But the same number can be find more times in the first array.
Before returning the answer, the result should be checked for duplicate values. And this is another problem.
It would be more convenient to check before adding number to list.
Check if the answer list already contains the number value.
And then add the number to the list, if a match is not found.
So this can be done more easier:
if (!answer.contains(u)) answer.add(u);
Since you check this condition, the break is not anymore needed.
But searching the list so many times, can slow down your code.
From this reason, the u value is read only once, before starting to compare with the another array. So you don't have to read manytimes the same array item, just store it in a temporary variable, u.
In another point of view, when iterating over a collection object,
the current value for the current position index could change.
It also depends on the basic interface implementation for this object.
If this function would have been written in C, it would have been a very serious problem, to get the value of an item in array, because the current position of the pointer changes. And here is the same, the current read value changes, excepting that we can't see all the underlying mechanism. And if I am not wrong too much, the original Java first time was based also on the C code.
Best regards, Adrian Brinas.
Have a nice day.

Check if array does NOT contain a certain value

I know that if I want to check if an array does contain a certain value I should use Arrays.asList(arrayName).contains(valueName).
But how do I check if that value is not present? At first I just thought of putting ! in front like:
!Arrays.asList(arrayName).contains(valueName)
but that doesn't seem to work.
I even tried writing the if statement like this:
if (Arrays.asList(arrayName).contains(valueName)==false)
but that doesn't seem to work either.
Here is the code:
public int[] duplikati(int[] tabela){
int len = tabela.length;
int c = 0;
int[] count = new int[len];
for (int i=0;i<len;i++){
if (Arrays.asList(count).contains(tabela[i])==false){
c++;
}
}
int[] result = new int[c];
int d = 0;
for (int j=0;j<len;j++){
if (Arrays.asList(result).contains(tabela[j])==false){
System.out.print(tabela[j]+" ");
result[d] = tabela[j];
d++;
}
}
return result;
}

In, this specific case when you pass an array of primitive types into Arrays.asList you'll get back a List with a single element which is the provided array.
So, when you do:
Arrays.asList(arrayName).contains(valueName)
The call Arrays.asList(arrayName) will return a List<int[]> and then when you call contains the valueName will get boxed to an Integer and then get's compared with the element(s) in the list. because an int[] is never equal to an integer value, the contains call will always return false.
Solution 1 - change the type of your arrays from int[] to Integer[], then everything should work as you expect.
Solution 2 - Assuming you do not want to change the type of the arrays for some reason, then you can do:
final int index = i;
if(Arrays.stream(count).noneMatch(e -> e == tabela[index])){...}
inside the for loops.
You can think of the noneMatch method as !Arrays.asList(someArray).contains(someValue) if it helps.
Similarly, you can check if the array contains an element with:
final int index = i;
if(Arrays.stream(count).anyMatch(e -> e == tabela[index])){...}
You can think of the anyMatch method as Arrays.asList(someArray).contains(someValue) if it helps.

You can use Java 8 stream api as follows
Integer arr[]=new Integer[]{1,2,30,61};
System.out.println(Arrays.asList(arr).stream().noneMatch(element>element==10));
You can go through the below link for explaination of
noneMatch()

Passing an Array and sort

Good day guys, I am trying to sort here using an array, Check my codes
public int[] Sort(int[] arr) {
int[] value = arr;
int min, temp, out;
for (out = 0; out < value.length - 1; out++) {
for (min = out + 1; min < value.length; min++) {
if(value[out] > value[min]){
temp = value[min];
value[min] = value[out];
value[out] = temp;
}
}
}
return value;
}
The problem here is I pass the array 'arr' value to the array 'value' and sort the 'value' array then the output is what i expect, he sorted the number, but the problem is, when i tried to return the 'arr' array it also return a sorted value even though i didn't tried to sort it .. is it a bug or just my ugly coding ?

When you make the assignment int[] value = arr, you give value the same reference as arr. This means that assigning, for example, value[1] will affect the original array. If you want to return a new sorted array without affecting the original one, then you can try making a copy of it:
public int[] Sort(int[] arr) {
int[] value = new int[arr.length];
System.arraycopy(arr, 0, value, 0, arr.length);
// ...
return value;
}

Your variables arr and value both point to the same array.
Apparently you thought your sorting manipulations were applied to a second array. But, no, you were changing the original array.
Learn about reference variables. The two variables are not an array themselves, they are a pointer to an array that lives elsewhere in memory. So there are three “things” in play here. One reference variable, another reference variable, and an array. All three are distinct from one another.
When these reference variables go out of scope or get assigned to another object, so no more reference variables point to the array object, then the array object becomes a candidate for garbage collection.
Seems that you want to copy the array to another array. Stack Overflow has many Questions and Answers on the topic of copying an array in Java for you to study. Like this one.

Here is another approach, You'd clone the array and sort
int[] value = arr.clone();
any operation on the cloned array wont affect the original array.
Ex
int[] arr = { 1, 4, 3 };
int[] a = arr.clone();
a[2] = 5;
System.out.println(Arrays.toString(arr));
System.out.println(Arrays.toString(a));
output
[1, 4, 3]
[1, 4, 5]

java array exact length

I set an array of integer like below
int[] a = new int[11111];
//if I set
a[0] = 1;
a[1] = 2;
a[2] = 3;
a[3] = 4;
I want a method such that it gives me
4 but 11111.
Is there any method which I can use?

You should look into using an ArrayList
ArrayList<Integer> myList=new ArrayList<Integer>();
myList.add(1);
myList.add(2);
myList.add(3);
System.out.println("Size:"+myList.size());

Well, the following method will do what you asked for:
public int m() {
return 4;
}
On the assumption that you want a method that takes an array, and returns the greatest index that has been populated - you're right that the a.length only tells you the size of the array, i.e. the number of cells allocated.
This is going to be harder than you might expect, especially with an int array. Those unassigned cells are initialised to a value of 0. If you might actually use zero values in your array, then there is absolutely no way to tell whether the value in a cell is the "default" zero or one that you've set yourself.
If the array can't have zero values in it, then you'd need to loop over its entire length, checking for the highest index with a corresponding non-zero value; something like this:
public int dynamicLength(int[] a) {
int max = -1;
for (i = 0; i < a.length; i++) {
if (a[i] != 0) max = i;
}
return max;
}
Even then this might not be ideal, since arrays can be sparsely populated. Do you want the count of assigned indices, or the index of the highest assigned index?
The short answer is almost certainly "use an ArrayList".

When you do
int[] a = new int[11111]
It creates an array with 11111 elements and as it is int it will assign it to default value that is 0 so you have array with all values set.
You should move to List

You should use an ArrayList if the size of the array is changing. There is little performance difference.
See here for how to use one. See here for the API also.
I understand that you only want the assigned elements to be counted but it would be safer at runtime and simpler to use an ArrayList. The ArrayList class just wraps a Java array and handles the changing size for you. You can get the size by calling the size() method on the ArrayList.
See this example using a for-each loop if you want to iterate over the elements:
ArrayList<Integer> list = new ArrayList<Integer>();
list.add(1); //size is 1
list.add(2); //size is 2
list.add(3); //size is 3
list.add(4); //size is 4
for(Integer n : list)
System.out.println(n);
An ArrayList uses an iterator and the for-each loop uses it to iterate over the ArrayList. Makes life much simpler.

As suggested above, using a List is probably the right answer. However, in the interest of solving the original problem, you could try this instead:
Integer[] foo = new Integer[11111];
foo[0] = new Integer(1);
foo[1] = new Integer(2);
foo[2] = new Integer(3);
foo[3] = new Integer(4);
and create a method that counts non-null values:
public static int countItems(Integer[] array) {
int count = 0;
for (Integer i : array) {
if (i != null) {
count++;
}
}
return count;
}
Of course, this will be a pain to manage as you would need to nullify any items no longer needed. It also raises the question of whether you would accept "holes" in your array, e.g. null values amongst non-null values. My example counting function above would accept such holes.
So, yes. Use a List.

You can create a method which calculates the non-0 elements of the array using a for/while loop.