Posted on by Kalkicode
Code Pattern

# Draw a chart

In this article, we will discuss the problem of drawing a chart based on a given set of data. The task is to visualize the data in the form of a chart, where the height of each bar represents the corresponding value in the dataset. We will provide a detailed explanation of the problem, along with a suitable example, algorithm, pseudocode, and the resultant output explanation. ## Problem Statement

The problem is to draw a chart based on a given set of data, where each element in the dataset represents the number of runs scored by a player. The chart should represent the frequency of runs scored by each player in a visually appealing manner. Each bar in the chart corresponds to a particular run value, and its height represents the frequency of that run value in the dataset.

For example, consider the following dataset:

```    [4, 6, 2, 1, 4, 7, 3]
```

The chart for this dataset would look as follows:

```    7∣                       ▒
6∣       ▒               ▒
5∣       ▒               ▒
4∣   ▒   ▒           ▒   ▒
3∣   ▒   ▒           ▒   ▒   ▒
2∣   ▒   ▒   ▒       ▒   ▒   ▒
1∣   ▒   ▒   ▒   ▒   ▒   ▒   ▒
∣--------------------------------------------------------
4   6   2   1   4   7   3
```

The x-axis represents the different run values, and the y-axis represents the frequency of each run value. The bars in the chart are represented by '▒' characters, and the numbers at the bottom indicate the run values. The chart provides a visual representation of the frequency distribution of the runs scored by each player.

## Algorithm and Pseudocode

To solve this problem, we can follow the given algorithm:

```    1. Find the maximum element in the given dataset.
2. Initialize a variable 'status' to 0.
3. Iterate from the maximum element down to 1:
4. Print the current value as the y-axis label.
5. Iterate over each element in the dataset:
6. If the element is equal to the current value:
7. Set 'status' to 1.
8. Decrement the element by 1.
9. Print a '▒' character to represent the bar.
10. If 'status' is 1:
11. Recursively call the function with the updated dataset.
12. Else:
13. Print a horizontal line to represent the bottom layer.
14. Print the run values at the bottom of the chart.
```

The pseudocode representation of the algorithm is as follows:

``````function find_max(result[], size):
max = result
for i = 1 to size - 1:
if result[i] > max:
max = result[i]
return max

function print_chart(runs[], result[], size):
status = 0
max = find_max(result, size)
if max > 0:
print "\n \t%d∣", max
for i = 0 to size - 1:
print "\t"
if result[i] == max:
status = 1
result[i]--
print "▒"
if status == 1:
print_chart(runs, result, size)
else:
print "\n \t ∣"
for i = 0 to size:
print "-------"
print "\n \t "
for i = 0 to size - 1:
print "\t%d", runs[i]

function draw_chart(runs[], size):
create an array result[size]
for i = 0 to size - 1:
result[i] = runs[i]
print_chart(runs, result, size)

function main():
runs = [4, 6, 2, 1, 4, 7, 3]
size = length(runs)
draw_chart(runs, size)
return 0```
```

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

## Code Solution

``````// 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;
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);
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;
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;
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);
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;
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;
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;
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
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 =  * 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
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;
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``````

## Time Complexity

The time complexity of the given algorithm depends on the size of the dataset, represented by 'size'. Let 'n' be the value of 'size'.

The function 'find_max' iterates through the 'result' array once, resulting in a time complexity of O(n).

The function 'print_chart' iterates through the 'result' array once for each unique run value, which can be at most 'n'. Hence, the time complexity of 'print_chart' is O(n^2).

The function 'draw_chart' copies the 'runs' array into the 'result' array, resulting in a time complexity of O(n).

Therefore, the overall time complexity of the code is O(n^2) due to the recursive nature of the 'print_chart' function.

## 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.

Categories
Relative Post