Is Number Negative? (Time Complexity: O(1), Language: Java)

## Understanding the Problem The problem is straightforward: we need to determine if a given number `n` is negative or not. If `n` is less than zero, we print "negative"; otherwise, we print "positive". ### Input and Output Formats - **Input**: A single integer `n`. - **Output**: A string, either "negative" or "positive". ### Constraints and Assumptions - The input will always be an integer. - There are no constraints on the range of the integer. ### Example to Illustrate the Problem **Example 1:**

Input: n = 5
Output: "positive"
Explanation: 5 is greater than or equal to zero, so our function prints "positive" to the console.

**Example 2:**

Input: n = 0
Output: "positive"
Explanation: 0 is greater than or equal to zero, so our function prints "positive" to the console.

**Example 3:**

Input: n = -2
Output: "negative"
Explanation: -2 is less than zero, so our function prints "negative" to the console.

## Core Challenge The core challenge is to correctly identify whether the number is negative or not. This is a fundamental problem that can be solved using basic conditional statements. ### Significance and Applications This problem is a basic example of using conditional statements, which are fundamental in programming. Understanding how to use these statements is crucial for more complex decision-making processes in software development. ### Potential Pitfalls and Misconceptions - Misunderstanding the condition: Ensure that the condition `n < 0` is correctly implemented. - Handling edge cases like zero: Remember that zero is not negative. ## Approach ### Naive Solution The naive solution involves using an `if-else` statement to check if the number is less than zero. #### Why It Is Not Optimal In this case, the naive solution is actually optimal because the problem is simple and the `if-else` statement is the most straightforward and efficient way to solve it. ### Optimized Solution Since the naive solution is already optimal, there is no need for further optimization. ## Algorithm 1. Take the input number `n`. 2. Use an `if` statement to check if `n` is less than zero. 3. If true, print "negative". 4. Otherwise, print "positive". ## Code Implementation Here is the Java code to solve the problem:

public class Main {
    public static void main(String[] args) {
        // Test cases
        checkNumber(5);   // Output: positive
        checkNumber(0);   // Output: positive
        checkNumber(-2);  // Output: negative
    }

    /**
     * This function checks if the number is negative or positive.
     * @param n the number to check
     */
    public static void checkNumber(int n) {
        if (n < 0) {
            System.out.println("negative");
        } else {
            System.out.println("positive");
        }
    }
}

### Explanation of the Code - The `checkNumber` function takes an integer `n` as input. - It uses an `if-else` statement to check if `n` is less than zero. - Depending on the result, it prints either "negative" or "positive". ## Complexity Analysis ### Time Complexity The time complexity of this solution is O(1) because the check and print operations take constant time. ### Space Complexity The space complexity is O(1) as well, since no additional space is required beyond the input number. ## Edge Cases - **Zero**: The function correctly identifies zero as "positive". - **Negative Numbers**: Any negative number will be correctly identified as "negative". - **Positive Numbers**: Any positive number will be correctly identified as "positive". ### Examples of Edge Cases - `n = 0` should output "positive". - `n = -1` should output "negative". - `n = 1` should output "positive". ## Testing To test the solution comprehensively: 1. Use a variety of test cases, including positive numbers, negative numbers, and zero. 2. Ensure the function handles edge cases correctly. ### Test Cases - `checkNumber(5)` should print "positive". - `checkNumber(0)` should print "positive". - `checkNumber(-2)` should print "negative". ## Thinking and Problem-Solving Tips - Always start by understanding the problem and identifying the core challenge. - Use simple and efficient solutions for straightforward problems. - Practice using conditional statements as they are fundamental in programming. ## Conclusion This problem is a basic example of using conditional statements to make decisions in code. Understanding and solving such problems is crucial for developing more complex algorithms and software. ## Additional Resources - [Java Documentation](https://docs.oracle.com/javase/8/docs/api/) - [Conditional Statements in Java](https://www.geeksforgeeks.org/decision-making-javaif-else-switch-break-continue-jump/) - [Practice Problems on LeetCode](https://leetcode.com/) By practicing and understanding these fundamental concepts, you can build a strong foundation in programming and problem-solving.