A tarefa

Essa é uma tarefa de codificação bastante simples, tudo o que seu programa precisa fazer é colocar um ponto em uma tela (ou sua alternativa em outra linguagem de codificação) e conectá-lo a todos os pontos já colocados. Seu programa deve receber uma entrada, o número de pontos que devem ser colocados e gerar algum tipo de exibição com os pontos conectados. Exemplo

Exigências

• Eu preciso executá-lo, o que significa que ele precisa ter um compilador / ferramenta para executá-lo on-line ou publicamente disponível para download.
• Você pode usar qualquer biblioteca criada antes que esse desafio seja definido, desde que não tenha sido projetado com o único objetivo de solucionar isso.
• Essa é uma tarefa de código mais curta, o que significa caracteres. Comentários, códigos que mudam de cor (por beleza) e bibliotecas serão ignorados.
• Sua resposta deve ser única, não roube o código de outras pessoas, reduza alguns caracteres e repita-o.
• Ele deve ser capaz de executar em menos de 5 minutos, para os valores de 5 e 100. Também deve usar uma resolução de pelo menos 200 * 200 e colocar cada ponto em um local aleatório na tela usando uma distribuição não trivial.

Classificação atual

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

Se eu senti sua falta, sinto muito, basta adicionar um comentário ao seu trabalho dizendo isso e eu o adicionarei assim que o ver =)

TL; DR

• Entrada - Número de pontos (int, pode ser codificado)
• Saída - Imagem de pontos colocados aleatoriamente, todos conectados um ao outro (gráfico)
• Vencedor - Código mais curto

Matlab (22)

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

Supõe-se que n é o número de pontos e é assim para n = 10:

n=6:

Explicação

gploté um comando para plotar gráficos. O primeiro argumento é uma n x nmatriz de incidência (cheia de uns, obviamente). O segundo argumento deve ser uma n x 2matriz com as coordenadas dos pontos, mas não importa se a segunda dimensão é maior que 2, então eu apenas gero uma n x nmatriz de valores aleatórios (que é 2 caracteres menor que a geração de uma n x 2matriz).

Links para documentação

• gplot
• uns
• rand

Java: 318282 265

Porque, você sabe, 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();}}

É apenas um loop simples que cria pontos aleatórios e desenha linhas entre o ponto atual e todos os anteriores.

Exemplo com 25 pontos:

Com quebras de linha e importações:

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

Edit: Como não estamos contando as importações, importei mais algumas coisas para salvar alguns caracteres posteriormente.

Edit 2: OP adicionou uma permissão para o número de pontos codificados. -17 caracteres :)

Python 2-41 35

Depois de importar algumas bibliotecas conforme permitido para esse desafio

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 plotar algum número de pontos conectados com apenas uma linha de código:

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

(A captura de tela foi gerada com 10 pontos.)

Mathematica 95 87

Com alguma ajuda de belisarius.

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

n = 5

n = 100

Tempo: 2,082654 seg

Python 2, 158

Instruções de importação não incluídas na contagem de caracteres, conforme observado na pergunta ("as bibliotecas serão 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()

Saídas de amostra:

n = 2 (...):

n = 10 (parece coisa 3D chique ou algo assim):

n = 100 (parece que alguém foi BLELEEEAARARHHHH com uma caneta vermelha):

n = 500, 1000, 10000 (executado em cerca de 1,5 segundos, 5-6 segundos e 3,5 minutos, respectivamente):

Nota: os 10000 pontos um foram executados com uma versão ligeiramente otimizada que alterou a linha 3 (não incluindo importações) para isso:

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

Caso contrário, levaria uma eternidade. : P

Ungolfed:

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

Essa é uma trapaça na fronteira, mas ainda acho que está dentro das regras. Configure carregando o igraphpacote com library(igraph), que pode ser baixado do CRAN com install.packages("igraph"). Em seguida, atribua a entrada à variável N. De acordo com as regras, elas não são contadas no total.

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

N = 50

Observe que esse código também desenha auto-conexões. Eliminá-los (embora não haja regra contra eles) adiciona 6 caracteres:

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

R, 141

Esta é uma solução honesta para a bondade na 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]))

embora você ainda precise entrar Nmanualmente.

N = 50

Gostaria de saber se um forloop seria menos caracteres do que, applymas estou feliz com o que tenho.

QBasic ou 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

Variações de código

• Se você não deseja que uma semente seja solicitada, substitua RANDOMIZEpor RANDOMIZE TIMER.
• Se você desejar N, substitua N=10por INPUT Nou INPUT "N";N.

Execuções de amostra

Para N=5, testado com o QBasic 1.1 em execução no DOSBox 0.74:

Para N=100, testado com o QBasic 1.1 em execução no 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:

Exemplo de execução:

bash-4.3$ time ./line.sh 5

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

Saída de amostra:

Exemplo de execução:

bash-4.3$ time ./line.sh 25

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

Saída de amostra:

Exemplo de execução:

bash-4.3$ time ./line.sh 100

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

Saída de amostra:

TCL 161 chars

Claramente não vai ganhar, mas supera vários outros apresentados aqui, e acho que faz bom uso de uma linguagem altamente subvalorizada.

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

O tamanho da tela padrão no meu sistema parece ser 291x204. Não sei por que, mas usá-lo salva 13 caracteres.

Bastante rápido, 400 pontos em <5 segundos, 500 em ~ 10 s. O tamanho e os pontos podem ser escalados arbitrariamente e as cores e os estilos de linha podem ser alterados, ao custo dos caracteres, é claro. Sem golfe e usando variáveis ​​para torná-lo mais claro e fácil de dimensionar e colorir:

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

(Versão fixa atualizada)

"Importando" math.random como "r", primeiro, conforme permitido: r=math.random

Código atual:

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 nas calculadoras TI-Nspire (a TI adicionou scripts Lua aos sistemas operacionais recentes desta plataforma, com uma API uniforme que permite aos usuários criar gráficos etc., por exemplo.)
Ele também pode ser experimentado online aqui (basta apagar o script de demonstração e inclua o meu n=10por exemplo)

Formulários C # 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

Código completo é fornecido abaixo

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, graças à 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});}}}

Gostaria de dizer que eu poderia remover o Stroke = Brushed.Red. Mas, infelizmente, isso significa que estou pintando linhas transparentes, e acho que isso realmente não conta. : O PI também pode raspar alguns bytes apenas criando uma grade na exibição XAML. Mas isso parecia injusto, então tirei o XAML para se tornar uma tela em branco. (Não conto o 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

100

HPPPL, 231 220

(Linguagem de programação HP Prime para a calculadora gráfica em cores HP Prime)

jogou para baixo. 11 caracteres a menos, desenhando todas as novas linhas possíveis logo após cada nova criação de ponto. Apenas dois loops aninhados em vez dos três 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;

Sem Golfe (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;

exemplos:

c (10)

c (30)

A calculadora gráfica em cores HP Prime possui uma tela colorida de 320x240 pixels.

Um emulador que também funciona com o kit de conectividade está disponível no site da HP ou aqui: http://www.hp-prime.de/en/category/6-downloads

... ainda esperando o hardware chegar. Atualização sobre o tempo de execução seguirá.

Hoje meu HP Prime chegou. Aqui está o tempo de execução para n = 100 em uma calculadora real:

Cerca de 0,65 s para n = 100.

O emulador é cerca de 4 vezes mais rápido (cerca de 0,178 s) no meu laptop Core i5 2410M.

NetLogo, 51 bytes

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

Substitua 9s por outras constantes ou variáveis, conforme necessário.