Print number in ascending order which contains 1, 2 and 3 in their digits.

Given an array of numbers, the task is to print those numbers in ascending order separated by commas that have 1, 2, and 3 in their digits. If no number containing digits 1, 2, and 3 is present then print -1.

Examples:

Input : numbers[] = {123, 1232, 456, 234, 32145}
Output : 123, 1232, 32145

Input : numbers[] = {9821, 627183, 12, 1234}
Output : 1234, 627183

Input : numbers[] = {12, 232, 456, 234}
Output : -1

First finding all the number in form of array which contains 1, 2 & 3 then sort the number according to 1, 2 and 3 and then print it.

Follow the steps below to implement the above idea:

• Iterate over the given array numbers[] and check if the number is valid or not.
  • For checking the validity of a number:
    • Take three variables countOnes, countTwo, countThee, and initialize to 0.
    • Increment the value for the above variables accordingly, if found.
  • Finally, Check if all the above three variables contain some value, then return true.
  • Otherwise, return false.
• If the number is valid then push the number into array oneTwoThree[].
• Sort the array and print the result.

Below is the implementation of the above approach:

CPP

// CPP program to print all number containing
// 1, 2 and 3 in any order.
#include <bits/stdc++.h>
using namespace std;

// convert the number to string and find
// if it contains 1, 2 & 3.
bool findContainsOneTwoThree(int number)
{
    string str = to_string(number);
    int countOnes = 0, countTwo = 0, countThree = 0;
    for (int i = 0; i < str.length(); i++) {
        if (str[i] == '1')
            countOnes++;
        else if (str[i] == '2')
            countTwo++;
        else if (str[i] == '3')
            countThree++;
    }
    return (countOnes && countTwo && countThree);
}
// prints all the number containing 1, 2, 3
string printNumbers(int numbers[], int n)
{
    vector<int> oneTwoThree;
    for (int i = 0; i < n; i++) {
        // check if the number contains 1,
        // 2 & 3 in any order
        if (findContainsOneTwoThree(numbers[i]))
            oneTwoThree.push_back(numbers[i]);
    }

    // sort all the numbers
    sort(oneTwoThree.begin(), oneTwoThree.end());

    string result = "";
    for (auto number : oneTwoThree) {
        int value = number;
        if (result.length() > 0)
            result += ", ";

        result += to_string(value);
    }

    return (result.length() > 0) ? result : "-1";
}

// Driver Code
int main()
{
    int numbers[] = { 123, 1232, 456, 234, 32145 };

    int n = sizeof(numbers) / sizeof(numbers[0]);

    string result = printNumbers(numbers, n);
    cout << result;
    return 0;
}
// This code is contributed
// by Sirjan13

Java

// Java program to print all number containing
// 1, 2 and 3 in any order.
import java.io.FileNotFoundException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;

class GFG {

    // prints all the number containing 1, 2, 3
    // in any order
    private static String printNumbers(int[] numbers)
    {

        ArrayList<Integer> array = new ArrayList<>();
        for (int number : numbers) {

            // check if the number contains 1,
            // 2 & 3 in any order
            if (findContainsOneTwoThree(number))
                array.add(number);
        }

        // sort all the numbers
        Collections.sort(array);

        StringBuffer strbuf = new StringBuffer();
        Iterator it = array.iterator();
        while (it.hasNext()) {

            int value = (int)it.next();
            if (strbuf.length() > 0)
                strbuf.append(", ");

            strbuf.append(Integer.toString(value));
        }

        return (strbuf.length() > 0) ? strbuf.toString()
                                     : "-1";
    }

    // convert the number to string and find
    // if it contains 1, 2 & 3.
    private static boolean
    findContainsOneTwoThree(int number)
    {

        String str = Integer.toString(number);
        return (str.contains("1") && str.contains("2")
                && str.contains("3"));
    }

    public static void main(String[] args)
    {
        int[] numbers = { 123, 1232, 456, 234, 32145 };
        System.out.println(printNumbers(numbers));
    }
}

Python

# Python program for printing
# all numbers containing 1,2 and 3


def printNumbers(numbers):

    # convert all numbers
    # to strings
    numbers = map(str, numbers)
    result = []
    for num in numbers:

        # check if each number
        # in the list has 1,2 and 3
        if ('1' in num and
            '2' in num and
                '3' in num):
            result.append(num)

    # if there are no
    # valid numbers
    if not result:
        result = ['-1']

    return sorted(result)


# Driver Code
numbers = [123, 1232, 456,
           234, 32145]
result = printNumbers(numbers)
print ', '.join(num for num in result)

# This code is contributed
# by IshitaTripathi

C#

// C# program to print all number
// containing 1, 2 and 3 in any order.
using System;
using System.Collections.Generic;
using System.Text;

class GFG {

    // prints all the number
    // containing 1, 2, 3
    // in any order
    private static string printNumbers(int[] numbers)
    {

        List<int> array = new List<int>();
        foreach(int number in numbers)
        {

            // check if the number contains 1,
            // 2 & 3 in any order
            if (findContainsOneTwoThree(number)) {
                array.Add(number);
            }
        }

        // sort all the numbers
        array.Sort();

        StringBuilder strbuf = new StringBuilder();
        System.Collections.IEnumerator it
            = array.GetEnumerator();
        while (it.MoveNext()) {

            int value = (int)it.Current;
            if (strbuf.Length > 0) {
                strbuf.Append(", ");
            }

            strbuf.Append(Convert.ToString(value));
        }

        return (strbuf.Length > 0) ? strbuf.ToString()
                                   : "-1";
    }

    // convert the number
    // to string and find
    // if it contains 1, 2 & 3.
    private static bool findContainsOneTwoThree(int number)
    {

        string str = Convert.ToString(number);
        return (str.Contains("1") && str.Contains("2")
                && str.Contains("3"));
    }

    // Driver Code
    public static void Main(string[] args)
    {
        int[] numbers
            = new int[] { 123, 1232, 456, 234, 32145 };
        Console.WriteLine(printNumbers(numbers));
    }
}

// This code is contributed by Shrikant13

Javascript

<script>

// JavaScript program to print all number containing
// 1, 2 and 3 in any order.

// convert the number to string and find
// if it contains 1, 2 & 3.
function findContainsOneTwoThree(number)
{
    let str = number.toString();
    let countOnes = 0, countTwo = 0, countThree = 0;
    for(let i = 0; i < str.length; i++) {
        if(str[i] == '1') countOnes++;
        else if(str[i] == '2') countTwo++;
        else if(str[i] == '3') countThree++;
    }
    return (countOnes && countTwo && countThree);
}

// prints all the number containing 1, 2, 3
function printNumbers(numbers, n)
{
    let oneTwoThree = [];
    for (let i = 0; i < n; i++)
    {

        // check if the number contains 1,
        // 2 & 3 in any order
        if (findContainsOneTwoThree(numbers[i]))
            oneTwoThree.push(numbers[i]);
    }

    // sort all the numbers
    oneTwoThree.sort();

    let result = "";
    for(let number of oneTwoThree)
    {
        let value = number;
        if (result.length > 0)
            result += ", ";

        result += value.toString();
    }

    return (result.length > 0) ? result : "-1";
}

// Driver Code

let numbers = [ 123, 1232, 456, 234, 32145 ];
let n = numbers.length;
let result = printNumbers(numbers, n);
document.write(result);

// This code is contributed
// by shinjanpatra

</script>

Output

123, 1232, 32145

Time Complexity: O(N log(N)), where N is the length of the given number.
Auxiliary Space: O(N) 

Please suggest if someone has a better solution that is more efficient in terms of space and time.
This article is contributed by Aarti_Rathi.