Language agnostic 以最少的代码字符创建、排序和打印100个随机整数的列表

创建、排序（升序）和打印100个随机正整数的列表所需的最少代码量是多少？我所说的最少代码量是指整个源文件中包含的字符数，所以开始缩小

我对使用任何和所有编程语言看到答案感兴趣。让我们试着每种语言保留一个答案，编辑前面的答案以更正或简化。如果无法编辑，请评论？

我的条目：

echo enter a bunch of ints, hit control-D when done
cat - | sort -n

或者，根据亚当的评论：

echo enter a bunch of ints, hit control-D when done
sort -n

Linux，命令行：

% od -dAn -N40 /dev/random | tr ' ' '\n' | sort -nu
4959
6754
8133
10985
11121
14413
17335
20754
21317
30008
30381
33494
34935
41210
41417
43054
48254
51279
54055
55306

---

Python打印100个随机排序的整数

import random,sys
print sorted(random.randint(1,sys.maxint)for x in range(100))

已经超过我了，但我认为使用randint（）和sys.maxint已经足够不同了，无论如何都可以发布。

Tcl已经死了

tcl万岁。 创建一个随机（0-99）长度列表，并将随机（0-99）整数放入其中

还可以打印到屏幕上，并且可以完全按照tcl文件或tcl shell中显示的方式运行

set l {}
proc r {} {expr { int(floor(rand()*99)) }}
for {set i 0} {$i<[r]} {incr i} {lappend l [r]}
puts [lsort -integer $l]

set l{}
proc r{}{expr{int（floor（rand（）*99））}
对于{set i 0}{$iPerl，比nrich的版本整整短8字节，并在“use warnings；”下运行：）

公共Lisp，int介于0和10000之间（没有上限，但必须选择一个）

（排序（循环重复100次收集（随机10000次））35;'Java:

import java.util.ArrayList；
导入java.util.Collections；
导入java.util.List；
导入java.util.Random；
类Rnd{
公共静态void main（字符串[]args）{
列表=新的ArrayList（100）；
对于（inti=0；i<100；i++）list.add（newrandom（）.nextInt（））；
集合。排序（列表）；
系统输出打印项次（列表）；
}
}
在BASH中：

for i in `seq 100`; do echo $RANDOM; done | sort -n

C#
编辑：使程序完整。假定可以删除换行符和空格，但为了清晰起见，请保留在中：）

编辑：变得更短了……我敢说有人会改进这个……我已经试了一个小时了

编辑：我想这要短一点

编辑：我想那更简短。啊，让我停下来

编辑：多一行，少一个字符。有争议


解释

import java.util.*;
class R
{
    public static void main(String[]a)
    {
        List x=new Stack();
        while(x.size()<100)x.add((int)(Math.random()*9e9));
        Collections.sort(x);
        System.out.print(x);
    }
}

A[100]
-任何旧事物的数组-在本例中是A的（这是一个很好的短名称）。内容被完全忽略，重要的是数组的大小

.Select（i=>r.Next（））
-生成r.Next（）的100个值的可枚举项

.OrderBy（i=>i）
-按顺序对上一个进行排序

.ToList（）
-将int的已排序可枚举项转换为列表，以便我们可以使用ForEach

ForEach（Console.WriteLine）
调用Console.WriteLine 100次，传入列表中的每个整数值。
mzscheme-e“（排序（生成列表100（λx（随机9）））C#

mzscheme -e "(sort (build-list 100 (λ x (random 9))) <)"

如果您同意对数组大小施加限制，则：

Array.ForEach(Guid.NewGuid().ToByteArray().OrderBy(c => c).ToArray(), c => Console.WriteLine(c));

否则，可以采取限制性较小（但略为详细）的角度：

var r = new Random();
(new int[100]).Select(i => r.Next()).OrderBy(i => i).ToList().ForEach(Console.WriteLine);

好吧，我想这是我最后一次回到这一次

116个字符：

using System;
class A
{
    static void Main()
    {
        var r=new Random();
        var n=1D;
        for(int i=0;i<100;i++,Console.WriteLine(n+=r.Next()));
    }
}

使用系统；
甲级
{
静态void Main（）
{
var r=新的随机变量（）；
var n=1D；
对于（int i=0；iJ中的10个字符：

/:~100?9e9

说明：

/：~
对数组进行排序（从技术上讲，将列表排序的排列向量应用于自身）

x？limit
返回小于limit的x个随机数

9e9
（900000000）是一个合理的上限，可以用3个字符表示。！9（9阶乘）更小，但需要更少的一个字符。
尝试使用ruby：

p [].tap{|a|100.times{a<<rand(9e9)}}.sort

30个字符。（可以通过改回9e9来修剪2个字符，但有问题的评论说范围应该是MaxInt32。
groovy:

r=new Random()
List l=[]
100.times{ l << r.nextInt(1000) }
l.sort().each { println it }

r=newrandom（）
列表l=[]
100.时报{l（交互式）：

如果希望数字0-99（或1-100，取决于工作区中的索引原点设置为0还是1）是唯一的，则需要8个字符，如下所示：

↑100？100

如果您不关心唯一性，请执行以下操作（9个字符）：

↑?100ρ100

想要更大的数字吗？只需将每行的第二个100替换为上限N，您的随机数将在0-N-1范围内（如果索引原点设置为1，则为1-N）

如果你想保证你的数字范围在0-99之间（或者如果你想要一个更大的上限，则为0-N-1），而不管索引原点设置如何，只需将上面的任何一行括在括号中并加上

-⎕IO

到底在哪里⎕ 是APL的四位字符）。这是另外6个字符。
Javascript：（在shell模式下使用via或Mozilla）

x=[]；for（i=0；iWindows批处理：160）。这会在数字中添加前导零，但在其他方面排序有点混乱（因为排序按字符排序-它对数字一无所知）

作为单班轮和短路线（72）：

F#

C++不是此项工作的合适工具，但以下是：

#include <algorithm>
#include <stdio.h>

#define each(x) n=0; while(n<100) x

int main()
{
     int v[100], n;
     srand(time(0));
     each(v[n++]=rand());
     std::sort(v, v+100);
     each(printf("%d\n",v[n++]));
}

#包括
#包括
#定义每个（x）n=0；而（nmackenir:7个字符的改进：

namespace System.Linq {
    class A {
        static void Main() {
            var r = new Random();
            new A[100].Select( i => r.Next() ).OrderBy( i => i ).ToList().ForEach( Console.WriteLine );
        }
    }
}

Clojure
在PHP中：

for（$i=0；$iC++和boost。太糟糕了，#include已经是所有文本的一半：）

#包括
#包括
#包括
#包括
#包括
int main（）{
使用名称空间std；
载体a（100）；
转换（a.begin（）、a.end（）、a.begin（）、boost:：bind（&rand））；
排序（a.begin（），a.end（））；
复制（a.begin（），a.end（），ostream_迭代器（cout，“\n”）；
}
Mathematica，28个字符
它在{0，…，2^32}中给出100个（排序）随机整数。
167个字符的普通旧c代码：

main(){int i=100,x[i],n=i;while(i)x[--i]=rand();for(i=0;i<n;i++){int b=x[i],m=i,j=0;for(;j<n;j++)if(x[j]<x[m])m=j;x[i]=x[m];x[m]=b;}i=n;while(i)printf("%d ",x[--i]);}

main（）{inti=100，x[i]，n=i；而（i）x[--i]=rand（）；for（i=0；iAPL
13个字符：

a[⍋a←100?9e8]

Java，同样

import java.util.*;
class R
{
    public static void main(String[]a)
    {
        List x=new Stack();
        while(x.size()<100)x.add((int)(Math.random()*9e9));
        Collections.sort(x);
        System.out.print(x);
    }
}

import java.util.*；
R类
{
公共静态void main（字符串[]a）
{
列表x=新堆栈（）；
而（x.size（）Haskell:

import Random
import List
main=newStdGen>>=print.sort.(take 100).randomRs(0,2^32)

在OCaml中：

List.sort compare (let rec r = function 0 -> [] | a -> (Random.int 9999)::(r (a-1)) in r 100);;

E
x=[];for(i=0;i<100;i++)x[i]=(Math.random()+"").slice(-8);x.sort();

@echo off
set n=%random%.tmp
call :a >%n%
type %n%|sort
del /Q %n%
exit /B 0
:a
for /L %%i in (1,1,100) do call :b
exit /B 0
:b
set i=00000%random%
echo %i:~-5%

cmd/v/c"for /l %x in (0,1,99)do @(set x=0000!RANDOM!&echo !x:~-5!)"|sort

let r = new System.Random();;

[ for i in 0..100 -> r.Next()] |> List.sort (fun x y -> x-y);;

#include <algorithm>
#include <stdio.h>

#define each(x) n=0; while(n<100) x

int main()
{
     int v[100], n;
     srand(time(0));
     each(v[n++]=rand());
     std::sort(v, v+100);
     each(printf("%d\n",v[n++]));
}

namespace System.Linq {
    class A {
        static void Main() {
            var r = new Random();
            new A[100].Select( i => r.Next() ).OrderBy( i => i ).ToList().ForEach( Console.WriteLine );
        }
    }
}

(defn gen-rands []
(sort (take 100 (repeatedly #(rand-int Integer/MAX_VALUE)))))

for($i=0;$i<100;$i++) echo "4\n";

#include <boost/bind.hpp>
#include <algorithm>
#include <vector>
#include <iterator>
#include <cstdlib>
int main() {
    using namespace std;
    vector<int> a(100);
    transform(a.begin(), a.end(), a.begin(), boost::bind(&rand));
    sort(a.begin(), a.end());
    copy(a.begin(), a.end(), ostream_iterator<int>(cout, "\n"));
}

Sort@RandomInteger[2^32, 100]

main(){int i=100,x[i],n=i;while(i)x[--i]=rand();for(i=0;i<n;i++){int b=x[i],m=i,j=0;for(;j<n;j++)if(x[j]<x[m])m=j;x[i]=x[m];x[m]=b;}i=n;while(i)printf("%d ",x[--i]);}

a[⍋a←100?9e8]

import java.util.*;
class R
{
    public static void main(String[]a)
    {
        List x=new Stack();
        while(x.size()<100)x.add((int)(Math.random()*9e9));
        Collections.sort(x);
        System.out.print(x);
    }
}

import java.util.*;
class R
{
    public static void main(String[]a)
    {
        Set x=new TreeSet();
        while(x.size()<100)x.add((int)(Math.random()*9e9));
        System.out.print(x);
    }
}

import Random
import List
main=newStdGen>>=print.sort.(take 100).randomRs(0,2^32)

List.sort compare (let rec r = function 0 -> [] | a -> (Random.int 9999)::(r (a-1)) in r 100);;

List.iter (fun x -> Printf.printf "%d\n" x) (List.sort compare (let rec r = function 0 -> [] | a -> (Random.int 9999)::(r (a-1)) in r 100));;

0..99|%{[int]((random)*10000)}|sort

0..99|%{random}|sort