### 控制流陳述句

#### 數字和挑戰

- Write a method with the name
**sumDigits**that has one**int**parameter called**number**. - If parameter is
**>= 10**then the method should process the number and return**sum of all digits**, otherwise return**-1**to indicate an invalid value. - The number from
**0-9**have 1 digit so we don’t want to process them, also we don’t want to process negative numbers, so also return**-1**for negative numbers. - For example calling the method
**sumDigits(125)**should return**8**since**1 + 2 + 5 = 8**. - Calling the method
**sumDigit(1)**should return**-1**as per requirements described above. - Add some code to the main method to test out the
**sumDigits**method to determine that it is working correctly for valid and invalid values passed as arguments. - Hint
- Use
**n % 10**to extract the least-significant digit. - Use
**n = n /10**to discard the least-significant digit. - The method needs to be static like other methods so far in the course.

- Use
- Tip
- Create a project with the name
**DigitSumChallenge**.

- Create a project with the name

#### 數字和挑戰(解答)

1 | public static void main(String[] args) { |

#### 題目一

Write a method called isPalindrome with one int parameter called number.

The method needs to return a boolean.

It should return true if the number is a palindrome number otherwise it should return false.

Check the tips below for more info about palindromes.

1 | Example Input/Output |

Tip: What is a Palindrome number? A palindrome number is a number which when reversed is equal to the original number. For example: 121, 12321, 1001 etc.

Tip: Logic to check a palindrome number

Find the the reverse of the given number. Store it in some variable say reverse. Compare the number with reverse.

If both are the the same then the number is a palindrome otherwise it is not.

Tip: Logic to reverse a number

Declare and initialize another variable to store the reverse of a number, for example reverse = 0.

Extract the last digit of the given number by performing the modulo division (remainder).

Store the last digit to some variable say lastDigit = num % 10.

Increase the place value of reverse by one.

To increase place value multiply the reverse variable by 10 e.g. reverse = reverse * 10.

Add lastDigit to reverse.

Since the last digit of the number is processed, remove the last digit of num. To remove the last digit divide number by 10.

Repeat steps until number is not equal to (or greater than) zero.

A while loop would be good for this coding exercise.

Tip: Be careful with negative numbers. They can also be palindrome numbers.

Tip: Be careful with reversing a number, you will need a parameter for comparing a reversed number with the starting number (parameter).

NOTE: The method isPalindrome needs to be defined as public static like we have been doing

#### 題目一(答案)

1 | public class NumberPalindrome { |

#### 題目二

Write a method named sumFirstAndLastDigit with one parameter of type int called number.

The method needs to find the first and the last digit of the parameter number passed to the method, using a loop and return the sum of the first and the last digit of that number.

If the number is negative then the method needs to return -1 to indicate an invalid value.

1 | Example input/output |

NOTE: The method sumFirstAndLastDigit needs to be defined as public static like we have been doing so far in the course.

NOTE: Do not add a main method to solution code.

#### 題目二(答案)

1 | public class FirstLastDigitSum { |

#### 題目三

Write a method named getEvenDigitSum with one parameter of type int called number.

The method should return the sum of the even digits within the number.

If the number is negative, the method should return -1 to indicate an invalid value.

1 | EXAMPLE INPUT/OUTPUT: |

NOTE: The method getEvenDigitSum should be defined as public static like we have been doing so far in the course.

NOTE: Do not add a main method to the solution code.

#### 題目三(答案)

1 | public class EvenDigitSum { |

#### 題目四

Write a method named hasSharedDigit with two parameters of type int.

Each number should be within the range of 10 (inclusive) - 99 (inclusive). If one of the numbers is not within the range, the method should return false.

The method should return true if there is a digit that appears in both numbers, such as 2 in 12 and 23; otherwise, the method should return false.

1 | EXAMPLE INPUT/OUTPUT: |

NOTE: The method hasSharedDigit should be defined as public static like we have been doing so far in the course.

NOTE: Do not add a main method to the solution code.

#### 題目四(答案)

1 | public class SharedDigit { |

#### 題目五

Write a method named hasSameLastDigit with three parameters of type int.

Each number should be within the range of 10 (inclusive) - 1000 (inclusive). If one of the numbers is not within the range, the method should return false.

The method should return true if at least two of the numbers share the same rightmost digit; otherwise, it should return false.

1 | EXAMPLE INPUT/OUTPUT: |

Write another method named isValid with one parameter of type int.

The method needs to return true if the number parameter is in range of 10(inclusive) - 1000(inclusive), otherwise return false.

1 | EXAMPLE INPUT/OUTPUT |

NOTE: All methods need to be defined as public static as we have been doing so far in the course.

NOTE: Do not add a main method to the solution code.

#### 題目五(答案)

1 | public class LastDigitChecker { |

#### 題目六

Write a method named getGreatestCommonDivisor with two parameters of type int named first and second.

If one of the parameters is < 10, the method should return -1 to indicate an invalid value.

The method should return the greatest common divisor of the two numbers (int).

The greatest common divisor is the largest positive integer that can fully divide each of the integers (i.e. without leaving a remainder).

For example 12 and 30:

12 can be divided by 1, 2, 3, 4, 6, 12

30 can be divided by 1, 2, 3, 5, 6, 10, 15, 30

The greatest common divisor is 6 since both 12 and 30 can be divided by 6, and there is no resulting remainder.

1 | EXAMPLE INPUT/OUTPUT: |

HINT: Use a while or a for loop and check if both numbers can be divided without a remainder.

HINT: Find the minimum of the two numbers.

NOTE: The method getGreatestCommonDivisor should be defined as public static like we have been doing so far in the course.

NOTE: Do not add a main method to the solution code.

#### 題目六(答案)

1 | public class GreatestCommonDivisor { |

#### 題目七

Write a method named printFactors with one parameter of type int named number.

If number is < 1, the method should print “Invalid Value”.

The method should print all factors of the number. A factor of a number is an integer which divides that number wholly (i.e. without leaving a remainder).

For example, 3 is a factor of 6 because 3 fully divides 6 without leaving a remainder. In other words 6 / 3 = 2.

1 | EXAMPLE INPUT/OUTPUT: |

HINT: Use a while or for loop.

NOTE: When printing numbers, each number can be in its own line. They don’t have to be separated by a space.

For example, the printout for printFactors(10); can be:

1

2

5

10

NOTE: The method printFactors should be defined as public static like we have been doing so far in the course.

NOTE: Do not add a main method to the solution code.

#### 題目七(答案)

1 | public class FactorPrinter { |

#### 題目八

What is the perfect number?

A perfect number is a positive integer which is equal to the sum of its proper positive divisors.

Proper positive divisors are positive integers that fully divide the perfect number without leaving a remainder and exclude the perfect number itself.

For example, take the number 6:

Its proper divisors are 1, 2, and 3 (since 6 is the value of the perfect number, it is excluded), and the sum of its proper divisors is 1 + 2 + 3 = 6.

Therefore, 6 is a perfect number (as well as the first perfect number).

Write a method named isPerfectNumber with one parameter of type int named number.

If number is < 1, the method should return false.

The method must calculate if the number is perfect. If the number is perfect, the method should return true; otherwise, it should return false.

1 | EXAMPLE INPUT/OUTPUT: |

HINT: Use a while or for loop.

HINT: Use the remainder operator.

NOTE: The method isPerfectNumber should be defined as public static like we have been doing so far in the course.

NOTE: Do not add a main method to the solution code.

#### 題目八(答案)

1 | public class PerfectNumber { |

#### 題目九

Write a method called numberToWords with one int parameter named number.

The method should print out the passed number using words for the digits.

If the number is negative, print “Invalid Value”.

To print the number as words, follow these steps:

- Extract the last digit of the given number using the remainder operator.
- Convert the value of the digit found in Step 1 into a word. There are 10 possible values for that digit, those being 0, 1, 2, 3, 4, 5, 6, 7, 8, 9. Print the corresponding word for each digit, e.g. print “Zero” if the digit is 0, “One” if the digit is 1, and so on.
- Remove the last digit from the number.
- Repeat Steps 2 through 4 until the number is 0.

The logic above is correct, but in its current state, the words will be printed in reverse order. For example, if the number is 234, the logic above will produce the output “Four Three Two” instead of “Two Three Four”. To overcome this problem, write a second method called reverse.

The method reverse should have one int parameter and return the reversed number (int). For example, if the number passed is 234, then the reversed number would be 432. The method reverse should also reverse negative numbers.

Use the method reverse within the method numberToWords in order to print the words in the correct order.

Another thing to keep in mind is any reversed number with leading zeroes (e.g. the reversed number for 100 is 001). The logic above for the method numberToWords will print “One”, but that is incorrect. It should print “One Zero Zero”. To solve this problem, write a third method called getDigitCount.

The method getDigitCount should have one int parameter called number and return the count of the digits in that number. If the number is negative, return -1 to indicate an invalid value.

For example, if the number has a value of 100, the method getDigitCount should return 3 since the number 100 has 3 digits (1, 0, 0).

1 | Example Input/Output - getDigitCount method |

1 | Example Input/Output - reverse method |

1 | Example Input/Output - numberToWords method |

HINT: Use a for loop to print zeroes after reversing the number. As seen in a previous example, 100 reversed becomes 1, but the method numberToWords should print “One Zero Zero”. To get the number of zeroes, check the difference between the digit count from the original number and the reversed number.

NOTE: When printing words, each word can be in its own line. For example, numberToWords(123); can be:

One

Two

Three

They don’t have to be separated by a space.

NOTE: The methods numberToWords, getDigitCount, reverse should be defined as public static like we have been doing so far in the course.

NOTE: In total, you have to write 3 methods.

NOTE: Do not add a main method to the solution code.

#### 題目九(答案)

1 | public class NumberToWords { |