Parsing numeric arguments - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of parsing integer with strtol

What is the output of this C program when parsing the string "123abc" using strtol?

C

#include <stdio.h>
#include <stdlib.h>

int main() {
    const char *str = "123abc";
    char *endptr;
    long val = strtol(str, &endptr, 10);
    printf("Value: %ld\n", val);
    printf("Remaining string: %s\n", endptr);
    return 0;
}

A

Value: 123
Remaining string: abc

B

Value: 0
Remaining string: 123abc

C

Value: 0
Remaining string: 

D

Value: 123
Remaining string: 

💡 Hint

Remember that strtol stops parsing when it encounters a non-digit character.

The function strtol parses the initial part of the string as a number until it finds a character that is not valid for the number base. Here, it parses "123" and stops at "a", so val is 123 and endptr points to "abc".

❓ Predict Output

intermediate

Output when parsing invalid number with strtol

What is the output of this C program when parsing the string "abc123" using strtol?

C

#include <stdio.h>
#include <stdlib.h>

int main() {
    const char *str = "abc123";
    char *endptr;
    long val = strtol(str, &endptr, 10);
    if (endptr == str) {
        printf("No digits were found\n");
    } else {
        printf("Value: %ld\n", val);
    }
    return 0;
}

A

No digits were found

B

Value: 0

C

Value: -1

D

Value: 123

💡 Hint

Check what happens if the string does not start with digits.

strtol returns 0 and sets endptr to the original string if no digits are found at the start. The program checks if endptr equals str to detect this case and prints "No digits were found".

❓ Predict Output

advanced

Output of parsing hexadecimal number with strtol

What is the output of this C program when parsing the string "0x1A3f" using strtol with base 0?

C

#include <stdio.h>
#include <stdlib.h>

int main() {
    const char *str = "0x1A3f";
    char *endptr;
    long val = strtol(str, &endptr, 0);
    printf("Value: %ld\n", val);
    printf("Remaining string: %s\n", endptr);
    return 0;
}

A

Value: 0
Remaining string: 0x1A3f

B

Value: 6719
Remaining string: 

C

Value: 1
Remaining string: A3f

D

Value: 6719
Remaining string: 0x1A3f

💡 Hint

Base 0 lets strtol detect the base from the string prefix.

When base is 0, strtol detects the base automatically. The prefix "0x" means hexadecimal, so it parses "1A3f" as hex which is 6719 decimal. The entire string is parsed, so endptr points to the empty string.

❓ Predict Output

advanced

Output when parsing float with strtol

What is the output of this C program when parsing the string "3.14" using strtol?

C

#include <stdio.h>
#include <stdlib.h>

int main() {
    const char *str = "3.14";
    char *endptr;
    long val = strtol(str, &endptr, 10);
    printf("Value: %ld\n", val);
    printf("Remaining string: %s\n", endptr);
    return 0;
}

A

Value: 3
Remaining string: 14

B

Value: 0
Remaining string: 3.14

C

Value: 3
Remaining string: .14

D

Value: 314
Remaining string: 

💡 Hint

strtol stops parsing at the first character that is not valid for an integer.

strtol parses the initial integer part "3" and stops at the dot "." which is not valid for integers. So val is 3 and endptr points to ".14".

🧠 Conceptual

expert

Behavior of strtol on overflow

What happens when strtol parses a number larger than LONG_MAX in C?

A It causes a runtime crash due to overflow.

B It returns 0 and sets errno to EINVAL.

C It returns the number modulo LONG_MAX without error.

D It returns LONG_MAX and sets errno to ERANGE.

💡 Hint

Check the C standard behavior for overflow in strtol.

When the parsed number is out of range for long, strtol returns LONG_MAX or LONG_MIN depending on sign and sets errno to ERANGE to indicate overflow.

Practice

1. What does the atoi function do in C when parsing numeric arguments?

easy

A. Converts a string to an integer without error checking

B. Converts a string to a floating-point number

C. Checks if a string contains only digits

D. Parses a string and returns a pointer to the next character

Solution

1. Step 1: Understand atoi function purpose

   atoi converts a string to an integer but does not check for errors or invalid input.

2. Step 2: Compare with other parsing functions

   Unlike strtol, atoi does not provide error detection or pointer to next character.

3. Final Answer:

   Converts a string to an integer without error checking -> Option A

4. Quick Check:

   atoi = simple integer conversion [OK]

Hint: Remember: atoi converts but doesn't check errors [OK]

Common Mistakes:

• Thinking atoi checks for invalid input
• Confusing atoi with strtol
• Assuming atoi returns pointer to next char

2. Which of the following is the correct syntax to parse a string "1234" to an integer using strtol in C?

easy

A. int num = strtol("1234", NULL, 10);

B. long num = strtol("1234", NULL, 10);

C. long num = atoi("1234", NULL, 10);

D. int num = strtol("1234", 10, NULL);

Solution

1. Step 1: Check strtol return type

   strtol returns a long, so the variable must be long.

2. Step 2: Verify argument order

   Arguments are: string, pointer to char* for end, and base (10 for decimal). So strtol("1234", NULL, 10) is correct.

3. Final Answer:

   long num = strtol("1234", NULL, 10); -> Option B

4. Quick Check:

   strtol returns long, args: string, endptr, base [OK]

Hint: Remember strtol returns long, not int [OK]

Common Mistakes:

• Using int instead of long for strtol result
• Mixing argument order in strtol
• Using atoi syntax with strtol

3. What will be the output of this C code snippet?

#include 
#include 

int main() {
    char *str = "42abc";
    char *endptr;
    long val = strtol(str, &endptr, 10);
    printf("%ld %s\n", val, endptr);
    return 0;
}

medium

A. Error

B. 0 42abc

C. 42abc (null)

D. 42 abc

Solution

1. Step 1: Understand strtol parsing behavior

   strtol converts initial numeric part "42" to long and sets endptr to point after parsed number, which is "abc".

2. Step 2: Analyze printf output

   It prints the number 42 and then the string starting at endptr, which is "abc".

3. Final Answer:

   42 abc -> Option D

4. Quick Check:

   Parsed number + leftover string = 42 abc [OK]

Hint: Check where endptr points after strtol [OK]

Common Mistakes:

• Assuming strtol parses entire string
• Ignoring endptr usage
• Expecting error on non-digit suffix

4. Identify the error in this code snippet that parses a numeric argument:

#include 

int main(int argc, char *argv[]) {
    int num = atoi(argv[1]);
    if (num == 0) {
        printf("Invalid number\n");
    }
    return 0;
}

medium

A. Missing check if argc > 1 before accessing argv[1]

B. Using int instead of long for atoi result

C. atoi returns 0 for invalid input and valid zero, causing confusion

D. No error, code is correct

Solution

1. Step 1: Check argument count before access

   The code uses argv[1] without verifying argc > 1, risking out-of-bounds access.

2. Step 2: Understand atoi zero ambiguity

   While atoi returns 0 for invalid input and valid zero, the bigger issue is missing argument check causing runtime error.

3. Final Answer:

   Missing check if argc > 1 before accessing argv[1] -> Option A

4. Quick Check:

   Always check argc before argv access [OK]

Hint: Always check argc before argv usage [OK]

Common Mistakes:

• Ignoring argc check leads to crashes
• Confusing atoi zero return meaning
• Assuming atoi handles errors

5. You want to safely parse a command-line argument as a positive integer in C. Which approach correctly handles invalid input and zero?

#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[]) {
    if (argc <= 1) {
        printf("No input provided\n");
        return 1;
    }
    char *endptr;
    long val = strtol(argv[1], &endptr, 10);
    if (*endptr != '\0' || val <= 0) {
        printf("Invalid positive integer\n");
        return 1;
    }
    printf("Parsed value: %ld\n", val);
    return 0;
}

hard

A. Fails to check if argv[1] is NULL before parsing

B. Does not handle negative numbers correctly

C. Correctly parses positive integers and rejects invalid or zero input

D. Should use atoi instead of strtol for safety

Solution

1. Step 1: Check argument count

   The code checks if argc <= 1 to ensure input is provided.

2. Step 2: Use strtol with endptr to detect invalid characters and check if value is positive

   It verifies *endptr == '\0' to confirm full string parsed and val > 0 to ensure positive integer.

3. Final Answer:

   Correctly parses positive integers and rejects invalid or zero input -> Option C

4. Quick Check:

   strtol + endptr + value check = safe parsing [OK]

Hint: Use strtol with endptr and check value > 0 [OK]

Common Mistakes:

• Using atoi which can't detect invalid input
• Not checking endptr for leftover chars
• Ignoring zero or negative values