# Print all sequences starting with n and consecutive difference limited to k

Given three positive integer n, s and k. The task is to print all possible sequence of length s, starting with n and the absolute difference between consecutive element is less than k.

Examples :

```Input : n = 5, s = 3, k = 2
Output :
5 5 5
5 5 6
5 5 4
5 6 6
5 6 7
5 6 5
5 4 4
5 4 5
5 4 3

Input : n = 3, s = 2, k = 1
Output :
3 3
```

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Observe, to get the absolute difference between consecutive element less than k, we can increase from 0 to k – 1. Similarly, we can decrease the next element from 1 to k – 1.
Now, to form the required sequence, we will first push ‘n’ to the vector. And then try to fill the other element of the sequence by making recursive call for each element in the sequence. At each recursive call we run a loop from 0 to k – 1 and add (n + i) to the sequence. Once we make the sequence of size ‘s’, we will print the whole sequence and return back to the recursively calling function and remove (n + i).
Similarly, we can run loop from 1 to k – 1 and insert (n – i) to next element position.
To check the number of remaining element required we will pass size – 1 to recursive call and when size become 0, we will print the whole sequence.

Below is the implementation of this approach:

## C++

 `// CPP Program all sequence of length s  ` `// starting with n such that difference  ` `// between consecutive element is less than k. ` `#include ` `using` `namespace` `std; ` ` `  `// Recursive function to print all sequence  ` `// of length s starting with n such that  ` `// difference between consecutive element  ` `// is less than k. ` `void` `printSequence(vector<``int``>& v, ``int` `n, ` `                               ``int` `s, ``int` `k) ` `{ ` `    ``// If size become 0, print the sequence. ` `    ``if` `(s == 0) { ` `        ``for` `(``int` `i = 0; i < v.size(); i++) ` `            ``cout << v[i] << ``" "``; ` `        ``cout << endl; ` `        ``return``; ` `    ``} ` ` `  `    ``// Increment the next element and make  ` `    ``// recursive call after inserting the  ` `    ``// (n + i) to the sequence. ` `    ``for` `(``int` `i = 0; i < k; i++) { ` `        ``v.push_back(n + i); ` `        ``printSequence(v, n + i, s - 1, k); ` `        ``v.pop_back(); ` `    ``} ` ` `  `    ``// Decrementing the next element and' ` `    ``// make recursive call after inserting  ` `    ``// the (n - i) to the sequence. ` `    ``for` `(``int` `i = 1; i < k; i++) { ` `        ``v.push_back(n - i); ` `        ``printSequence(v, n - i, s - 1, k); ` `        ``v.pop_back(); ` `    ``} ` `} ` ` `  `// Wrapper Function ` `void` `wrapper(``int` `n, ``int` `s, ``int` `k) ` `{ ` `    ``vector<``int``> v; ` `    ``v.push_back(n); ` `    ``printSequence(v, n, s - 1, k); ` `} ` ` `  `// Driven Program ` `int` `main() ` `{ ` `    ``int` `n = 5, s = 3, k = 2; ` `    ``wrapper(n, s, k); ` `    ``return` `0; ` `} `

## Java

 `// Java Program all sequence of length s  ` `// starting with n such that difference  ` `// between consecutive element is less than k. ` `import` `java.io.*; ` `import` `java.util.*; ` ` `  `public` `class` `GFG { ` `  `  `    ``static` `List v = ``new` `ArrayList(); ` `    ``// Recursive function to print all sequence  ` `    ``// of length s starting with n such that  ` `    ``// difference between consecutive element  ` `    ``// is less than k. ` `    ``static` `void` `printSequence(``int` `n, ` `                                   ``int` `s, ``int` `k) ` `    ``{ ` `        ``// If size become 0, print the sequence. ` `        ``if` `(s == ``0``) { ` `            ``for` `(``int` `i = ``0``; i < v.size(); i++) ` `                ``System.out.print(v.get(i) + ``" "``); ` `            ``System.out.println(); ` `            ``return``; ` `        ``} ` `       `  `        ``// Increment the next element and make  ` `        ``// recursive call after inserting the  ` `        ``// (n + i) to the sequence. ` `        ``for` `(``int` `i = ``0``; i < k; i++) { ` `            ``v.add(n + i); ` `            ``printSequence(n + i, s - ``1``, k); ` `            ``v.remove(v.size() - ``1``); ` `        ``} ` `       `  `        ``// Decrementing the next element and' ` `        ``// make recursive call after inserting  ` `        ``// the (n - i) to the sequence. ` `        ``for` `(``int` `i = ``1``; i < k; i++) { ` `            ``v.add(n - i); ` `            ``printSequence(n - i, s - ``1``, k); ` `            ``v.remove(v.size() - ``1``); ` `        ``} ` `    ``} ` `       `  `    ``// Wrapper Function ` `    ``static` `void` `wrapper(``int` `n, ``int` `s, ``int` `k) ` `    ``{ ` `        ``v.add(n); ` `        ``printSequence(n, s - ``1``, k); ` `    ``} ` `       `  `    ``// Driven Program ` `    ``public` `static` `void` `main(String args[]) ` `    ``{ ` `        ``int` `n = ``5``, s = ``3``, k = ``2``; ` `        ``wrapper(n, s, k); ` `    ``} ` `} ` `  `  `// This code is contributed by Manish Shaw ` `// (manishshaw1) `

## Python3

 `# Python3 Program all sequence of length s  ` `# starting with n such that difference  ` `# between consecutive element is less than k. ` ` `  `# Recursive function to print all sequence  ` `# of length s starting with n such that  ` `# difference between consecutive element  ` `# is less than k. ` `def` `printSequence(v, n, s, k): ` ` `  `    ``# If size become 0, print the sequence. ` `    ``if` `(s ``=``=` `0``) : ` `        ``for` `i ``in` `range``(``0``, ``len``(v)): ` `            ``print` `(``"{} "``.``format``(v[i]), end``=``"") ` `        ``print` `("") ` `        ``return``; ` `     `  ` `  `    ``# Increment the next element and make  ` `    ``# recursive call after inserting the  ` `    ``# (n + i) to the sequence. ` `    ``for` `i ``in` `range``(``0``,k): ` `        ``v.append(n ``+` `i) ` `        ``printSequence(v, n ``+` `i, s ``-` `1``, k) ` `        ``v.pop() ` `     `  ` `  `    ``# Decrementing the next element and' ` `    ``# make recursive call after inserting  ` `    ``# the (n - i) to the sequence. ` `    ``for` `i ``in` `range``(``1``,k): ` `        ``v.append(n ``-` `i) ` `        ``printSequence(v, n ``-` `i, s ``-` `1``, k) ` `        ``v.pop() ` `     `  ` `  ` `  `# Wrapper Function ` `def` `wrapper(n, s, k): ` `    ``v ``=` `[] ` `    ``v.append(n) ` `    ``printSequence(v, n, s ``-` `1``, k) ` ` `  `# Driven Program ` `n ``=` `5``; s ``=` `3``; k ``=` `2``; ` `wrapper(n, s, k); ` ` `  `# This code is contributed by  ` `# Manish Shaw(manishshaw1) `

## C#

 `// C# Program all sequence of length s  ` `// starting with n such that difference  ` `// between consecutive element is less than k. ` `using` `System; ` `using` `System.Collections.Generic; ` `using` `System.Linq; ` `using` `System.Collections; ` ` `  `class` `GFG { ` ` `  `    ``// Recursive function to print all sequence  ` `    ``// of length s starting with n such that  ` `    ``// difference between consecutive element  ` `    ``// is less than k. ` `    ``static` `void` `printSequence(``ref` `List<``int``> v, ``int` `n, ` `                                   ``int` `s, ``int` `k) ` `    ``{ ` `        ``// If size become 0, print the sequence. ` `        ``if` `(s == 0) { ` `            ``for` `(``int` `i = 0; i < v.Count; i++) ` `                ``Console.Write(v[i] + ``" "``); ` `            ``Console.WriteLine(); ` `            ``return``; ` `        ``} ` `      `  `        ``// Increment the next element and make  ` `        ``// recursive call after inserting the  ` `        ``// (n + i) to the sequence. ` `        ``for` `(``int` `i = 0; i < k; i++) { ` `            ``v.Add(n + i); ` `            ``printSequence(``ref` `v, n + i, s - 1, k); ` `            ``v.RemoveAt(v.Count - 1); ` `        ``} ` `      `  `        ``// Decrementing the next element and' ` `        ``// make recursive call after inserting  ` `        ``// the (n - i) to the sequence. ` `        ``for` `(``int` `i = 1; i < k; i++) { ` `            ``v.Add(n - i); ` `            ``printSequence(``ref` `v, n - i, s - 1, k); ` `            ``v.RemoveAt(v.Count - 1); ` `        ``} ` `    ``} ` `      `  `    ``// Wrapper Function ` `    ``static` `void` `wrapper(``int` `n, ``int` `s, ``int` `k) ` `    ``{ ` `        ``List<``int``> v = ``new` `List<``int``>(); ` `        ``v.Add(n); ` `        ``printSequence(``ref` `v, n, s - 1, k); ` `    ``} ` `      `  `    ``// Driven Program ` `    ``public` `static` `void` `Main() ` `    ``{ ` `        ``int` `n = 5, s = 3, k = 2; ` `        ``wrapper(n, s, k); ` `    ``} ` `} ` ` `  `// This code is contributed by Manish Shaw ` `// (manishshaw1) `

## PHP

 ` `

Output :

```5 5 5
5 5 6
5 5 4
5 6 6
5 6 7
5 6 5
5 4 4
5 4 5
5 4 3```

My Personal Notes arrow_drop_up Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.

Improved By : manishshaw1, nidhi_biet

Article Tags :
Practice Tags :

Be the First to upvote.

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.