Spiral Numbers

Hello /prog/, I have a challenge for you.

It's called spiral numbers.  Being the expert programmers you are you've probably already have heard of it, but if not it goes a little something like this:

Given two positive integers a and b, output on the screen a rectangle with width = b numbers and height = a rows, containing the numbers from 1 to a*b in a spiraling fashion, as shown below.  For a = 4 and b = 3, the output is:
    1    2    3
    10    11    4
    9    12    5
    8    7    6
The columns must be properly n+1 positions, where n is the number of digits in the decimal representation of a *b.

Write a program that prompts for a and b and then displays the appropriate rectangle of numbers.

Example:
    If a = 3 and b = 4, the above rectangle should be
    1    2    3    4
    10    11    12    5
    9    8    7    6

Here's some more examples from my own implementation written in snake tongue.



Have fun!
H:\Documents\Python\Program of the week>"april15 Spiral.py"
Width:8
Height:12
1       2       3       4       5       6       7       8
36      37      38      39      40      41      42      9
35      64      65      66      67      68      43      10
34      63      84      85      86      69      44      11
33      62      83      96      87      70      45      12
32      61      82      95      88      71      46      13
31      60      81      94      89      72      47      14
30      59      80      93      90      73      48      15
29      58      79      92      91      74      49      16
28      57      78      77      76      75      50      17
27      56      55      54      53      52      51      18
26      25      24      23      22      21      20      19

Seems like the fastest way, if you disregard the fact it is written in Java.

public class Spiral {
    public static void main(String[] args) {
        java.util.Scanner sc = new java.util.Scanner(System.in);
        System.out.print("Width: ");
        int width = sc.nextInt();
        System.out.print("Height: ");
        int height = sc.nextInt();
       
        int[] xmove = {0, 1, 0, -1};
        int[] ymove = {-1, 0, 1, 0};
        int gap = 0, direction = 1, x = 0, y = 0, num = 1;
        int[][] grid = new int[width][height];
        int[] pad = new int[width];
        while(true) {
            grid[x][y] = num;
            int len = String.valueOf(num).length();
            if(len>pad[x]) pad[x] = len;
            num++;
            if(num>width*height) break;
            x+=xmove[direction];
            y+=ymove[direction];
            if(x>=width-gap || x<gap || y>=height-gap || (y<gap+1 && direction==0)) {
                x-=xmove[direction];
                y-=ymove[direction];
                if(direction==0)
                    gap++;
                direction = (direction+1)%4;
                x+=xmove[direction];
                y+=ymove[direction];
            }
        }
        for(int i=0; i<height; i++) {
            for(int j=0; j<width; j++) {
                int padAmt = pad[j] - String.valueOf(grid[j][i]).length();
                StringBuilder tmpPad = new StringBuilder(padAmt+1);
                for(int k=0; k<padAmt+(j==0?0:1); k++) tmpPad.append(" ");
                System.out.print(tmpPad.toString()+grid[j][i]);
            }
            System.out.println();
        }
    }
}

Post your python implementation and I'll get some benchmarks going. I removed all arrays as well.

#include <stdio.h>
#include <stdlib.h>
int main() {
    int gap = 0, direction = 1, x = 0, y = 0, num = 1, i, strlen, width, height;
    int *grid, *pad, *xmove, *ymove;
    xmove = malloc(4*sizeof(int));
    ymove = malloc(4*sizeof(int));
    *xmove = 0; *(xmove+1) = 1; *(xmove+2) = 0; *(xmove+3) = -1;
    *ymove = -1; *(ymove+1) = 0; *(ymove+2) = 1; *(ymove+3) = 0;
    fprintf(stdout, "Width: ");
    fscanf(stdin, "%d", &width);
    fprintf(stdout, "Height: ");
    fscanf(stdin, "%d", &height);
    grid = malloc(width*height*sizeof(int));
    pad = malloc(width*sizeof(int));
    for(;;) {
        *(grid+x+y*width) = num;   
        for(strlen=1, i=10; i<=num; i*=10, strlen++);
        if(strlen>*(pad+x)) *(pad+x)=strlen;
        ++num;
        if(num>width*height) break;
        x+=xmove[direction];
        y+=ymove[direction];
        if(x>=width-gap || x<gap || y>=height-gap || (y<gap+1 && !direction)) {
            x-=xmove[direction];
            y-=ymove[direction];
            if(!direction) ++gap;
            direction = (++direction)%4;
            x+=xmove[direction];
            y+=ymove[direction];
        }
    }
    for(x=0; x<height; x++) {
        for(y=0; y<width; y++) {
            if(y) fprintf(stdout, " ");
            num = *(grid+y+width*x);
            for(strlen=1, i=10; i<=num; i*=10, strlen++);
            num = *(pad+y) - strlen;
            for(i=0; i<num; ++i) fprintf(stdout, " ");
            fprintf(stdout, "%d", *(grid+y+width*x));
        }
        fprintf(stdout, "\n");
    }
    return 0;
}