We Keep Coding

Recursive function that has an array of integers and it's size as parameters that will return true if the sum of the array elements is even?

How do I create a function that has an array of integers and the array's length as parameters that will return true if the sum of the array elements is even and false otherwise?
How would I do this without using any static variables?
I've tried making a code that will check if,
current is odd and previous is even will return false recursively, else will return true recursively, this idea is based on the mathematical axiom that only even plus odd is equal to odd, every other combination is even.
public static boolean q3(int[] arr, int index) {
if (index == 0) {
return arr[index] % 2 == 0;
}
if (arr[index] % 2 == 0) {//if current is even
if (!q3(arr, index - 1)) {//even plus odd = odd
return false;
} else
return true; //every other combo equal true
} else if (q3(arr, index - 1)) {//if current is odd
return true;
} else {
return false;
}
}

I wrote 2 versions, one with recursion, other with no recursion
import java.util.Arrays;
public class MyClass {
public static void main(String args[]) {
int[] arr={5, 3, 1};
System.out.println("sum of "+Arrays.toString(arr)+" is " + size_ispair_rec(arr, arr.length));
}
public static boolean size_ispair_rec(int[] arr, int size){
if(size-1 == 0){
return arr[size]%2==0;
}
return !((arr[size-1]%2 == 0) ^ size_ispair_rec(arr, size-1));
}
public static boolean size_ispair(int[] arr, int size){
int sum=0;
for(int i=0; i<size; ++i){
sum+=arr[i];
}
return sum%2 == 0 ? true : false;
}
}

Here is a recursive method that does the job. I've tried to keep the code readable.
The idea is that the only time you get an even number by addition is when
Both the numbers are even
Both the numbers are odd
At every recursive call, we check if adding the number to the previous calculated value makes it even or odd.
public static boolean isSumEven(int arr[], int length){
if(length == 0){
return true;
} else {
boolean sumPreviousElemsEven = isSumEven(arr, length - 1);
boolean currentElemEven = arr[length-1]%2 == 0 ? true : false;
if(sumPreviousElemsEven && currentElemEven || !sumPreviousElemsEven && !currentElemEven){
return true;
} else {
return false;
}
}
}

find if given pack of coins can make a given value - coin row problem

given array of coins (int) and an int n the function need to return true if there is atleast one solution to the coin-change problem.
meaning: for array of ints> 0: [c(0) ,c(1) ,c(2) ,c(3) ,...... ,c(k)]. check if there is a solution for
the eqauation: a(0)*c(0)+ a(1)*c(1)+.....+ a(k)*c(k)= n. //n is the money we need to change
given c(0),c(1),....,c(n) >0 and a(0),a(1),....,a(n) =>0 both integers.
so I managed to make this code: the problem is that its algorithmic efficiency sucks, and this should be running on high values, and big coins array, so I need a code that is able to do this quicker.
public static boolean change(int[] coins, int n) {
boolean ans = false;
//loop running in recursion till founds ans/ passing limit
for (int i = 0; i < coins.length & (!ans); i = i + 1) {
if (n % coins[i] == 0) {
return true;
}
if (n >= coins[i]) {
ans = change(coins, n - coins[i]);
}
}
return ans;
}//O(n*k^n) solution for false ans , very bad :(
for example: for coins = {2,4,8} and n= 4111; I should get false, but the program unable to run this.
btw I would prefer this function to use recursion, but any solution/ guidnes is good :)
this is an other try doing this better but still not running as wanted.
//trying to use binary search and using divisions instead of minus
public static int iscashable(int[] coins, int n, int min, int max)
{
int check=(max+min)/2;
if(check == coins.length-1 | check == 0)
return check;
if(n/coins[check] > n% coins[check])
{
return (iscashable(coins,n,check,max));
}
else
{
return check;
}
}
public static int canchange(int[] coins, int n, int count)
{
int x=0;
int check= iscashable(coins,n,0,coins.length-count);
if(n%coins[check]==0)
{
return 0;
}
if(check==0)
{
return n;
}
if(n/coins[check] > n% coins[check])
{
x= (n/coins[check]) - (n% coins[check]);
int k= n-(coins[check]*x);
return canchange(coins, k, count+1);
}
else
{
return canchange(coins,n-coins[check],count+1);
}
}
the problem is both about runtime and number of recursion calls (with big number given, every recursion layer is coins.length^(num of layers));
I really thank you for your help!

Using IsPrime method in Java [closed]

Closed. This question needs debugging details. It is not currently accepting answers.
Edit the question to include desired behavior, a specific problem or error, and the shortest code necessary to reproduce the problem. This will help others answer the question.
Closed 7 years ago.
Improve this question
This is my code to use IsPrime method to determine total number of primes between 0 and 1000 and print the total number of primes at last. Can anyone tell what's wrong with the code.
public static void main(String[] args) {
int z=0;
// z is the variable that holds total number of primes
//n is divisor
//i is dividend
if (isPrime(i)) {
z++;
}
System.out.print(z+"\n");
}
public static boolean isPrime(int n){
{
for(i=0; i<1000; i++)
{
for(n=0; n<i; n++)
if(i%n==0)
return false;
else
return true;
}
}
}
Thanks in advance

Formatting it might help you discover the error.
I see a few things that's wrong with your code:
From what I can see, you have an extra open curly bracket in your isPrime method.
i isn't declared in your main method.
You need to wrap your if(isPrime(i)) statement inside a for loop that goes from 0 to 1000. Like the following:
for (int i = 0; i <= 1000; i++) {
if (isPrime(i))
z++;
}
That way, it will be actually checking all the prime numbers from 0 to 1000
For good coding practices, I would name your z variable to be something like counter so that it's clear what that variable is supposed to be doing. i in for-loop is okay since that's a common way to index through the loop.
You can also use several tactics to optimize your code. You can use Math.sqrt() function, as well as start your for loop from 3 and go up by increment of 2 (since any even number will be dividable by 2) and initialize your counter from 1 since 2 will already be a prime number.

public static boolean isPrime(int n){
int factors = 0;
for(int i = 1; i <= n; i++){
if(n % i == 0) // ensure that you mod n not i
factors++;
}
// if factors count is equals to 2 then it is prime number else it's not prime number
if(factors == 2)
return true;
else
return false;
}
Check this modified code once for your reference.

I think you had a few things turned around.
Why not loop from 1 to 1000 in your primary function and then use the isPrime function to determine if each number is prime.
In the isPrime function, you count from 2 to 1/2 the value of the number and do the divisions to determine if it is prime. Return False if it is divisible.
public static void main(String[] args) {
int z=0;
for (i=1;i<=1000;i++) {
if (isPrime(i))
{
z++;
}
}
System.out.print(z+"\n");
}
public static boolean isPrime(int n){
for(i=2; i<=n/2; i++)
{
if(n%i==0) return false;
}
return true;
}

This will count the number of primes based on this link and your original answer...
public static void main(String[] args) {
int isPrimeCount = 0;
for(i=0; i<1000; i++)
{
if(Check_Prime(i))
{
isPrimeCount++;
}
System.out.println(isPrimeCount);
}
}
private static boolean Check_Prime(int number) {
int i;
for (i = 2; i <= number - 1; i++)
{
if (number % i == 0)
{
return false;
}
}
if (i == number)
{
return true;
}
return false;
}

You need to define the variable "i" before you pass it to the isPrime() method in main(). It seems as though whoever wrote the code did not fully understand what a prime number was. According to wikipedia "A prime number (or a prime) is a natural number greater than 1 that has no positive divisors other than 1 and itself. " With this in mind you need to make sure that the value you pass to the isPrime() method is greater than 1. After look at your code I made some changes. I made the isPrime() method return false if the input value is <=1. Also, I made the isPrime() method return true if the input value is 2. I made other changes in the code that would make the for statement operate n-1 times because that is all that is needed to find out if the number is prime because all numbers are divisible by themselves. Also the for statement starts at the value 2. Your if-then-else return statements within the for loop is illogical because it will return a value without going through the entire loop. You did not need the inner for loop.
Here's a link on prime numbers
Here is the new code:
public class AreaComparison {
/**
* Starts the program.
*
* #param command line arguments
*/
public static void main(String[] args) {
int z = 0;
int i = 2;
// z is the variable that holds total number of primes
//n is divisor
//i is dividend
if (isPrime(i)) {
z++;
}
System.out.print(z + "\n");
}
public static boolean isPrime(int n) {
if (n <= 1) {
return false;
}
if(n == 2){
return true;
}
for (int i = 2; i < n; i++) {
if (n % i == 0) {
return false;
}
}
return true;
}
}

Translate Pseudocode and get the result

Can you help translating this Pseudocode into java and get the result
as I tried but didn't get the results and I'm starting to learn Java.
num=2
create list called list
while(true){
empty list
bool = false
for i=1 to num-1
if(num mod i==0){
add i to list
if((i &(bitwise)1)==1)
bool=!bool
}
if sum(list)==num && bool//logical and
return num; //Found the number we seek
num++
}
This is Java translating but I'm not sure as it didn't get the result numbers
/* package whatever; // don't place package name! */
import java.util.*;
import java.lang.*;
import java.io.*;
import java.util.ArrayList;
/* Name of the class has to be "Main" only if the class is public. */
class Ideone
{
public static void main (String[] args) throws java.lang.Exception
{
// your code goes here
//set a number
int num=2;
//make list called list
ArrayList<Integer> list = new ArrayList<Integer>();
//run this while true, but just saying true makes an infinite loop
boolean bool = true;
while(bool){
//clear the list
list.clear();
//set
bool = false;
for (int i= 1; i < num-1; i = i + 1){
//If number modulo i is 0
if((num % i) ==0){
list.add(i);
//If bitwise and of i and 1 is true
//This is doing things with the underlying binary
if((i & 1)==1)
//Reverse the valuse of bool
bool = !bool;
}
int sum = 0;
//for each element in the list
for(int x: list){
//add it to sum
sum += sum;
}
//execute is sum and num are the same and bool is true
if ((sum == num )&& bool){}
return num;
//This does nothing as it is never reached. return ends your execution
num++;
}
}
}
}

This sure looks like some assignment. Anyways, here's the translation of the pseudocode:
public int code ()
{
int num = 2;
List<Integer> list = new ArrayList<> ();
while (true)
{
list.clear ();
boolean bool = false;
for (int i = 1; i < num; ++i)
{
if (num % i == 0)
{
list.add (i);
if ((i & 1) == 1)
{
bool = !bool;
}
}
}
if (sum (list) == num && bool)
{
return num;
}
num++;
}
}
private int sum (List<Integer> list)
{
return list.stream ().mapToInt (i -> i).sum ();
}
The code is sure taking time to print out any result.
Try calling the code method and you'll see.
Apart from that, what number this code is trying to find, you may ask?
Well, through logical deduction, I can tell that this code is trying to find the smallest Perfect Number that has odd number of odd factors. Try thinking about it.

It will never get the result, most probably at least.
As someone already said it is trying to find "the smallest Perfect Number that has odd number of odd factors", and any number that have in its sum odd number of odd numbers is odd. So its searching for odd perfect number which is yet to proven if it exist or not that is why it will never give you result fast enough. It could take million years it could take forever. The question was supposed to be solved by logic.
BTW: Actually I am the one who made this pseudocode, better luck solving the code next weak. (:

Prime Tester for speed

I was given a homework assignment in Java to create classes that find Prime number and etc (you will see in code better).
My code:
class Primes {
public static boolean IsPrime(long num) {
if (num%2==0){
return false;
}
for (int i=3; i*i<=num;i+=2) {
if (num%i==0) {
return false;
}
}
return true;
} // End boolen IsPrime
public static int[] primes(int min, int max){
int counter=0;
int arcount=0;
for (int i=min;i<max;i++){
if (IsPrime(i)){
counter++;
}
}
int [] arr= new int[counter];
for (int i=min;i<max;i++){
if (IsPrime(i)){
arr[arcount]=i;
arcount++;
}
}
return arr;
} // End Primes
public static String tostring (int [] arr){
String ans="";
for (int i=0; i<arr.length;i++){
ans= ans+arr[i]+ " ";
}
return ans;
}
public static int closestPrime(long num){
long e = 0 , d = 0 , f = num;
for (int i = 2; i <= num + 1 ; i++){
if ((num + 1) % i == 0){
if ((num + 1) % i == 0 && (num + 1) == i){
d = num + 1;
break;
}
num++;
i = 1;
}
}
num = f;
for (int i = 2; i < num; i++){
if ((num - 1) % i == 0){
if ((num - 1) % i == 0 && (num - 1) == i){
e = num - 1;
break;
}
num--;
i = 1;
}
}
num = f;
if (d - num < num - e) System.out.println("Closest Prime: "+d);
else System.out.println("Closest Prime: "+e);
return (int) num;
} // End closestPrime
}//end class
The goal of my code is to be faster (and correct). I'm having difficulties achieving this. Suggestions?
**New code:
class Primes {
public static boolean IsPrime(int num) {
if (num==1){
return false;
}
for (int i=2; i<Math.sqrt(num);i++) {
if (num%i==0) {
return false;
}
}
return true;
}
// End boolen IsPrime
public static int[] primes(int min, int max){
int size=0;
int [] arrtemp= new int[max-min];
for (int i=min;i<max;i++){
if (IsPrime(i)){
arrtemp[size]=i;
size++;
}
}
int [] arr= new int[size];
for (int i=0;i<size;i++){
arr[i]=arrtemp[i];
}
return arr;
}
public static String tostring (int [] arr){
String ans="";
for (int i=0; i<arr.length;i++){
ans= ans+arr[i]+ " ";
}
return ans;
}
public static int closestPrime(int num) {
int count=1;
for (int i=num;;i++){
int plus=num+count, minus=num-count;
if (IsPrime(minus)){
return minus;
}
if (IsPrime(plus)) {
return plus;
}
count=count+1;
}
} // End closestPrime
}//end class
I did try to make it a bit better. what do you think, it can be improved more? (the speed test is still high...)

In your primes function you:
Check if the current number is divisible by two
Check to see if it's prime
Create an array to put your output in.
Check every number in the range again for primality before putting it in your array.
The problem is in the last step. By double-checking whether each number is prime, you're duplicating your most expensive operations.
You could use a dynamic data structure and add prime numbers to it as you find them. That way you only need to check once.
Alternatively, you could create a boolean array which is the size of your input range. Then as you find primes, set the corresponding array value to true.
UPDATE:
There are still a number of improvements you can make, but some will require more work than others to implement. Look at the specifics of your test and see what fits your needs.
Low-hanging fruit:
Use an ArrayList to collect primes as you find them in primes, as opposed to looping over the values twice.
In closestPrime, you're checking every single value on either side of num: half of these are even, thus not prime. You could adapt your code to check only odd numbers for primality.
Trickier to implement:
Try a more advanced algorithm for IsPrime: check out the Sieve of Eratosthenes
Above all, you should spend some time figuring out exactly where the bottlenecks are in your code. Oftentimes performance problems are caused by code we thought was perfectly fine. You might consider looking into the code-profiling options available in your development environment.

You make quite a few calls to isPrime(), each of which is very expensive. Your first step should be to minimize the number of times you do that, since the result doesn't change for any given number, there's no point calling more than once. You can do this with memoization by storing the values once they're computed:
ArrayList<Integer> memoList = new ArrayList<Integer>();
for(int i = 0; i < max; i++) {
if(isPrime(i)) {
memoList.add(i);
}
}
Now memoList holds all the primes you need, up to max, and you can loop over them rapidly without needing to recompute them every time.
Secondly, you can improve your isPrime() method. Your solution loops over every odd number from 3 to sqrt(n), but why not just loop over the primes, now that we know them?
public static boolean IsPrime(long num) {
for(int p : memoList) {
if(num % p == 0) {
return false;
}
}
return true;
}
These changes should dramatically improve how quickly your code runs, but there has been a lot of research into even more efficient ways of calculating primes. The Wikipedia page on Prime Numbers has some very good information on further tactics (prime sieves, in particular) you can experiment with.
Remember that as this is homework you should be sure to cite this page when you turn it in. You're welcome to use and expand upon this code, but not citing this question and any other resources you use is plagiarism.

I see a couple problems with your answer. First, 2 is a prime number. Your first conditional in IsPrime breaks this. Second, in your primes method, you are cycling through all number from min to max. You can safely ignore all negative numbers and all even numbers (as you do in IsPrime). It would make more sense to combine these two methods and save all the extra cycles.