Code Golf: Ulam Spiral

Question

Le Défi

Le plus court code par le nombre de caractères de sortie Ulam spirale avec une spirale taille donnée par la saisie de l'utilisateur.

Ulam spirale est une méthode pour cartographier des nombres premiers. La spirale commence à partir du numéro 1 dans le centre (1 n'est pas premier) et de générer une spirale autour d'elle, le marquage de tous les nombres premiers que le caractère '*'. Non, le premier sera imprimé comme un espace ' '.

Des cas de Test

Input:
    2
Output:
    * *
      *
    *  

Input:
    3
Output:
    *   *
     * * 
    *  **
     *   
      *  

Input:
    5
Output:
        * *  
     *     * 
    * *   *  
       * * * 
      *  ** *
     * *     
    *   *    
     *   *   
    *     *

Code de comptage d'entrée/de sortie (j'.e programme complet).

Answer 1

Python - 203 Caractères

  _________________________________________________________
 /x=input();y=x-1;w=x+y;A=[];R=range;k,j,s,t=R(4)          \
| for i in R(2,w*w):                                        |
|  A+=[(x,y)]*all(i%d for d in R(2,i))                      |
|  if i==s:j,k,s,t=k,-j,s+t/2,t+1                           |
|  x+=j;y+=k                                                | 
| for y in R(w):print"".join(" *"[(x,y)in A]for x in R(w))  |
 \_________________________________________________________/
        \   ^__^
         \  (oo)\_______
            (__)\       )\/\
                ||----w |
                ||     ||


x=input();y=x-1;w=x+y
A=[];R=range;k,j,s,t=R(4)
for i in R(2,w*w): 
 A+=[(x,y)]*all(i%d for d in R(2,i))
 if i==s:j,k=k,-j;s,t=s+t/2,t+1
 x+=j;y+=k
for y in R(w):print"".join(" *"[(x,y)in A]for x in R(w))

Comment ça marche
L'idée est de remplir Un avec x,y coordonnées qui doivent être imprimés comme '*'
L'algorithme commence à la cellule correspondant à 2, pour le cas particulier du test 1 de primalité est à éviter.
x,y est la cellule d'intérêt
j,k garder une trace de savoir si nous devons inc ou dec x ou y pour se rendre à la cellule suivante
s est la valeur de i au prochain coin de la
t conserve la trace de l'incrément de s

tous les(i%d de d dans R(2,i)) ne la primalité de vérifier

La dernière ligne est plutôt maladroit. Il passe en revue toutes les cellules et décide de l'opportunité d'un espace ou d'un astérisque

Answer 2

Matlab: 182 167 156 caractères

Script ulam.m :

 A=1;b=ones(1,4);for i=0:(input('')-2),c=b(4);b=b+i*8+(2:2:8);A=[b(2):-1:b(1);(b(2)+1:b(3)-1)' A (b(1)-1:-1:c+1)';b(3):b(4)];end;disp(char(isprime(A)*10+32))
 

Et formaté un peu mieux:

 A = 1;
b = ones(1,4);
for i = 0:(input('')-2),
  c = b(4);
  b = b+i*8+(2:2:8);
  A = [b(2):-1:b(1); (b(2)+1:b(3)-1)' A (b(1)-1:-1:c+1)'; b(3):b(4)];
end;
disp(char(isprime(A)*10+32))
 

Cas de test:

 >> ulam
2
* *
  *
*  
>> ulam
3
*   *
 * * 
*  **
 *   
  *  
>> ulam
5
    * *  
 *     * 
* *   *  
   * * * 
  *  ** *
 * *     
*   *    
 *   *   
*     *
 

Answer 3

Golfscript - 92 Caractères

~.(:S+,:R{S\-:|;R{S-:$|>' *'1/[|$.|]2/@:d|~)$<!^=~:$;:y.*4*$-y-)2*$y-*+:$,{)$\%!},,2==}%n}%

97 caractères
~.(:S+,:R{S\-:|;R{S-:$|>' *'1/[|$.|]2/@:d|~)$<!^=~:$;:y.*4*$-y-)2*y$-*+.1=3*+:$,2>{$\%!},!=}%n}%

99 caractères
~.(:S+,{S}%:R{~):|;R{:$|>' *'1/[|$.|]2/@:d|~)$<!^=~:$;:y.*4*$-y-)2*y$-*+.1=3*+:$,2>{$\%!},!=}%n}%

De 100 caractères
~:S.(+,{S(-}%:R{~):|;R{:$|>' *'1/[|$.|]2/@:d|~)$<!^=~:$;:y.*4*$-y-)2*y$-*+.1=3*+:$,2>{$\%!},!=}%n}%

101 caractères
~:S.(+,{S(-}%:R{~):v;R{:$v>:d;' *'1/[v$.v]2/v~)$<!d^=~:$;:y.*4*$-y-)2*y$-*+.1=3*+:$,2>{$\%!},!=}%n}%

Answer 4

C, 208 206 201 200 199 196 194 193 194 193 188 185 183 180 176 Octets

(si les retours à la ligne sont supprimés):

main(int u,char**b){
for(int v,x,y,S=v=**++b-48;--v>-S;putchar(10))
for(u=-S;++u<S;){
x=u;y=v;v>-u^v<u?:(x=v,y=u);
x=4*y*y-x-y+1+2*(v<u)*(x-y);
for(y=1;x%++y;);
putchar(y^x?32:42);}}

Compilé avec

> gcc -std=c99 -o ulam ulam.c

Avertissement. Ce programme est lent, car il est en fait une division de première instance jusqu'à 2^31. Mais ne produit pas de sortie requises:

    * *
 *     *
* *   *
   * * *
  *  ** *
 * *
*   *
 *   *
*     *

Dans bien formaté C et la redondance de l' #comprend:

#include <stdio.h>
#include <stdlib.h>

int main(int argc, char** argv) {

    int u,v,x,y,d,S = atoi(argv[1]);

    /* v is the y coordinate of grid */
    for (v=S; v>=-S; --v)

        /* u is the x coordinate. The second operand (!putchar...) of the boolean or
         * is only ececuted a a end of a x line and it prints a newline (10) */
        for (u=-S; u<=S || !putchar(10); ++u) {

            /* x,y are u,v after "normalizing" the coordintes to quadrant 0
               normalizing is done with the two comparisions, swapping and and
               an additional term later */
            d = v<u;
            x=u;
            y=v;

            if (v<=-u ^ d) {
                x=v;
                y=u;
            }

            /* reuse x, x is now the number at grid (u,v) */
            x = 4*y*y -x-y+1 +2*d*(x-y);   

           /* primality test, y resused as loop variable, won't win a speed contest */
            for (y=2; y<x && x%y; ++y)
                 ;

            putchar(y!=x?' ':'*');
        }
}

Il fonctionne en transformant les coordonnées de la grille sur le numéro approprié et puis en effectuant le test de primalité, intead de dessin dans un serpent de la même manière. Les différentes équations pour les quatre quadrants" peuvent être regroupés en un seul, avec la permutation de x et y et un autre terme pour "arrière de comptage".

Answer 5

Ruby 1.8.7, 194 caractères

 n=2*gets.to_i-1
r=n**2
l,c=[nil]*r,r/2
r.times{|i|l[c]=i+1;c=i==0||l[c-n]&&!l[c+1]?c+1:l[c-1]&&!l[c-n]?c-n:l[c+n]?c-1:c+n}
r.times{|i|print"1"*l[i]!~/^1?$|^(11+?)\1+$/?'*':' ',i%n==n-1?"\n":''}
 

Pour une raison quelconque, ruby1.9 veut un autre espace sur la ligne 4:

 r.times{|i|l[c]=i+1;c=i==0||l[c-n]&&!l[c+1]?c+1:l[c-1]&&!l[c-n]?c-n :l[c+n]?c-1:c+n}