language-agnostic code-golf rosetta-stone

language agnostic - Cree, ordene e imprima una lista de 100 entradas aleatorias en el menor número de caracteres del código



language-agnostic code-golf (30)

Common Lisp, int entre 0 y 10000 (no hay un límite superior para eso, pero debes elegir uno).

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

¿Cuál es la cantidad mínima de código que puede escribir para crear, clasificar (ascendente) e imprimir una lista de 100 enteros positivos al azar? Al menos la cantidad de código me refiero a los caracteres contenidos en todo el archivo fuente, por lo que llegar a minificar.

Estoy interesado en ver las respuestas usando cualquiera y todos los lenguajes de programación. Tratemos de mantener una respuesta por idioma, editemos la anterior para corregirla o simplificarla. Si no puede editar, ¿comenta?


En BASH:

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


Java:

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


Linux, línea de comando:

% 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


Perl, un total de 8 bytes más corto que la versión de nrich, y se ejecuta bajo "advertencias de uso"; :)

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


groovy:

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


10 caracteres en J:

/:~100?9e9

explicación:

/:~ ordena una matriz (técnicamente, aplica una lista de vectores de permutación ordenados a sí mismo)

x ? limit x ? limit devoluciones x números aleatorios inferiores al límite

9e9 (9000000000) es un límite superior razonable expresable en 3 caracteres. ! 9 (9 factorial) es más pequeño, pero requiere un carácter menos.


C ++ no es la herramienta adecuada para este trabajo, pero aquí va:

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


F#

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


Javascript: (a través de JSDB o el Rhino de Mozilla utilizado en modo shell)

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

Aquí hay una prueba completa:

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

editar: parece que puedo acortarlo unos pocos caracteres por asignación directa en lugar de "presionar", y no necesito {} s:

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


Mi entrada:

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

o, según Adam en los comentarios:

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


Un intento en ruby:

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

(Con ocho caracteres menos, pero que requiere el cernícalo de Ruby 1.9)

-para ruby ​​1.8:

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

30 caracteres. (Podría recortar en 2 cambiando a 9e9, pero el comentario en cuestión dice que el rango debería ser MaxInt32.


mackenir: una mejora de 7 caracteres:

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


estilo xkcd en PHP:

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


Clojure

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


C ++ con impulso. Lástima que los #includes ya sean la mitad de todo el texto :)

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


Mathematica, 28 caracteres

Sort@RandomInteger[2^32, 100]

Eso da 100 enteros aleatorios (ordenados) en {0, ..., 2 ^ 32}.


DO#

Si está de acuerdo con imponer un límite en el tamaño de la matriz, entonces:

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

De lo contrario, se podría tomar un ángulo menos restrictivo (pero un poco más detallado):

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

Bueno, creo que esta es la última vez que vuelvo a este ...

116 caracteres :

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


simple c-código viejo en 167 caracteres:

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


Java, de nuevo

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

No creo que se pueda hacer más corto que esto ... también recorté espacios innecesarios.

LE: oh sí, puede :) inspirado por la publicación de 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); } }


En OCaml:

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

Editar: en OCaml tipeando que en el toplevel se imprimirá la lista, pero si desea que la lista se imprima en 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));;


Tcl está muerto.

Larga vida tcl.

Crea una lista de longitud RANDOM (0-99) y pone números enteros RANDOM (0-99) en ella.

También se imprime en la pantalla y se puede ejecutar exactamente como se muestra en un archivo tcl o en el shell tcl.

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 también es bueno.

confirma completamente para ejercitar

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


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

Dijo el mínimo de caracteres, no menos bytes. =)


DO#

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

EDITAR : hizo el programa completo. asume que las nuevas líneas y los espacios se pueden quitar, pero se dejó en la claridad :)

EDITAR : hecho aún más corto .... Me atrevo a alguien a mejorar este ... Lo he intentado durante una hora.

EDIT : Creo que es un poco más corto.

EDITAR : Creo que es aún más corto. Uf, hazme parar.

EDITAR : Una línea más, un personaje menos. Discutible...

Explicación

A[100] - una matriz de cualquier cosa antigua - en este caso A''s (es un buen nombre corto). Los contenidos se ignoran por completo, lo que cuenta es el tamaño de la matriz.

.Select(i=>r.Next()) - genera un enumerable de 100 valores de r.Next ().

.OrderBy(i=>i) - ordena el orden anterior.

.ToList() - convierte el enumerable ordenado de int en una Lista, para que podamos usar ForEach.

ForEach(Console.WriteLine) : llame a Console.WriteLine 100 veces, pasando cada valor entero en la lista.


Haskell:

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


Potencia Shell :

35 caracteres (con PowerShell Community Extensions, que reemplaza a Get-Random ):

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

20 caracteres (simple PowerShell v2):

0..99|%{random}|sort


Windows BATCH: 160. Esto agrega un cero a los números, pero de lo contrario la clasificación es un poco desordenada (porque la ordena ordena por caracteres, no sabe nada de números).

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

Como una línea y mucho más corta (72):

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


APL (interactivo):

Si desea que los números 0-99 (o 1-100, según si tiene el origen del índice en su espacio de trabajo configurado en 0 o 1) sean únicos, toma 8 caracteres, como los siguientes:

↑100?100

Si no te importa la singularidad, haz esto (9 caracteres):

↑?100ρ100

¿Quieres números más grandes? Simplemente sustituya su límite superior, N, por el segundo 100 en cada línea, y sus números aleatorios estarán en el rango 0 - N-1 (o 1-N si el origen de su índice está establecido en 1).

Si desea garantizar que sus números vayan del 0-99 (o 0 - N-1 si va a un límite superior más grande) independientemente de la configuración de origen del índice, simplemente encierre entre las líneas arriba entre paréntesis y agregue

-⎕IO

hasta el final (donde ⎕ es el carácter cuádruple de APL). Eso es un adicional de 6 caracteres.


APL

13 caracteres:

a[⍋a←100?9e8]


Python para imprimir 100 enteros ordenados al azar

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

@Adam ya me ganó, pero pensé que usar randint () y sys.maxint era lo suficientemente diferente como para publicar de todos modos.