在最少的代码中创建，排序和打印100个随机整数的列表

Question

您可以创建，排序（升序）和打印100个随机正整数列表的最少代码量是多少？至少代码量我的意思是整个源文件中包含的字符，所以要缩小。

我有兴趣使用任何和所有编程语言查看答案。让我们尝试为每种语言保留一个答案，编辑前一个以纠正或简化。如果你不能编辑，评论？

Answer 1

J中的10个字符：

/:~100?9e9

说明：

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

x ? limit返回小于限制的x随机数

9e9（9000000000）是一个合理的上限，可用3个字符表示。 ！9（9阶乘）较小，但需要少一个字符。

Answer 2

PHP中的

xkcd style：

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

Answer 3

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

Answer 4

我的参赛作品：

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

Answer 5

C＃

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

编辑：制定完整的计划。假设可以删除换行符和空格，但为了清楚起见，请将其留下：）

编辑：做得更短......我敢于有人改进这个......我已经试了一个小时。

编辑：我认为这有点短。

编辑：我认为这更短。呃，让我停下来。

编辑：还有一行，少一个字符。值得商榷...

<小时/> 的说明

A[100] - 任何旧东西的数组 - 在这种情况下是A（它是一个很好的短名称）。内容完全被忽略，它是数组的大小。

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

.OrderBy(i=>i) - 按顺序对前一个进行排序。

.ToList() - 将已排序的int枚举转换为List，因此我们可以使用ForEach。

ForEach(Console.WriteLine) - 调用Console.WriteLine 100次，传入列表中的每个整数值。

Answer 6

Mathematica，28个字符

Sort@RandomInteger[2^32, 100]

在{0，...，2 ^ 32}中给出100个（已排序的）随机整数。

Answer 7

APL

13个字符：

a[⍋a←100?9e8]

Answer 8

Common Lisp，0到10000之间的int（没有上限，但你必须选择一个）。

(sort (loop repeat 100 collect (random 10000)) #'<)

Answer 9

<强> Haskell中：

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

Answer 10

F＃

let r = new System.Random();;

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

Answer 11

尝试红宝石：

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

（少了八个字符，但需要{1.9}的tap红宝石。）

- 为红宝石1.8：

p (0..?d).map{rand 1<<32}.sort

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

Answer 12

在BASH：

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

Answer 13

Powershell：

35个字符（使用PowerShell社区扩展，取代Get-Random）：

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

20个字符（普通PowerShell v2）：

0..99|%{random}|sort

Answer 14

Python打印100个随机排序整数

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

@Adam已经打败了我，但我认为使用randint（）和sys.maxint完全不同于帖子。

Answer 15

Javascript :(通过JSDB或在shell模式下使用的Mozilla Rhino）

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

这是一个完整的测试运行：

c:\>java org.mozilla.javascript.tools.shell.Main
Rhino 1.7 release 1 2008 03 06
js> x=[];for(i=0;i<100;i++){x.push((Math.random()+"").slice(-8));};x.sort();
01499626,02403545,02800791,03320788,05748566,07789074,08998522,09040705,09115996,09379424,10940262,11743066,13806434,14113139,14336231,14382956,15581655,16573104,20043435,21234726,21473566,22078813,22378284,22884394,24241003,25108788,25257883,26286262,28212011,29596596,32566749,33329346,33655759,34344559,34666071,35159796,35310143,37233867,37490513,37685305,37845078,38525696,38589046,40538689,41813718,43116428,43658007,43790468,43791145,43809742,44984312,45115129,47283875,47415222,47434661,54777726,55394134,55798732,55969764,56654976,58329996,59079425,59841404,60161896,60185483,60747905,63075065,69348186,69376617,69680882,70145733,70347987,72551703,73122949,73507129,73609605,73979604,75183751,82218859,83285119,85332552,85570024,85968046,86236137,86700519,86974075,87232105,87839338,88577428,90559652,90587374,90916279,90934951,94311632,94422663,94788023,96394742,97573323,98403455,99465016

编辑：看起来我可以通过直接分配而不是“推送”来缩短它的几个字符，而且我不需要{} s：

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

Answer 16

APL（互动）：

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

↑100?100

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

↑?100ρ100

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

如果你想保证你的数字范围从0-99（如果你想要更大的上限，则为0 - N-1），无论索引原点设置如何，只需将上述任一行括在括号中并添加

-⎕IO

到最后（其中⎕是APL的四字符）。这是另外6个字符。

Answer 17

Perl，比nrich的版本短8个字节，并在“使用警告”下运行; ：）

perl -wle "$,=' ';print sort map {int rand 100} 1..100"

Answer 18

在OCaml：

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

编辑：在OCaml输入中，在顶层打印将打印出列表，但如果你想将列表打印到stdout：

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

Answer 19

爪哇：

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Random;

class Rnd {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<Integer>(100);
        for (int i = 0; i < 100; i++) list.add(new Random().nextInt());
        Collections.sort(list);
        System.out.println(list);
    }
}

Answer 20

Windows BATCH：160。这会为数字添加一个前导零，但是排序有点混乱（因为排序按字符排序 - 它对数字一无所知）。

@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%

作为一个单线和更短的方式（72）：

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

Answer 21

Clojure的

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

Answer 22

常规：

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

Answer 23

麦肯尼尔：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 );
        }
    }
}

Answer 24

xkcd风格的Python答案 - 比当前短一些！

print [4]*100

真实答案，63个字符：

from random import*;print sorted(randrange(9e9)for i in[0]*100)

Answer 25

C ++ with boost。太糟糕了，#include已经是所有文本的一半：）

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

Answer 26

Golfscript - 15个字符

[100.{rand}+*]$

Answer 27

Prolog，78个字符：

r([]).
r([H|T]):-random(0,1000000,H),r(T).
f(L):-length(R,100),r(R),sort(R,L).

在REPL中的用法：

| ?- f(X).

X = [1251,4669,8789,8911,14984,23742,56213,57037,63537,91400,92620,108276,119079,142333,147308,151550,165893,166229,168975,174102,193298,205352,209594,225097,235321,266204,272888,275878,297271,301940,303985,345550,350280,352111,361328,364440,375854,377868,385223,392425,425140,445678,450775,457946,462066,468444,479858,484924,491882,504791,513519,517089,519866,531646,539337,563568,571166,572387,584991,587890,599029,601745,607147,607666,608947,611480,657287,663024,677185,691162,699737,710479,726470,726654,734985,743713,744415,746582,751525,779632,783294,802581,802856,808715,822814,837585,840118,843627,858917,862213,875946,895935,918762,925689,949127,955871,988494,989959,996765,999664]

yes

正如我的一些老师所说，这是自我解释的： - ）

Answer 28

#!perl

print join "\n", sort { $a <=> $b } map { int rand 0xFFFFFFFF } 1 .. 100;

Answer 29

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

Answer 30

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

Answer 31

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

我认为它不能比这更短。 我也删掉了不必要的空间。

LE：哦，是的，它可以:)灵感来自ding的帖子..

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

Answer 32

Python（交互式）：

import random
[int(9*random.random())]

什么？它创建一个随机整数的列表，对其进行排序（平凡），并将其打印出来。

好的，这是一个认真的答案

import random
sorted([int(9*random.random()) for x in range(9)])

它在[0,9]中生成9个随机整数，对它们进行排序，然后打印它们（在交互式shell中）。

这是一个较短的变体，实际上产生了所需的100个：

from random import*
sorted(randint(0,9)for x in' '*100)

Answer 33

C＃：

using System;
using System.Collections.Generic;

class App
{
  static void Main()
  {
    List<int> TheList = new List<int>();
    Random r = new Random();
    for ( int i = 0; i < 10; i++ )
      TheList.Add(r.Next());
    TheList.Sort();
    foreach ( int i in TheList )
      Console.WriteLine(i);
  }
}

如果你想要原始字符数，你可以再压缩一下。但基本上就是这样。

编辑：尝试2：

using System;

class App
{
  static void Main()
  {
    Random r= new Random();
    for ( int i = 0, j=0; i < 100; i++ )
      Console.WriteLine(j+=r.Next(int.MaxValue/100));
  }
}

Answer 34

Tcl死了。

万岁tcl。

创建一个RANDOM（0-99）长度列表并将RANDOM（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]

---

PHP也很好。

完全确认运动

<?
for($i=100;$i--;$l[]=rand());
sort($l);
print_r($l);

Answer 35

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

他说最少的字符，而不是最少的字节。 =）

Answer 36

C＃

如果你可以对数组大小施加限制，那么：

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

Answer 37

C而不分配数组（基本上一直在向打印的最后一个值添加一个随机整数，隐式排序）：

#include <stdlib.h>

int main(int argc, char **argv) {
    int i;
    unsigned long baseline = 0;
    srand(atoi(argv[1]));
    for ( i = 0 ; i < 100 ; i++ ) {
        baseline += rand();
        printf("%ld\n", baseline);
    }

}

，通常的混淆+删除换行符，下降到136个字符。

ps：显然在命令行上使用$ RANDOM运行。

Answer 38

ColdFusion的：

<cfloop index="i" to="100" from="1">
    <cfset a[i] = randrange(1,10000)>
</cfloop>

<cfset ArraySort(a, "numeric")>

<cfdump var="#a#">

Answer 39

Qt4版本（c ++），116个字符。

#include <QtCore>
int main(){QList<int>l;int i=101;while(--i)l<<qrand()%101;qSort(l);foreach(i,l)printf("%d\n",i);}

-> wc -c main.cpp
116 main.cpp

Answer 40

C＃

var sequence = Enumerable.Range(1, 100)
                         .OrderBy(n => n * n * (new Random()).Next());

foreach (var el in sequence.OrderBy(n => n))
    Console.Out.WriteLine(el);

F＃

let rnd = System.Random(System.DateTime.Now.Millisecond)

List.init 100 (fun _ -> rnd.Next(100)) 
|> List.sort 
|> List.iter (fun (x: int) -> System.Console.Out.WriteLine(x))

Answer 41

Common Lisp（我记得它，可能有一些细节错误）：

(setf a '(99 61 47))
(setf a (sort a))
(princ a)

这些数字当然是随机的;我现在通过掷骰子选择它们。

（也许我们可以稍微收紧一下这个定义？）

Answer 42

python，71个字符

import random
print sorted(random.randint(0,2**31)for i in range(100))

Answer 43

C＃

var r=new Random();
var l=from i in new C[100] let n=r.Next() orderby n select n;

81个字符（包括换行符）

Answer 44

Matlab的：

arrayfun( @(x) display(x), sort( rand(1,100) ) )

Answer 45

使用C-152字符

main(){int a=100,b,t,x[a];while(a--)x[a]=rand();a=100;while(b=a--)while(b--)if(x[a]>x[b]){t=x[a];x[a]=x[b];x[b]=t;}a=100;while(a--)printf("%d\n",x[a]);}

或扩展

#include <stdio.h>
int main()
{
    int a=100,b,t,x[a];

    while(a--)x[a]=rand();
    a=100;

    while(b=a--)
        while(b--)
            if(x[a]>x[b])
            {
                t=x[a];
                x[a]=x[b];
                x[b]=t;
            }

    a=100;
    while(a--)
        printf("%d\n",x[a]);
}

Answer 46

打印在C ++中排序的[0,100]范围内的随机100个随机数

srand((unsigned int)time(NULL)); list<int> r;
for (int i=0;i<100;i++) r.push_back((int)((100)*rand()/(float)RAND_MAX));
r.sort();
for (list<int>::iterator j=r.begin();j!=r.end();j++) cout << *j << endl;

如果您不关心奇偶校验，请将r.push_back((int)((100)*rand()/(float)RAND_MAX))替换为r.push_back(rand()%(101))

-

这是一个200字符的完整程序：

#include <algorithm>
#include <iostream>
#include <random>
using namespace std;int main(){int a[100];generate_n(a,100,tr1::mt19937());sort(a,a+100);for(int i=0;i<100;++i){cout<<a[i]<<endl;}return 0;}

数组表示法比我能找到的任何标准容器都要短。 tr1::mt19937是我能找到的最短随机数生成器。 using namespace std;比std::的几个实例短。

Answer 47

R：

sort(round(runif(100)*99+1))

Answer 48

Windows命令shell - 71个字符

cmd/v/c"for /L %i in (0,1,99)do @set r=     !random!&echo !r:~-5!"|sort

Answer 49

Scala :( 61个字符）

1 to 100 map {_ ⇒ Random.nextInt} sortBy identity foreach println

修改

通过定义identity内联，可以压缩更多（56个字符）。

1 to 100 map {_ ⇒ Random.nextInt} sortBy {i ⇒ i} foreach println

Answer 50

Perl命令行：

perl -e 'print $_, "\n" foreach sort map {int rand 10} (1..10)'

在0到9之间打印10个整数并对它们进行排序。

Answer 51

爪哇：

  public void randList()
  {
  final int NUM_INTS = 100;
  Random r = new Random();
  List<Integer> s = new ArrayList<Integer>();

  for(int i = 0; i < NUM_INTS; i++)
    s.add(r.nextInt());

  Collections.sort(s);

  for(Integer i : s)
    System.out.println(i);
  }

可能会更短，但上述内容非常清晰且符合最佳做法。这将生成警告（原始类型）并且具有错误的变量名称，但是更短。

  void rl()
  {
  Random r = new Random();
  List s = new ArrayList();

  for(int i = 0; i < 100; i++)
    s.add(r.nextInt());

  for(Object i : s)
    System.out.println((Integer) i);
  }

Answer 52

我不接受这个程序规范，太不精确了！ ： - ）

Lua版本：

t=table;l={}for i=1,20 do l[#l+1]=math.random(99)end;t.sort(l)print(t.concat(l,' '))

可能会略微缩短，也可能有更智能的代码。

Answer 53

命令行PHP one-liner（是的，需要使用尾随分号...）

php -r 'while (++$i % 101) $j[] = rand(0, 99); sort($j); echo implode(" ", $j)."\n";'

Answer 54

请注意，没有人用C或C ++给出答案？

一旦它们被称为高级语言（与汇编程序相比）。好吧，我想现在他们是低级别的。

Answer 55

VB - 151个字符：

不如C＃那么优雅......

Sub Main()
    Dim r = New Random
    Enumerable.Range(1, 100) _
      .Select(Function(i) r.Next) _
      .OrderBy(Function(i) i) _
      .ToList _
      .ForEach(AddressOf Console.WriteLine)
End Sub

Answer 56

Delphi ...按字母顺序排序的版本

program PrintRandomSorted;

{$APPTYPE CONSOLE}
uses SysUtils,Classes;

var I:Byte;
begin
  with TStringList.Create do
  begin
    for I in [0..99] do
      Add(IntToStr(Random(MaxInt)));
    Sort; Write(Text); Free;
  end;
end.

---

使用泛型正确排序..

program PrintRandomSorted;
{$APPTYPE CONSOLE}
uses SysUtils, generics.collections;
var I:Byte;S:String;
begin
  with TList<Integer>.Create do
  begin
    for I in [0..99] do Add(Random(MaxInt));
    Sort;
    for I in [0..99] do WriteLn(Items[I]);
    Free;
  end;
end.

Answer 57

这不是开玩笑。这是我现在能做的最好的事情。 ：）

JavaScript：

a=[];for(i=0;i<100;i++){b=Math.round(Math.random()*100);a[i]=b;}c=0;
while(c==0){c=1;for(j=0;j<99;j++){if(a[j]>a[j+1]){d=a[j];a[j]=a[j+1];a[j+1]=d;c=0;}}}
for(k=0;k<100;k++)document.write(a[k],"<br>")

Answer 58

你会认为SQL会擅长这类事情： -

SELECT * FROM
(SELECT TRUNC(dbms_random.value(1,100)) r
FROM user_objects
WHERE rownum < 101)
ORDER BY r

这是一个108个字符的Oracle版本。有人可能会使用TOP 100语法在不同的变体中做得更好。

编辑，共82个字符：

select trunc(dbms_random.value(1,100))
from dual 
connect by level < 101
order by 1

Answer 59

这是我使用Delphi 2007 Win32控制台应用程序所能做的最好的事情（除了删除一些换行符和缩进）：

{$APPTYPE CONSOLE}
var a:array[0..99] of integer; i,j,k:integer;
begin
  FOR i:=0 to 99 DO a[i]:=random(maxint)+1;
  FOR i:=0 to 98 DO
    FOR j:=i+1 to 99 DO
      IF a[j]<a[i] THEN begin
        k:=a[i]; a[i]:=a[j]; a[j]:=k
      end;
  FOR i:=0 to 99 DO writeln(a[i])
end.

AFAIK，没有一个标准单位包含一个排序例程，所以我必须写出我所知道的最短的一个。此外，由于我没有调用Randomize，因此每次运行时都会产生相同的结果。

编辑：我将“正整数”表示整数类型范围内的每个正（非零）数字，因此使用maxint（系统常量）和“+1”以确保它不为零。

Answer 60

普通的老C，没有那么简单到被混淆：

#include <stdio.h>
#include <stdlib.h>
static int cmp(const void *a, const void *b)
{
    return *(const int *) a > *(const int *) b;
}
int main(void)
{
    int x[100], i;
    for(i = 0; i < 100; i++)
            x[i] = rand();
    qsort(x, 100, sizeof *x, cmp);
    for(i = 0; i < 100; i++)
            printf("%d\n", x[i]);
    return 0;
}

在Linux中使用gcc 4.1.2时无需警告即可构建。在实际代码中，我当然会：

• 返回EXIT_SUCCESS而不是0
• 仅编写100次，并将sizeof x用于其余参考

Answer 61

Erlang，157个字符

-module (intpr).
-export ([q/0]).
q() ->
    lists:foldl(
    fun(X,A)->io:format("~p,",[X]),A end, 
    n, 
    lists:sort( 
        lists:map(fun(_)->random:uniform(100) end, lists:seq(1,100)) 
    )
    ).

当然它不是最好的erlang解决方案，基本上它会创建一个从1到100的列表（仅因为我没有找到更好/更短的方式来初始化列表）并使用随机整数映射每个项目（＆lt; 100） ），然后对结果列表进行排序。 最后，列表被“折叠”，用作浏览所有项目并打印它们的方式。

Answer 62

Pike

void main() {
  array a=({});
  while (sizeof(a)<100) a+=({random(1<<30)});
  sort(a);
  foreach (a, int b) write("%d\n",b);
}

Answer 63

我无法编辑或评论，所以这里是Java v3（前两个有负数）：

import java.util.TreeSet;

class Test {

    public static void main(String[] args) {
        Collection<Double> s = new TreeSet<Double>();
        while (s.size() < 100) s.add(Math.random());
        System.out.println(s);
    }
}