La tarea

Esta es una tarea de codificación bastante simple, todo lo que su programa tiene que hacer es colocar un punto en un lienzo (o su alternativa en otro lenguaje de codificación) y conectarlo a todos los puntos ya colocados. Su programa debe incluir una entrada, la cantidad de puntos que se deben colocar y mostrar algún tipo de pantalla con los puntos conectados. Ejemplo

Requisitos

• Tengo que poder ejecutarlo, lo que significa que tiene que tener un compilador / herramienta para ejecutarlo en línea o públicamente disponible para descargar.
• Puede usar cualquier biblioteca creada antes de que se establezca este desafío, siempre que no haya sido diseñada con el único propósito de resolver esto.
• Esta es una tarea de código más corta, que significa caracteres. Se ignorarán los comentarios, el código que cambia de color (para la belleza) y las bibliotecas.
• Su respuesta debe ser única, no robe el código de otras personas, acorte algunos caracteres y vuelva a publicarlo.
• Debe poder ejecutarse en menos de 5 minutos, para los valores de 5 y 100. También debe usar una resolución de al menos 200 * 200 y colocar cada punto en una ubicación aleatoria en el lienzo utilizando una distribución no trivial.

Tabla de clasificación actual

Flawr        - Matlab        - 22  - Confirmed
Falko        - Python 2      - 41  - Confirmed
Wyldstallyns - NetLogo       - 51  - Confirmed 
Ssdecontrol  - R             - 66  - Confirmed
David        - Mathematica   - 95  - Confirmed
ILoveQBasic  - QBasic        - 130 - Confirmed
Adriweb      - TI-Nspire Lua - 145 - Confirmed
Manatwork    - Bash          - 148 - Confirmed
Doorknob     - Python 2      - 158 - Confirmed
Kevin        - TCL           - 161 - Confirmed
M L          - HPPPL         - 231 - Confirmed
Manatwork    - HTML/JS       - 261 - Confirmed - Improved code of Scrblnrd3
Makando      - C#            - 278 - Confirmed
Scrblnrd3    - HTML/JS       - 281 - Confirmed
Geobits      - Java          - 282 - Confirmed

Si te he extrañado, lo siento mucho, solo agrega un comentario a tu trabajo diciéndolo y lo agregaré tan pronto como lo vea =)

TL; DR

• Entrada: número de puntos (int, puede estar codificado)
• Salida: imagen de puntos colocados al azar, todos conectados entre sí (gráfico)
• Ganador - Código más corto

Matlab (22)

gplot(ones(n),rand(n))

Se supone que n es el número de puntos, y se ve así para n = 10:

n=6:

Explicación

gplotes un comando para trazar gráficos. El primer argumento es una n x nmatriz de incidencia (llena de unos, obviamente). El segundo argumento debe ser una n x 2matriz con las coordenadas de los puntos, pero no importa si la segunda dimensión es mayor que 2, por lo que solo genero una n x nmatriz de valores aleatorios (que es 2 caracteres más cortos que generar una n x 2matriz).

Enlaces a documentación

• gplot
• unos
• rand

Java: 318 282 265

Porque, ya sabes, Java:

class M{public static void main(String[]a){new Frame(){public void paint(Graphics g){int i=0,j,d=640,n=25,x[]=new int[n],y[]=x.clone();for(setSize(d,d);i<n;i++)for(j=0,x[i]=(int)(random()*d),y[i]=(int)(random()*d);j<i;g.drawLine(x[i],y[i],x[j],y[j++]));}}.show();}}

Es solo un bucle simple que crea puntos aleatorios y dibuja líneas entre el punto actual y todos los anteriores.

Ejemplo con 25 puntos:

Con saltos de línea e importaciones:

import java.awt.*;
import static java.lang.Math.*;

class M{
    public static void main(String[]a){
        new Frame(){
            public void paint(Graphics g){
                int i=0,j,d=640,n=25,x[]=new int[n],y[]=x.clone();
                for(setSize(d,d);i<n;i++)
                    for(j=0,x[i]=(int)(random()*d),y[i]=(int)(random()*d);
                        j<i;
                        g.drawLine(x[i],y[i],x[j],y[j++]));
            }
        }.show();
    }
}

Editar: como no contamos las importaciones, importé un par de cosas más para guardar algunos caracteres más adelante.

Edición 2: OP agregó una asignación para codificar el número de puntos. -17 caracteres :)

Python 2 - 41 35

Después de importar algunas bibliotecas según lo permitido para este desafío

from pylab import rand as r
from pylab import plot as p
from itertools import product as x
from itertools import chain as c

podemos trazar un número de puntos conectados con una sola línea de código:

X=r(5,2);p(*zip(*c(*list(x(X,X)))))

(La captura de pantalla se generó con 10 puntos).

Mathematica 95 87

Con un poco de ayuda de belisario.

CompleteGraph[n, VertexSize -> {2, 2},
VertexCoordinates -> Table[RandomInteger[{0, 199}, 2], {n}]]

n = 5

n = 100

Tiempo: 2.082654 segundos

Pitón 2, 158

Importar declaraciones no incluidas en el recuento de caracteres, como se indica en la pregunta ("las bibliotecas serán ignoradas").

from PIL import Image,ImageDraw
from random import randint

s=[(randint(0,200),randint(0,200))for _ in range(int(input()))]
i=Image.new('RGB',(200,200))
[ImageDraw.Draw(i).line((p,q),255)for p in s for q in s]
i.show()

Resultados de muestra:

n = 2 (...):

n = 10 (parece una cosa 3d elegante o algo así):

n = 100 (parece que alguien se fue BLELEEEAARARHHH con un bolígrafo rojo):

n = 500, 1000, 10000 (se ejecuta en aproximadamente 1.5 segundos, 5-6 segundos y 3.5 minutos respectivamente):

Nota: el de 10000 puntos se ejecutó con una versión ligeramente optimizada que cambió la línea 3 (sin incluir las importaciones) a esto:

d=ImageDraw.Draw
for p in s:
  for q in s:d.line((p,q),255)

De lo contrario, habría tomado una eternidad. :PAGS

Sin golf:

from PIL import Image, ImageDraw
from random import randint
point_count = int(input())
image_size = 200
points = [(randint(0, image_size), randint(0, image_size)) for _ in range(point_count)]
image = Image.new('RGB', (200, 200))
draw = ImageDraw.Draw(image)
for start_point in points:
    for end_point in points:
        draw.line((start_point, end_point), 255)
image.show()

R, 66

Esta es una trampa límite, pero todavía creo que está dentro de las reglas. Configure cargando el igraphpaquete con library(igraph), que se puede descargar desde CRAN con install.packages("igraph"). Luego asigne la entrada a la variable N. Según las reglas, estos no se cuentan en el total.

G=graph.adjacency(matrix(1,N,N),"un")
plot(G,layout=layout.random)

N = 50

Tenga en cuenta que este código también dibuja las auto-conexiones. Al eliminarlos (aunque no hay una regla en contra de ellos) se agregan 6 caracteres:

G=graph.adjacency(matrix(1,N,N),"un",diag=F)
plot(G,layout=layout.random)

R, 141

Esta es una solución honesta a la bondad en la base R:

p=replicate(2,runif(N))
g=as.matrix(expand.grid(1:N,1:N))
plot.new()
apply(g,1,function(i) segments(p[i[1],1],p[i[1],2],p[i[2],1],p[i[2],2]))

aunque todavía tienes que ingresar Na mano.

N = 50

Me pregunto si un forbucle tendría menos caracteres que, applypero estoy contento con lo que tengo.

QBasic o QuickBasic, 130 caracteres

SCREEN 1:RANDOMIZE:N=10:DIM X(100),Y(100):FOR I=1 TO N:X(I)=RND*320:Y(I)=RND*200:FOR J=1 TO I:LINE(X(I),Y(I))-(X(J),Y(J)):NEXT J,I

Variaciones de código

• Si no desea que se le solicite una semilla, reemplácela RANDOMIZEcon RANDOMIZE TIMER.
• Si desea que se le solicite N, reemplácelo N=10con INPUT No INPUT "N";N.

Ejecuciones de muestra

Para N=5, probado con QBasic 1.1 ejecutándose en DOSBox 0.74:

Para N=100, probado con QBasic 1.1 ejecutándose en DOSBox 0.74:

Bash + ImageMagick: 148 caracteres

c=()
while((i++<$1)); do
p=$[RANDOM%200],$[RANDOM%200]
c+=($p)
for e in ${c[@]};do
d+="line $p $e"
done
done
convert -size 200x200 xc: -draw "$d" x:

Ejecución de muestra:

bash-4.3$ time ./line.sh 5

real    0m5.256s
user    0m0.137s
sys     0m0.017s

Salida de muestra:

Ejecución de muestra:

bash-4.3$ time ./line.sh 25

real    0m3.043s
user    0m0.574s
sys     0m0.023s

Salida de muestra:

Ejecución de muestra:

bash-4.3$ time ./line.sh 100

real    0m5.662s
user    0m11.156s
sys     0m0.076s

Salida de muestra:

TCL 161 caracteres

Claramente no va a ganar, pero supera a muchos otros presentados aquí, y creo que hace un buen uso de un lenguaje altamente infravalorado.

for {set i 0} {$i<10} {incr i} {lappend l [expr rand()*291] [expr rand()*204]}
pack [canvas .c]
foreach {x y} $l {foreach {w z} $l {.c create line $x $y $w $z}}

El tamaño de lienzo predeterminado en mi sistema parece ser 291x204. No estoy seguro de por qué, pero usarlo ahorra 13 caracteres.

Bastante rápido, 400 puntos en <5 segundos, 500 en ~ 10 s. El tamaño y los puntos se pueden escalar arbitrariamente y los colores y los estilos de línea se pueden alterar, a costa de los caracteres, por supuesto. Sin golf y utilizando variables para hacerlo más claro y fácil de escalar y colorear:

set n 20
set width 500
set height 500
set bg_color black
set line_color white
for {set i 0} {$i < $n} {incr i} {
        lappend points [expr rand() * $width] [expr rand() * $height]
}
canvas .c -width $width -height $height -background $bg_color 
pack .c
foreach {x1 y1} $points {
        foreach {x2 y2} $points {
                .c create line $x1 $y1 $x2 $y2 -fill $line_color
        }
}       

[TI-Nspire] Lua - 145 135 130

(Versión fija actualizada)

"Importando" math.random como "r", primero, según lo permitido: r=math.random

Código actual:

function on.paint(g)t={}for b=1,2*n-1,2 do t[b]=r(318)t[b+1]=r(212)for c=1,b-1,2 do g:drawLine(t[b],t[b+1],t[c],t[c+1])end end end

Nota: Este código funciona en las calculadoras TI-Nspire (TI agregó secuencias de comandos Lua a los sistemas operativos recientes de esta plataforma, con una API uniforme que permite a los usuarios graficar cosas, etc., por ejemplo).
También se puede probar en línea aquí (solo borrar el script de demostración y anteponer el mío con, n=10por ejemplo)

C # formularios Windows, 268

static void k(int n,int s){var f=new Form{Height=s+50,Width=s+25};f.Paint+=(u,v)=>{var r=new Random();var p=new Point[n];while(n>0)p[--n]=new Point(r.Next(s),r.Next(s));foreach(var a in p)foreach(var b in p)f.CreateGraphics().DrawLine(Pens.Tan,a,b);};f.ShowDialog();}

N = 5

N = 50

El código completo se da a continuación

using System;
using System.Drawing;
using System.Windows.Forms;

namespace WindowsFormsApplication2
{
    static class Program
    {
        static void Main()
        {
            k(50, 200);
        }
        static void k(int n, int s)
        {
            var f = new Form {Height = s + 50, Width = s + 25};
            f.Paint += (u, v) =>
            {
                var r = new Random();
                var p = new Point[n];
                while (n > 0)
                    p[--n] = new Point(r.Next(s), r.Next(s));
                foreach (var a in p)
                    foreach (var b in p)
                        f.CreateGraphics().DrawLine(Pens.Tan, a, b);
            };
            f.ShowDialog();
        }
    }
}

HTML / JS, 210, gracias a manatwork

<canvas id=q /><script>c=q.getContext("2d");r=Math.random;e=prompt(a=[]);for(i=0;i<e;i++){a[i]={x:r()*300,y:r()*150};for(j in a)c.beginPath()+c.moveTo(a[i].x,a[i].y)+c.lineTo(a[j].x,a[j].y)+c.stroke()}</script>

JSFiddle

C # WPF 306 296

partial class W:Window{public W(){InitializeComponent();int x=5,i=0,j,z=200;int[]f=new int[x],s=new int[x];var r=new Random();var X=new Grid();AddChild(X);for(;i<x;i++){f[i]=r.Next(z);s[i]=r.Next(z);for(j=i;j>=0;)X.Children.Add(newLine(){X1=s[j],Y1=f[j--],X2=s[i],Y2=f[i],Stroke=Brushes.Red});}}}

Me gustaría decir que podría eliminar Stroke = Brushed.Red. Pero lamentablemente eso significa que estoy pintando líneas transparentes, y mi suposición es que realmente no contaría. : PI también puede reducir un par de bytes simplemente creando una cuadrícula en la vista XAML. Pero eso parecía injusto, por lo que quité el XAML para convertirlo en un lienzo en blanco. (No cuento el XAML como bytes ...)

partial class W:Window
{
    public W()
    {
        InitializeComponent();
        int x=5,i=0,j,z=200;
        int[]f=new int[x],s=new int[x];
        var r = new Random();
        var X = new Grid();
        AddChild(X);
        for (;i<x;i++)
        {
            f[i]=r.Next(z);
            s[i]=r.Next(z);
            for (j=i;j>=0;)
                X.Children.Add(new Line()
                {
                    X1 = s[j],
                    Y1 = f[j--],
                    X2 = s[i],
                    Y2 = f[i],
                    Stroke = Brushes.Red
                });
        }
    }
}

XAML

<Window x:Class="W"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        Title="MainWindow" Height="350" Width="525">
</Window>

5 5

100

HPPPL, 231 220

(Lenguaje de programación HP Prime para la calculadora gráfica en color HP Prime)

Golfed hacia abajo. 11 caracteres menos dibujando todas las líneas nuevas posibles justo después de cada nueva creación de puntos. Solo dos bucles anidados en lugar de los tres anteriores.

export c(n) begin rect();local g,h;a:=makemat(0,n,2);for g from 1 to n do a(g,1):=ip(random(1,320));a(g,2):=ip(random(1,240));if g>1 then for h from 1 to g-1 do line_p(a(h,1),a(h,2),a(g,1),a(g,2));end;end;end;freeze;end;

Sin golf (270 caracteres):

export randomnet(n)
begin
rect();
local g,h;
a:=makemat(0,n,2);
for g from 1 to n do
  a(g,1):=ip(random(1,320));
  a(g,2):=ip(random(1,240));
    if g>1 then
      for h from 1 to g-1 do
        line_p(a(h,1),a(h,2),a(g,1),a(g,2));
      end;
    end;
end;
freeze;
end;

ejemplos:

c (10)

c (30)

La calculadora gráfica en color HP Prime tiene una pantalla a color de 320x240 píxeles.

Un emulador que también funciona con el kit de conectividad está disponible en el sitio web de HP o aquí: http://www.hp-prime.de/en/category/6-downloads

... sigo esperando que llegue el hardware. La actualización sobre el tiempo de ejecución seguirá.

Hoy llegó mi HP Prime. Aquí está el tiempo de ejecución para n = 100 en una calculadora real:

Alrededor de 0.65 s para n = 100.

El emulador es aproximadamente 4 veces más rápido (alrededor de 0.178 s) en mi computadora portátil Core i5 2410M.

NetLogo, 51 bytes

crt 9 [create-links-with other turtles fd random 9]

Reemplace 9s con otras constantes o variables según sea necesario.