Python, 92, 95 , 110 , 111 , 114 , 120 , 122 , 162 , 164 chars

N=input()
for a in sorted((p%N+p/N,(p%N,p/N)[(p%N-p/N)%2],p)for p in range(N*N)):print a[2],

Test:

$ echo 3 | python ./code-golf.py 
0 1 3 6 4 2 5 7 8

$ echo 4 | python ./code-golf.py 
0 1 4 8 5 2 3 6 9 12 13 10 7 11 14 15

cette solution généralise facilement pour les cartes N x M : modifier le traitement d'entrée et remplacer N*N avec N*M :

N,M=map(int,raw_input().split())
for a in sorted((p%N+p/N,(p%N,p/N)[(p%N-p/N)%2],p)for p in range(N*M)):print a[2],

je soupçonne qu'il y a une façon plus facile/plus courte de lire deux chiffres.

Test:

$ echo 4 3 | python ./code-golf.py 
0 1 4 8 5 2 3 6 9 10 7 11

Ruby, 69 89 chars

n=gets.to_i
puts (0...n*n).sort_by{|p|[t=p%n+p/n,[p%n,p/n][t%2]]}*' '

89 caractères

n=gets.to_i
puts (0...n*n).map{|p|[t=p%n+p/n,[p%n,p/n][t%2],p]}.sort.map{|i|i[2]}.join' '

Exécuter

> zigzag.rb
3
0 1 3 6 4 2 5 7 8

> zigzag.rb
4
0 1 4 8 5 2 3 6 9 12 13 10 7 11 14 15

crédits à doublep pour la méthode de tri.

F#, 126 caractères

let n=stdin.ReadLine()|>int
for i=0 to 2*n do for j in[id;List.rev].[i%2][0..i]do if i-j<n&&j<n then(i-j)*n+j|>printf"%d "

exemples:

$ echo 3 | fsi --exec Program.fsx
0 1 3 6 4 2 5 7 8

$ echo 4 | fsi --exec Program.fsx
0 1 4 8 5 2 3 6 9 12 13 10 7 11 14 15

Golfscript, 26/30 32/36 45 59 les caractères

solution non-J la plus courte jusqu'à présent:

nouveau tri (ne dites rien aux autres!) - 30 caractères:

 ~:1.*,{..1/%+.2%.+(@*]}$' '* #solution 1
#~:\.*,{.\/1$\%+.1&@.~if]}$' '* #solution 2
#~\:1*,{..1/%+.2%.+(@*]}$' '* #(bonus)
#~\:\*,{.\/1$\%+.1&@.~if]}$' '* #(bonus)

Droit de mise en œuvre - 36 caractères:

 ~:@.*,{[.@%:|\@/:^+|^- 2%^|if]}$' '*
#~\:@*,{[.@%:|\@/:^+|^- 2%^|if]}$' '* #(bonus)

si vous pouvez fournir la sortie comme "013642578" au lieu de "0 1 3 6 4 2 5 7 8", ensuite, vous pouvez supprimer les 4 derniers caractères.

crédit à doublep pour la technique de tri.

explication:

~\:@*        #read input, store first number into @, multiply the two
,            #put range(@^2) on the stack
{...}$       #sort array using the key in ...
" "*         #join array w/ spaces

et pour la clé:

[            #put into an array whatever is left on the stack until ]
.@%:|        #store @%n on the stack, also save it as |
\@/:^        #store @/n on the stack, also save it as ^
+            #add them together. this remains on the stack.
|^- 2%^|if   #if (| - ^) % 2 == 1, then put ^ on stack, else put | on stack.
]            #collect them into an array

MATLAB, 101/116 chars

c'est essentiellement une version condensée de la même réponse donnée ici , à exécuter directement sur l'invite de commande:

N=input('');i=fliplr(spdiags(fliplr(reshape(1:N*N,N,N)')));i(:,1:2:end)=flipud(i(:,1:2:end));i(i~=0)'

et un étendu qui lit deux valeurs de l'utilisateur:

S=str2num(input('','s'));i=fliplr(spdiags(fliplr(reshape(1:prod(S),S)')));i(:,1:2:end)=flipud(i(:,1:2:end));i(i~=0)'

Test:

3
ans =
     1     2     4     7     5     3     6     8     9

et

4 3
ans =
     1     2     5     9     6     3     4     7    10    11     8    12

Ruby 137 130 138 caractères

n=gets.to_i
def g(a,b,r,t,s);x=[s*r]*t;t==r ?[a,x,a]:[a,x,g(b,a,r,t+1,-s),x,a];end
q=0;puts ([1]+g(1,n,n-1,1,1)).flatten.map{|s|q+=s}*' '

$ zz.rb
3
1 2 4 7 5 3 6 8 9

$ zz.rb
4
1 2 5 9 6 3 4 7 10 13 14 11 8 12 15 16

C89 (280 octets)

je suppose que cela peut encore être optimisé - j'utilise quatre tableaux pour stocker le mouvement possible des vecteurs quand on frappe un mur. Je suppose que cela peut être fait, en économisant quelques caractères à la définition, mais je pense qu'il en coûtera plus cher de mettre en œuvre la logique plus bas. Bref, voilà:

t,l,b,r,i,v,n;main(int c,char**a){n=atoi(*++a);b=n%2;int T[]={n-1,1},L[]={1-n,n}
,B[]={1-n,1},R[]={n-1,n};for(c=n*n;c--;){printf("%d%c",i,c?32:10);if(i>=n*(n-1))
v=B[b=!b];else if(i%n>n-2){if(!(n%2)&&i<n)goto g;v=R[r=!r];}else if(i<n)g:v=T[t=
!t];else if(!(i%n))v=L[l=!l];i+=v;}}

se compile avec quelques avertissements, mais pour autant que je sache c'est portable C89. Je ne suis vraiment pas sûr si mon algorithme est intelligent, peut-être que tu peux raccourcir avec un meilleur. (Je n'ai pas encore pris le temps de comprendre les autres solutions).

Haskell 117 caractères

i s=concatMap(\q->d q++(reverse.d$q+1))[0,2..s+s]
 where d r=[x+s*(r-x)|x<-[0..r],x<s&&(r-x)<s]
main=readLn>>=print.i

Run:

$ echo 3 | ./Diagonals 
[0,1,3,6,4,2,5,7,8]

$ echo 4 | ./Diagonals 
[0,1,4,8,5,2,3,6,9,12,13,10,7,11,14,15]

la variante rectangulaire est un peu plus longue, à 120 caractères:

j(w,h)=concatMap(\q->d q++(reverse.d$q+1))[0,2..w+h]
 where d r=[x+w*(r-x)|x<-[0..r],x<w&&(r-x)<h]
main=readLn>>=print.j

Entrée ici nécessite un n-uplet:

$ echo '(4,3)' | ./Diagonals 
[0,1,4,8,5,2,3,6,9,10,7,11]

$ echo '(3,4)' | ./Diagonals 
[0,1,3,6,4,2,5,7,9,10,8,11]

les réponses sont toutes basées sur 0, et retournées sous forme de listes (formes naturelles pour Haskell).

Perl 102 caractères

<>=~/ /;print map{$_%1e6," "}sort map{($x=($%=$_%$`)+($/=int$_/$`))*1e9+($x%2?$/:$%)*1e6+$_}0..$'*$`-1

utilisation :

echo 3 4 | perl zigzag.pl
0 1 3 6 4 2 5 7 9 10 8 11