Java 素数计算的最短代码

我学校计算机科学专栏的报纸（名为《挪威语》，第19页）举办了一场有趣的竞赛，为下面的问题编写尽可能短的Java代码

将整数（作为字符串数组的第一个条目中的字符串，因为Java main方法只接受字符串数组）作为参数，首先写出该数字以下的所有素数，然后写出所有非素数。最短的代码获胜

作为回答，我将发布赢得竞争的最短Java代码。我想知道Stack Overflow社区是否可以编写一个更短的代码如果你懂挪威语，你会发现如果你做到了，你本来可以赢得一瓶香槟，但不幸的是，比赛的最后提交日期已经过去了

---

您是如何解决这个问题的？

赢得竞争的Java代码（153字节不带空格，此处包含空格以便于阅读）：

F类{
公共静态void main（字符串[]a）{
对于（int i，j，k=2；k-->0；）
对于（i=1；i++0；）
;
如果（k>0？j<2:j>1）
系统输出打印LN（i）；
}
}
}

在您将标题更改为“Java”之前，我已经在Haskell中完成了。因为这是一个社区维基，所以它就在这里

primes n = 
let sieve (p:xs) = p : sieve [x | x<-xs, x `mod` p /= 0] in 
let primes = takeWhile (<n) $ sieve [2..] in 
([0..n] \\ primes, primes)

*Main> primes 20
([0,1,4,6,8,9,10,12,14,15,16,18,20],[2,3,5,7,11,13,17,19])

---

为了好玩，这里有一个Java版本的程序，在给定足够堆的情况下，终止所有参数

import fj.data.Natural;
import fj.data.Stream;
import static fj.data.Stream.*;
import static fj.pre.Ord.naturalOrd;
import fj.pre.Show;
import static fj.pre.Show.streamShow;
import static fj.pre.Show.naturalShow;
import static fj.data.Natural.ZERO;
import static fj.data.Natural.natural;
import fj.P1;
import fj.F;
import static fj.data.Enumerator.naturalEnumerator;

import java.math.BigInteger;

public class Primes2
  {public static Stream<Natural> sieve(final Stream<Natural> xs)
    {return cons(xs.head(), new P1<Stream<Natural>>()
      {public Stream<Natural> _1()
        {return sieve(xs.tail()._1().filter(new F<Natural, Boolean>()
          {public Boolean f(final Natural x)
            {return !naturalOrd.eq(x.mod(xs.head()), ZERO);}}));}});}

  public static Stream<Natural> primes(final Natural n)
    {return sieve(forever(naturalEnumerator, natural(2).some()))
            .takeWhile(naturalOrd.isLessThan(n));}

  public static void main(final String[] a)
    {final Natural n = natural(new BigInteger(a[0])).some();
     final Show<Stream<Natural>> s = streamShow(naturalShow);
     s.println(primes(n));
     s.println(range(naturalEnumerator, ZERO, n)
               .minus(naturalOrd.equal(), primes(n)));}
}

导入fj.data.Natural；
导入fj.data.Stream；
导入静态fj.data.Stream.*；
导入静态fj.pre.Ord.naturalOrd；
导入fj.pre.Show；
导入静态fj.pre.Show.streamShow；
导入静态fj.pre.Show.naturalShow；
导入静态fj.data.Natural.ZERO；
导入静态fj.data.Natural.Natural；
进口fj.P1；
进口fj.F；
导入静态fj.data.Enumerator.naturalEnumerator；
导入java.math.biginger；
公共类素数2
{公共静态流筛（最终流xs）
{返回cons（xs.head（），new P1（））
{公共流_1（）
{返回筛（xs.tail（）.u 1（）.filter（新的F（））
{公共布尔f（最终自然x）
{return！naturalOrd.eq（x.mod（xs.head（）），ZERO）；}}}}}}}
公共静态流素数（最终自然n）
{返回筛（永远（naturalEnumerator，natural（2）.some（））
.takeWhile（自然领主）isLessThan（n））；}
公共静态void main（最终字符串[]a）
{final Natural n=Natural（新的BigInteger（a[0]））.some（）；
最终展示s=流线展示（自然展示）；
s、 println（素数（n））；
s、 println（范围（自然计数器，零，n）
.减号（naturalOrd.equal（），素数（n））；}
}

---

我在Ruby中的尝试。93个字符

def s n
(a=(2..n).to_a).each{|n|a.reject!{|k|k%n==0&&k/n!=1}}
p[[1]+a,(2..n).to_a-a]
end

133个字符：-）

F类{
公共静态void main（字符串[]z）{
l:
对于（int a=1，b；a

如果您想要js代码：n是最大值（62个字符）

for（i=1；iPython，65个字符）
用法：

>>> print[i for i in range(2,input())if all(i%j for j in range(2,i))]
70
[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67]
>>> 

易于理解且智能的代码可能如下所示：

public class test3 {
    public static void main(String[] args) {
        for (int i = 2; i <= 100; i++) {
            int count = 0;
            for (int j = i / 2; j >= 2; j--) {
                if (i % j == 0)
                    count = count + 1;
            }
            if (count == 0)
                System.out.println(i);
        }
    }
}

公共类test3{
公共静态void main（字符串[]args）{
对于（int i=2；i=2；j--）{
如果（i%j==0）
计数=计数+1；
}
如果（计数=0）
系统输出打印LN（i）；
}
}
}
为完整起见，我们再提供两个Haskell定义。原型

primes=map head.scanl（\\）[2...map（\p->[p，p+p..]）$primes
哪里
（\\）=Data.List.Ordered.减号

而且在简洁性上是绝对的冠军

nubBy（（>1）。.gcd）[2..]（（>1）。.gcd）意思是（\ab->gcd a b>1）
使用哪种语言？Java并不以其简洁著称。我同意..编辑了它并使其成为一个社区Wiki:）它必须有一个main吗？您的问题说它需要一个整数，但main只需要字符串参数？添加了一些说明：）最短源代码或字节码？对于大于整数的输入，此程序不会终止。对于循环，new Long（字符串）相当昂贵。cf.Long.parseLong（字符串），但它较短。；）美好的这可以通过使用简单的试算法来缩短，而不是使用各种筛选法（上述算法的性能比试算法差；请参阅Melissa O'Neill关于这一点的论文）。@Gracenotes你有这篇论文的链接吗？接受了这个答案，如果有人提出较短的内容，我将更改接受=）我认为Gracenotes指的是这篇论文：[Eratosthenes的真正筛][1][1]：将1列为素数，不将2列为素数，不列为非素数，并且在测试w/jre-1.7时不进行修改
def s n
(a=(2..n).to_a).each{|n|a.reject!{|k|k%n==0&&k/n!=1}}
p[[1]+a,(2..n).to_a-a]
end

class F {

    public static void main(String[] z) {

        l:
        for (int a=1,b; a < z; a += 2) {

            for (b = 2; b < a; b++)
                if (a % b == 0) 
                    continue l;
            System.out.println(a);
        }
    }
}

  for(i=1; i<n;i++)
    {
        for(f = j= 2;j<i && f;)
            f = i%j++
        if(f) console.log(i)
    }

print[i for i in range(2,input())if all(i%j for j in range(2,i))]

>>> print[i for i in range(2,input())if all(i%j for j in range(2,i))]
70
[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67]
>>> 

public class test3 {
    public static void main(String[] args) {
        for (int i = 2; i <= 100; i++) {
            int count = 0;
            for (int j = i / 2; j >= 2; j--) {
                if (i % j == 0)
                    count = count + 1;
            }
            if (count == 0)
                System.out.println(i);
        }
    }
}