# Draw a chart

Given collection of positive integers, Our goal is to draw a chart using of this data. Let see an example.

In above chart given number are not large. and number of elements are less than 10. Here given code implementation process.

``````// C program
// Draw a chart
#include <stdio.h>

//Find the maximum element of given result
int find_max(int result[], int size)
{
int max = result[0];
for (int i = 1; i < size; ++i)
{
if (result[i] > max)
{
max = result[i];
}
}
return max;
}
//Display chart of given elements
void print_chart(int runs[], int result[], int size)
{
int status = 0;
int i = 0;
int max = find_max(result, size);
if (max > 0)
{
printf("\n \t%d∣", max);
for (i = 0; i < size; ++i)
{
printf("\t");
if (result[i] == max)
{
status = 1;
result[i]--;
printf("▒");
}
}
}
if (status == 1)
{
//Recursively executing function print chart
print_chart(runs, result, size);
}
else
{
//Display bottom layer
printf("\n \t ∣");
for (i = 0; i <= size; ++i)
{
//printf("▔▔▔▔▔▔▔");
printf("-------");
}
printf("\n \t ");
for (i = 0; i < size; ++i)
{
printf("\t%d", runs[i]);
}
}
}
void draw_chart(int runs[], int size)
{
int result[size];
//Copy array elements
for (int i = 0; i < size; ++i)
{
//check condition here when invalid input
//such as negative element
//max run in a ball etc
//we are assume that given input valid
result[i] = runs[i];
}
print_chart(runs, result, size);
}
int main()
{
//Assume that each element are indicate  runs of a ball
//No negative elements are possible
//When ball is no ball then max run can be 7 and add one extra ball
int runs[] = {
4,
6,
2,
1,
4,
7,
3
};
int size = sizeof(runs) / sizeof(runs[0]);
draw_chart(runs, size);
return (0);
}``````

#### Output

`````` 	7∣						▒
6∣		▒				▒
5∣		▒				▒
4∣	▒	▒			▒	▒
3∣	▒	▒			▒	▒	▒
2∣	▒	▒	▒		▒	▒	▒
1∣	▒	▒	▒	▒	▒	▒	▒
∣--------------------------------------------------------
4	6	2	1	4	7	3``````
``````// Java program
// Draw a chart
class MyPattern
{
//Find the maximum element of given result
public int find_max(int[] result, int size)
{
int max = result[0];
for (int i = 1; i < size; ++i)
{
if (result[i] > max)
{
max = result[i];
}
}
return max;
}
//Display chart of given elements
public void print_chart(int[] runs, int[] result, int size)
{
int status = 0;
int i = 0;
int max = find_max(result, size);
if (max > 0)
{
System.out.print("\n \t" + max + "∣");
for (i = 0; i < size; ++i)
{
System.out.print("\t");
if (result[i] == max)
{
status = 1;
result[i]--;
System.out.print("▒");
}
}
}
if (status == 1)
{
//Recursively executing function print chart
print_chart(runs, result, size);
}
else
{
System.out.print("\n \t ∣");
for (i = 0; i <= size; ++i)
{
System.out.print("-------");
}
System.out.print("\n \t ");
for (i = 0; i < size; ++i)
{
System.out.print("\t" + runs[i] + "");
}
}
}
public void draw_chart(int[] runs, int size)
{
int[] result = new int[size];
//Copy array elements
for (int i = 0; i < size; ++i)
{
//check condition here when invalid input
//such as negative element
//max run in a ball etc
//we are assume that given input valid
result[i] = runs[i];
}
print_chart(runs, result, size);
}
public static void main(String[] args)
{
MyPattern obj = new MyPattern();
//Assume that each element are indicate  runs of a ball
//No negative elements are possible
//When ball is no ball then max run can be 7 and add one extra ball
int[] runs = {
4,
6,
2,
1,
4,
7,
3
};
int size = runs.length;
obj.draw_chart(runs, size);
}
}``````

#### Output

`````` 	7∣						▒
6∣		▒				▒
5∣		▒				▒
4∣	▒	▒			▒	▒
3∣	▒	▒			▒	▒	▒
2∣	▒	▒	▒		▒	▒	▒
1∣	▒	▒	▒	▒	▒	▒	▒
∣--------------------------------------------------------
4	6	2	1	4	7	3``````
``````//Include header file
#include <iostream>

using namespace std;
// C++ program
// Draw a chart
class MyPattern
{
public:
//Find the maximum element of given result
int find_max(int result[], int size)
{
int max = result[0];
for (int i = 1; i < size; ++i)
{
if (result[i] > max)
{
max = result[i];
}
}
return max;
}
//Display chart of given elements
void print_chart(int runs[], int result[], int size)
{
int status = 0;
int i = 0;
int max = this->find_max(result, size);
if (max > 0)
{
cout << "\n \t" << max << "∣";
for (i = 0; i < size; ++i)
{
cout << "\t";
if (result[i] == max)
{
status = 1;
result[i]--;
cout << "▒";
}
}
}
if (status == 1)
{
//Recursively executing function print chart
this->print_chart(runs, result, size);
}
else
{
cout << "\n \t ∣";
for (i = 0; i <= size; ++i)
{
cout << "-------";
}
cout << "\n \t ";
for (i = 0; i < size; ++i)
{
cout << "\t" << runs[i] << "";
}
}
}
void draw_chart(int runs[], int size)
{
int result[size];
//Copy array elements
for (int i = 0; i < size; ++i)
{
//check condition here when invalid input
//such as negative element
//max run in a ball etc
//we are assume that given input valid
result[i] = runs[i];
}
this->print_chart(runs, result, size);
}
};
int main()
{
MyPattern obj = MyPattern();
int runs[] = {
4 , 6 , 2 , 1 , 4 , 7 , 3
};
int size = sizeof(runs) / sizeof(runs[0]);
obj.draw_chart(runs, size);
return 0;
}``````

#### Output

`````` 	7∣						▒
6∣		▒				▒
5∣		▒				▒
4∣	▒	▒			▒	▒
3∣	▒	▒			▒	▒	▒
2∣	▒	▒	▒		▒	▒	▒
1∣	▒	▒	▒	▒	▒	▒	▒
∣--------------------------------------------------------
4	6	2	1	4	7	3``````
``````//Include namespace system
using System;
// C# program
// Draw a chart
class MyPattern
{
//Find the maximum element of given result
public int find_max(int[] result, int size)
{
int max = result[0];
for (int i = 1; i < size; ++i)
{
if (result[i] > max)
{
max = result[i];
}
}
return max;
}
//Display chart of given elements
public void print_chart(int[] runs, int[] result, int size)
{
int status = 0;
int i = 0;
int max = find_max(result, size);
if (max > 0)
{
Console.Write("\n \t" + max + "∣");
for (i = 0; i < size; ++i)
{
Console.Write("\t");
if (result[i] == max)
{
status = 1;
result[i]--;
Console.Write("▒");
}
}
}
if (status == 1)
{
//Recursively executing function print chart
print_chart(runs, result, size);
}
else
{
Console.Write("\n \t ∣");
for (i = 0; i <= size; ++i)
{
Console.Write("-------");
}
Console.Write("\n \t ");
for (i = 0; i < size; ++i)
{
Console.Write("\t" + runs[i] + "");
}
}
}
public void draw_chart(int[] runs, int size)
{
int[] result = new int[size];
//Copy array elements
for (int i = 0; i < size; ++i)
{
//check condition here when invalid input
//such as negative element
//max run in a ball etc
//we are assume that given input valid
result[i] = runs[i];
}
print_chart(runs, result, size);
}
public static void Main(String[] args)
{
MyPattern obj = new MyPattern();
int[] runs = {
4 , 6 , 2 , 1 , 4 , 7 , 3
};
int size = runs.Length;
obj.draw_chart(runs, size);
}
}``````

#### Output

`````` 	7∣						▒
6∣		▒				▒
5∣		▒				▒
4∣	▒	▒			▒	▒
3∣	▒	▒			▒	▒	▒
2∣	▒	▒	▒		▒	▒	▒
1∣	▒	▒	▒	▒	▒	▒	▒
∣--------------------------------------------------------
4	6	2	1	4	7	3``````
``````<?php
// Php program
// Draw a chart
class MyPattern
{
//Find the maximum element of given result
public	function find_max( & \$result, \$size)
{
\$max = \$result[0];
for (\$i = 1; \$i < \$size; ++\$i)
{
if (\$result[\$i] > \$max)
{
\$max = \$result[\$i];
}
}
return \$max;
}
//Display chart of given elements
public	function print_chart( & \$runs, & \$result, \$size)
{
\$status = 0;
\$i = 0;
\$max = \$this->find_max(\$result, \$size);
if (\$max > 0)
{
echo "\n \t". \$max ."∣";
for (\$i = 0; \$i < \$size; ++\$i)
{
echo "\t";
if (\$result[\$i] == \$max)
{
\$status = 1;
\$result[\$i]--;
echo "▒";
}
}
}
if (\$status == 1)
{
//Recursively executing function print chart
\$this->print_chart(\$runs, \$result, \$size);
}
else
{
echo "\n \t ∣";
for (\$i = 0; \$i <= \$size; ++\$i)
{
echo "-------";
}
echo "\n \t ";
for (\$i = 0; \$i < \$size; ++\$i)
{
echo "\t". \$runs[\$i] ."";
}
}
}
public	function draw_chart( & \$runs, \$size)
{
\$result = array_fill(0, \$size, 0);
//Copy array elements
for (\$i = 0; \$i < \$size; ++\$i)
{
//check condition here when invalid input
//such as negative element
//max run in a ball etc
//we are assume that given input valid
\$result[\$i] = \$runs[\$i];
}
\$this->print_chart(\$runs, \$result, \$size);
}
}

function main()
{
\$obj = new MyPattern();
//Assume that each element are indicate  runs of a ball
//No negative elements are possible
//When ball is no ball then max run can be 7 and add one extra ball
\$runs = array(4, 6, 2, 1, 4, 7, 3);
\$size = count(\$runs);
\$obj->draw_chart(\$runs, \$size);
}
main();``````

#### Output

`````` 	7∣						▒
6∣		▒				▒
5∣		▒				▒
4∣	▒	▒			▒	▒
3∣	▒	▒			▒	▒	▒
2∣	▒	▒	▒		▒	▒	▒
1∣	▒	▒	▒	▒	▒	▒	▒
∣--------------------------------------------------------
4	6	2	1	4	7	3``````
``````// Node Js program
// Draw a chart
class MyPattern
{
//Find the maximum element of given result
find_max(result, size)
{
var max = result[0];
for (var i = 1; i < size; ++i)
{
if (result[i] > max)
{
max = result[i];
}
}
return max;
}
//Display chart of given elements
print_chart(runs, result, size)
{
var status = 0;
var i = 0;
var max = this.find_max(result, size);
if (max > 0)
{
process.stdout.write("\n \t" + max + "∣");
for (i = 0; i < size; ++i)
{
process.stdout.write("\t");
if (result[i] == max)
{
status = 1;
result[i]--;
process.stdout.write("▒");
}
}
}
if (status == 1)
{
//Recursively executing function print chart
this.print_chart(runs, result, size);
}
else
{
process.stdout.write("\n \t ∣");
for (i = 0; i <= size; ++i)
{
process.stdout.write("-------");
}
process.stdout.write("\n \t ");
for (i = 0; i < size; ++i)
{
process.stdout.write("\t" + runs[i] + "");
}
}
}
draw_chart(runs, size)
{
var result = Array(size).fill(0);
//Copy array elements
for (var i = 0; i < size; ++i)
{
//check condition here when invalid input
//such as negative element
//max run in a ball etc
//we are assume that given input valid
result[i] = runs[i];
}
this.print_chart(runs, result, size);
}
}

function main()
{
var obj = new MyPattern();
//Assume that each element are indicate  runs of a ball
//No negative elements are possible
//When ball is no ball then max run can be 7 and add one extra ball
var runs = [4, 6, 2, 1, 4, 7, 3];
var size = runs.length;
obj.draw_chart(runs, size);
}
main();``````

#### Output

`````` 	7∣						▒
6∣		▒				▒
5∣		▒				▒
4∣	▒	▒			▒	▒
3∣	▒	▒			▒	▒	▒
2∣	▒	▒	▒		▒	▒	▒
1∣	▒	▒	▒	▒	▒	▒	▒
∣--------------------------------------------------------
4	6	2	1	4	7	3``````
``````#  Python 3 program
#  Draw a chart
class MyPattern :
# Find the maximum element of given result
def find_max(self, result, size) :
max = result[0]
i = 1
while (i < size) :
if (result[i] > max) :
max = result[i]

i += 1

return max

# Display chart of given elements
def print_chart(self, runs, result, size) :
status = 0
i = 0
max = self.find_max(result, size)
if (max > 0) :
print("\n \t", max ,"∣", end = "")
i = 0
while (i < size) :
print("\t", end = "")
if (result[i] == max) :
status = 1
result[i] -= 1
print("▒", end = "")

i += 1

if (status == 1) :
# Recursively executing function print chart
self.print_chart(runs, result, size)
else :
print("\n \t ∣", end = "")
i = 0
while (i <= size) :
print("-------", end = "")
i += 1

print("\n \t ", end = "")
i = 0
while (i < size) :
print("\t", runs[i] ,"", end = "")
i += 1

def draw_chart(self, runs, size) :
result = [0] * size
# Copy array elements
i = 0
while (i < size) :
# check condition here when invalid input
# such as negative element
# max run in a ball etc
# we are assume that given input valid
result[i] = runs[i]
i += 1

self.print_chart(runs, result, size)

def main() :
obj = MyPattern()
# Assume that each element are indicate  runs of a ball
# No negative elements are possible
# When ball is no ball then max run can be 7 and add one extra ball
runs = [4, 6, 2, 1, 4, 7, 3]
size = len(runs)
obj.draw_chart(runs, size)

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

#### Output

`````` 	 7 ∣						▒
6 ∣		▒				▒
5 ∣		▒				▒
4 ∣	▒	▒			▒	▒
3 ∣	▒	▒			▒	▒	▒
2 ∣	▒	▒	▒		▒	▒	▒
1 ∣	▒	▒	▒	▒	▒	▒	▒
∣--------------------------------------------------------
4 	 6 	 2 	 1 	 4 	 7 	 3``````
``````#  Ruby program
#  Draw a chart
class MyPattern

# Find the maximum element of given result
def find_max(result, size)

max = result[0]
i = 1
while (i < size)

if (result[i] > max)

max = result[i]
end
i += 1
end
return max
end
# Display chart of given elements
def print_chart(runs, result, size)

status = 0
i = 0
max = self.find_max(result, size)
if (max > 0)

print("\n \t", max ,"∣")
i = 0
while (i < size)

print("\t")
if (result[i] == max)

status = 1
result[i] -= 1
print("▒")
end
i += 1
end
end
if (status == 1)

# Recursively executing function print chart
self.print_chart(runs, result, size)
else

print("\n \t ∣")
i = 0
while (i <= size)

print("-------")
i += 1
end
print("\n \t ")
i = 0
while (i < size)

print("\t", runs[i] ,"")
i += 1
end
end
end
def draw_chart(runs, size)

result = Array.new(size) {0}
# Copy array elements
i = 0
while (i < size)

# check condition here when invalid input
# such as negative element
# max run in a ball etc
# we are assume that given input valid
result[i] = runs[i]
i += 1
end
self.print_chart(runs, result, size)
end
end
def main()

obj = MyPattern.new()
# Assume that each element are indicate  runs of a ball
# No negative elements are possible
# When ball is no ball then max run can be 7 and add one extra ball
runs = [4, 6, 2, 1, 4, 7, 3]
size = runs.length
obj.draw_chart(runs, size)
end
main()``````

#### Output

`````` 	7∣						▒
6∣		▒				▒
5∣		▒				▒
4∣	▒	▒			▒	▒
3∣	▒	▒			▒	▒	▒
2∣	▒	▒	▒		▒	▒	▒
1∣	▒	▒	▒	▒	▒	▒	▒
∣--------------------------------------------------------
4	6	2	1	4	7	3``````
``````// Scala program
// Draw a chart
class MyPattern
{
//Find the maximum element of given result
def find_max(result: Array[Int], size: Int): Int = {
var max: Int = result(0);
var i: Int = 1;
while (i < size)
{
if (result(i) > max)
{
max = result(i);
}
i += 1;
}
return max;
}
//Display chart of given elements
def print_chart(runs: Array[Int], result: Array[Int], size: Int): Unit = {
var status: Int = 0;
var i: Int = 0;
var max: Int = find_max(result, size);
if (max > 0)
{
print("\n \t" + max + "∣");
i = 0;
while (i < size)
{
print("\t");
if (result(i) == max)
{
status = 1;
result(i) -= 1;
print("▒");
}
i += 1;
}
}
if (status == 1)
{
//Recursively executing function print chart
print_chart(runs, result, size);
}
else
{
print("\n \t ∣");
i = 0;
while (i <= size)
{
print("-------");
i += 1;
}
print("\n \t ");
i = 0;
while (i < size)
{
print("\t" + runs(i) + "");
i += 1;
}
}
}
def draw_chart(runs: Array[Int], size: Int): Unit = {
var result: Array[Int] = Array.fill[Int](size)(0);
//Copy array elements
var i: Int = 0;
while (i < size)
{
//check condition here when invalid input
//such as negative element
//max run in a ball etc
//we are assume that given input valid
result(i) = runs(i);
i += 1;
}
print_chart(runs, result, size);
}
}
object Main
{
def main(args: Array[String]): Unit = {
var obj: MyPattern = new MyPattern();
//Assume that each element are indicate  runs of a ball
//No negative elements are possible
//When ball is no ball then max run can be 7 and add one extra ball
var runs: Array[Int] = Array(4, 6, 2, 1, 4, 7, 3);
var size: Int = runs.length;
obj.draw_chart(runs, size);
}
}``````

#### Output

`````` 	7∣						▒
6∣		▒				▒
5∣		▒				▒
4∣	▒	▒			▒	▒
3∣	▒	▒			▒	▒	▒
2∣	▒	▒	▒		▒	▒	▒
1∣	▒	▒	▒	▒	▒	▒	▒
∣--------------------------------------------------------
4	6	2	1	4	7	3``````
``````// Swift program
// Draw a chart
class MyPattern
{
//Find the maximum element of given result
func find_max(_ result: [Int], _ size: Int) -> Int
{
var max: Int = result[0];
var i: Int = 1;
while (i < size)
{
if (result[i] > max)
{
max = result[i];
}
i += 1;
}
return max;
}
//Display chart of given elements
func print_chart(_ runs: [Int], _ result: inout[Int], _ size: Int)
{
var status: Int = 0;
var i: Int = 0;
let max: Int = self.find_max(result, size);
if (max > 0)
{
print("\n \t", max ,"∣", terminator: "");
i = 0;
while (i < size)
{
print("\t", terminator: "");
if (result[i] == max)
{
status = 1;
result[i] -= 1;
print("▒", terminator: "");
}
i += 1;
}
}
if (status == 1)
{
//Recursively executing function print chart
self.print_chart(runs, &result, size);
}
else
{
print("\n \t ∣", terminator: "");
i = 0;
while (i <= size)
{
print("-------", terminator: "");
i += 1;
}
print("\n \t ", terminator: "");
i = 0;
while (i < size)
{
print("\t", runs[i] ,"", terminator: "");
i += 1;
}
}
}
func draw_chart(_ runs: [Int], _ size: Int)
{
var result: [Int] = Array(repeating: 0, count: size);
//Copy array elements
var i: Int = 0;
while (i < size)
{
//check condition here when invalid input
//such as negative element
//max run in a ball etc
//we are assume that given input valid
result[i] = runs[i];
i += 1;
}
self.print_chart(runs, &result, size);
}
}
func main()
{
let obj: MyPattern = MyPattern();
//Assume that each element are indicate  runs of a ball
//No negative elements are possible
//When ball is no ball then max run can be 7 and add one extra ball
let runs: [Int] = [4, 6, 2, 1, 4, 7, 3];
let size: Int = runs.count;
obj.draw_chart(runs, size);
}
main();``````

#### Output

`````` 	 7 ∣						▒
6 ∣		▒				▒
5 ∣		▒				▒
4 ∣	▒	▒			▒	▒
3 ∣	▒	▒			▒	▒	▒
2 ∣	▒	▒	▒		▒	▒	▒
1 ∣	▒	▒	▒	▒	▒	▒	▒
∣--------------------------------------------------------
4 	 6 	 2 	 1 	 4 	 7 	 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.