L'obiettivo

Questa è un'attività di codifica piuttosto semplice, tutto ciò che il tuo programma deve fare è posizionare un punto su una tela (o la tua alternativa in un altro linguaggio di codifica) e collegarlo a tutti i punti già posizionati. Il programma deve contenere un input, il numero di punti da posizionare e produrre una sorta di display con i punti collegati. Esempio

Requisiti

• Devo essere in grado di eseguirlo, il che significa che deve avere un compilatore / strumento per eseguirlo online o disponibile pubblicamente per il download.
• È consentito utilizzare qualsiasi libreria creata prima dell'impostazione di questa sfida, purché non sia stata progettata al solo scopo di risolverlo.
• Questa è un'attività di codice più breve, che significa caratteri. Commenti, codice che cambia colore (per la bellezza) e librerie verranno ignorati.
• La tua risposta deve essere unica, non rubare il codice di altre persone, accorciarlo di alcuni caratteri e ripubblicarlo.
• Deve essere in grado di funzionare in meno di 5 minuti, per i valori di 5 e 100. Deve inoltre utilizzare una risoluzione di almeno 200 * 200 e posizionare ciascun punto in una posizione casuale sulla tela utilizzando una distribuzione non banale.

Classifica attuale

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 mi sei mancato, mi dispiace molto, basta aggiungere un commento al tuo lavoro dicendo così e lo aggiungerò non appena lo vedo =)

TL; DR

• Input - Numero di punti (int, può essere hard coded)
• Output - Immagine di punti posizionati casualmente, tutti collegati tra loro (grafico)
• Vincitore: il codice più breve

Matlab (22)

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

Si presume che n sia il numero di punti e si presenta così per n = 10:

n=6:

spiegazione

gplotè un comando per tracciare grafici. Il primo argomento è una n x nmatrice di incidenza (piena di quelli, ovviamente). Il secondo argomento dovrebbe essere una n x 2matrice con le coordinate dei punti, ma non importa se la seconda dimensione è maggiore di 2, quindi ho appena generato una n x nmatrice di valori casuali (che è più corta di 2 caratteri rispetto alla generazione di una n x 2matrice).

Collegamenti alla documentazione

• gplot
• quelli
• rand

Java: 318282 265

Perché, sai, 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();}}

È solo un semplice ciclo che crea punti casuali e traccia linee tra il punto corrente e tutti quelli precedenti.

Esempio con 25 punti:

Con interruzioni di riga e importazioni:

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

Modifica: dal momento che non stiamo contando le importazioni, ho importato un paio di cose in più per salvare alcuni personaggi in seguito.

Modifica 2: OP ha aggiunto un margine per il numero di punti hardcoding. -17 caratteri :)

Python 2-41 35

Dopo aver importato alcune librerie come consentito per questa sfida

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

possiamo tracciare un numero di punti collegati con una sola riga di codice:

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

(Lo screenshot è stato generato con 10 punti.)

Mathematica 95 87

Con l'aiuto di Belisarius.

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

n = 5

n = 100

Tempi: 2.082654 sec

Python 2, 158

Dichiarazioni di importazione non incluse nel conteggio dei caratteri, come indicato nella domanda ("le librerie verranno ignorate").

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

Output di esempio:

n = 2 (...):

n = 10 (sembra qualcosa di fantasia 3d o qualcosa del genere):

n = 100 (sembra che qualcuno sia andato BLELEEEAARARGHHH con una penna rossa):

n = 500, 1000, 10000 (funziona rispettivamente in circa 1,5 secondi, 5-6 secondi e 3,5 minuti):

Nota: i 10000 punti uno è stato eseguito con una versione leggermente ottimizzata che ha cambiato la linea 3 (escluse le importazioni) in questo:

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

Altrimenti ci sarebbe voluto per sempre. : 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

Questo è un imbroglio borderline ma penso ancora che rientri nelle regole. Configurare caricando il igraphpacchetto con library(igraph), che può essere scaricato da CRAN con install.packages("igraph"). Quindi assegnare l'input alla variabile N. Secondo le regole, queste non sono conteggiate nel totale.

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

N = 50

Si noti che questo codice disegna anche le auto-connessioni. Eliminandoli (anche se non ci sono regole contro di loro) si aggiungono 6 caratteri:

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

R, 141

Questa è una soluzione onesta per la bontà nella 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]))

anche se devi ancora entrare Na mano.

N = 50

Mi chiedo se un forloop sarebbe composto da meno personaggi rispetto a applyma sono contento di quello che ho.

QBasic o QuickBasic, 130 caratteri

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

Variazioni del codice

• Se non si desidera che venga richiesto un seme, sostituirlo RANDOMIZEcon RANDOMIZE TIMER.
• Se si desidera che venga richiesto N, sostituirlo N=10con INPUT No INPUT "N";N.

Esecuzioni campione

Per N=5, testato con QBasic 1.1 in esecuzione su DOSBox 0.74:

Per N=100, testato con QBasic 1.1 in esecuzione su DOSBox 0.74:

Bash + ImageMagick: 148 caratteri

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:

Esecuzione di esempio:

bash-4.3$ time ./line.sh 5

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

Uscita campione:

Esecuzione di esempio:

bash-4.3$ time ./line.sh 25

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

Uscita campione:

Esecuzione di esempio:

bash-4.3$ time ./line.sh 100

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

Uscita campione:

TCL 161 caratteri

Chiaramente non vincerà, ma batte molti altri qui presentati, e penso che faccia buon uso di un linguaggio altamente sottovalutato.

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

La dimensione di tela predefinita sul mio sistema sembra essere 291x204. Non so perché, ma usandolo salva 13 caratteri.

Abbastanza veloce, 400 punti in <5 secondi, 500 in ~ 10 s. Dimensioni e punti possono essere ridimensionati in modo arbitrario e i colori e gli stili di linea possono essere modificati, ovviamente a spese dei personaggi. Non golfato e utilizzo di variabili per rendere più chiaro e facile ridimensionare e colorare:

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

(Versione fissa aggiornata)

"Importazione" math.random come "r", innanzitutto, come consentito: r=math.random

Codice reale:

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: questo codice funziona sui calcolatori TI-Nspire (TI ha aggiunto gli script Lua ai recenti sistemi operativi di questa piattaforma, con un'API basata su pari che consente agli utenti di rappresentare graficamente cose ecc., Ad esempio.)
Può anche essere provato online qui (basta cancellare lo script demo e anteporre il mio con n=10ad esempio)

Moduli Windows C #, 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

Di seguito è riportato il codice completo

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

Vorrei dire che potrei rimuovere Stroke = Brushed.Red. Ma purtroppo questo significa che sto dipingendo linee trasparenti, e la mia ipotesi è che non conterebbe davvero. : PI può anche radere un paio di byte semplicemente creando una griglia nella vista XAML. Ma ciò sembrava ingiusto, quindi ho spogliato la XAML per diventare una tela bianca. (Non conto XAML come byte ...)

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

(Linguaggio di programmazione HP Prime per la calcolatrice grafica a colori HP Prime)

lo golfò. 11 caratteri in meno disegnando tutte le possibili nuove linee subito dopo ogni nuova creazione di punti. Solo due loop nidificati anziché i tre precedenti.

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;

Ungolfed (270 caratteri):

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;

esempi:

c (10)

c (30)

La calcolatrice grafica a colori HP Prime ha un display a colori da 320x240 pixel.

Un emulatore che funziona anche con il kit di connettività è disponibile sul sito Web HP o qui: http://www.hp-prime.de/en/category/6-downloads

... sto ancora aspettando che arrivi l'hardware. Seguirà l'aggiornamento sul tempo di esecuzione.

Oggi è arrivato il mio HP Prime. Ecco il tempo di esecuzione per n = 100 su un calcolatore effettivo:

Circa 0,65 s per n = 100.

L'emulatore è circa 4 volte più veloce (circa 0,178 s) sul mio laptop Core i5 2410M.

NetLogo, 51 byte

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

Sostituisci 9s con altre costanti o variabili secondo necessità.