画图时遇到的问题？可以说是一个算法题吧。

public class PositionTest {
	public static void main(String[] args) {
		for (int i = 1; i <= 100; i++) {
			showPosition(i);
		}
	}

	public static void showPosition(int number) {
		int i = 0;
		for (;; i++) {
			if (i * i == number) {
				System.out.println(number + "的坐标是(" + i + "," + i + ")");
				return;
			}
			if (i * i > number) {
				break;
			}
		}
		int preNumber = (i - 1) * (i - 1);
		int nextNumber = i * i;
		int more = number - preNumber;
		if (more <= (nextNumber - preNumber - 1) / 2) {
			System.out.println(number + "的坐标是(" + i + "," + more + ")");
		} else {
			System.out
					.println(number + "的坐标是("
							+ (more - (nextNumber - preNumber - 1) / 2) + ","
							+ i + ")");
		}
	}
}

其实这个题很有意思的，不用循环也可以解决，我把它画成图（见附件）就好明白了，然后我写了个如下的程序用来解答：

 

import java.util.Scanner;

public class MathTest {
	public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);
		System.out.print("请输入一个数字：");
		int num = scan.nextInt();
		Point p = getPointByNum(num);
		System.out.println(num + "的坐标是：(" + p.getX() + "," + p.getY() + ")。");
	}

	/**
	 * 根据一个数字获取其坐标
	 * @param num 
	 * @return 对应的坐标
	 */
	public static Point getPointByNum(int num) {
		double numSqrtDou = Math.sqrt(num);
		int numSqrtInt = (int) numSqrtDou;
		int x = 0, y = 0;
		x = numSqrtInt + 1;//默认X轴为平方数的下一个X值（默认以图中竖线的坐标为基础）
		y = num - numSqrtInt * numSqrtInt;//Y默认为其原值减去其最接近最小的平方数（默认以图中竖线的坐标为基础）
		if (numSqrtInt == numSqrtDou) {//如果此数开方后没有余数，则为某数的平方，即X等于Y（从图中可见）
			x = numSqrtInt;
			y = x;
		} else if (numSqrtInt * (x) < num) {//否则就是横线上的坐标对应的数了(把X值与Y值对调一下就OK了，从图中可看出来)
			int temp = x;
			x = y;
			y = temp;
		}
		return new Point(x, y);
	}
}
//自己写的Point类，类库的是双精度型的
class Point {
	private int x;
	private int y;

	public Point() {
	}

	public Point(int x, int y) {
		this.x = x;
		this.y = y;
	}

	public int getX() {
		return x;
	}

	public void setX(int x) {
		this.x = x;
	}

	public int getY() {
		return y;
	}

	public void setY(int y) {
		this.y = y;
	}
}

function createData(length){
   var array=[];
   var num=0;
   for(var i=0;i<length;i++){
    array[i]=[];
    for(var j=0;j<i;j++){
     array[j][i]=++num;
    }
    for(var j=0;j<i;j++){
     array[i][j]=++num;
    }
    array[i][j]=++num;
   }
   return array;
  }

def xy_of_n(n)
  m = Math.sqrt(n).to_i
  left = n - m*m
  if left==0
    x,y = m,m
  elsif left <= m
    x = m+1
    y = left
  else
    x = (left-m)
    y = m+1
  end
  return x,y  
end

require 'test/unit'
class XY_OF_N_Test < Test::Unit::TestCase
  def test_1_17
    assert_equal([1,1], xy_of_n(1))
    assert_equal([2,1], xy_of_n(2))
    assert_equal([1,2], xy_of_n(3))
    assert_equal([2,2], xy_of_n(4))
    assert_equal([3,1], xy_of_n(5))
    assert_equal([3,2], xy_of_n(6))
    assert_equal([1,3], xy_of_n(7))
    assert_equal([2,3], xy_of_n(8))
    assert_equal([3,3], xy_of_n(9))
    assert_equal([4,1], xy_of_n(10))
    assert_equal([4,2], xy_of_n(11))
    assert_equal([4,3], xy_of_n(12))
    assert_equal([1,4], xy_of_n(13))
    assert_equal([2,4], xy_of_n(14))
    assert_equal([3,4], xy_of_n(15))
    assert_equal([4,4], xy_of_n(16))
    assert_equal([5,1], xy_of_n(17))
  end
end

var N = 23; // 22,30,78
var n = Math.floor(Math.sqrt(N));

var c = N - n*n;
if( c == 0 )
{
    y = x = n;
}
else if( c <= n )
{
    y = c;
    x = n + 1;
}
else
{
    y = n + 1;
    x = c - n;
}

 

Sub f1()

m = InputBox("Please enter your number!")

For i = 1 To m
    For j = 1 To m
   
        If i = j Then   ' 对角线
        Cells(i, j).Value = i * i
        Cells(i, j).Interior.ColorIndex = 35
        End If
       
        If i > j Then   ' 下三角
        Cells(i, j).Value = i * (i - 1) + j
        Cells(i, j).Interior.ColorIndex = 28
        End If
       
        If i < j Then   ' 上三角
        Cells(i, j).Value = (j - 1) * (j - 1) + i
        Cells(i, j).Interior.ColorIndex = 14
        End If
   
    Next j
Next i

End Sub

    function getPosition(num){
        var x =0,y=0;
        
        // 1, 2 太特殊去掉
        if(num == 1){
            return {x:1,y:1};
        }else if(num == 2){
            return {x:2,y:1};
        }

        // 开方
        var sqrt = Math.sqrt(num);
        
        var side = Math.ceil(sqrt);
        var step = Math.floor(sqrt)
        
        // 如果恰好是某个数的平方
        if(side == step){
            return {x:side,y:side};
        }
        
        var sideSquare = side*side;
        var stepSquare = step*step;

        // 求差值
        var dvalue = sideSquare - num;
        
        // 如果差值大于 step 就在纵向的那条边上
        if(dvalue > step){
            x = side;
            y = num-stepSquare;
        }
        // 如果差值小于 step 就在横向的那条边上
        else{
            y = side;
            x = side - dvalue;
        }
        
        return {x:x,y:y};
    }

先 图画出来 找规律，很快就能明白，计算的方法很笨，你可以再调节。
方法：
1. 找出这个数的点在哪个正方形上
2. 找出在这个正方形的哪条边上（横向的 or 纵向）
3. 在推算其具体坐标

f(m,n)的表达式如下：
f(m,n) = m^2  (m=n)
f(m,n) = (m-1)^2 + m + n - 1 (m>n)
f(m,n) = (n-1)^2 + m (m<n)
找出满足条件(x-1)^2 <f(m,n) <= x^2的x值，然后就好做了

1.矩阵是Cnn型（n行n列），矩阵的规律是对角线上的数据多是1的平方，2的平方，3的平方....
2.如C22的矩阵的排列是这样的：先确定对角 1 和 4,在最大的对角数据上顺序从上都到下填充列：2,列填完在顺序从左到右填充列，3
  对于C33也是这样：确定对角 1 ，4，9，在C22的数据的基础上（也就是从5开始），在9的列上顺序填充行:5，6 ，在9的行上从左到右填充7，8

  ......

 

3.所以递归解决时合理的，但是也不需要用

 

4.假设要找出的数据时m,(1=<m<=N,总的矩阵为N介的）

5.初次确定m的行列（m为开平方开不尽的情况,开平方为整数的在对角线上，如4的坐标为（2，2））：

    m开平方取整数部分：x   （[square(m)]）

   // m开平方取小数第一位：y

    (1). x<x.5   m在(x+1)列

    (2).x>x.5    m在(x+1)行

               

   比如6这个数，6开平方是2.4...多，所以它的横坐标是3；

6.在确定m的具体位置：

    (1)  m在(x+1)列    (x+1)^2(对角数据)-m(求的数据)-（x+1-1）(行上数据的个数)=DIFF(m与(x+1)行相隔的行数);

          所以m的横坐标是：(x+1)-DIFF

    (2)   m在(x+1)行    (x+1)-{(x+1)^2(对角数据)-m(求的数据)};

 

9当然要求的是在第四象限，所以求到的行数做负数处理 ，其实没用到什么东东