Code Golf：Ulam Spiral

时间：2009-11-26 21:42:31

标签： language-agnostic code-golf rosetta-stone

挑战

按字符数排序的最短代码输出Ulam's spiral，其中螺旋尺寸由用户输入给出。

Ulam的螺旋是一种映射素数的方法。螺旋线从中间的数字1开始（1不是素数）并在其周围产生螺旋线，将所有素数标记为字符“*”。非素数将打印为空格“”。

alt text http://liranuna.com/junk/ulam.gif

测试用例

Input:
    2
Output:
    * *
      *
    *  

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

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

代码计数包括输入/​​输出（即完整程序）。

19 个答案:

答案 0 :(得分：28)

Python - 203个字符

  _________________________________________________________
 /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))

工作原理
这个想法是用一个需要打印为“*”的x，y坐标填充A. 该算法从对应于2的单元开始，因此避免了测试1的原始性的特殊情况 x，y是感兴趣的细胞
j，k跟踪我们是否需要inc或dec x或y来到下一个单元格 s是下一个角落的i值 t跟踪增量到s

所有（对于R（2，i）中的d为i％d）进行素性检查

最后一行相当笨拙。它迭代所有单元格并决定是否放置空格或星号

答案 1 :(得分：10)

MATLAB： 182 167 156个字符

脚本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))

格式化得更好一点：

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))

测试用例：

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

答案 2 :(得分：8)

Golfscript - 92个字符

〜。（：S +，：R {S \ - ：|; R {S - ：$ |＆gt;'*'1 / [| $。|] 2 / @：d |〜）$＆lt;！ ^ =〜：$ ;: Y * 4 * $ - Y-）2D * $ y的 - * +：$ {！）$ \％} ,, 2 ==}％N}％

97个字符
〜。（：S +，：R {S \ - ：|; R {S - ：$ |＆gt;'*'1 / [| $。|] 2 / @：d |〜）$＆lt;！^ =〜 。！：$ ;: Y * 4 * $ - Y-）2D * $ y的 - * + 1 = 3 * +：$，2 - ; {！$ \％}，=}％N}％

99个字符
〜（：S +，{S - }％：R t {〜）：|;环R {：$ |＆GT;” ！*'1 / [|。$ |] 2 / @：d |〜）$＆LT; ^ =〜：$ ;: Y * 4 * $ - Y-）2D * $ y的 - * + 1 = 3。 * +：$，2 - ; {！$ \％}，=}％N}％

100个字符
〜：S。（+，{S（ - }％：R {〜）：|; R {：$ |＆gt;'*'1 / [| $。|] 2 / @：d |〜）$＆lt; ！^ =〜：$ ;: Y * 4 * $ - Y-）2D * $ y的 - * + 1 = 3 * +：$，2 - ; {$ \％！}，=}％N}％！

101个字符
    〜：S。（+，{S（ - }％：R {〜）：v; R {：$ v＆gt;：d;'*'1 / [v $ .v] 2 / v~）$＆lt;！ 。！d ^ =〜：$ ;: Y * 4 * $ - Y-）2D * $ y的 - * + 1 = 3 * +：$，2 - ; {！$ \％}，=}％N}％

答案 3 :(得分：7)

C， 208 206 201 200 199 196 < / strike> 194 193 194 193 188 185 183 180 176 Bytes

（如果删除换行符）：

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);}}

编译

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

警告。这个程序很慢，因为试验分区最多可达2 ^ 31。但确实产生了所需的输出：

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

格式良好的C和冗余的#includes：

#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?' ':'*');
        }
}

它的工作原理是将网格的坐标转换为适当的数字，然后执行素性测试，以类似蛇的方式绘制。四个“象限”的不同方程可以折叠成一个交换x和y，另一个用于“向后计数”。

答案 4 :(得分：5)

MATLAB，56个字符

基于@gnovice解决方案，通过使用MATLAB的螺旋功能改进：）

disp(char(isprime(flipud(spiral(2*input('')-1)))*10+32))

测试用例： 

>> disp(char(isprime(flipud(spiral(2*input('')-1)))*10+32))
2
* *
  *
*  
>> disp(char(isprime(flipud(spiral(2*input('')-1)))*10+32))
3
*   *
 * * 
*  **
 *   
  *  
>> disp(char(isprime(flipud(spiral(2*input('')-1)))*10+32))
5
    * *  
 *     * 
* *   *  
   * * * 
  *  ** *
 * *     
*   *    
 *   *   
*     *

答案 5 :(得分：5)

Ruby 1.8.7,19​​4个字符

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":''}

出于某种原因，ruby1.9需要第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}

答案 6 :(得分：5)

Python - 171

drhirsch的C移植到了python。

S=input();R=range(-S+1,S)
for w in R:
 p="";v=-w
 for u in R:d=v<u;x,y=[(u,v),(v,u)][(w>=u)^d];x=4*y*y-x-y+1+2*d*(x-y);p+=" *"[(x>1)*all(x%f for f in range(2,x))]
 print p

echo 20 |python ulam.py 
      *     *   * *   *             *  
 *     * *     *   * *                 
*     * *                     *     *  
       * *     *   *           *     * 
                  *   * *   *          
 *               *   *       *   * *   
*     *   *           * *     *        
 *   * *     * *     *     *           
* *           *           *   *     * *
   *     *   *       *     *           
    *   *         *   * *   * * *      
 * *       *     *         * *   *     
      *     *   * *               *    
                   * *     *   *   * * 
*   *   *   * *   *       *   * *      
                   * *   *             
  *       *   * *     * * *     * * *  
   * * * * * * * *   *       *         
                  * * *           *    
             *   *  ** * * *   * * *   
      *       * * *                    
               *   *                   
    *   * *   * *   *   * *   *   * *  
 *     *   *   *     *     * *   *     
                *           *          
 *         * *     *   *   *       * * 
* *     *   *           *       *     *
   *     *     *   * *                 
              * *   *     *   *     *  
   * * * *         * *     *     * *   
      *   *           * *              
 *   * *     *     *   * *           * 
  * *       *         *       *     *  
             * *   * *         *     * 
          *   *     *     *         * *
       * *     *                 *     
*   *       *           *   *     *    
                             *     *   
*   * *   *     *           *

答案 7 :(得分：3)

我的第一个代码高尔夫！

Ruby， 309 301 283 271 265个字符

s=gets.to_i;d=s*2-1;a=Array.new(d){' '*d}
e=d**2;p='*'*e;2.upto(e){|i|2.upto(e/i){|j|p[i*j-1]=' '}};p[0]=' '
s.times{|i|k=s-i-1;l=2*i;m=l+1;o=l-1
m.times{|j|n=j+k;a[k][n]=p[l**2-j];a[n][k]=p[l**2+j];a[k+l][n]=p[m**2-m+j]}
l.times{|j|a[j+k][k+l]=p[o**2+o-j]}}
puts a

答案 8 :(得分：3)

Ruby - 158个字符

与this one相同的算法，只是主要测试是不同的

p=(v=(w=gets.to_i*2)-1)*w/2-1
a='
'*v*w
d=0
(v*v).times{|i|a[p]="1"*(i+1)!~/^1?$|^(11+?)\1+$/?42:32;d=(a[p+(z=[w,-1,-w,1])[d-1]]<32)?(d-1):d%4;p+=z[d]}
puts a

答案 9 :(得分：3)

J解决方案： 197 173 165 161字节（到目前为止）
这不使用OP评论中提到的方法

p=:j./<.-:$g=:1$~(,])n=:<:+:".1!:1]3
d=:j.r=:1
(m=:3 :'if.y<*:n do.if.0=t=:<:t do.d=:d*0j1[t=:<.r=:r+0.5 end.m>:y[g=:y(<+.p=:p+d)}g end.')t=:2
1!:2&2(1 p:g){' *'

答案 10 :(得分：3)

Python 2.x， 220C 213C 207C 204C 201C 198C 196C 188C

特别感谢gnibbler #stackoverflow Freenode上的一些提示。输出包括前导和尾随换行符。

import math
v=input()*2
w=v-1
a=['\n']*w*v
p=w*v/2
for c in range(1,w*w):a[p]=' *'[(c>1)*all(c%d for d in range(2,c))];x=int(math.sqrt(c-1));p+=(-1)**x*((x*x<c<=x*x+x)*w+1)
print''.join(a)

（Python 3兼容性需要额外的字符;它使用input，print 语句和/进行整数除法。）

答案 11 :(得分：3)

Haskell - 224个字符

(%)=zipWith(++)
r x=[x]
l 1=r[1]
l n=r[a,a-1..b]++(m r[a+1..]%l s%m r[b-1,b-2..])++r[d-s*2..d]where{d=(n*2-1)^2;b=d-s*6;a=d-s*4;s=n-1}
p[_]='*'
p _=' '
i n=p[x|x<-[2..n],n`mod`x==0]
m=map
main=interact$unlines.m(m i).l.read

我不是哈斯克尔最好的，所以这里可能会出现更多的收缩

echo 6 | runghc ulam.hs

的输出 
*   *      
     * *   
* *     * *
 * *   *   
    * * *  
   *  ** * 
* * *      
 *   *     
* *   *   *
 *     *   
  *

这是一个不同的算法（类似于@ drhirsch的），遗憾的是我似乎无法在 239 字符下面得到它

p[_]='*'
p _=' '
main=interact$unlines.u.read
i n=p[x|x<-[2..n],n`mod`x==0]
u(n+1)=map(map(i.f.o).zip[-n..n].replicate((n+1)*2-1))[n,n-1..(-n)]
f(x,y,z)=4*y*y-x-y+1+if z then 2*(x-y)else 0
o(u,v)=if(v> -u)==(v<u)then(v,u,v<u)else(u,v,v<u)

答案 12 :(得分：1)

不如之前的C条目那么漂亮，但这是我的。

注意：我发帖是因为它采用了与前一种方法不同的方法，主要是

  • 没有坐标重新映射
  • 它提供与测试相同的结果

  • 适用于输入＆gt; 9（两位数 - 没有-47技巧）

    enum directions_e { dx, up, sx, dn } direction;

int main (int argc, char **argv) {
    int len = atoi(argv[1]);
    int offset = 2*len-1;
    int size = offset*offset;
    char *matrix = malloc(size);
    int startfrom = 2*len*(len-1);
    matrix[startfrom] = 1;
    int next = startfrom;
    int count = 1;
    int i, step = 1;
    direction = dx ;

    for (;; step++ )
        do { 
            for ( i = 0 ; i < step ; i++ ) {
                switch ( direction ) {
                    case dx:
                        next++;
                        break;
                    case up:
                        next = next - offset;
                        break;
                    case sx:
                        next--;
                        break;
                    case dn:
                        next = next + offset;
                }
                int div = ++count;
                do {
                    div--;
                } while ( count % div );
                if ( div > 1 ) {
                    matrix[next] = ' ';
                }
                else { 
                    matrix[next] = '*';
                }
                if (count >= size) goto dontusegoto;
            }
            direction = ++direction % 4;
        } while ( direction %2);
dontusegoto:
    for ( i = 0 ; i < size ; i++ ) {
        putchar(matrix[i]);
        if ( !((i+1) % offset) ) putchar('\n'); 
    }
    return 0;
}

，在不可读的C中充分翻译，变成339个字符。

编译：{{1​​}}适用于osx

gcc -o ulam_compr ulam_compr.c

和debian Lenny。

i686-apple-darwin9-gcc-4.0.1 (GCC) 4.0.1 (Apple Inc. build 5465)

这是一些输出：

main(int a,char**v){
    int l=atoi(v[1]),o=2*l-1,z=o*o,n=2*l*(l-1),c=1,i,s=1,d;
    char*m=malloc(z);
    m[n]=1;
    for(;;s++)do{
            for(i=0;i<s;i++){
                if(d==0)n++;
                else if(d==1)n-=o;
                else if(d==2)n--;
                else n+=o;
                int j=++c;
                while(c%--j);
                if(j>1)m[n]=' ';else m[n]='*';
                if(c>=z)goto g;
            }d=++d%4;}while(d%2);
g:for(i=0;i<z;i++){
        putchar(m[i]);
        if(!((i+1)%o))putchar('\n');
    }
}

答案 13 :(得分：1)

Python - 176

这一行以一长串新行字符开头，并替换所有这些字符，除了行尾所需的那些字符。

从中心开始，算法会在每个步骤的左侧角落窥视。如果那里有换行符，请向左转，否则继续前进。

w=input()*2;v=w-1;a=['\n']*v*w;p=w/2*v-1;d=0;z=[w,-1,-w,1]
for i in range(v*v):a[p]=' *'[i and all((i+1)%f for f in range(2,i))];d=d%4-(a[p+z[d-1]]<' ');p+=z[d]
print"".join(a)

Python - 177
使用字符串可以避免“连接”，但由于字符串是不可变的，因此最终会延长一个字节

w=input()*2;v=w-1;a='\n'*v*w;p=w/2*v-1;d=0;z=[w,-1,-w,1]
for i in range(v*v):a=a[:p]+' *'[i and all((i+1)%f for f in range(2,i))]+a[p+1:];d=d%4-(a[p+z[d-1]]<' ');p+=z[d]
print a

答案 14 :(得分：1)

第一篇文章！（等等，这不是SlashDot？）

我的团队Clojure， 685 528个字符。

(defn ulam[n] (let [z (atom [1 0 0 {[0 0] " "}])
m [[0 1 1 0][2 -1 0 -1][2 0 -1 0][2 0 0 1][2 0 1 0]]
p (fn [x] (if (some #(zero? (rem x %)) (range 2 x)) " " "*"))]
(doseq [r (range 1 (inc n)) q (range (count m)) [a b dx dy] [(m q)]
s (range (+ (* a r) b))]
(let [i (inc (first @z)) x (+ dx (@z 1)) y (+ dy (@z 2))]
(reset! z [i x y (assoc (last @z) [x y] (p i))])))
(doseq [y (range (- n) (inc n))] (doseq [x (range (- n) (inc n))]
(print ((last @z) [x y]))) (println))))
(ulam (dec (.nextInt (java.util.Scanner. System/in))))---

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

Input:
10
Output:
        *   * *   *
 *     *         * 
  *   * *          
         * *     * 
  * *   *       *  
         * *   *   
*   * *     * * *  
 * * * *   *       
        * * *      
   *   *  ** * * * 
    * * *          
     *   *         
*   * *   *   * *  
 *   *     *     * 
      *           *
 * *     *   *   * 
  *           *    
     *   * *       
    * *   *     *

答案 15 :(得分：0)

Python 284 266 256 243 242 240 char

我想尝试递归，我相信它可能会大大缩短：

r=range
def f(n):
 if n<2:return[[4]]
 s=2*n-1;z=s*s;c=[r(z-2*s+2,z-3*s+2,-1)];e=1
 for i in f(n-1):c+=[[c[0][0]+e]+i+[c[0][-1]-e]];e+=1
 c+=[r(z-s+1,z+1)];return c
for l in f(input()):print''.join(' *'[all(x%f for f in r(2,x))]for x in l)

根据评论中的建议编辑

答案 16 :(得分：0)

Lua，302个字符

s=...t={" "}n=2 function p()for j=2,n-1 do if n%j==0 then n=n+1 return" "end
end n=n+1 return"*"end for i=2,s do for k=#t,1,-1 do t[k+1]=t[k]..p()end
t[1]=""for k=1,i*2-1 do t[1]=p()..t[1]end for k=2,#t do t[k]=p()..t[k]end
t[#t+1]=""for k=1,i*2-1 do t[#t]=t[#t]..p()end end print(table.concat(t,"\n"))

lua ulam.lua 6的输出：

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

答案 17 :(得分：0)

Python，299个字符： 

from sys import *
def t(n):
 if n==1:return ' '
 for i in range(2,n):
  if n%i==0:return ' '
 return '*'
i=int(stdin.readline())
s=i*2-1
o=['\n']*(s+1)*s
c=1
g=2
d=0
p=(s+2)*(i-1)
for n in range(s**2):
 o[p]=t(n+1);p+=[1,-s-1,-1,s+1][d%4];g-=1
 if g==c:d+=1
 if g==0:d+=1;c+=1;g=2*c
print ''.join(o)

答案 18 :(得分：0)

Mathematica 243 

l = Length; t = Table; f = Flatten;
h@m_ := With[{x = l@m[[1]], y = l@m}, f[{{Reverse@t[w + y + (x y), {w, x + 2}]}, 
  t[f[{(x y) + x + y + 2 + w, m[[w]], (x y) + y - w + 1}], {w, y}], 
  {t[2 + y + x + y + w + (x y), {w, x + 2}]}}, 1]];
m_~g~z_ := Nest[h, m, z] /. {_?PrimeQ -> "\[Bullet]", _Integer -> ""};
  Grid[Grid[{{1}}~g~#, Frame -> All] &[13]
~g~#, Frame -> All] &

<强>用法

13个绕组：

{{1}}

Ulam

相关问题
最新问题