本文所有程序的运行环境为控制台，通过字符在控制台中输出一些有趣的图案。
控制台输出五角星
注：本程序首先发布在 CSDN 我的博客 上，这里作为引用。
刚开始学习语言的时候，老师都很喜欢让我们在控制台上使用“*”来输出某些图形，比如：三角形、菱形、方块什么的，这主要能让我们能更好地理解循环的语法和逻辑思维能力。
这些图形基本上都是直线的，所以在控制台上可以很方便地进行输出，不知道有没有人想过在控制台上输出一条有斜率的斜线呢？
在 AWT 上使用 Graphics 对象来做这些事的话是相当简单的，其中有内置的 drawLine 方法，告诉它 4 个点的坐标就可以很方便地在界面上画出一条斜线，但是在控制台我们如何做到这些呢？
闲着没事的时候，写了一个在控制台上输出五角星的小程序，不过这里面有点小小的 bug，bug 是什么、究竟在什么地方呢？先卖个关子吧，我弄了好久头都大了不想去想了，如果发现的话或者是解决了的话，别忘记告诉我。
public class Test {
public static void main(String[] args) {
// 画一个半径为10，旋转为0，空白为全身空格，填充为的五角星
Pentagram pen = new Pentagram(10, 0, ' ', '');
// 在控制台上输出这个五角星
Draw.printCanvas(pen.getPentagram());
}
private static class Pentagram {
private final char FILL_CHAR; // 填充字符
private final char SPACE_CHAR; // 空档字符
private final int R; // 五角星的外接圆半径
private final float ROTATION; // 五角星逆时针旋转角度
private final int X; // 用于生成画图数组
private final int Y; // 用于生成画图数组
/**
* 构造一个Pentagram对象
* @param radius 五角星的半径
* @param rotation 五角星的逆时针旋转度数
* @param spaceChar 画布上空白处填充字符
* @param fillChar 画布上线条部分填充字符
*/
public Pentagram(int radius, float rotation, char spaceChar, char fillChar) {
this.R = radius;
this.ROTATION = rotation;
this.FILL_CHAR = fillChar;
this.SPACE_CHAR = spaceChar;
this.X = 2 * R + 1;
this.Y = 2 * R + 1;
}
public char[][] getPentagram() {
char[][] canvas = initCanvas();
Draw draw = new Draw(FILL_CHAR);
// 设五角星的最右边的一个点为 A，逆时针选取点 B~E
// 通过圆的极坐标公式可以得出：
// 得出以下各点的坐标
// A 点坐标(0.951R, 0.309R)
// B 点坐标(0, R)
// C 点坐标(-0.951R, 0.309R)
// D 点坐标(-0.588R, -0.809R)
// E 点坐标(0.588R, -0.809R)
// 画线段CA
draw.drawLine(mcos(162) * R, msin(162) * R, mcos(18) * R, msin(18) * R, canvas);
// 画线段DA
draw.drawLine(mcos(234) * R, msin(234) * R, mcos(18) * R, msin(18) * R, canvas);
// 画线段CE
draw.drawLine(mcos(162) * R, msin(162) * R, mcos(306) * R, msin(306) * R, canvas);
// 画线段DB
draw.drawLine(mcos(234) * R, msin(234) * R, mcos(90) * R, msin(90) * R, canvas);
// 画线段BE
draw.drawLine(mcos(90) * R, msin(90) * R, mcos(306) * R, msin(306) * R, canvas);
return canvas;
}
// 在方形的字符数组中指定两点画线条
// 对图形数组进行初始化，填充空格
private char[][] initCanvas() {
char[][] canvas = new char[Y][X];
for (int i = 0; i < Y; i++) {
for (int j = 0; j < X; j++) {
canvas[i][j] = SPACE_CHAR;
}
}
return canvas;
}
// 根据角度求正弦值，保留两位小数
private double msin(float a) {
return ((int) (Math.sin(Math.toRadians(a + ROTATION)) * 100)) / 100.0;
}
// 根据角度求余弦值，保留两位小数
private double mcos(float a) {
return ((int) (Math.cos(Math.toRadians(a + ROTATION)) * 100)) / 100.0;
}
}
private static class Draw {
private char fillChar;
public Draw(char fillChar) {
this.fillChar = fillChar;
}
/**
* 根据两个点画线在二维字符数组上画线
* @param x1
* @param y1
* @param x2
* @param y2
* @param canvas
*/
public void drawLine(double x1, double y1, double x2, double y2, char[][] canvas) {
int radius = (canvas.length - 1) / 2;
// 从 x 方向进行填充
if (x1 > x2) {
double t = x1;
x1 = x2;
x2 = t;
t = y1;
y1 = y2;
y2 = t;
}
// 获得直线方程的两个系数
double a = (y1 - y2) / (x1 - x2);
double b = y1 - a * x1;
// 根据 x 方向的值求出 y 值，并填充图形
for (int i = (int) Math.round(x1); i <= (int) Math.round(x2); i++) {
// 根据直线方程 y = ax + b，求 y
int y = (int) Math.round(a * i + b);
// 因为 y 和 i 算出来的结果有可能是负数，
// 为了采用数组来表示坐标，做了以下变换
// c[R][R] 即为坐标原点
// c[R][0..R] 为 x 方向的负半轴
// c[R][R+1..2*R] 为 x 方向的正半轴
// c[0..R][R] 为 y 方向的正半轴
// c[R+1..2*R][R] 为 y 方向的负半轴
int yy = radius - y;
int xx = radius + I;
yy = yy < 0 ? 0 : yy;
yy = yy > 2 * radius ? 2 * radius : yy;
xx = xx < 0 ? 0 : xx;
xx = xx > 2 * radius ? 2 * radius : xx;
canvas[yy][xx] = fillChar;
}
// 从 y 方向进行填充，便于减少间距问题产生的字符空档
if (y1 > y2) {
double t = x1;
x1 = x2;
x2 = t;
t = y1;
y1 = y2;
y2 = t;
}
// 根据 y 方向的值求出 x 值，并填充图形
for (int i = (int) Math.round(y1); i <= (int) Math.round(y2); i++) {
// 根据 x = (y - b) / a，求 x
int y = (int) Math.round((i - b) / a);
int yy = radius - I;
int xx = radius + y;
yy = yy < 0 ? 0 : yy;
yy = yy > 2 * radius ? 2 * radius : yy;
xx = xx < 0 ? 0 : xx;
xx = xx > 2 * radius ? 2 * radius : xx;
canvas[yy][xx] = fillChar;
}
}
/**
* 将画完图之后的画布输出到控制台上
* @param canvas
*/
public static void printCanvas(char[][] canvas) {
for (int i = 0; i < canvas.length; i++) {
for (int j = 0; j < canvas[i].length; j++) {
System.out.print(canvas[i][j]);
}
System.out.println();
}
}
}
}
下图是一个半径为 20，旋转度为 0 度的五角星控制台输出。
Pentagram_1.png
下图是一个半径为 20，旋转度为 15 度的五角星控制台输出。
Pentagram_2.png
菱形绘制及思路
先上代码：
public class Test {
public static void main(String[] args) {
printDiamond(7, true);
System.out.println();
printDiamond(7, false);
}
/**
* 输出菱形
* @param line 菱形的行数
* @param isSolid 是否为实心
*/
private static void printDiamond(int line, boolean isSolid) {
// 行数应为奇数，若为偶数时则向上取奇数
line |= 1;
for(int k = line / 2, i = -k; i <= k; i++) {
for(int j = -k, m = k - Math.abs(i); j <= m; j++) {
boolean b;
if(isSolid) {
b = Math.abs(j) + Math.abs(i) > k;
} else {
b = Math.abs(j) + Math.abs(i) != k;
}
System.out.print(b ? " " : "*");
}
System.out.println();
}
}
}
分析：菱形是一个上下、左右对称的图形，行列可以按照下面的方式来进行循环：
j=
-3 -2 -1 0 1 2 3
i= +---+---+---+---+
-3 | | | | * |
+---+---+---+---+---+
-2 | | | * | * | * |
+---+---+---+---+---+---+
-1 | | * | * | * | * | * |
+---+---+---+---+---+---+---+
0 | * | * | * | * | * | * | * |
+---+---+---+---+---+---+---+
1 | | * | * | * | * | * |
+---+---+---+---+---+---+
2 | | | * | * | * |
+---+---+---+---+---+
3 | | | | * |
+---+---+---+---+
行数为 ，则
，这个数值很有用处，暂且称为
。
和
的循环起始均为
，而
的终止循环为
，
的终止循环条件理应为
，注意右边，我特意把它挖空了，因为右边的都是空格，为了优化程序就没有必要输出了，这样
的循环终止条件与
是有密切关系的，为
，即：当
时，
，因此
只要从
循环到
就可以了。
再看看 * 位置上的规律，注意最左边的 *，在 时输出的是空格，小于等于
时，输出的是
*。
- 当
,
坐标上，
，
是大于
的，因此输出空格
- 当
坐标上，
，
是不大于
*
如果需要的是空心菱心，只要把判断条件设为 时才输出
*，否则输出空格。
因此，这样我们就利用于图形的对称性完成了菱形的输出。
杨辉三角形
public class Yanghui {
public static void main(String[] args) {
Yanghui yang = new Yanghui();
yang.printYanghuiTriangle(13);
}
/**
* 生成指定行数的杨辉三角形
*
* @param lines 杨辉三角形的行数
*/
public void printYanghuiTriangle(int lines) {
if(lines < 1) {
throw new IllegalArgumentException("lines must be great than 0.");
}
if(lines > 30) {
throw new IllegalArgumentException("lines is too big.");
}
int[] line = new int[lines];
int maxLen = getMaxLen(lines);
for(int i = 0; i < lines; i++) {
line[0] = line[i] = 1;
for(int j = 1, k = i / 2, pre = line[0]; j <= k; j++) {
int cur = line[j];
line[i - j] = line[j] += pre;
pre = cur;
}
printLine(line, i + 1, maxLen);
}
}
/**
* 根据指定行数的杨辉三角形，计算其中最大数字的长度
* @param lines 杨辉三角形的行数
* @return 最大数字的长度
*/
private int getMaxLen(int lines) {
int k = lines / 2;
long maxNum = factorial(k + 1, lines - 1) / factorial(1, lines - 1 - k);
return getLength(maxNum);
}
/**
* 阶乘计算
* @param start 阶乘计算的起始数字
* @param num 阶乘计算的终止数字
* @return 阶乘计算结果
*/
private long factorial(int start, int num) {
long result = start > 0 ? start : 1L;
while(num > start) {
result *= num--;
}
return result;
}
/**
* 根据指定数字计算数字的长度
* @param num 数字
* @return 数字的长度
*/
private int getLength(long num) {
int len = 0;
while(num > 0L) {
num /= 10L;
len++;
}
return len;
}
private void printLine(int[] yanghui, int line, int width) {
printSpaces((yanghui.length - line) * width);
for(int i = 0; i < line; i++) {
if(i > 0) {
printSpaces(width);
}
printSpaces(width - getLength(yanghui[i]));
System.out.print(yanghui[I]);
}
System.out.println();
if(width > 1) {
System.out.println();
}
}
private void printSpaces(int spaceCount) {
for(int i = 0; i < spaceCount; i++) {
System.out.print(" ");
}
}
}
1
1 1
1 2 1
1 3 3 1
1 4 6 4 1
1 5 10 10 5 1
1 6 15 20 15 6 1
1 7 21 35 35 21 7 1
1 8 28 56 70 56 28 8 1
1 9 36 84 126 126 84 36 9 1
1 10 45 120 210 252 210 120 45 10 1
1 11 55 165 330 462 462 330 165 55 11 1
1 12 66 220 495 792 924 792 495 220 66 12 1
正弦函数
public class Test {
public static void main(String[] args) {
TriFunc tri = new TriFunc();
// 生成一块25×100的画布
Canvas canvas = new Canvas(25, 120);
// 画sin曲线，周期为2
tri.drawSin(canvas, 2.0);
canvas.printCanvas();
System.out.println();
canvas.reset();
// 画cos曲线，周期为2
tri.drawCos(canvas, 2.0);
canvas.printCanvas();
}
}
class TriFunc {
/**
* 画sin曲线
* @param canvas 画布
* @param period 曲线周期
*/
public void drawSin(Canvas canvas, double period) {
char[][] chars = canvas.getCanvas();
// x 轴的比率
double xRatio = (2 * period * Math.PI) / (canvas.getWidth() - 1);
// y 轴的放大倍率
int yMulti = (canvas.getHeight() - 1) / 2;
for(int i = 0; i < canvas.getWidth(); i++) {
// 将数组索引映射为横坐标值
double k = (i - canvas.getWidth() / 2) * xRatio;
// 将sin值映射为数组索引
int h = yMulti - (int)Math.round(Math.sin(k) * yMulti);
chars[h][i] = Canvas.FILL_CHAR;
}
}
/**
* 画cos曲线
* @param canvas 画布
* @param period 曲线周期
*/
public void drawCos(Canvas canvas, double period) {
char[][] chars = canvas.getCanvas();
double xRatio = (2 * period * Math.PI) / (canvas.getWidth() - 1);
int yMulti = (canvas.getHeight() - 1) / 2;
for(int i = 0; i < canvas.getWidth(); i++) {
double k = (i - canvas.getWidth() / 2) * xRatio;
int h = yMulti - (int)Math.round(Math.cos(k) * yMulti);
chars[h][i] = Canvas.FILL_CHAR;
}
}
}
class Canvas {
private int height;
private int width;
private char[][] canvas;
// 填充字符
public static char FILL_CHAR = '+';
// 空白字符
public static char BLANK_CHAR = ' ';
/**
* 构建一块画布
* @param height
* @param width
*/
public Canvas(int height, int width) {
// 由于需要画坐标轴，所以得采用奇数
this.height = height % 2 == 0 ? height + 1 : height;
this.width = width % 2 == 0 ? width + 1 : width;
init();
}
/**
* 初始化画布
*/
private void init() {
this.canvas = new char[height][width];
for(int i = 0; i < height; i++) {
for(int j = 0; j < width; j++) {
canvas[i][j] = BLANK_CHAR;
}
}
addAxis();
}
/**
* 添加坐标轴
*/
private void addAxis() {
// 添加横坐标
int y = height / 2;
for(int x = 0; x < width; x++) {
canvas[y][x] = '-';
}
// 添加纵坐标
int xx = width / 2;
for(int yy = 0; yy < height; yy++) {
canvas[yy][xx] = '|';
}
// 添加原点
canvas[y][xx] = '+';
}
/**
* 输出画布
*/
public void printCanvas() {
for(int i = 0; i < height; i++) {
for(int j = 0; j < width; j++) {
System.out.print(canvas[i][j]);
}
System.out.println();
}
}
/**
* 清空画布
*/
public void reset() {
init();
}
public int getHeight() {
return height;
}
public int getWidth() {
return width;
}
public char[][] getCanvas() {
return canvas;
}
}
#### | ####
## ## | ## ##
# # | # #
# # | # #
# # | # #
# # | # #
# # | # #
|
# # | # #
# # | # #
# # |# #
|
#------------------------#------------------------#------------------------#------------------------#
|
# #| # #
# # | # #
# # | # #
|
# # | # #
# # | # #
# # | # #
# # | # #
# # | # #
## ## | ## ##
#### | ####
### ##### ###
## ## | ## ##
# # | # #
# # | # #
# # | # #
|
# # | # #
# # | # #
# # | # #
|
# # | # #
# # | # #
--------------------------------------------------+--------------------------------------------------
# # | # #
# # | # #
|
# # | # #
# # | # #
# # | # #
|
# # | # #
# # | # #
# # | # #
## ## | ## ##
##### | #####
LED
public class Test {
public static void main(String[] args) {
LED led = new LED();
char[][] chss = led.getLED("0123456789");
LED.print(chss);
}
}
class LED {
/**
* 每个 LED 的大小，可以进行调整
*/
public final static int ROW = 7;
public final static int COL = 7;
/**
* 每个 LED 的间隔
*/
private final static int SEPARATOR = 1;
private final static char FILL_CHAR = '#';
private final static char SPACE_CHAR = ' ';
/**
* 工具方法，用于输出 LED
* @param chs
*/
public static void print(char[][] chs) {
for (int i = 0; i < chs.length; i++) {
for (int j = 0; j < chs[i].length; j++) {
System.out.print(chs[i][j]);
}
System.out.println();
}
}
/**
* 根据数字得到 LED 显示数组
* @param num *
* @return
*/
public char[][] getLED(String num) {
char[] chs = num.toCharArray();
char[][][] chsss = new char[chs.length][][];
for (int i = 0; i < chs.length; i++) {
chsss[i] = showLed(chs[i] - '0');
}
return putManyLed(chsss);
}
/**
* 将多个 LED 组成一排
* @param chsss
* @return
*/
private char[][] putManyLed(char[][][] chsss) {
if (chsss.length < 1) {
throw new IllegalArgumentException("LED is NULL!");
}
if (chsss.length == 1) {
return chsss[0];
}
char[][] chss = new char[ROW][chsss.length * (COL + SEPARATOR)
- SEPARATOR];
for (int i = 0; i < chsss.length; i++) {
int m = i * (COL + SEPARATOR);
for (int j = 0; j < chsss[i].length; j++) {
for (int k = 0; k < chsss[i][j].length; k++) {
chss[j][m + k] = chsss[i][j][k];
}
}
}
for (int i = 0; i < chss.length; i++) {
for (int j = 0; j < chss[i].length; j++) {
if (chss[i][j] != FILL_CHAR) {
chss[i][j] = SPACE_CHAR;
}
}
}
return chss;
}
/**
*
* @param num
* @return
*/
private char[][] showLed(int num) {
boolean[] b = getLed(num);
char[][] chs = new char[ROW][COL];
if (b[0])
for (int i = 0; i < COL; I++)
chs[0][i] = FILL_CHAR;
if (b[1])
for (int i = 0; i <= ROW / 2; I++)
chs[i][COL - 1] = FILL_CHAR;
if (b[2])
for (int i = ROW / 2; i < ROW; I++)
chs[i][COL - 1] = FILL_CHAR;
if (b[3])
for (int i = 0; i < COL; I++)
chs[ROW - 1][i] = FILL_CHAR;
if (b[4])
for (int i = ROW / 2; i < ROW; I++)
chs[i][0] = FILL_CHAR;
if (b[5])
for (int i = 0; i <= ROW / 2; I++)
chs[i][0] = FILL_CHAR;
if (b[6])
for (int i = 0; i < COL; I++)
chs[ROW / 2][i] = FILL_CHAR;
return chs;
}
/**
*
* 译码器
*
* 0
* #######
* # # 1
* 5 # 6 #
* #######
* # #
* 4 # # 2
* #######
* 3
*
* 0 表示 leds[0]，若为 true 表示该 LED 显示，否则不显示
*
* @param num
* @return
*/
private boolean[] getLed(int num) {
boolean a = (num & 8) >>> 3 == 1;
boolean b = (num & 4) >>> 2 == 1;
boolean c = (num & 2) >>> 1 == 1;
boolean d = (num & 1) == 1;
boolean[] leds = new boolean[7];
leds[0] = a | (!a & c) |(!a & !b & !c & !d) | (!a & b & !c & d);
leds[1] = a | (!a & !b) | (!a & b & c & d) | (!a & b & !c & !d);
leds[2] = a | b | !c | d;
leds[3] = a | (!a & !b & c) | (!a & !b & !c & !d) | (!a & b & c & !d) |
(!a & b & !c & d);
leds[4] = (!a & c & !d) | (!b & !c & !d);
leds[5] = a | (!a & !b & !c & !d) | (!a & b & !d) | (!a & b & !c & d);
leds[6] = a | (!a & !b & c) | (!a & b & !c) | (!a & b & c & !d);
return leds;
}
}
####### # ####### ####### # # ####### ####### ####### ####### #######
# # # # # # # # # # # # # #
# # # # # # # # # # # # # #
# # # ####### ####### ####### ####### ####### # ####### #######
# # # # # # # # # # # # #
# # # # # # # # # # # # #
####### # ####### ####### # ####### ####### # ####### #######
下面的部分涉及数字电路中译码电路、卡诺图等方面的知识，有兴趣的话可以去查找相关资料。
七段 LED 各段位的真值表如下：
A, B, C, D 表示数字的各二进制位
a, b, c, d, e, f, g 表示 LED 的各段，为 1 时该段显示，为 0 时该段不显示
a
#######
# # b
f # g #
#######
# # c
e # #
#######
d
+---+---+---+---+---+ +---+---+---+---+---+---+---+
| | A | B | C | D | | a | b | c | d | e | f | g |
+---+---+---+---+---+ +---+---+---+---+---+---+---+
| 0 | 0 | 0 | 0 | 0 | | 1 | 1 | 1 | 1 | 1 | 1 | 0 |
+---+---+---+---+---+ +---+---+---+---+---+---+---+
| 1 | 0 | 0 | 0 | 1 | | 0 | 1 | 1 | 0 | 0 | 0 | 0 |
+---+---+---+---+---+ +---+---+---+---+---+---+---+
| 2 | 0 | 0 | 1 | 0 | | 1 | 1 | 0 | 1 | 1 | 0 | 1 |
+---+---+---+---+---+ +---+---+---+---+---+---+---+
| 2 | 0 | 0 | 1 | 1 | | 1 | 1 | 1 | 1 | 0 | 0 | 1 |
+---+---+---+---+---+ +---+---+---+---+---+---+---+
| 4 | 0 | 1 | 0 | 0 | | 0 | 1 | 1 | 0 | 0 | 1 | 1 |
+---+---+---+---+---+ +---+---+---+---+---+---+---+
| 5 | 0 | 1 | 0 | 1 | | 1 | 0 | 1 | 1 | 0 | 1 | 1 |
+---+---+---+---+---+ +---+---+---+---+---+---+---+
| 6 | 0 | 1 | 1 | 0 | | 1 | 0 | 1 | 1 | 1 | 1 | 1 |
+---+---+---+---+---+ +---+---+---+---+---+---+---+
| 7 | 0 | 1 | 1 | 1 | | 1 | 1 | 1 | 0 | 0 | 0 | 0 |
+---+---+---+---+---+ +---+---+---+---+---+---+---+
| 8 | 1 | 0 | 0 | 0 | | 1 | 1 | 1 | 1 | 1 | 1 | 1 |
+---+---+---+---+---+ +---+---+---+---+---+---+---+
| 9 | 1 | 0 | 0 | 1 | | 1 | 1 | 1 | 1 | 0 | 1 | 1 |
+---+---+---+---+---+ +---+---+---+---+---+---+---+
根据这个真值表可以得出这个反映了数字二进制位与 LED 各段之间的逻辑关系：
采用卡诺图化简后可以得到：
上面代码中的 getLed 方法中的算法就是这样来的。
螺旋矩阵
public class SpiralMatrix {
public final static int DOWN_FIRST = 0;
public final static int RIGHT_FIRST = 1;
public static void main(String[] args) {
final int N = 9;
final int DIRECT = RIGHT_FIRST;
int[][] spiralMatrix = new int[N][N];
int[] rc = { 0, 0 };
for(int c = 0, n = 1, t = (N << 1) - 1; c < t; ) {
int p = (c + 1) >> 1;
while(p++ < N) {
spiralMatrix[rc[0]][rc[1]] = n++;
if(p == N) {
c++;
}
rc[(c & 1) ^ DIRECT] += 1 - (c & 2);
}
}
output(spiralMatrix);
}
private static void output(int[][] matrix) {
for(int i = 0; i < matrix.length; i++) {
for(int j = 0; j < matrix[i].length; j++) {
if(j > 0) {
System.out.print(' ');
}
System.out.printf("%2d", matrix[i][j]);
}
System.out.println();
}
}
}
1 2 3 4 5 6 7 8 9
32 33 34 35 36 37 38 39 10
31 56 57 58 59 60 61 40 11
30 55 72 73 74 75 62 41 12
29 54 71 80 81 76 63 42 13
28 53 70 79 78 77 64 43 14
27 52 69 68 67 66 65 44 15
26 51 50 49 48 47 46 45 16
25 24 23 22 21 20 19 18 17
阿基米德螺线
根据阿基米德螺线参数方程画图：
import java.io.PrintStream;
public class ArchimedeanSpiral {
public static void main(String[] args) {
CoordinateCanvas canvas = new CoordinateCanvas(22);
for (double t = 0; t < 13; t += 0.00005) {
double r = 1.8 * t;
double radians = Math.toRadians(t * 180);
double x = r * Math.cos(radians);
double y = r * Math.sin(radians);
canvas.putPoint(x, y);
}
canvas.output(System.out, false);
}
}
class CoordinateCanvas {
private final int positiveX;
private final int negativeX;
private final int positiveY;
private final int negativeY;
private final char plotChar;
private final char[][] canvas;
public CoordinateCanvas(int quadrant) {
this(quadrant, '＃');
}
public CoordinateCanvas(int quadrant, char plotChar) {
this(quadrant, quadrant, plotChar);
}
public CoordinateCanvas(int x, int y) {
this(x, y, '＃');
}
public CoordinateCanvas(int x, int y, char plotChar) {
this(x, x, y, y, plotChar);
}
public CoordinateCanvas(int positiveX, int negativeX,
int positiveY, int negativeY, char plotChar) {
this.positiveX = Math.abs(positiveX);
this.negativeX = Math.abs(negativeX);
this.positiveY = Math.abs(positiveY);
this.negativeY = Math.abs(negativeY);
this.plotChar = plotChar;
this.canvas = new char[getHeigh()][getWidth()];
init();
}
public void putPoint(double x, double y) {
int ix = (int)Math.round(x);
int iy = (int)Math.round(y);
if (ix > positiveX || ix < -negativeX) {
return;
}
if (iy > positiveY || iy < -negativeY) {
return;
}
canvas[positiveY - iy][negativeX + ix] = plotChar;
}
public void output(PrintStream output, boolean line) {
for (int i = 0; i < canvas.length; i++) {
for (int j = 0; j < canvas[i].length; j++) {
output.print(canvas[i][j]);
if (line && i == negativeY) {
output.print('─');
}
if (line && j == negativeX) {
output.print('│');
}
if (line && i == negativeY && j == negativeX) {
output.print('┼');
}
}
output.println();
}
}
private int getHeigh() {
return positiveY + negativeY + 1;
}
private int getWidth() {
return positiveX + negativeX + 1;
}
private void init() {
for (int i = 0; i < canvas.length; i++) {
for (int j = 0; j < canvas[i].length; j++) {
canvas[i][j] = ' ';
}
}
}
}
＃＃＃＃＃＃＃＃＃＃＃＃＃＃
＃＃＃＃ ＃＃＃＃
＃＃＃ ＃＃＃
＃＃ ＃＃＃＃＃＃＃＃ ＃＃
＃＃＃ ＃＃＃＃＃ ＃＃＃＃＃ ＃＃＃
＃＃ ＃＃＃ ＃＃＃ ＃＃
＃＃ ＃＃ ＃＃ ＃＃
＃＃ ＃＃＃ ＃＃＃＃＃＃＃＃＃＃ ＃＃＃ ＃＃
＃＃ ＃＃ ＃＃＃＃ ＃＃＃＃ ＃＃ ＃
＃ ＃＃ ＃＃ ＃＃ ＃＃ ＃＃
＃＃ ＃＃ ＃＃＃ ＃＃＃＃＃＃ ＃＃ ＃ ＃＃
＃＃ ＃ ＃＃ ＃＃＃＃ ＃＃＃＃ ＃＃＃ ＃＃ ＃
＃ ＃＃ ＃＃ ＃＃ ＃＃ ＃ ＃＃ ＃＃
＃＃ ＃＃ ＃ ＃＃＃ ＃＃ ＃＃ ＃ ＃
＃ ＃ ＃＃ ＃＃ ＃＃＃＃＃＃＃＃ ＃＃ ＃＃ ＃＃ ＃
＃ ＃ ＃＃ ＃ ＃＃ ＃＃ ＃＃ ＃ ＃ ＃＃
＃ ＃＃ ＃ ＃＃ ＃＃＃ ＃＃ ＃＃ ＃＃ ＃ ＃
＃ ＃ ＃＃ ＃ ＃＃ ＃＃ ＃ ＃ ＃＃ ＃
＃ ＃＃ ＃ ＃＃ ＃＃＃＃＃＃＃ ＃＃ ＃ ＃ ＃ ＃
＃＃ ＃ ＃ ＃ ＃ ＃＃ ＃ ＃＃ ＃ ＃ ＃＃
＃ ＃ ＃ ＃＃ ＃＃ ＃＃ ＃ ＃ ＃ ＃ ＃
＃ ＃ ＃＃ ＃ ＃ ＃＃＃ ＃ ＃ ＃ ＃ ＃ ＃
＃ ＃ ＃ ＃ ＃ ＃ ＃ ＃＃ ＃ ＃ ＃ ＃ ＃
＃ ＃ ＃ ＃ ＃ ＃ ＃ ＃ ＃ ＃ ＃ ＃
＃ ＃ ＃＃ ＃ ＃ ＃＃ ＃＃ ＃ ＃＃ ＃ ＃ ＃＃
＃ ＃ ＃ ＃ ＃ ＃＃＃＃ ＃＃ ＃ ＃ ＃ ＃
＃＃ ＃ ＃ ＃＃ ＃＃ ＃＃ ＃ ＃＃ ＃＃ ＃
＃ ＃＃ ＃ ＃ ＃＃ ＃＃ ＃＃ ＃ ＃ ＃
＃ ＃ ＃＃ ＃＃ ＃＃＃＃＃＃＃＃ ＃＃ ＃ ＃ ＃＃
＃ ＃ ＃ ＃＃ ＃＃ ＃＃ ＃＃ ＃
＃＃ ＃＃ ＃＃ ＃＃ ＃＃ ＃＃ ＃ ＃
＃ ＃ ＃＃ ＃＃＃＃ ＃＃＃＃ ＃＃ ＃＃ ＃＃
＃＃ ＃＃ ＃＃ ＃＃＃＃＃＃ ＃＃ ＃＃ ＃
＃ ＃＃ ＃＃＃ ＃＃ ＃＃ ＃＃
＃＃ ＃＃ ＃＃ ＃＃＃ ＃＃ ＃＃
＃＃ ＃＃ ＃＃＃＃＃＃＃＃＃＃＃＃ ＃＃ ＃＃
＃＃ ＃＃＃ ＃＃ ＃＃ ＃＃
＃＃ ＃＃ ＃＃＃ ＃＃
＃＃ ＃＃＃＃ ＃＃＃＃ ＃＃
＃＃＃ ＃＃＃＃＃＃＃＃＃＃ ＃＃
＃＃ ＃＃＃
＃＃＃＃ ＃＃＃
＃＃＃＃＃ ＃＃＃＃＃
＃＃＃＃＃＃＃
约瑟夫问题
算法过程参考 Ronald L.Graham, Donald E.Knuth, Oren Patashnik 编写的 Concrete Mathematics（《具体数学》）第 1.3 节。
public class JosephusTest {
public static void main(String[] args) {
System.out.println(josephus2(5));
}
/**
* 计算约瑟夫问题，间隔 1 个的值，这个有数学解法，即：
* 将最高位的 1 取出，将数值左移一位，再将最高位的那
* 个 1 添至最低位即可。
* 例如 1010 的约瑟夫间隔为 1 的值为 0101（5）
* Concrete Mathematics 书中并未加 1，那是由于其第一个
* 从 0 开始的，如果从 1 开始时需要加 1
*/
public static int josephus2(int count) {
int n = (count ^ leftOneBit(count)) << 1;
return (n | 1) + 1;
}
/**
* 获得一个数最高位为 1 的值，比如 1111（15）
* 的最高位值为 1000
* 算法参考：Hacker's Delight 一书第三章
*/
public static int leftOneBit(int num) {
for (int i = 0; i < 5; i++) {
num |= (num >> (1 << i));
}
return num - (num >>> 1);
}
}
