# Find combination of k with consecutive absolute difference

Here given code implementation process.

``````// C Program
// Find combination of k with consecutive absolute difference
#include <stdio.h>

int absoluteValue(int x)
{
if (x < 0)
{
return -x;
}
return x;
}
void combinations(int k)
{
int n = absoluteValue(k);
if (n <= 1)
{
return;
}
printf("\n Given k : %d\n", k);
int result[n];
// Auxiliary variable
int min = 1;
int max = k;
int flag = 0;
if (k < 0)
{
min = k;
max = -1;
}
// Counter variable
int i = min;
int j = max;
int count = 0;
while (i - 1 <= j && count < n)
{
if (count % 2 == 0)
{
result[count] = j;
j--;
}
else
{
result[count] = i;
i++;
}
count++;
}
// Display calculated result
for (int i = 0; i < n; ++i)
{
printf("  %d", result[i]);
}
}
int main()
{
/*
k = 9
-------------------------
(9 - 1) : 8
(1 - 8) : -7
(8 - 2) : 6
(2 - 7) : -5
(7 - 3) : 4
(3 - 6) : -3
(6 - 4) : 2
(4 - 5) : -1
-------------------------
9  1  8  2  7  3  6  4  5

Alternate decreasing sequence
↑
╔┄┄┄┄┄╦┄┄┄┄┄╦┄┄┄┄┄╦┄┄┄┄┄╗
│     │     │     │     │
│     │     │     │     │
9  1  8  2  7  3  6  4  5
│     │     │     │
│     │     │     │
╰┄┄┄┄┄╩┄┄┄┄┄╩┄┄┄┄┄┘
ↆ
Alternate increasing order
*/
combinations(9);
/*
Given k : -9
---------------------------------
(-1 - -9) : 8
(-9 - -2) : -7
(-2 - -8) : 6
(-8 - -3) : -5
(-3 - -7) : 4
(-7 - -4) : -3
(-4 - -6) : 2
(-6 - -5) : -1
------------------------------------
-1  -9  -2  -8  -3  -7  -4  -6  -5
*/
combinations(-9);
/*
Given k : 5
-------------------
(5 - 1) : 4
(1 - 4) : -3
(4 - 2) : 2
(2 - 3) : -1
-------------------
5  1  4  2  3
*/
combinations(5);
return 0;
}``````

#### Output

`````` Given k : 9
9  1  8  2  7  3  6  4  5
Given k : -9
-1  -9  -2  -8  -3  -7  -4  -6  -5
Given k : 5
5  1  4  2  3``````
``````// Java program for
// Find combination of k with consecutive absolute difference
public class Combinations
{
public int absoluteValue(int x)
{
if (x < 0)
{
return -x;
}
return x;
}
public void combinations(int k)
{
int n = absoluteValue(k);
if (n <= 1)
{
return;
}
System.out.print("\n Given k : " + k + "\n");
int[] result = new int[n];
// Auxiliary variable
int min = 1;
int max = k;
int flag = 0;
if (k < 0)
{
min = k;
max = -1;
}
// Counter variable
int i = min;
int j = max;
int count = 0;
while (i - 1 <= j && count < n)
{
if (count % 2 == 0)
{
result[count] = j;
j--;
}
else
{
result[count] = i;
i++;
}
count++;
}
// Display calculated result
for (i = 0; i < n; ++i)
{
System.out.print(" " + result[i]);
}
}
public static void main(String[] args)
{
/*
k = 9
-------------------------
(9 - 1) : 8
(1 - 8) : -7
(8 - 2) : 6
(2 - 7) : -5
(7 - 3) : 4
(3 - 6) : -3
(6 - 4) : 2
(4 - 5) : -1
-------------------------
9  1  8  2  7  3  6  4  5

Alternate decreasing sequence
↑
╔┄┄┄┄┄╦┄┄┄┄┄╦┄┄┄┄┄╦┄┄┄┄┄╗
│     │     │     │     │
│     │     │     │     │
9  1  8  2  7  3  6  4  5
│     │     │     │
│     │     │     │
╰┄┄┄┄┄╩┄┄┄┄┄╩┄┄┄┄┄┘
ↆ
Alternate increasing order
*/
/*
Given k : -9
---------------------------------
(-1 - -9) : 8
(-9 - -2) : -7
(-2 - -8) : 6
(-8 - -3) : -5
(-3 - -7) : 4
(-7 - -4) : -3
(-4 - -6) : 2
(-6 - -5) : -1
------------------------------------
-1  -9  -2  -8  -3  -7  -4  -6  -5
*/
/*
Given k : 5
-------------------
(5 - 1) : 4
(1 - 4) : -3
(4 - 2) : 2
(2 - 3) : -1
-------------------
5  1  4  2  3
*/
}
}``````

#### Output

`````` Given k : 9
9 1 8 2 7 3 6 4 5
Given k : -9
-1 -9 -2 -8 -3 -7 -4 -6 -5
Given k : 5
5 1 4 2 3``````
``````// Include header file
#include <iostream>

using namespace std;
// C++ program for
// Find combination of k with consecutive absolute difference
class Combinations
{
public: int absoluteValue(int x)
{
if (x < 0)
{
return -x;
}
return x;
}
void combinations(int k)
{
int n = this->absoluteValue(k);
if (n <= 1)
{
return;
}
cout << "\n Given k : " << k << "\n";
int result[n];
// Auxiliary variable
int min = 1;
int max = k;
int flag = 0;
if (k < 0)
{
min = k;
max = -1;
}
// Counter variable
int i = min;
int j = max;
int count = 0;
while (i - 1 <= j && count < n)
{
if (count % 2 == 0)
{
result[count] = j;
j--;
}
else
{
result[count] = i;
i++;
}
count++;
}
// Display calculated result
for (i = 0; i < n; ++i)
{
cout << " " << result[i];
}
}
};
int main()
{
/*
k = 9
-------------------------
(9 - 1) : 8
(1 - 8) : -7
(8 - 2) : 6
(2 - 7) : -5
(7 - 3) : 4
(3 - 6) : -3
(6 - 4) : 2
(4 - 5) : -1
-------------------------
9  1  8  2  7  3  6  4  5
Alternate decreasing sequence
↑
╔┄┄┄┄┄╦┄┄┄┄┄╦┄┄┄┄┄╦┄┄┄┄┄╗
│     │     │     │     │
│     │     │     │     │
9  1  8  2  7  3  6  4  5
│     │     │     │
│     │     │     │
╰┄┄┄┄┄╩┄┄┄┄┄╩┄┄┄┄┄┘
ↆ
Alternate increasing order
*/
/*
Given k : -9
---------------------------------
(-1 - -9) : 8
(-9 - -2) : -7
(-2 - -8) : 6
(-8 - -3) : -5
(-3 - -7) : 4
(-7 - -4) : -3
(-4 - -6) : 2
(-6 - -5) : -1
------------------------------------
-1  -9  -2  -8  -3  -7  -4  -6  -5
*/
/*
Given k : 5
-------------------
(5 - 1) : 4
(1 - 4) : -3
(4 - 2) : 2
(2 - 3) : -1
-------------------
5  1  4  2  3
*/
return 0;
}``````

#### Output

`````` Given k : 9
9 1 8 2 7 3 6 4 5
Given k : -9
-1 -9 -2 -8 -3 -7 -4 -6 -5
Given k : 5
5 1 4 2 3``````
``````// Include namespace system
using System;
// Csharp program for
// Find combination of k with consecutive absolute difference
public class Combinations
{
public int absoluteValue(int x)
{
if (x < 0)
{
return -x;
}
return x;
}
public void combinations(int k)
{
int n = this.absoluteValue(k);
if (n <= 1)
{
return;
}
Console.Write("\n Given k : " + k + "\n");
int[] result = new int[n];
// Auxiliary variable
int min = 1;
int max = k;
if (k < 0)
{
min = k;
max = -1;
}
// Counter variable
int i = min;
int j = max;
int count = 0;
while (i - 1 <= j && count < n)
{
if (count % 2 == 0)
{
result[count] = j;
j--;
}
else
{
result[count] = i;
i++;
}
count++;
}
// Display calculated result
for (i = 0; i < n; ++i)
{
Console.Write(" " + result[i]);
}
}
public static void Main(String[] args)
{
/*
k = 9
-------------------------
(9 - 1) : 8
(1 - 8) : -7
(8 - 2) : 6
(2 - 7) : -5
(7 - 3) : 4
(3 - 6) : -3
(6 - 4) : 2
(4 - 5) : -1
-------------------------
9  1  8  2  7  3  6  4  5
Alternate decreasing sequence
↑
╔┄┄┄┄┄╦┄┄┄┄┄╦┄┄┄┄┄╦┄┄┄┄┄╗
│     │     │     │     │
│     │     │     │     │
9  1  8  2  7  3  6  4  5
│     │     │     │
│     │     │     │
╰┄┄┄┄┄╩┄┄┄┄┄╩┄┄┄┄┄┘
ↆ
Alternate increasing order
*/
/*
Given k : -9
---------------------------------
(-1 - -9) : 8
(-9 - -2) : -7
(-2 - -8) : 6
(-8 - -3) : -5
(-3 - -7) : 4
(-7 - -4) : -3
(-4 - -6) : 2
(-6 - -5) : -1
------------------------------------
-1  -9  -2  -8  -3  -7  -4  -6  -5
*/
/*
Given k : 5
-------------------
(5 - 1) : 4
(1 - 4) : -3
(4 - 2) : 2
(2 - 3) : -1
-------------------
5  1  4  2  3
*/
}
}``````

#### Output

`````` Given k : 9
9 1 8 2 7 3 6 4 5
Given k : -9
-1 -9 -2 -8 -3 -7 -4 -6 -5
Given k : 5
5 1 4 2 3``````
``````package main
import "fmt"
// Go program for
// Find combination of k with consecutive absolute difference
type Combinations struct {}
func getCombinations() * Combinations {
var me *Combinations = &Combinations {}
return me
}
func(this Combinations) absoluteValue(x int) int {
if x < 0 {
return -x
}
return x
}
func(this Combinations) combinations(k int) {
var n int = this.absoluteValue(k)
if n <= 1 {
return
}
fmt.Print("\n Given k : ", k, "\n")
var result = make([] int, n)
// Auxiliary variable
var min int = 1
var max int = k
if k < 0 {
min = k
max = -1
}
// Counter variable
var i int = min
var j int = max
var count int = 0
for (i - 1 <= j && count < n) {
if count % 2 == 0 {
result[count] = j
j--
} else {
result[count] = i
i++
}
count++
}
// Display calculated result
for i = 0 ; i < n ; i++ {
fmt.Print(" ", result[i])
}
}
func main() {
var task * Combinations = getCombinations()
/*
k = 9
-------------------------
(9 - 1) : 8
(1 - 8) : -7
(8 - 2) : 6
(2 - 7) : -5
(7 - 3) : 4
(3 - 6) : -3
(6 - 4) : 2
(4 - 5) : -1
-------------------------
9  1  8  2  7  3  6  4  5
Alternate decreasing sequence
↑
╔┄┄┄┄┄╦┄┄┄┄┄╦┄┄┄┄┄╦┄┄┄┄┄╗
│     │     │     │     │
│     │     │     │     │
9  1  8  2  7  3  6  4  5
│     │     │     │
│     │     │     │
╰┄┄┄┄┄╩┄┄┄┄┄╩┄┄┄┄┄┘
ↆ
Alternate increasing order
*/
/*
Given k : -9
---------------------------------
(-1 - -9) : 8
(-9 - -2) : -7
(-2 - -8) : 6
(-8 - -3) : -5
(-3 - -7) : 4
(-7 - -4) : -3
(-4 - -6) : 2
(-6 - -5) : -1
------------------------------------
-1  -9  -2  -8  -3  -7  -4  -6  -5
*/
/*
Given k : 5
-------------------
(5 - 1) : 4
(1 - 4) : -3
(4 - 2) : 2
(2 - 3) : -1
-------------------
5  1  4  2  3
*/
}``````

#### Output

`````` Given k : 9
9 1 8 2 7 3 6 4 5
Given k : -9
-1 -9 -2 -8 -3 -7 -4 -6 -5
Given k : 5
5 1 4 2 3``````
``````<?php
// Php program for
// Find combination of k with consecutive absolute difference
class Combinations
{
public	function absoluteValue(\$x)
{
if (\$x < 0)
{
return -\$x;
}
return \$x;
}
public	function combination(\$k)
{
\$n = \$this->absoluteValue(\$k);
if (\$n <= 1)
{
return;
}
echo("\n Given k : ".\$k."\n");
\$result = array_fill(0, \$n, 0);
// Auxiliary variable
\$min = 1;
\$max = \$k;
if (\$k < 0)
{
\$min = \$k;
\$max = -1;
}
// Counter variable
\$i = \$min;
\$j = \$max;
\$count = 0;
while (\$i - 1 <= \$j && \$count < \$n)
{
if (\$count % 2 == 0)
{
\$result[\$count] = \$j;
\$j--;
}
else
{
\$result[\$count] = \$i;
\$i++;
}
\$count++;
}
// Display calculated result
for (\$i = 0; \$i < \$n; ++\$i)
{
echo(" ".\$result[\$i]);
}
}
}

function main()
{
/*
k = 9
-------------------------
(9 - 1) : 8
(1 - 8) : -7
(8 - 2) : 6
(2 - 7) : -5
(7 - 3) : 4
(3 - 6) : -3
(6 - 4) : 2
(4 - 5) : -1
-------------------------
9  1  8  2  7  3  6  4  5
Alternate decreasing sequence
↑
╔┄┄┄┄┄╦┄┄┄┄┄╦┄┄┄┄┄╦┄┄┄┄┄╗
│     │     │     │     │
│     │     │     │     │
9  1  8  2  7  3  6  4  5
│     │     │     │
│     │     │     │
╰┄┄┄┄┄╩┄┄┄┄┄╩┄┄┄┄┄┘
ↆ
Alternate increasing order
*/
/*
Given k : -9
---------------------------------
(-1 - -9) : 8
(-9 - -2) : -7
(-2 - -8) : 6
(-8 - -3) : -5
(-3 - -7) : 4
(-7 - -4) : -3
(-4 - -6) : 2
(-6 - -5) : -1
------------------------------------
-1  -9  -2  -8  -3  -7  -4  -6  -5
*/
/*
Given k : 5
-------------------
(5 - 1) : 4
(1 - 4) : -3
(4 - 2) : 2
(2 - 3) : -1
-------------------
5  1  4  2  3
*/
}
main();``````

#### Output

`````` Given k : 9
9 1 8 2 7 3 6 4 5
Given k : -9
-1 -9 -2 -8 -3 -7 -4 -6 -5
Given k : 5
5 1 4 2 3``````
``````// Node JS program for
// Find combination of k with consecutive absolute difference
class Combinations
{
absoluteValue(x)
{
if (x < 0)
{
return -x;
}
return x;
}
combinations(k)
{
var n = this.absoluteValue(k);
if (n <= 1)
{
return;
}
process.stdout.write("\n Given k : " + k + "\n");
var result = Array(n).fill(0);
// Auxiliary variable
var min = 1;
var max = k;
if (k < 0)
{
min = k;
max = -1;
}
// Counter variable
var i = min;
var j = max;
var count = 0;
while (i - 1 <= j && count < n)
{
if (count % 2 == 0)
{
result[count] = j;
j--;
}
else
{
result[count] = i;
i++;
}
count++;
}
// Display calculated result
for (i = 0; i < n; ++i)
{
process.stdout.write(" " + result[i]);
}
}
}

function main()
{
/*
k = 9
-------------------------
(9 - 1) : 8
(1 - 8) : -7
(8 - 2) : 6
(2 - 7) : -5
(7 - 3) : 4
(3 - 6) : -3
(6 - 4) : 2
(4 - 5) : -1
-------------------------
9  1  8  2  7  3  6  4  5
Alternate decreasing sequence
↑
╔┄┄┄┄┄╦┄┄┄┄┄╦┄┄┄┄┄╦┄┄┄┄┄╗
│     │     │     │     │
│     │     │     │     │
9  1  8  2  7  3  6  4  5
│     │     │     │
│     │     │     │
╰┄┄┄┄┄╩┄┄┄┄┄╩┄┄┄┄┄┘
ↆ
Alternate increasing order
*/
/*
Given k : -9
---------------------------------
(-1 - -9) : 8
(-9 - -2) : -7
(-2 - -8) : 6
(-8 - -3) : -5
(-3 - -7) : 4
(-7 - -4) : -3
(-4 - -6) : 2
(-6 - -5) : -1
------------------------------------
-1  -9  -2  -8  -3  -7  -4  -6  -5
*/
/*
Given k : 5
-------------------
(5 - 1) : 4
(1 - 4) : -3
(4 - 2) : 2
(2 - 3) : -1
-------------------
5  1  4  2  3
*/
}
main();``````

#### Output

`````` Given k : 9
9 1 8 2 7 3 6 4 5
Given k : -9
-1 -9 -2 -8 -3 -7 -4 -6 -5
Given k : 5
5 1 4 2 3``````
``````#  Python 3 program for
#  Find combination of k with consecutive absolute difference
class Combinations :
def absoluteValue(self, x) :
if (x < 0) :
return -x

return x

def combinations(self, k) :
n = self.absoluteValue(k)
if (n <= 1) :
return

print("\n Given k : ", k )
result = [0] * (n)
#  Auxiliary variable
min = 1
max = k
if (k < 0) :
min = k
max = -1

#  Counter variable
i = min
j = max
count = 0
while (i - 1 <= j and count < n) :
if (count % 2 == 0) :
result[count] = j
j -= 1
else :
result[count] = i
i += 1

count += 1

i = 0
#  Display calculated result
while (i < n) :
print(" ", result[i], end = "")
i += 1

def main() :
#    k = 9
#    -------------------------
#    (9 - 1) : 8
#    (1 - 8) : -7
#    (8 - 2) : 6
#    (2 - 7) : -5
#    (7 - 3) : 4
#    (3 - 6) : -3
#    (6 - 4) : 2
#    (4 - 5) : -1
#    -------------------------
#    9  1  8  2  7  3  6  4  5
#    Alternate decreasing sequence
#                ↑
#    ╔┄┄┄┄┄╦┄┄┄┄┄╦┄┄┄┄┄╦┄┄┄┄┄╗
#    │     │     │     │     │
#    │     │     │     │     │
#    9  1  8  2  7  3  6  4  5
#       │     │     │     │
#       │     │     │     │
#       ╰┄┄┄┄┄╩┄┄┄┄┄╩┄┄┄┄┄┘
#                ↆ
#    Alternate increasing order
#    Given k : -9
#    ---------------------------------
#    (-1 - -9) : 8
#    (-9 - -2) : -7
#    (-2 - -8) : 6
#    (-8 - -3) : -5
#    (-3 - -7) : 4
#    (-7 - -4) : -3
#    (-4 - -6) : 2
#    (-6 - -5) : -1
#    ------------------------------------
#    -1  -9  -2  -8  -3  -7  -4  -6  -5
#    Given k : 5
#    -------------------
#    (5 - 1) : 4
#    (1 - 4) : -3
#    (4 - 2) : 2
#    (2 - 3) : -1
#    -------------------
#    5  1  4  2  3

if __name__ == "__main__": main()``````

#### Output

`````` Given k :  9
9  1  8  2  7  3  6  4  5
Given k :  -9
-1  -9  -2  -8  -3  -7  -4  -6  -5
Given k :  5
5  1  4  2  3``````
``````#  Ruby program for
#  Find combination of k with consecutive absolute difference
class Combinations
def absoluteValue(x)
if (x < 0)
return -x
end

return x
end

def combinations(k)
n = self.absoluteValue(k)
if (n <= 1)
return
end

print("\n Given k : ", k ,"\n")
result = Array.new(n) {0}
#  Auxiliary variable
min = 1
max = k
if (k < 0)
min = k
max = -1
end

#  Counter variable
i = min
j = max
count = 0
while (i - 1 <= j && count < n)
if (count % 2 == 0)
result[count] = j
j -= 1
else

result[count] = i
i += 1
end

count += 1
end

i = 0
#  Display calculated result
while (i < n)
print(" ", result[i])
i += 1
end

end

end

def main()
#    k = 9
#    -------------------------
#    (9 - 1) : 8
#    (1 - 8) : -7
#    (8 - 2) : 6
#    (2 - 7) : -5
#    (7 - 3) : 4
#    (3 - 6) : -3
#    (6 - 4) : 2
#    (4 - 5) : -1
#    -------------------------
#    9  1  8  2  7  3  6  4  5
#    Alternate decreasing sequence
#                ↑
#    ╔┄┄┄┄┄╦┄┄┄┄┄╦┄┄┄┄┄╦┄┄┄┄┄╗
#    │     │     │     │     │
#    │     │     │     │     │
#    9  1  8  2  7  3  6  4  5
#       │     │     │     │
#       │     │     │     │
#       ╰┄┄┄┄┄╩┄┄┄┄┄╩┄┄┄┄┄┘
#                ↆ
#    Alternate increasing order
#    Given k : -9
#    ---------------------------------
#    (-1 - -9) : 8
#    (-9 - -2) : -7
#    (-2 - -8) : 6
#    (-8 - -3) : -5
#    (-3 - -7) : 4
#    (-7 - -4) : -3
#    (-4 - -6) : 2
#    (-6 - -5) : -1
#    ------------------------------------
#    -1  -9  -2  -8  -3  -7  -4  -6  -5
#    Given k : 5
#    -------------------
#    (5 - 1) : 4
#    (1 - 4) : -3
#    (4 - 2) : 2
#    (2 - 3) : -1
#    -------------------
#    5  1  4  2  3
end

main()``````

#### Output

`````` Given k : 9
9 1 8 2 7 3 6 4 5
Given k : -9
-1 -9 -2 -8 -3 -7 -4 -6 -5
Given k : 5
5 1 4 2 3``````
``````// Scala program for
// Find combination of k with consecutive absolute difference
class Combinations()
{
def absoluteValue(x: Int): Int = {
if (x < 0)
{
return -x;
}
return x;
}
def combinations(k: Int): Unit = {
var n: Int = absoluteValue(k);
if (n <= 1)
{
return;
}
print("\n Given k : " + k + "\n");
var result: Array[Int] = Array.fill[Int](n)(0);
// Auxiliary variable
var min: Int = 1;
var max: Int = k;
if (k < 0)
{
min = k;
max = -1;
}
// Counter variable
var i: Int = min;
var j: Int = max;
var count: Int = 0;
while (i - 1 <= j && count < n)
{
if (count % 2 == 0)
{
result(count) = j;
j -= 1;
}
else
{
result(count) = i;
i += 1;
}
count += 1;
}
i = 0;
// Display calculated result
while (i < n)
{
print(" " + result(i));
i += 1;
}
}
}
object Main
{
def main(args: Array[String]): Unit = {
var task: Combinations = new Combinations();
/*
k = 9
-------------------------
(9 - 1) : 8
(1 - 8) : -7
(8 - 2) : 6
(2 - 7) : -5
(7 - 3) : 4
(3 - 6) : -3
(6 - 4) : 2
(4 - 5) : -1
-------------------------
9  1  8  2  7  3  6  4  5
Alternate decreasing sequence
↑
╔┄┄┄┄┄╦┄┄┄┄┄╦┄┄┄┄┄╦┄┄┄┄┄╗
│     │     │     │     │
│     │     │     │     │
9  1  8  2  7  3  6  4  5
│     │     │     │
│     │     │     │
╰┄┄┄┄┄╩┄┄┄┄┄╩┄┄┄┄┄┘
ↆ
Alternate increasing order
*/
/*
Given k : -9
---------------------------------
(-1 - -9) : 8
(-9 - -2) : -7
(-2 - -8) : 6
(-8 - -3) : -5
(-3 - -7) : 4
(-7 - -4) : -3
(-4 - -6) : 2
(-6 - -5) : -1
------------------------------------
-1  -9  -2  -8  -3  -7  -4  -6  -5
*/
/*
Given k : 5
-------------------
(5 - 1) : 4
(1 - 4) : -3
(4 - 2) : 2
(2 - 3) : -1
-------------------
5  1  4  2  3
*/
}
}``````

#### Output

`````` Given k : 9
9 1 8 2 7 3 6 4 5
Given k : -9
-1 -9 -2 -8 -3 -7 -4 -6 -5
Given k : 5
5 1 4 2 3``````
``````// Swift 4 program for
// Find combination of k with consecutive absolute difference
class Combinations
{
func absoluteValue(_ x: Int) -> Int
{
if (x < 0)
{
return -x;
}
return x;
}
func combinations(_ k: Int)
{
let n: Int = self.absoluteValue(k);
if (n <= 1)
{
return;
}
print("\n Given k : ", k );
var result: [Int] = Array(repeating: 0, count: n);
// Auxiliary variable
var min: Int = 1;
var max: Int = k;
if (k < 0)
{
min = k;
max = -1;
}
// Counter variable
var i: Int = min;
var j: Int = max;
var count: Int = 0;
while (i - 1 <= j && count < n)
{
if (count % 2 == 0)
{
result[count] = j;
j -= 1;
}
else
{
result[count] = i;
i += 1;
}
count += 1;
}
i = 0;
// Display calculated result
while (i < n)
{
print(" ", result[i], terminator: "");
i += 1;
}
}
}
func main()
{
/*
k = 9
-------------------------
(9 - 1) : 8
(1 - 8) : -7
(8 - 2) : 6
(2 - 7) : -5
(7 - 3) : 4
(3 - 6) : -3
(6 - 4) : 2
(4 - 5) : -1
-------------------------
9  1  8  2  7  3  6  4  5
Alternate decreasing sequence
↑
╔┄┄┄┄┄╦┄┄┄┄┄╦┄┄┄┄┄╦┄┄┄┄┄╗
│     │     │     │     │
│     │     │     │     │
9  1  8  2  7  3  6  4  5
│     │     │     │
│     │     │     │
╰┄┄┄┄┄╩┄┄┄┄┄╩┄┄┄┄┄┘
ↆ
Alternate increasing order
*/
/*
Given k : -9
---------------------------------
(-1 - -9) : 8
(-9 - -2) : -7
(-2 - -8) : 6
(-8 - -3) : -5
(-3 - -7) : 4
(-7 - -4) : -3
(-4 - -6) : 2
(-6 - -5) : -1
------------------------------------
-1  -9  -2  -8  -3  -7  -4  -6  -5
*/
/*
Given k : 5
-------------------
(5 - 1) : 4
(1 - 4) : -3
(4 - 2) : 2
(2 - 3) : -1
-------------------
5  1  4  2  3
*/
}
main();``````

#### Output

`````` Given k :  9
9  1  8  2  7  3  6  4  5
Given k :  -9
-1  -9  -2  -8  -3  -7  -4  -6  -5
Given k :  5
5  1  4  2  3``````
``````// Kotlin program for
// Find combination of k with consecutive absolute difference
class Combinations
{
fun absoluteValue(x: Int): Int
{
if (x < 0)
{
return -x;
}
return x;
}
fun combinations(k: Int): Unit
{
val n: Int = this.absoluteValue(k);
if (n <= 1)
{
return;
}
print("\n Given k : " + k + "\n");
val result: Array < Int > = Array(n)
{
0
};
// Auxiliary variable
var min: Int = 1;
var max: Int = k;
if (k < 0)
{
min = k;
max = -1;
}
// Counter variable
var i: Int = min;
var j: Int = max;
var count: Int = 0;
while (i - 1 <= j && count < n)
{
if (count % 2 == 0)
{
result[count] = j;
j -= 1;
}
else
{
result[count] = i;
i += 1;
}
count += 1;
}
i = 0;
// Display calculated result
while (i < n)
{
print(" " + result[i]);
i += 1;
}
}
}
fun main(args: Array < String > ): Unit
{
/*
k = 9
-------------------------
(9 - 1) : 8
(1 - 8) : -7
(8 - 2) : 6
(2 - 7) : -5
(7 - 3) : 4
(3 - 6) : -3
(6 - 4) : 2
(4 - 5) : -1
-------------------------
9  1  8  2  7  3  6  4  5
Alternate decreasing sequence
↑
╔┄┄┄┄┄╦┄┄┄┄┄╦┄┄┄┄┄╦┄┄┄┄┄╗
│     │     │     │     │
│     │     │     │     │
9  1  8  2  7  3  6  4  5
│     │     │     │
│     │     │     │
╰┄┄┄┄┄╩┄┄┄┄┄╩┄┄┄┄┄┘
ↆ
Alternate increasing order
*/
/*
Given k : -9
---------------------------------
(-1 - -9) : 8
(-9 - -2) : -7
(-2 - -8) : 6
(-8 - -3) : -5
(-3 - -7) : 4
(-7 - -4) : -3
(-4 - -6) : 2
(-6 - -5) : -1
------------------------------------
-1  -9  -2  -8  -3  -7  -4  -6  -5
*/
/*
Given k : 5
-------------------
(5 - 1) : 4
(1 - 4) : -3
(4 - 2) : 2
(2 - 3) : -1
-------------------
5  1  4  2  3
*/
}``````

#### Output

`````` Given k : 9
9 1 8 2 7 3 6 4 5
Given k : -9
-1 -9 -2 -8 -3 -7 -4 -6 -5
Given k : 5
5 1 4 2 3``````

## Comment

Please share your knowledge to improve code and content standard. Also submit your doubts, and test case. We improve by your feedback. We will try to resolve your query as soon as possible.