C Program to Print Command Line Arguments in Reverse Order

Introduction

In this C program, we will learn how to print Command Line Arguments in both their original order and reverse order using argc and argv. The program first displays all arguments exactly as they were passed from the command line. It then traverses the argument list in reverse direction and prints them from the last argument to the first. This example helps beginners understand forward traversal, reverse traversal, array indexing, and the usage of command line arguments in C programming.

---

Table of Contents

• Algorithm
• C Program
• Input
• Sample Output
• Explanation
• Dry Run
• Flow of Execution
• Time Complexity
• Space Complexity
• Applications
• Key Points
• Interview Questions
• Frequently Asked Questions
• Keywords
• Conclusion

---

Algorithm

1. Start the program.
2. Receive command line arguments using argc and argv.
3. Print a heading "Before Reverse".
4. Traverse the command line arguments from index 0 to argc - 1 and print each argument.
5. Print a heading "After Reverse".
6. Traverse the command line arguments from index argc - 1 to 0.
7. Print each argument in reverse order.
8. Terminate the program.

---

C Program

#include<stdio.h>

int main(int argc, char *argv[])
{
    printf("Before Reverse:\n");

    for(int i = 0; i < argc; i++)
    {
        printf("Argument[%d]=%s\n", i, argv[i]);
    }

    printf("\n\nAfter Reverse:\n");

    for(int i = argc - 1; i >= 0; i--)
    {
        printf("Argument[%d]=%s\n", i, argv[i]);
    }

    return 0;
}

---

Input

Run the program by passing one or more command line arguments through the terminal.

./a.out Apple Banana Mango Orange

---

Sample Output

Before Reverse:

Argument[0]=./a.out
Argument[1]=Apple
Argument[2]=Banana
Argument[3]=Mango
Argument[4]=Orange


After Reverse:

Argument[4]=Orange
Argument[3]=Mango
Argument[2]=Banana
Argument[1]=Apple
Argument[0]=./a.out

---

Output

Displays all command line arguments in their original order followed by the same arguments printed in reverse order.

---

Explanation

Step 1

The program receives command line arguments using the parameters argc and argv.

int main(int argc, char *argv[])

• argc stores the total number of command line arguments.
• argv stores all command line arguments as strings.
• argv[0] always contains the program name or executable path.

---

Step 2

Print the heading before displaying the arguments.

printf("Before Reverse:\n");

This heading indicates that the following output represents the original order of the command line arguments.

---

Step 3

Traverse the command line arguments from the first argument to the last argument.

for(int i = 0; i < argc; i++)
{
    printf("Argument[%d]=%s\n", i, argv[i]);
}

• The loop starts from index 0.
• It continues until argc - 1.
• Each iteration prints one command line argument.
• This displays the arguments exactly in the order they were entered.

---

Step 4

Print a heading before displaying the reverse order.

printf("\n\nAfter Reverse:\n");

This heading separates the original output from the reverse output, making the program output easier to understand.

---

Step 5

Traverse the command line arguments in reverse order.

for(int i = argc - 1; i >= 0; i--)
{
    printf("Argument[%d]=%s\n", i, argv[i]);
}

• The loop starts from the last index (argc - 1).
• The loop variable is decremented after every iteration.
• Each argument is printed from the last argument to the first.
• The program does not modify the original command line arguments.
• Only the order of printing is reversed.

---

Dry Run

Input

./a.out Apple Banana Mango Orange

Processing

Index	Command Line Argument	Original Order	Reverse Order
0	./a.out	1st	5th
1	Apple	2nd	4th
2	Banana	3rd	3rd
3	Mango	4th	2nd
4	Orange	5th	1st

The first loop prints the arguments from the beginning to the end. The second loop starts from the last index (argc - 1) and prints every argument in reverse order.

Output

Before Reverse:

Argument[0]=./a.out
Argument[1]=Apple
Argument[2]=Banana
Argument[3]=Mango
Argument[4]=Orange


After Reverse:

Argument[4]=Orange
Argument[3]=Mango
Argument[2]=Banana
Argument[1]=Apple
Argument[0]=./a.out

---

Flow of Execution

                Start
                  │
                  ▼
     Receive argc and argv
                  │
                  ▼
      Print "Before Reverse"
                  │
                  ▼
 Loop from i = 0 to argc - 1
                  │
                  ▼
 Print Each Command Line Argument
                  │
                  ▼
      Print "After Reverse"
                  │
                  ▼
Loop from i = argc - 1 to 0
                  │
                  ▼
Print Arguments in Reverse Order
                  │
                  ▼
                 Stop

---

Time Complexity

Operation	Complexity
Printing Arguments (Forward)	O(n)
Printing Arguments (Reverse)	O(n)

Best Case: O(n)

Average Case: O(n)

Worst Case: O(n)

Overall Time Complexity: O(n), where n is the total number of command line arguments.

Since the program traverses the command line arguments twice (once in the forward direction and once in the reverse direction), the total work performed is 2n. After removing the constant factor, the overall time complexity remains O(n).

---

Space Complexity

• No additional array or data structure is created.
• The program only uses the loop variable i.
• The existing argv array is provided by the operating system.

Auxiliary Space Complexity: O(1)

The program does not allocate any extra memory based on the number of command line arguments. Therefore, the auxiliary space complexity remains constant.

---

Applications

• Displaying command line arguments in reverse order.
• Learning forward and reverse traversal using loops.
• Developing Linux command-line utilities.
• Understanding the usage of argc and argv in C programming.
• Debugging command line inputs during program execution.
• Practicing array indexing and reverse iteration.
• Preparing for C programming and Linux interview questions.

---

Key Points

• argc stores the total number of command line arguments.
• argv is an array of character pointers that stores all command line arguments as strings.
• argv[0] always contains the program name or executable path.
• The first for loop prints the arguments in the same order in which they were entered.
• The second for loop starts from argc - 1 and prints the arguments in reverse order.
• The original command line arguments are not modified; only their display order is reversed.
• No additional memory is required to print the arguments in reverse order.
• This program is a good example for understanding reverse traversal using loops.

---

Interview Questions

1. What is the purpose of argc and argv in C?
2. Why does argv[0] contain the program name?
3. Why is the reverse loop initialized with argc - 1 instead of argc?
4. Does this program actually reverse the command line arguments?
5. Why is the loop condition written as i >= 0?
6. Can this program print reverse arguments without creating another array?
7. What happens if no additional command line arguments are supplied?
8. What is the time complexity of printing the arguments in reverse order?
9. What is the auxiliary space complexity of this program?
10. Where are command line arguments stored during program execution?

---

Frequently Asked Questions (FAQs)

1. What are command line arguments?

Command line arguments are values passed to a program while executing it from the terminal. They allow users to provide input without using functions like scanf().

2. What is stored in argv[0]?

The first element, argv[0], stores the program name or the path of the executable file.

3. Why does the reverse loop start from argc - 1?

Array indexing starts from 0, so the last valid index is always argc - 1.

4. Does this program reverse the original command line arguments?

No. The program only prints the arguments in reverse order. The original arguments remain unchanged in memory.

5. What happens if no additional command line arguments are passed?

Only the program name (argv[0]) is available. Therefore, both the forward and reverse outputs will display only the executable name.

6. Can command line arguments contain numbers?

Yes. However, every command line argument is received as a string. Numeric arguments can be converted into integers using functions such as atoi() or strtol().

7. What is the time complexity of this program?

The program traverses the arguments twice, resulting in an overall time complexity of O(n).

8. Is any extra memory allocated to reverse the arguments?

No. The program simply changes the direction of traversal and prints the arguments in reverse order without creating any additional array.

---

Keywords

C Program to Print Command Line Arguments in Reverse Order, Reverse Command Line Arguments in C, argc and argv in C, Print Arguments in Reverse Using argc argv, Command Line Arguments Example, Linux C Programming, Reverse Traversal in C, C Programming Examples, Command Line Input in C, C Interview Programs, Reverse Loop in C, argc argv Tutorial.

---

Conclusion

This program demonstrates how to print command line arguments in both their original order and reverse order using argc and argv in C. It first traverses the argument list from the beginning to the end and then performs a reverse traversal starting from argc - 1. Since the program only changes the order of printing and does not modify the original command line arguments, it is an excellent example for understanding array indexing, reverse iteration, command line argument handling, and loop traversal techniques in C programming. This is also a commonly asked interview program for beginners learning Linux programming and system programming concepts.