Sum of first and last digit in recursion

Question

I had a test exam in java, that almost no one have succeeded in this question and I can't figure out the solution.

The question was like this:

Find the sum of an integer last and first number. For example 1234-->5, 137-->8, 4-->8. You are only allowed to use recursion and no helper function"

I tried various things. Here is my last attempt:

public static int sumOfFirstandLastdigits(int number)
 {
    int lastdigit=sumOfFirstandLastdigits(number/10);
    if(number/10==0)
      {
           return number%10;
      }
     return lastdigit+sumOfFirstandLastdigits(number%10);

 }

my general idea was that i store the last digit in the variable thats recursive until (n/10==0) it will return the last digit in this condition,then the function will add the last digit to the other recursion at first place meaning :"number%10"; it will the result will be number%10; — WinnyPoh, Jun 16 '21 at 17:52
It didn't *change*; each recursive call computed its own. Have you learned about "default parameters" yet? — Scott Hunter, Jun 16 '21 at 18:01
Is the signature of the method given with only one parameter, or can you add a second? — csalmhof, Jun 16 '21 at 18:01
only one parameter @ScottHunter i didn't learn "default parameters" and not allowed to use — WinnyPoh, Jun 16 '21 at 18:09

score 4 · Answer 1 · answered Jun 16 '21 at 18:23

4

Assuming the input is supposed to be non-negative:

//If n < 0, return first digit of -n
//Otherwise, return sum of first and last digits of n
int sumLastAndFirstDigit(int n) {
    if (n < -9)
        return sumLastAndFirstDigit(-(-n/10));
    if (n <= 0)
        return -n;
    if (n < 10)
        return n+n;
    return n%10 + sumLastAndFirstDigit(-(n/10));
}

answered Jun 16 '21 at 18:23

Scott Hunter

46,905
10
55
92

Interesting solution, I can see why most people would get this wrong on the test is this the intended answer. – Nexevis Jun 16 '21 at 18:35
when i get the official answer i will post it. – WinnyPoh Jun 16 '21 at 18:44

Nexevis · Answer 2 · 2021-06-16T18:12:45.680

1

You can do this by overloading the method and passing the last digit as a second parameter to keep track of it through the recursion without changing the value (AKA Default Parameter):

public static void main(String[] args) {
    
    System.out.println(sumDigits(3891901));
    System.out.println(sumDigits(1234));
    System.out.println(sumDigits(5678));

}

private static int sumDigits(int i) {
    return sumDigits(i, i % 10);
}

private static int sumDigits(int i, int j) {
    if (i / 10 == 0) {
        return i % 10 + j;
    }
    return sumDigits(i / 10, j);
}

Output:

4
5
13

This thread on default parameters might help learn more as well.

edited Jun 16 '21 at 18:12

answered Jun 16 '21 at 18:10

Nexevis

4,383
3
12
21

1

Unclear if an overloaded method counts as a helper. – Scott Hunter Jun 16 '21 at 18:11
2

@WinnyPoh I would be interested to see the solution with only a single parameter then while using recursion. – Nexevis Jun 16 '21 at 18:13
2

i guess the answer will be published tommorow,ill update here anyways what my professor solution – WinnyPoh Jun 16 '21 at 18:40

score 0 · Answer 3 · answered Jun 16 '21 at 18:07

Found a solution using String, not sure it's the best :

    public int sumLastAndFirstDigit(Integer firstDigit, int number) {
        String numberAsString = String.valueOf(number);
        //Set the first digit
        if(firstDigit == null) {
            firstDigit = Integer.valueOf(numberAsString.substring(0,1));
            //If there is only one digit in number for the first loop, then return 2 x firstDigit
            if(numberAsString.length() == 1) {
                return 2 * firstDigit;
            }
        }
        //Remove the first digit to create the new number
        String newNumberAsString = numberAsString.substring(1);
        Integer newNumber = Integer.valueOf(newNumberAsString);
        if(newNumberAsString.length() == 1) {
            //When it's the last digit, sum first and last
            return firstDigit + newNumber;
        }
        return sumLastAndFirstDigit(firstDigit, newNumber);
    }

Then do :

sumLastAndFirstDigit(null,1234);
sumLastAndFirstDigit(null,137);
sumLastAndFirstDigit(null,4);

sorry that dosen't help im not allowed to use string otherwise i would use it,thanks anyways — WinnyPoh, Jun 16 '21 at 18:09

score 0 · Answer 4 · answered Jun 16 '21 at 18:13

What i would do is to add a second parameter, which states if it is the first call of the recursive method.

public static int sumOfFirstandLastdigits(int number, boolean isFirstCall)
{
  int last = 0; //stays 0 if it is not the first call

  if(isFirstCall) {
    last = number%10;
  }

  if(number/10 == 0) {
    return last + number;
  } else {
    return last + sumOfFirstandLastdigits(number/10, false);
  }
}

An overloaded method for the first call then could look like this:

public static int sumOfFirstandLastdigits(int number) {
  sumOfFirstandLastdigits(number, true)
}

QuinncyJones · Answer 5 · 2021-06-16T19:28:49.863

0

Use the sign as a flag to recognize the initial call. Only works with positive numbers, of course.

public static int sum(int value){ 
    if(value > 0)
        // initial call
        return value % 10 + sum(-value);
    else
        // recursive call
        return -value < 10 ? -value : sum(value / 10);
}

edited Jun 16 '21 at 19:28

answered Jun 16 '21 at 19:07

QuinncyJones

539
1
4
10

score 0 · Answer 6 · edited Jun 19 '21 at 09:04

This are the 2 different solutions my professor suggested, although he said no helper (the first one is without an helper).

public static int sumFirstAndLast2(int num) {
        if (num < 10 )
            return num+num;
        return sumFirstAndLast2(num/10) - num%100/10 + num%10;
    }
    
    public static int sumFirstAndLast(int num) {
        if ( num < 10 )
            return num+num;
        return sumFirstAndLastHelper(num,true);
    }
    private static int sumFirstAndLastHelper(int num, boolean isLast) {
        if ( isLast )
            return num%10 + sumFirstAndLastHelper(num/10,false);
        if ( num < 10 )
            return num;
        return sumFirstAndLastHelper(num/10,false);
    }

Sum of first and last digit in recursion

6 Answers6