 Open in App
Not now

# Construct a sequence from given frequencies of N consecutive integers with unit adjacent difference

• Last Updated : 20 Aug, 2021

Given an array freq[] which stores the frequency of N integers from 0 to N – 1. The task is to construct a sequence where number i appears freq[i] number of times (0 ≤ i ≤ N – 1) such that the absolute difference between two adjacent numbers is 1. If it’s not possible to generate any sequence then print -1.

Examples:

Input: freq[] = {2, 2, 2, 3, 1}
Output: 0 1 0 1 2 3 2 3 4 3
Explanation:
The absolute difference between the adjacent numbers in the above sequence is always 1.

Input: freq[] = {1, 2, 3}
Output: -1
Explanation:
There cannot be any sequence whose absolute difference will always be one.

Approach: The sequence can start from any number between 0 and N – 1. The idea is to consider all possibilities for the starting elements namely 0 to N – 1. After choosing the element, we try to construct the sequence. Below are the steps:

1. Create a map M to store the frequency of numbers. Also, find the sum of frequencies in a variable say total.
2. Iterate in the map and do the following for each element in the map:
• Create a copy of the map M.
• Create a vector sequence that stores the possible answer. If the frequency of the current element is non-zero then decrement its frequency and push it into the sequence and try to form the rest of the total – 1 elements of the sequence in the following way:
1. Let us call the last element inserted in the sequence as last. If the frequency of last – 1 is non-zero, then decrement its frequency and push it into the sequence. Update the last element.
2. Otherwise, if the frequency of last + 1 is non-zero, then decrement its frequency and push it into the sequence. Update the last element.
3. Otherwise, break from the inner loop.
• If the size of the sequence is equal to the total then return it as the answer.
• If no such sequence is found, then just return an empty sequence.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach``#include ``using` `namespace` `std;` `// Function generates the sequence``vector<``int``> generateSequence(``int``* freq,``                             ``int` `n)``{``    ``// Map to store the frequency``    ``// of numbers``    ``map<``int``, ``int``> m;` `    ``// Sum of all frequencies``    ``int` `total = 0;` `    ``for` `(``int` `i = 0; i < n; i++) {``        ``m[i] = freq[i];` `        ``total += freq[i];``    ``}` `    ``// Try all possibilities``    ``// for the starting element``    ``for` `(``int` `i = 0; i < n; i++) {` `        ``// If the frequency of current``        ``// element is non-zero``        ``if` `(m[i]) {` `            ``// vector to store the answer``            ``vector<``int``> sequence;` `            ``// Copy of the map for every``            ``// possible starting element``            ``auto` `mcopy = m;` `            ``// Decrement the frequency``            ``mcopy[i]--;` `            ``// Push the starting element``            ``// to the vector``            ``sequence.push_back(i);` `            ``// The last element inserted``            ``// is i``            ``int` `last = i;` `            ``// Try to fill the rest of``            ``// the positions if possible``            ``for` `(``int` `i = 0;``                 ``i < total - 1; i++) {` `                ``// If the frequency of last - 1``                ``// is non-zero` `                ``if` `(mcopy[last - 1]) {` `                    ``// Decrement the frequency``                    ``// of last - 1``                    ``mcopy[last - 1]--;` `                    ``// Insert  it into the``                    ``// sequence``                    ``sequence.push_back(last - 1);` `                    ``// Update last number``                    ``// added to sequence``                    ``last--;``                ``}` `                ``else` `if` `(mcopy[last + 1]) {``                    ``mcopy[last + 1]--;``                    ``sequence.push_back(last + 1);``                    ``last++;``                ``}` `                ``// Break from the inner loop``                ``else``                    ``break``;``            ``}` `            ``// If the size of the sequence``            ``// vector is equal to sum of``            ``// total frequqncies``            ``if` `(sequence.size() == total) {` `                ``// Return sequence``                ``return` `sequence;``            ``}``        ``}``    ``}` `    ``vector<``int``> empty;` `    ``// If no such sequence if found``    ``// return empty sequence``    ``return` `empty;``}` `// Function Call to print the sequence``void` `PrintSequence(``int` `freq[], ``int` `n)``{``    ``// The required sequence``    ``vector<``int``> sequence``        ``= generateSequence(freq, n);` `    ``// If the size of sequence``    ``// if zero it means no such``    ``// sequence was found``    ``if` `(sequence.size() == 0) {``        ``cout << ``"-1"``;``    ``}` `    ``// Otherwise print the sequence``    ``else` `{` `        ``for` `(``int` `i = 0;``             ``i < sequence.size(); i++) {``            ``cout << sequence[i] << ``" "``;``        ``}``    ``}``}` `// Driver Code``int` `main()``{``    ``// Frequency of all elements``    ``// from 0 to n-1``    ``int` `freq[] = { 2, 2, 2, 3, 1 };` `    ``// Number of elements whose``    ``// frequencies are given``    ``int` `N = 5;` `    ``// Function Call``    ``PrintSequence(freq, N);``    ``return` `0;``}`

## Java

 `// Java program for the above approach``import` `java.util.*;` `class` `GFG{` `// Function generates the sequence``static` `Vector generateSequence(``int` `[]freq,``                                        ``int` `n)``{``    ` `    ``// Map to store the frequency``    ``// of numbers``    ``HashMap m = ``new` `HashMap();` `    ``// Sum of all frequencies``    ``int` `total = ``0``;` `    ``for``(``int` `i = ``0``; i < n; i++)``    ``{``        ``m.put(i, freq[i]);``        ``total += freq[i];``    ``}` `    ``// Try all possibilities``    ``// for the starting element``    ``for``(``int` `i = ``0``; i < n; i++)``    ``{``        ` `        ``// If the frequency of current``        ``// element is non-zero``        ``if` `(m.containsKey(i))``        ``{``            ` `            ``// vector to store the answer``            ``Vector sequence = ``new` `Vector();` `            ``// Copy of the map for every``            ``// possible starting element``            ``@SuppressWarnings``(``"unchecked"``)``            ``HashMap mcopy = (HashMap) m.clone();` `            ``// Decrement the frequency``            ``if` `(mcopy.containsKey(i) && mcopy.get(i) > ``0``)``                ``mcopy.put(i, mcopy.get(i) - ``1``);` `            ``// Push the starting element``            ``// to the vector``            ``sequence.add(i);` `            ``// The last element inserted``            ``// is i``            ``int` `last = i;` `            ``// Try to fill the rest of``            ``// the positions if possible``            ``for``(``int` `i1 = ``0``; i1 < total - ``1``; i1++)``            ``{``                ` `                ``// If the frequency of last - 1``                ``// is non-zero``                ``if` `(mcopy.containsKey(last - ``1``) &&``                            ``mcopy.get(last - ``1``) > ``0``)``                ``{``                    ` `                    ``// Decrement the frequency``                    ``// of last - 1``                    ``mcopy.put(last - ``1``,``                    ``mcopy.get(last - ``1``) - ``1``);` `                    ``// Insert  it into the``                    ``// sequence``                    ``sequence.add(last - ``1``);` `                    ``// Update last number``                    ``// added to sequence``                    ``last--;``                ``}` `                ``else` `if` `(mcopy.containsKey(last + ``1``))``                ``{``                    ``mcopy.put(last + ``1``,``                    ``mcopy.get(last + ``1``) - ``1``);``                    ``sequence.add(last + ``1``);``                    ``last++;``                ``}` `                ``// Break from the inner loop``                ``else``                    ``break``;``            ``}` `            ``// If the size of the sequence``            ``// vector is equal to sum of``            ``// total frequqncies``            ``if` `(sequence.size() == total)``            ``{``                ` `                ``// Return sequence``                ``return` `sequence;``            ``}``        ``}``    ``}` `    ``Vector empty = ``new` `Vector();` `    ``// If no such sequence if found``    ``// return empty sequence``    ``return` `empty;``}` `// Function call to print the sequence``static` `void` `PrintSequence(``int` `freq[], ``int` `n)``{``    ` `    ``// The required sequence``    ``Vector sequence = generateSequence(freq, n);` `    ``// If the size of sequence``    ``// if zero it means no such``    ``// sequence was found``    ``if` `(sequence.size() == ``0``)``    ``{``        ``System.out.print(``"-1"``);``    ``}` `    ``// Otherwise print the sequence``    ``else``    ``{``        ``for``(``int` `i = ``0``; i < sequence.size(); i++)``        ``{``            ``System.out.print(sequence.get(i) + ``" "``);``        ``}``    ``}``}` `// Driver Code``public` `static` `void` `main(String[] args)``{``    ` `    ``// Frequency of all elements``    ``// from 0 to n-1``    ``int` `freq[] = { ``2``, ``2``, ``2``, ``3``, ``1` `};` `    ``// Number of elements whose``    ``// frequencies are given``    ``int` `N = ``5``;` `    ``// Function call``    ``PrintSequence(freq, N);``}``}` `// This code is contributed by Amit Katiyar`

## Python3

 `# Python3 program for the above approach` `# Function generates the sequence``def` `generateSequence(freq, n):``    ` `    ``# Map to store the frequency``    ``# of numbers``    ``m ``=` `{}` `    ``# Sum of all frequencies``    ``total ``=` `0` `    ``for` `i ``in` `range``(n):``        ``m[i] ``=` `freq[i]``        ``total ``+``=` `freq[i]` `    ``# Try all possibilities``    ``# for the starting element``    ``for` `i ``in` `range``(n):` `        ``# If the frequency of current``        ``# element is non-zero``        ``if` `(m[i]):` `            ``# vector to store the answer``            ``sequence ``=` `[]` `            ``# Copy of the map for every``            ``# possible starting element``            ``mcopy ``=` `{}` `            ``for` `j ``in` `m:``                ``mcopy[j] ``=` `m[j]` `            ``# Decrement the frequency``            ``mcopy[i] ``-``=` `1` `            ``# Push the starting element``            ``# to the vector``            ``sequence.append(i)` `            ``# The last element inserted``            ``# is i``            ``last ``=` `i` `            ``# Try to fill the rest of``            ``# the positions if possible``            ``for` `j ``in` `range``(total ``-` `1``):``                ` `                ``# If the frequency of last - 1``                ``# is non-zero``                ``if` `((last ``-` `1``) ``in` `mcopy ``and``                   ``mcopy[last ``-` `1``] > ``0``):` `                    ``# Decrement the frequency``                    ``# of last - 1``                    ``mcopy[last ``-` `1``] ``-``=` `1` `                    ``# Insert  it into the``                    ``# sequence``                    ``sequence.append(last ``-` `1``)` `                    ``# Update last number``                    ``# added to sequence``                    ``last ``-``=` `1` `                ``elif` `(mcopy[last ``+` `1``]):``                    ``mcopy[last ``+` `1``] ``-``=` `1``                    ``sequence.append(last ``+` `1``)``                    ``last ``+``=` `1` `                ``# Break from the inner loop``                ``else``:``                    ``break` `            ``# If the size of the sequence``            ``# vector is equal to sum of``            ``# total frequqncies``            ``if` `(``len``(sequence) ``=``=` `total):` `                ``# Return sequence``                ``return` `sequence` `    ``# If no such sequence if found``    ``# return empty sequence``    ``return` `[]` `# Function Call to print the sequence``def` `PrintSequence(freq, n):``    ` `    ``# The required sequence``    ``sequence ``=` `generateSequence(freq, n)` `    ``# If the size of sequence``    ``# if zero it means no such``    ``# sequence was found``    ``if` `(``len``(sequence) ``=``=` `0``):``        ``print``(``"-1"``)` `    ``# Otherwise print the sequence``    ``else``:``        ``for` `i ``in` `range``(``len``(sequence)):``            ``print``(sequence[i], end ``=` `" "``)` `# Driver Code``if` `__name__ ``=``=` `'__main__'``:``    ` `    ``# Frequency of all elements``    ``# from 0 to n-1``    ``freq ``=` `[ ``2``, ``2``, ``2``, ``3``, ``1` `]` `    ``# Number of elements whose``    ``# frequencies are given``    ``N ``=` `5` `    ``# Function Call``    ``PrintSequence(freq, N)` `# This code is contributed by mohit kumar 29`

## C#

 `// C# program for``// the above approach``using` `System;``using` `System.Collections.Generic;``class` `GFG{` `// Function generates the sequence``static` `List<``int``> generateSequence(``int` `[]freq,``                                  ``int` `n)``{``  ``// Map to store the frequency``  ``// of numbers``  ``Dictionary<``int``,``             ``int``> m = ``new` `Dictionary<``int``,``                                     ``int``>();` `  ``// Sum of all frequencies``  ``int` `total = 0;` `  ``for``(``int` `i = 0; i < n; i++)``  ``{``    ``m.Add(i, freq[i]);``    ``total += freq[i];``  ``}` `  ``// Try all possibilities``  ``// for the starting element``  ``for``(``int` `i = 0; i < n; i++)``  ``{``    ``// If the frequency of current``    ``// element is non-zero``    ``if` `(m.ContainsKey(i))``    ``{``      ``// vector to store the answer``      ``List<``int``> sequence = ``new` `List<``int``>();` `      ``// Copy of the map for every``      ``// possible starting element` `      ``Dictionary<``int``,``                 ``int``> mcopy = ``new` `Dictionary<``int``,``                                             ``int``>(m);` `      ``// Decrement the frequency``      ``if` `(mcopy.ContainsKey(i) && mcopy[i] > 0)``        ``mcopy[i] = mcopy[i] - 1;` `      ``// Push the starting element``      ``// to the vector``      ``sequence.Add(i);` `      ``// The last element inserted``      ``// is i``      ``int` `last = i;` `      ``// Try to fill the rest of``      ``// the positions if possible``      ``for``(``int` `i1 = 0; i1 < total - 1; i1++)``      ``{``        ``// If the frequency of last - 1``        ``// is non-zero``        ``if` `(mcopy.ContainsKey(last - 1) &&``            ``mcopy[last - 1] > 0)``        ``{``          ``// Decrement the frequency``          ``// of last - 1``          ``mcopy[last - 1] = mcopy[last - 1] - 1;` `          ``// Insert  it into the``          ``// sequence``          ``sequence.Add(last - 1);` `          ``// Update last number``          ``// added to sequence``          ``last--;``        ``}` `        ``else` `if` `(mcopy.ContainsKey(last + 1))``        ``{``          ``mcopy[last + 1] = mcopy[last + 1] - 1;``          ``sequence.Add(last + 1);``          ``last++;``        ``}` `        ``// Break from the inner loop``        ``else``          ``break``;``      ``}` `      ``// If the size of the sequence``      ``// vector is equal to sum of``      ``// total frequqncies``      ``if` `(sequence.Count == total)``      ``{``        ``// Return sequence``        ``return` `sequence;``      ``}``    ``}``  ``}` `  ``List<``int``> empty = ``new` `List<``int``>();` `  ``// If no such sequence if found``  ``// return empty sequence``  ``return` `empty;``}` `// Function call to print the sequence``static` `void` `PrintSequence(``int` `[]freq, ``int` `n)``{``  ``// The required sequence``  ``List<``int``> sequence = generateSequence(freq, n);` `  ``// If the size of sequence``  ``// if zero it means no such``  ``// sequence was found``  ``if` `(sequence.Count == 0)``  ``{``    ``Console.Write(``"-1"``);``  ``}` `  ``// Otherwise print the sequence``  ``else``  ``{``    ``for``(``int` `i = 0; i < sequence.Count; i++)``    ``{``      ``Console.Write(sequence[i] + ``" "``);``    ``}``  ``}``}` `// Driver Code``public` `static` `void` `Main(String[] args)``{``  ``// Frequency of all elements``  ``// from 0 to n-1``  ``int` `[]freq = {2, 2, 2, 3, 1};` `  ``// Number of elements whose``  ``// frequencies are given``  ``int` `N = 5;` `  ``// Function call``  ``PrintSequence(freq, N);``}``}` `// This code is contributed by Princi Singh`

## Javascript

 ``

Output:

`0 1 0 1 2 3 2 3 4 3`

Time Complexity: O(N * total), where N is the size of the array, and the total is the cumulative sum of the array.
Auxiliary Space: O(total), where the total is the cumulative sum of the array.

My Personal Notes arrow_drop_up