Well we all have seen the common questions on creating squares and hollow squares out of asterisks in C++, but how about creating a program that prints out a circle in asterisks? Obviously this would look like an oval due to line adjustment, but it would be quite interesting to see if someone could do it.
I have tried myself and I must admit it is a fairly decent challenge.
If you figure it out, post your code here!
Hint: r^2 = x^2 + y^2
Piece of cake, kinda crude approximation tho.
#include <iostream>
#include <cmath>
#include <string>
#include <vector>
using namespace std;
const unsigned CANVAS_WIDTH = 20;
const unsigned CANVAS_HEIGHT = 20;
const unsigned char BACKGROUND_FILL = '#';
const char POINT = '*';
const float PI = 3.14159265f;
const float DEGREE_TO_RADIAN_FACTOR = 0.0174532925f;
typedef std::vector<std::string> Canvas;
float toRadians(const float deg){ return deg * DEGREE_TO_RADIAN_FACTOR;}
int roundPositive(const float n){ return int(n + 0.5f); }
Canvas createDefaultCanvas(){
return Canvas(CANVAS_HEIGHT, std::string(CANVAS_WIDTH,BACKGROUND_FILL) );
}
void fillCircle(Canvas& canvas,const unsigned radius){
const int canvasMidX = canvas[0].size() / 2; //assume same width for each height
const int canvasMidY = canvas.size() / 2;
const int STEP_SIZE = 1;
for(int deg = 0; deg < 360; deg += STEP_SIZE){
float radian = toRadians(deg);
float x = cos(radian) * radius + canvasMidX;
float y = sin(radian) * radius + canvasMidY;
x = roundPositive(x);
y = roundPositive(y);
canvas[y][x] = POINT;
}
}
void showCanvas(const Canvas& canvas){
for(unsigned height = 0; height < canvas.size(); ++height){
for(unsigned width = 0; width < canvas[height].size(); ++width){
cout << canvas[height][width];
}
cout << endl;
}
}
int main(){
using namespace std;
const unsigned RADIUS = 5;
Canvas canvas = createDefaultCanvas();
fillCircle(canvas,RADIUS);
showCanvas(canvas);
return 0;
}example output :
####################
####################
####################
####################
####################
########*****#######
######***###***#####
######*#######*#####
#####**#######**####
#####*#########*####
#####*#########*####
#####*#########*####
#####**#######**####
######*#######*#####
######***###***#####
########*****#######
####################
####################
####################
####################
Would look more like a circle if the characters were square and line spacing was the same as character spacing.
#include <iostream>
using namespace std;
int main()
{
double r = 1.2;
for( double y = -r-0.1; y <= r+0.2; y += 0.1 )
{
for( double x = -r-0.1; x <= r+0.2; x += 0.1 )
{
if( (x*x + y*y <= (r*r)*1.1) && (x*x + y*y >= (r*r)*0.9) )
cout << "*";
else
cout << "#";
}
cout << endl;
}
return 0;
}Output:
###########################
##########*******##########
#######****#####****#######
######**###########**######
#####**#############**#####
####*#################*####
###**#################**###
##**###################**##
##*#####################*##
##*#####################*##
#**#####################**#
#*#######################*#
#*#######################*#
#*#######################*#
#*#######################*#
#*#######################*#
#**#####################**#
##*#####################*##
##*#####################*##
##**###################**##
###**#################**###
####*#################*####
#####**#############**#####
######**###########**######
#######****#####****#######
##########*******##########
###########################Very Cool. Now how about a solid circle? =o
C'mon, lets address the aspect ratio.
#include <iostream>
int foo(double a, double b, double x, double y) {
return ((x*x)/(a*a) + (y*y)/(b*b));
}
int main () {
int b = 4, a = 10;
const int min = -15, max = 15;
int x = min, y = min;
for (; y < max; ++y) {
for (x = min; x < max; ++x)
std::cout << (foo(a,b,x,y) == 1 ? '*' : '#');
std::cout << std::endl;
}
return 0;
}##############################
##############################
##############################
##############################
##############################
##############################
##############################
##############################
##############################
##############################
#########*************########
######*******************#####
####*****#############*****###
##*****#################*****#
##****###################****#
#*****###################*****
##****###################****#
##*****#################*****#
####*****#############*****###
######*******************#####
#########*************########
##############################
##############################
##############################
##############################
##############################
##############################
##############################
##############################
##############################
#include <iostream>
#include <cmath>
#include <sstream>
int pth (int x,int y) {
return std::sqrt (std::pow(x,2)+std::pow(y,2));
}
int main (int argc,char* argv[]) {
int c=0;
int r;
std::istringstream i(argv[1]);
i >> r;
const int width=r;
const int length=r*1.5;
for (int y=width;y >= -width;y-=2) {
for (int x=-length;x <= length;x++) {
if ((int) pth(x,y)==r) std::cout << "*";
else std::cout << " ";
}
std::cout << "\n";
}
std::cin.get();
}
***************
*** ***
** **
** **
* *
* *
** **
* *
* *
* *
* *
* *
* *
* *
* *
* *
* *
* *
* *
* *
* *
* *
* *
* *
** **
* *
* *
** **
** **
*** ***
***************#include <iostream>
#include <cmath>
#include <sstream>
int pth (int x,int y) {
return std::sqrt (std::pow(x,2)+std::pow(y,2));
}
int main (int argc,char* argv[1]) {
if (argv[1]==NULL) argv[1]="30";
int c=0;
int r;
std::istringstream i(argv[1]);
i >> r;
const int width=r;
const int length=r*1.5;
bool in=1;
for (int y=width;y >= -width;y-=2) {
for (int x=-length;x <= length;x++) {
if (pth(x,y)==r && pth(x-1,y)!=r) {
std::cout << "*";
in^=1;
}
else if (in) std::cout << "*";
else std::cout << " ";
}
std::cout << "\n";
}
std::cin.get();
}
***************************************
*************************
********************************
**************************************
*******************************************
***********************************************
**************************************************
*****************************************************
*******************************************************
*********************************************************
***********************************************************
***********************************************************
*************************************************************
*************************************************************
*************************************************************
*************************************************************
*************************************************************
*************************************************************
*************************************************************
***********************************************************
***********************************************************
*********************************************************
*******************************************************
*****************************************************
**************************************************
***********************************************
*******************************************
**************************************
********************************
*************************
*****************************************************Using midpoint circle algorithm:
#include <stack>
#include <string>
#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
using namespace std;
typedef std::vector<std::string> Canvas;
void setPixel(int x, int y, Canvas& canvas){
canvas[y][x] = '*';
}
//midpoint circle algorithm -- src via wiki
void renderCircle(const int x0, const int y0, const int radius,Canvas& c){
int f = 1 - radius;
int ddF_x = 1;
int ddF_y = -2 * radius;
int x = 0;
int y = radius;
setPixel(x0, y0 + radius, c);
setPixel(x0, y0 - radius, c);
setPixel(x0 + radius, y0, c);
setPixel(x0 - radius, y0, c);
while(x < y)
{
// ddF_x == 2 * x + 1;
// ddF_y == -2 * y;
// f == x*x + y*y - radius*radius + 2*x - y + 1;
if(f >= 0)
{
y--;
ddF_y += 2;
f += ddF_y;
}
x++;
ddF_x += 2;
f += ddF_x;
setPixel(x0 + x, y0 + y, c);
setPixel(x0 - x, y0 + y, c);
setPixel(x0 + x, y0 - y, c);
setPixel(x0 - x, y0 - y, c);
setPixel(x0 + y, y0 + x, c);
setPixel(x0 - y, y0 + x, c);
setPixel(x0 + y, y0 - x, c);
setPixel(x0 - y, y0 - x, c);
}
}
void show(const Canvas& c){
struct _show{
void operator()(const std::string& str){ cout << str << endl; }
};
std::for_each(c.begin(),c.end(),_show());
}
int main(){
const unsigned RADIUS = 10;
Canvas c = Canvas(50,string(50,' ') );
renderCircle(25,25,RADIUS,c);
show(c);
return 0;
}*******
** **
* *
* *
* *
* *
* *
* *
* *
* *
* *
* *
* *
* *
* *
* *
* *
* *
* *
** **
*******C'mon, lets address the aspect ratio.
#include <iostream> int foo(double a, double b, double x, double y) { return ((x*x)/(a*a) + (y*y)/(b*b)); } int main () { int b = 4, a = 10; const int min = -15, max = 15; int x = min, y = min; for (; y < max; ++y) { for (x = min; x < max; ++x) std::cout << (foo(a,b,x,y) == 1 ? '*' : '#'); std::cout << std::endl; } return 0; }############################## ############################## ############################## ############################## ############################## ############################## ############################## ############################## ############################## ############################## #########*************######## ######*******************##### ####*****#############*****### ##*****#################*****# ##****###################****# #*****###################***** ##****###################****# ##*****#################*****# ####*****#############*****### ######*******************##### #########*************######## ############################## ############################## ############################## ############################## ############################## ############################## ############################## ############################## ##############################
@L7Sqr: Cool program man, could be please also comment the code so that beginners like me would know what is happening in every line of code, thanks in advance!
#include<iostream.h>
#include<conio.h>
#include<math.h>
void main()
{ clrscr();
double r;
cout<<"enter radius";
cin>>r;
for(double y=-r;y<=r;y++)
{
for(double x=-r;x<=r;x++)
{
double d=sqrt(xx+yy);
if(d<r+0.5&&d>r-0.5)
cout<<"*";
else
cout<<" ";
}
cout<<endl;
}
getch();
}
``
my first post here:
#include <cmath>
#include <iostream>
#include <functional>
using namespace std;
struct coord { int x, y; };
struct pixel { char c; };
ostream& operator<<(ostream& s, pixel p) { return s << p.c << p.c; }
void canvas(ostream &s, function<pixel(coord)> F, coord size, coord center) {
for (int y = 0; y < size.y; ++y) {
for (int x = 0; x < size.x; ++x)
s << F({center.x - x, center.y - y});
s << endl;
}
}
int main() {
int radius = 10;
coord size = {radius * 4, radius * 3};
auto circle = [&](coord c) {
return int(sqrt(c.x * c.x + c.y * c.y)) == radius ? pixel {'#'} : pixel {' '};
};
canvas(cout, circle, size, {size.x / 2, size.y / 2});
}
$ ./circle
##################
#### ####
#### ####
## ##
#### ####
## ##
## ##
## ##
## ##
## ##
## ##
## ##
## ##
## ##
## ##
## ##
#### ####
## ##
#### ####
#### ####
##################
We're a friendly, industry-focused community of developers, IT pros, digital marketers, and technology enthusiasts meeting, networking, learning, and sharing knowledge.