Here ! we tackle an interesting 🧠 problem: given an 🧮 array of integers, we aim to print all its 🔁 distinct elements, arranged in a specific ↔️ alternating order of smallest, largest, second smallest, second largest, and so on. This challenge not only tests our ability to handle arrays 📦 and remove duplicates ❌ but also involves sorting 📊 and creative output manipulation. 🛠️

Problem Statement

🎯 Given an 🧮 array of integers, print the distinct elements such that the output alternates between the smallest 🔽 and largest 🔼 values, followed by the second smallest and second largest, and so on.

Input Format 📝

💻 A single line containing an array of integers.

Constraints ⛓️

• 🔢 All numbers in the input array are integers.

Output Format 🖨️

Print the distinct integers in the specified ↔️ alternating order.

Example

Input:

1 7 9 1 4 3 2 4

Output:

1 9 2 7 3 4

Approach 🚀

To solve this problem, we’ll break it down into smaller steps:

1️⃣ Parse Input: Read the 🧮 array of integers as input. 2️⃣ Remove Duplicates: Use a data structure 📂 to remove duplicates and sort the elements. 3️⃣ Arrange in Alternating Order: Use two pointers 👆👇 to alternate between the smallest and largest elements. 4️⃣ Output the Result: Print 🖨️ the processed array in the desired order.

Step-by-Step Solution 🛠️

Step 1: Parse Input 📥

We’ll read the input as a single line of 📝 text and extract integers 🔢 from it. This step ensures flexibility in handling input formats.

Step 2: Remove Duplicates ❌

To remove duplicates and maintain sorted order, we’ll use a std::set. This data structure automatically handles duplicate removal and keeps elements in ascending order 🔼.

Step 3: Arrange in Alternating Order ↔️

With the distinct and sorted elements, we use two pointers 👆👇: one starting from the smallest element 🔽 and the other from the largest 🔼. By alternating between these pointers, we can construct the desired order.

Step 4: Output the Result 🖨️

Finally, print 🖨️ the elements with appropriate formatting.

Code Implementation 💻

low is the complete implementation in C++:

#include <iostream> 📥
#include <vector> 📦
#include <set> 📂
#include <algorithm> 🔄
using namespace std; 🚀

int main() {
    // Step 1: Parse Input 📥
    string input;
    getline(cin, input);

    vector<int> arr;
    int num;
    for (size_t i = 0; i < input.size(); ++i) {
        if (isdigit(input[i]) || input[i] == '-') {
            size_t idx;
            num = stoi(input.substr(i), &idx);
            arr.push_back(num);
            i += idx - 1;
        }
    }

    // Step 2: Remove Duplicates ❌ and Sort 🔼
    set<int> uniqueElements(arr.begin(), arr.end());
    vector<int> sortedElements(uniqueElements.begin(), uniqueElements.end());

    // Step 3: Arrange in Alternating Order ↔️
    vector<int> result;
    int left = 0, right = sortedElements.size() - 1;
    while (left <= right) {
        result.push_back(sortedElements[left++]);
        if (left <= right) result.push_back(sortedElements[right--]);
    }

    // Step 4: Output the Result 🖨️
    for (size_t i = 0; i < result.size(); ++i) {
        if (i > 0) cout << " ";
        cout << result[i];
    }
    cout << endl;

    return 0;
}

Explanation of Code 🧵
Input Parsing 📥
getline(cin, input);

📜 Reads the input as a single line of 📝 text.
for (size_t i = 0; i < input.size(); ++i) {
    if (isdigit(input[i]) || input[i] == '-') {
        size_t idx;
        num = stoi(input.substr(i), &idx);
        arr.push_back(num);
        i += idx - 1;
    }
}

• 🔄 Loops through the input string 🧵, extracts integers 🔢 using stoi(), and appends them to the array arr 📦.

Removing Duplicates ❌

set<int> uniqueElements(arr.begin(), arr.end());
vector<int> sortedElements(uniqueElements.begin(), uniqueElements.end());

• A std::set 📂 is initialized with the array, removing duplicates ❌ and sorting the elements 🔼.
• The sorted elements are transferred to a vector 📦 for further manipulation.

Alternating Order ↔️

int left = 0, right = sortedElements.size() - 1;
while (left <= right) {
    result.push_back(sortedElements[left++]);
    if (left <= right) result.push_back(sortedElements[right--]);
}

• Two pointers 👆👇 (left and right) are used to alternately pick elements 🔁 from the smallest 🔽 and largest 🔼 ends of the sorted array until all elements are used.

Output 🖨️

for (size_t i = 0; i < result.size(); ++i) {
    if (i > 0) cout << " ";
    cout << result[i];
}
cout << endl;

• The result vector 📦 is printed with spaces ➖ between the elements.

Example Walkthrough 👣

Input:

1 7 9 1 4 3 2 4

Execution 🔄:

1️⃣ Parse Input: arr = [1, 7, 9, 1, 4, 3, 2, 4]

2️⃣ Remove Duplicates: uniqueElements = {1, 2, 3, 4, 7, 9} sortedElements = [1, 2, 3, 4, 7, 9]

3️⃣ Alternating Order: result = [1, 9, 2, 7, 3, 4]

4️⃣ Output:

1 9 2 7 3 4

Complexity Analysis 📊

1️⃣ Input Parsing: , where is the length of the input string 🧵. 2️⃣ Removing Duplicates: for inserting elements into the set 📂. 3️⃣ Alternating Order Construction: , where is the number of unique elements 🔢.

Overall: 🚀

Key Takeaways 🗝️

1️⃣ Using Sets: std::set is an efficient 💡 way to remove duplicates ❌ and sort elements 🔼. 2️⃣ Two-Pointer Technique: Ideal for alternating ↔️ between the smallest 🔽 and largest 🔼 values. 3️⃣ Flexible Input Handling: Parsing strings 🧵 with mixed characters is crucial 🌟 for real-world 🌍 scenarios.

This problem demonstrates how combining simple 🛠️ data structures 📂 and algorithms 🔄 can solve complex tasks effectively ✅.