中秋好礼，送亲友卷一枚！你值得拥有 - 黑马程序员技术交流社区

/*
* 螺旋矩阵是指一个呈螺旋状的矩阵，它的数字由第一行开始到右边不断变大，向下变大，
* 向左变大，向上变大，如此循环。
*/
public class Circle {
/**
* 接收三个参数，矩阵的行和列，以及起始数字
*/
public static void main(String[] args) {
helix(4,4,1);
}
/*
* 这个是左上角开始，顺时针转的螺旋
*
* 思想：先给最外层一圈赋值，再给第二圈赋值，直至结束
* 循环次数由行和列中较小一个决定，即为大于--较小者一半的---最小整数
*/
public static void helix(int w,int h,int start){
int[][] arr = new int[w][h];
int left=0,top=0,right=w-1,botton=h-1;
int max = w>h?(h+1)/2:(w+1)/2;
for(int i=0;i<max;i++){
for(int x=left;x<=right;x++){
arr[top][x] = start++;
}
top++;
for(int y=top;y<=botton;y++){
arr[y][right] = start++;
}
right--;
for(int z=right;z>=left;z--){
arr[botton][z]=start++;
}
botton--;
for(int k=botton;k>=top;k--){
arr[k][left]=start++;
}
left++;
}
for(int i=0;i<w;i++){
for(int j=0;j<h;j++){
System.out.print(arr[i][j]+"\t");
}
System.out.println();
}
}
}

复制代码

/*
* 3DCaptcha for .net
*
* http://www-personal.umich.edu/~mressl/3dcaptcha/ (php)
* http://code.google.com/p/3dcaptcha/ (php)
*
* Translate : Aimeast
* Blog : http://www.cnblogs.com/Aimeast/
*/
using System;
using System.Drawing;
namespace Captcha
{
public static class Captcha
{
private static double[] addVector(double[] a, double[] b)
{
return new double[] { a[0] + b[0], a[1] + b[1], a[2] + b[2] };
}
private static double[] scalarProduct(double[] vector, double scalar)
{
return new double[] { vector[0] * scalar, vector[1] * scalar, vector[2] * scalar };
}
private static double dotProduct(double[] a, double[] b)
{
return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
}
private static double norm(double[] vector)
{
return Math.Sqrt(dotProduct(vector, vector));
}
private static double[] normalize(double[] vector)
{
return scalarProduct(vector, 1.0 / norm(vector));
}
// http://en.wikipedia.org/wiki/Cross_product
private static double[] crossProduct(double[] a, double[] b)
{
return new double[] {
(a[1] * b[2] - a[2] * b[1]),
(a[2] * b[0] - a[0] * b[2]),
(a[0] * b[1] - a[1] * b[0])
};
}
private static double[] vectorProductIndexed(double[] v, double[] m, int i)
{
return new double[]{
v[i + 0] * m[0] + v[i + 1] * m[4] + v[i + 2] * m[8] + v[i + 3] * m[12],
v[i + 0] * m[1] + v[i + 1] * m[5] + v[i + 2] * m[9] + v[i + 3] * m[13],
v[i + 0] * m[2] + v[i + 1] * m[6] + v[i + 2] * m[10]+ v[i + 3] * m[14],
v[i + 0] * m[3] + v[i + 1] * m[7] + v[i + 2] * m[11]+ v[i + 3] * m[15]
};
}
private static double[] vectorProduct(double[] v, double[] m)
{
return vectorProductIndexed(v, m, 0);
}
private static double[] matrixProduct(double[] a, double[] b)
{
double[] o1 = vectorProductIndexed(a, b, 0);
double[] o2 = vectorProductIndexed(a, b, 4);
double[] o3 = vectorProductIndexed(a, b, 8);
double[] o4 = vectorProductIndexed(a, b, 12);
return new double[]{
o1[0], o1[1], o1[2], o1[3],
o2[0], o2[1], o2[2], o2[3],
o3[0], o3[1], o3[2], o3[3],
o4[0], o4[1], o4[2], o4[3]
};
}
// http://graphics.idav.ucdavis.edu/education/GraphicsNotes/Camera-Transform/Camera-Transform.html
private static double[] cameraTransform(double[] C, double[] A)
{
double[] w = normalize(addVector(C, scalarProduct(A, -1)));
double[] y = new double[] { 0, 1, 0 };
double[] u = normalize(crossProduct(y, w));
double[] v = crossProduct(w, u);
double[] t = scalarProduct(C, -1);
return new double[]{
u[0], v[0], w[0], 0,
u[1], v[1], w[1], 0,
u[2], v[2], w[2], 0,
dotProduct(u, t), dotProduct(v, t), dotProduct(w, t), 1
};
}
// http://graphics.idav.ucdavis.edu/education/GraphicsNotes/Viewing-Transformation/Viewing-Transformation.html
private static double[] viewingTransform(double fov, double n, double f)
{
fov *= (Math.PI / 180);
double cot = 1.0 / Math.Tan(fov / 2);
return new double[]{
cot, 0, 0, 0,
0, cot, 0, 0,
0, 0, (f + n) / (f - n), -1,
0, 0, 2 * f * n / (f - n), 0
};
}
public static Image Generate(string captchaText)
{
Random rnd = new Random();
// 3dcha parameters
int fontsize = 24;
Font font = new Font("Arial", fontsize);
SizeF sizeF;
using (Graphics g = Graphics.FromImage(new Bitmap(1, 1)))
{
sizeF = g.MeasureString(captchaText, font, 0, StringFormat.GenericDefault);
}
int image2d_x = (int)sizeF.Width;
int image2d_y = (int)(fontsize * 1.3);
double bevel = 4;
// Create 2d image
Bitmap image2d = new Bitmap(image2d_x, image2d_y);
Color black = Color.Black;
Color white = Color.White;
// Paint 2d image
using (Graphics g = Graphics.FromImage(image2d))
{
g.Clear(black);
g.DrawString(captchaText, font, Brushes.White, 0, 0);
}
// Calculate projection matrix
double[] T = cameraTransform(
new double[] { rnd.Next(-90, 90), -200, rnd.Next(150, 250) },
new double[] { 0, 0, 0 }
);
T = matrixProduct(
T,
viewingTransform(60, 300, 3000)
);
// Calculate coordinates
double[][] coord = new double[image2d_x * image2d_y][];
int count = 0;
for (int y = 0; y < image2d_y; y += 2)
{
for (int x = 0; x < image2d_x; x++)
{
// calculate x1, y1, x2, y2
int xc = x - image2d_x / 2;
int zc = y - image2d_y / 2;
double yc = -(double)(image2d.GetPixel(x, y).ToArgb() & 0xff) / 256 * bevel;
double[] xyz = new double[] { xc, yc, zc, 1 };
xyz = vectorProduct(xyz, T);
coord[count] = xyz;
count++;
}
}
// Create 3d image
int image3d_x = 256;
//$image3d_y = $image3d_x / 1.618;
int image3d_y = image3d_x * 9 / 16;
Bitmap image3d = new Bitmap(image3d_x, image3d_y);
Color fgcolor = Color.White;
Color bgcolor = Color.Black;
using (Graphics g = Graphics.FromImage(image3d))
{
g.Clear(bgcolor);
count = 0;
double scale = 1.75 - (double)image2d_x / 400;
for (int y = 0; y < image2d_y; y += 2)
{
for (int x = 0; x < image2d_x; x++)
{
if (x > 0)
{
double x0 = coord[count - 1][0] * scale + image3d_x / 2;
double y0 = coord[count - 1][1] * scale + image3d_y / 2;
double x1 = coord[count][0] * scale + image3d_x / 2;
double y1 = coord[count][1] * scale + image3d_y / 2;
g.DrawLine(new Pen(fgcolor), (float)x0, (float)y0, (float)x1, (float)y1);
}
count++;
}
}
}
return image3d;
}
}
}

复制代码

this.BackgroundImage = Captcha.Generate("Code");

复制代码

/*
快速排序：
步骤：
1、选择一个标准元素
2、使用该标准元素分割数组，使得比该元素小的元素在它的左边，比它大的在右边。并
把标准元素放在合适的位置。
3、根据标准元素最后确定的位置，把数组分成三部分，左边的，右边的，枢纽元素自己，
然后再对左边的和右边的分别递归调用快速排序算法即可。
*/
class QuickSort{
public static void main(String[] args) {
int [] x = new int[]{16,54,5,61,12,31,25,11,76,22,10};
sopArray(x);
quickSort(x,0,x.length-1);
sopArray(x);
}
private static void quickSort(int[] arr, int left, int right) {
int l,r; //左右哨兵，l为左哨兵位置，r为右哨兵位置
int baseNum; //存储基准数
if(left > right)
return;
baseNum = arr[left]; //第一次基准数默认为数组首位
l = left; //左哨兵从左边出发扫描
r = right; //右哨兵从右边出发扫描
while(l != r) {
//先从右边开始往左扫描,找到第一个比基准数小的
while(arr[r] >= baseNum && l < r)
r--;
//再从左边开始往右扫描,找到第一个比基准数大的
while(arr[l] <= baseNum && l < r)
l++;
//交换两个数位置
if(l < r) {
int temp = arr[l];
arr[l] = arr[r];
arr[r] = temp;
}
}
//基准数归位
arr[left] = arr[l];
arr[l] = baseNum;
//递归处理左边
quickSort(arr, left, l - 1);
//递归处理右边
quickSort(arr, l + 1, right);
}

复制代码

约瑟夫环是一个数学的应用问题：已知n个人（以编号1，2，3...n分别表示）围坐在一张圆桌周围,从1开始报数，数到m的那个人出列；他的下一个人又从1开始报数，数到m的那个人又出列；依此规律重复下去，直到最后一个人。
//下面是报数14
import java.util.Scanner;
public class Ex14 {
public static void main(String[] args) {
Scanner s = new Scanner(System.in);
int n = s.nextInt();
boolean[] arr = new boolean[n];
for (int i = 0; i < arr.length; i++) {
arr[i] = true;// 下标为TRUE时说明还在圈里
}
int leftCount = n;
int countNum = 0;
int index = 0;
while (leftCount > 1) {
if (arr[index] == true) {// 当在圈里时
countNum++; // 报数递加
if (countNum == 14) {// 报道14时
countNum = 0;// 从零开始继续报数
arr[index] = false;// 此人退出圈子
leftCount--;// 剩余人数减一
}
}
index++;// 每报一次数，下标加一
if (index == n) {// 是循环数数，当下标大于n时，说明已经数了一圈，
index = 0;// 将下标设为零重新开始。
}
}
for (int i = 0; i < n; i++) {
if (arr[i] == true) {
System.out.println(i + 1);
}
}
}
}

复制代码

import java.util.LinkedList;
public class Test7 {
public static void main(String[] args) {
LinkedList<Integer> num=new LinkedList<>(); //定义list集合接收1~500的数据
for(int i=1;i<=500;i++){ //将这500个数据存入集合
num.add(i);
}
int count=0; //定义计数器用来数数
for(int i=0;i<num.size();){ //遍历集合
count++; //计数器增加
if(count%3==0){
num.remove(i--); //当计数器为3的倍数的时候,从集合中去掉当前的数,去掉当前的数后,另索引回拨一个
}
i++; //下一个数
if((i==num.size())&&num.size()!=1){ //当索引等于集合个数时,并且集合元素大于1,则从头开始遍历集合
i=0;
}
}
System.out.println("幸存的是第"+num.get(0)+"人"); //最后留下的一个数就是那个幸运的人
}
}

复制代码

import java.util.Scanner;
class MatrixArray
{
public static void main(String[] args)
{
Scanner input = new Scanner(System.in);
System.out.println("请输入矩阵的宽度：");
int length=input.nextInt();
//矩阵用二维数组位置可以一一对应
int[][] arr = new int[length][length];
//定义一个变量控制循环所在位置，当count 每自增一次循环内圈进入一次
int count =0;
//字义数值，每次赋值都自增一次让值一直是+1
int number=1;
//利用循环控制count自增，以达到控制循环所在位置，不断向内赋值
/*
while(count<length/2+1)
{//每行数据赋值个数相同都是length-1个
//for循环输入第一行数据，其中不包括最后一个数
for(int x =count;x<length-1-count;x++,number++)
{
arr[count][x]=number;
}
//for循环输入纵向还没赋值的最后一排的数据，其中不包括最下面一个数
for(int x =count;x<length-1-count;x++,number++)
{
arr[x][length-1-count]=number;
}
//for循环输入还没赋值的最下边一行数据，其中不包括行第一个数
for(int x = length-1-count;x>count;x--,number++)
{
arr[length-1-count][x]=number;
}
//for循环输入还没赋值的纵向第一排数据，其中不包括最上面的数
for(int x = length-1-count;x>count;x--,number++)
{
arr[x][count]=number;
}
count++;
}
*/
//这种方式会把中间位置重复赋值，运算完成后需要对中间位置进行判定
//此时中间公位置的元素赋值不正确
while(count<length/2+1)
{//第次赋值数据不相同，上和下赋值时数据个数为length，左右赋值为length-2
//for循环输入第一行数据，其中不包括最后一个数
for(int x =count;x<length-count;x++,number++)
{
arr[count][x]=number;
}
//for循环输入纵向还没赋值的最后一排的数据，其中不包括最下面一个数
for(int x =count+1;x<length-1-count;x++,number++)
{
arr[x][length-1-count]=number;
}
//for循环输入还没赋值的最下边一行数据，其中不包括行第一个数
for(int x = length-count-1;x>=count;x--,number++)
{
if((length%2==1)&&(length - 1 - count) == (length/2))
{
break;
}
arr[length-1-count][x]=number;
}
//for循环输入还没赋值的纵向第一排数据，其中不包括最上面的数
for(int x = length-2-count;x>count;x--,number++)
{
arr[x][count]=number;
}
count++;
}
for(int x=0;x<length;x++)
{
for(int y=0;y<length;y++)
{
System.out.print(arr[x][y]+"\t");
}
System.out.println();
}
}
}

复制代码