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

• Difficulty Level : Medium
• Last Updated : 09 Nov, 2022

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 ``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 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

 ``

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.