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)
{
Combinations task = 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
*/
task.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
*/
task.combinations(-9);
/*
Given k : 5
-------------------
(5 - 1) : 4
(1 - 4) : -3
(4 - 2) : 2
(2 - 3) : -1
-------------------
5 1 4 2 3
*/
task.combinations(5);
}
}
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()
{
Combinations *task = 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
*/
task->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
*/
task->combinations(-9);
/*
Given k : 5
-------------------
(5 - 1) : 4
(1 - 4) : -3
(4 - 2) : 2
(2 - 3) : -1
-------------------
5 1 4 2 3
*/
task->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
// 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)
{
Combinations task = 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
*/
task.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
*/
task.combinations(-9);
/*
Given k : 5
-------------------
(5 - 1) : 4
(1 - 4) : -3
(4 - 2) : 2
(2 - 3) : -1
-------------------
5 1 4 2 3
*/
task.combinations(5);
}
}
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
*/
task.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
*/
task.combinations(-9)
/*
Given k : 5
-------------------
(5 - 1) : 4
(1 - 4) : -3
(4 - 2) : 2
(2 - 3) : -1
-------------------
5 1 4 2 3
*/
task.combinations(5)
}
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()
{
$task = 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
*/
$task->combination(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
*/
$task->combination(-9);
/*
Given k : 5
-------------------
(5 - 1) : 4
(1 - 4) : -3
(4 - 2) : 2
(2 - 3) : -1
-------------------
5 1 4 2 3
*/
$task->combination(5);
}
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()
{
var task = 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
*/
task.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
*/
task.combinations(-9);
/*
Given k : 5
-------------------
(5 - 1) : 4
(1 - 4) : -3
(4 - 2) : 2
(2 - 3) : -1
-------------------
5 1 4 2 3
*/
task.combinations(5);
}
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() :
task = 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
task.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
task.combinations(-9)
# Given k : 5
# -------------------
# (5 - 1) : 4
# (1 - 4) : -3
# (4 - 2) : 2
# (2 - 3) : -1
# -------------------
# 5 1 4 2 3
task.combinations(5)
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()
task = Combinations.new()
# 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
task.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
task.combinations(-9)
# Given k : 5
# -------------------
# (5 - 1) : 4
# (1 - 4) : -3
# (4 - 2) : 2
# (2 - 3) : -1
# -------------------
# 5 1 4 2 3
task.combinations(5)
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
*/
task.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
*/
task.combinations(-9);
/*
Given k : 5
-------------------
(5 - 1) : 4
(1 - 4) : -3
(4 - 2) : 2
(2 - 3) : -1
-------------------
5 1 4 2 3
*/
task.combinations(5);
}
}
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()
{
let task: Combinations = 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
*/
task.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
*/
task.combinations(-9);
/*
Given k : 5
-------------------
(5 - 1) : 4
(1 - 4) : -3
(4 - 2) : 2
(2 - 3) : -1
-------------------
5 1 4 2 3
*/
task.combinations(5);
}
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
{
val task: Combinations = 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
*/
task.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
*/
task.combinations(-9);
/*
Given k : 5
-------------------
(5 - 1) : 4
(1 - 4) : -3
(4 - 2) : 2
(2 - 3) : -1
-------------------
5 1 4 2 3
*/
task.combinations(5);
}
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
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.
New Comment