**Hexaware Coding Questions**

**Problem 1:**

**Adam's Charity**

Adam decides to be generous and do some charity. Starting today, from day 1 until day n, he gives i^2 coins to charity on day ‘i’ (1≤i≤n).

Return the total coins, he would give to charity.

**Input specification:**

**Input 1:** number of days of Charity.

**Output Specification:**

Return the total number of coins till charity days.

**Example 1:**

**Input 1:** 2

**Output: **5

**Explanation:**

There are 2 days.

**Example 2:**

**Input 1:** 3

**Output:** 14

**Explanation:**

There are 3 days.

**Code:**

import java.util.*;

class Main

{

public static void main(String args[])

{

Scanner scan = new Scanner(System.in);

int n = scan.nextInt();

int sum = 0;

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

sum = sum + (int)Math.pow(i, 2);

}

System.out.println(sum);

}

}

**Explanation:**

1. The code begins by importing the required classes, `java.util.*`, which includes the Scanner class.

2. The `Main` class is defined.

3. The `main` method is the entry point of the program.

4. The code creates a Scanner object `scan` to read input from the user.

5. The variable `n` is initialized by reading an integer from the user using `scan.nextInt()`.

6. The variable `sum` is initialized to 0. This variable will store the sum of squares of numbers.

7. The code enters a for loop that iterates from `i = 1` to `i = n`.

8. Inside the loop, `Math.pow(i, 2)` calculates the square of the current number `i` and returns a double value.

9. `(int)` is used to cast the result of `Math.pow(i, 2)` to an integer to store it in the `sum` variable.

10. The calculated square is added to the `sum` variable using the `+=` operator.

11. After the loop ends, the final value of `sum` is printed using `System.out.println(sum)`.

12. The program execution ends.

Overall, the code calculates the sum of squares of numbers from 1 to `n` and prints the result.

**Problem 2:**

Problem Statement:

**The Cuckoo Sequence**

A Cuckoo Sequence is defined as shown.

Cuckoo[1]=0

Cuckoo[2]=1

Cuckoo[n]=1*Cuckoo[n-1]+2*Cuckoo[n-2]+3*1, for n>2

Given n(1<= n <=10^8), find Cuckoo[n].

**Input Specification:**

**Input1: **Integer n

**Output Specification:**

Return the value of Cuckoo[n]

**Example:**

Input: 3

Output: 4

Explanation: cuckoo(3) = 1*cuckoo(2) + 2*cuckoo(1) + 3*1

= 1*1 + 2*0 + 3 = 4

**Code:**

import java.util.*;

class Main

{

public static void main(String args[])

{

Scanner scan = new Scanner(System.in);

int n = scan.nextInt();

int res = cuckoo(n);

System.out.println(res);

}

public static int cuckoo(int n ){

if(n==1){

return 0;

}

else if (n==2){

return 1;

}

else{

return 1*cuckoo(n-1) + 2*cuckoo(n-2) + 3*1;

}

}

}

**Explanation:**

Code calculates the result of a recursive function `cuckoo()` and prints the result.

1. The code begins by importing the required classes, `java.util.*`, which includes the Scanner class.

2. The `Main` class is defined.

3. The `main` method is the entry point of the program.

4. The code creates a Scanner object `scan` to read input from the user.

5. The variable `n` is initialized by reading an integer from the user using `scan.nextInt()`. This value represents the input to the `cuckoo()` function.

6. The code calls the `cuckoo()` function with `n` as an argument and stores the result in the variable `res`.

7. Finally, the result `res` is printed using `System.out.println(res)`.

8. The `cuckoo()` function is defined outside the `main` method and takes an integer `n` as input.

9. The function checks for base cases using if-else conditions. If `n` is equal to 1, the function returns 0. If `n` is equal to 2, the function returns 1.

10. If none of the base cases match, the function uses recursion to calculate the result. The formula `1*cuckoo(n-1) + 2*cuckoo(n-2) + 3*1` is used to compute the result.

11. The function recursively calls itself with `n-1` and `n-2` as arguments and multiplies the results by 1 and 2, respectively. The final term `3*1` is added to the calculation.

12. The calculated result is returned by the function.

13. The program execution ends.

Overall, the code calculates the result of the `cuckoo()` function using recursion and prints the result. The function follows a specific formula based on the value of `n` to calculate the result.