Cerchio allineato, n punti

39

Traccia linee tra ogni coppia di punti distinti per npunti disposti in un cerchio, producendo qualcosa come il risultato qui sotto. Il codice più corto (in byte) vince! Le tue linee non devono essere trasparenti, ma sembrano migliori in questo modo. L'output deve essere una grafica vettoriale o essere un'immagine di almeno 600 pixel per 600 pixel (salvata su un file o visualizzata sullo schermo). Per completare la sfida devi pescare almeno 20.

inserisci qui la descrizione dell'immagine

code-golf  kolmogorov-complexity  graphical-output 
— J. Antonio Perez
fonte
7
Sarebbe bello se dovessi prendere un numero ne tracciare linee per npunti.
— Yodle,
2
Sono d'accordo con questa idea. Modificalo prima che qualcuno ottenga la prima risposta.
— shooqie,
2
@shooqie Quindi il titolo non avrebbe senso, a meno che non possa essere modificato dalle mod?
— Yodle,
2
Non penso che cambiare 37 in un arbitrario naggiungerebbe molto alla sfida poiché mi aspetto che la maggior parte delle soluzioni funzioni con qualsiasi numero, soprattutto perché 37 è dispari e quindi non ci sono simmetrie speculari.
— Laikoni,
3
Prendiamo ncome input o semplicemente selezioniamo un arbitrario noltre 20?
— R

Risposte:

26

Mathematica, 13 byte

CompleteGraph

allineati-up punti-cerchio-37-

Sembra che questo non riesca solo a dare un incorporamento circolare per n=4, ma la domanda afferman>=20

— ngenisis
fonte
1
... e stavo cercando di trovare il modo corretto di eseguire una funzione n(avevo la risposta pronta dal 37 fisso) :(
— Jonathan Allan,
6
@carusocomputing Questa funzione non ha nulla a che fare con la "rappresentazione grafica" nel senso della stampa. Mathematica è anche molto utile per i problemi di teoria dei grafi e avere un built-in per generare un grafico completo sembra la prima cosa che aggiungerei se aggiungessi il supporto per i grafici nella mia lingua. L'unico motivo per cui questa funzione risulta utile per questa sfida è che i grafici completi sono resi di default con tutti i vertici disposti in un cerchio.
— Martin Ender,
2
Se hai intenzione di supportare i grafici, è meglio avere una funzione grafica completa integrata, IMO.
— ngenisi,
2
@carusocomputing Benvenuto in Mathematica, il linguaggio che ha un built-in per ogni funzione esistente. :-P
— HyperNeutrino
1
Stavo scaricando NetLogo perché pensavo che "la multi-tartaruga renderà breve questo lavoro!" poi ti ricordasti che i matematici stanno usando la versione adulta.
— wyldstallyns,
13

MATL , 16 14 byte

Poiché non sono molto fluente con MATL, mi aspetto che questo sia un po 'più golfabile. (Sarebbe bello almeno battere Mathematica :-) Cioè il capovolgimento wnon è ottimale, probabilmente potrebbe essere evitato ...

:G/4*Jw^2Z^!XG

Provalo online! (Grazie @Suever per questo servizio, grazie @DrMcMoylex per -2 byte.)

Spiegazione (per N=3):

  :               Generate Range 1:input:       [1,2,3]
   G/             Divide By the first input     [0.333,0.666,1]
     4*           Multiply by 4                 [1.33,2.66,4.0]
       Jw^        i ^ (the result so far)       [-0.49+ 0.86i,-.5-0.86i,1.00]
                  (This results in a list of the n-th roots of unity)
          2Z^     Take the cartesian product with itself (i.e. generate all 2-tuples of those points)
             !XG  Transpose and plot

Vale la pena notare che per generare l'ennesima radice dell'unità è possibile utilizzare la formula exp(2*pi*i*k/N)per k=1,2,3,...,N. Ma dal momento exp(pi*i/2) = iche potresti anche scrivere i^(4*k/N)per k=1,2,3,...,Nquello che sto facendo qui.

— flawr
fonte
1
È possibile passare XH:Ha:G
— DJMcMayhem
1
Aaah, mi sono dimenticato Ggrazie mille!
— flawr
11

PICO-8 , 131 byte

Non ero davvero sicuro che avrei infranto le regole, ma l'ho fatto comunque!

golfed

p={}for i=0,19 do add(p,{64+64*cos(i/20),64+64*sin(i/20)})end for x in all(p)do for y in all(p)do line(x[1],x[2],y[1],y[2])end end

Ungolfed

points={}

for i=0,19 do 
  x=64+64*cos(i/20)
  y=64+64*sin(i/20)
  add(points,{x,y})
end

for x in all(points) do
  for y in all(points) do
    line(x[1],x[2],y[1],y[2])
  end
end

128x128 follia

PICO-8 è una console fantasy basata su Lua con una risoluzione nativa di 128x128. Ho fatto il cerchio più grande che potevo ...

— Tyler MacDonell
fonte
9

Mathematica, 42 byte

Crea un set di 37 punti disposti in un cerchio, quindi disegna linee tra tutti i possibili sottoinsiemi di due punti. Qualcuno ha pubblicato una risposta più breve che sfrutta CompleteGraph, ma credo che questa sia la più breve a parte quelle che si affidano a CompleteGraph.

Graphics@Line@Subsets[CirclePoints@37,{2}]

inserisci qui la descrizione dell'immagine

— J. Antonio Perez
fonte
3
Non è necessario evitare di disegnare linee da un punto a se stesso, quindi è possibile salvare 3 byte utilizzando Tuple. È inoltre necessario aggiornare questo per accettare arbitrari n, ma convenientemente che non ti costerà alcun byte.
— ngenisi,
1
Tuples
— Volevo
9

HTML + JS (ES6), 34 + 177 164 162 = 196 byte

Utilizzo dell'API HTML5 Canvas .

Guardalo su CodePen .

f=n=>{with(Math)with(c.getContext`2d`)for(translate(S=300,S),O=n;O--;)for(rotate(a=PI*2/n),N=n;N--;)beginPath(stroke()),lineTo(0,S),lineTo(sin(a*N)*S,cos(a*N)*S)}


/* Demo */
f(20)
<canvas id=c width=600 height=600>
Espandi frammento

-13 byte : rimosso closePath(), spostato stroke()all'internobeginPath()

-2 byte : variabile definita aall'internorotate()

— darrylyeo
fonte
8

Java, 346 338 322 301 byte

Questa soluzione funziona per tutti n>1, anche se il post originale non lo richiede, lo fa.

Il mio preferito è n=5, non chiedere perché, inoltre, se vuoi una GUI più interessante, usa:

int a=Math.min(this.getHeight(),this.getWidth())/2;

Al posto del 300 hardcoded, utilizzerà la larghezza o l'altezza del telaio come diametro.

Risparmiato 8 byte grazie a Shooqie. Risparmiato 21 byte grazie a Geobits.

import java.awt.*;void m(final int n){new Frame(){public void paint(Graphics g){Point[]p=new Point[n];int a=300;for(int i=1;i<n+1;i++){p[i-1]=new Point(a+(int)(a*Math.cos(i*2*Math.PI/n)),a+(int)(a*Math.sin(i*2*Math.PI/n)));for(int j=0;j<i;j++){g.drawLine(p[i-1].x,p[i-1].y,p[j].x,p[j].y);}}}}.show();}

Uscita per n=37:

inserisci qui la descrizione dell'immagine

— Urna di polpo magico
fonte
Puoi lasciar perdere Frame x=e final(penso?)
— shooqie
@shooqie oops, Frame xproveniva da un'altra soluzione che prevedeva un thread. È necessario il finale, poiché si tratta di un riferimento di classe interno a una variabile esterna nella classe proprietaria.
— Magic Octopus Urn
Funziona benissimo sulla mia macchina. A proposito, penso che puoi radere alcuni byte spostando le intdichiarazioni al di fuori dei forcircuiti
— shooqie,
@shooqie in Java 6 sta dicendo "Impossibile fare riferimento alla variabile locale non finale n in un ambito" al momento della compilazione.
— Magic Octopus Urn
Ha funzionato per me su Java 8, ma dopo aver modificato il tuo post ricevo solo una schermata bianca.
— shooqie,
7

Python 2, 258 235 229 byte

import itertools as T,math as M
from PIL import Image as I,ImageDraw as D
s=300
n=input()
t=2*M.pi/n
o=I.new('RGB',(s*2,)*2)
for x in T.combinations([(s*M.cos(t*i)+s,s*M.sin(t*i)+s)for i in range(n)],2):D.Draw(o).line(x)
o.show()

Uscita per n=37
n = 37

— asta
fonte
1
Non sarebbe from PIL import*più breve?
— Roman Gräf,
@ RomanGräf PIL è un pacchetto strano, non puoi import *, a seconda di come installi, puoi saltare il PIL e importare direttamente Image / ImageDraw
— Rod
6

Ottava, 88 69 byte

N=input('');t=0:2*pi/N:N;k=nchoosek(1:N,2)';line(cos(t)(k),sin(t)(k))

Uscita per N=37:

inserisci qui la descrizione dell'immagine

Uscita per N=19:

inserisci qui la descrizione dell'immagine

— Stewie Griffin
fonte
Oh, non ho nemmeno notato che c'era già un'altra risposta per Octave :)
— flawr
Comunque, battiti ya :-)
— flawr
Di un miglio! Anche il mio primo pensiero è stato gplot, ma non sono riuscito a renderlo abbastanza breve ...
— Stewie Griffin,
6

Perl, 229 byte

Utilizza la stessa formula della maggior parte dei linguaggi che non hanno una soluzione conveniente per questa sfida (anche se non li ho guardati per trovarla, ma è una formula abbastanza facile da trovare). Quindi non molto interessante, ma di solito non ci sono molte risposte del Perl a questo tipo di sfide, quindi volevo solo proporne una.

$i=new Imager xsize=>700,ysize=>700;for$x(1..$_){for$y(1..$_){$i->line(color=>red,x1=>350+300*cos($a=2*pi*$x/$_),x2=>350+300*cos($b=2*pi*$y/$_),y1=>350+300*sin$a,y2=>350+300*sin$b)}}$i->write(file=>"t.png")

E avrai bisogno di -MImager(9 byte), -MMath::Trig(fornire pi, 13 byte) e -n(1 byte) ==> + 23 byte.

Per eseguirlo:

perl -MImager -MMath::Trig -ne '$i=new Imager xsize=>700,ysize=>700;for$x(1..$_){for$y(1..$_){$i->line(color=>red,x1=>350+300*cos($a=2*pi*$x/$_),x2=>350+300*cos($b=2*pi*$y/$_),y1=>350+300*sin$a,y2=>350+300*sin$b)}}$i->write(file=>"t.png")' <<< 27

Creerà un file denominato t.pngche contiene l'immagine.

Dovrai installarlo Imagerperò, ma non preoccuparti, è abbastanza facile:

(echo y;echo) | perl -MCPAN -e 'install Imager'

(Gli echos configureranno il tuo cpan se non l'hai mai usato prima (in realtà funzionerà solo se il tuo perl è abbastanza recente, penso che per molti di voi lo sarà, e mi dispiace per gli altri!)) .

E la versione più leggibile (sì, è abbastanza leggibile per uno script Perl!):

#!/usr/bin/perl -n
use Imager;
use Math::Trig;
$i=Imager->new(xsize=>700,ysize=>700);
for $x (1..$_){
    for $y (1..$_){
    $i->line(color=>red,x1=>350+300*cos($a=2*pi*$x/$_), x2=>350+300*cos($b=2*pi*$y/$_),
         y1=>350+300*sin($a), y2=>350+300*sin($b));
    }
}
$i->write(file=>"t.png");

inserisci qui la descrizione dell'immagine

-1 byte grazie a Titus.

— Dada
fonte
Perl richiede parentesi graffe attorno a singoli comandi?
— Tito
@Titus Se fai riferimento alle parentesi graffe dopo i forloop, allora sì, sono obbligatorie.
— Dada,
C'è un vuoto prima y2. Scommetto che non ti serve. E puoi scrivere a STDOUT?
— Tito
@Titus hmm davvero, grazie. Penso che il mio terminale abbia messo una nuova riga qui, quindi non ho visto lo spazio.
— Dada,
5

GeoGebra , 92 byte

a=polygon((0,0),(1,0),20)
sequence(sequence(segment(vertex(a,i),vertex(a,j)),j,1,20),i,1,20)

Ogni riga viene inserita separatamente nella barra di input. Ecco una gif che mostra l'esecuzione:

Esecuzione

Come funziona

Il polygoncomando crea un poligono a 20 facce, con i vertici della linea di base su (0,0)e (1,0). Il comando successivo quindi scorre su ogni vertice del poligono con indice i, usando i comandi sequencee vertex, e per ogni vertice con indice i, disegna un segmento di linea su ogni altro vertice con indice jusando il segmentcomando.

— TheBikingViking
fonte
4

PHP, 186 184 196 byte

imagecolorallocate($i=imagecreate(601,601),~0,~0,~0);for(;$a<$p=2*M_PI;)for($b=$a+=$p/=$argv[1];$b>0;)imageline($i,(1+cos($a))*$r=300,$r+$r*sin($a),$r+$r*cos($b-=$p),$r+$r*sin($b),1);imagepng($i);

scrive l'immagine su STDOUT

abbattersi

// create image with white background
imagecolorallocate($i=imagecreate(601,601),~0,~0,~0);

// loop angle A from 0 to 2*PI
for(;$a<$p=2*M_PI;)
    // loop angle B from A down to 0
    for($b=$a+=$p/=$argv[1];$b;)    // ($a pre-increment)
        // draw black line from A to B
        imageline($i,                           // draw line
            (1+cos($a))*$r=300,$r+$r*sin($a),   // from A
            $r+$r*cos($b-=$p),$r+$r*sin($b),    // to B ($b pre-decrement)
            1                                   // undefined color=black
        );
// output
imagepng($i);

-12 byte per fisso n=20

Sostituisci $p=2*M_PIcon 6(-8), /=$argv[1]con =M_PI/10(-2) e $b>0con $b(-2)

L'uso esatto di PI / 10 non fa male. Con .3142, gli errori di arrotondamento dalla versione parametrizzata sono rimasti, ma con M_PI/10essi sono svaniti e posso controllare $b(<> 0) invece di $b>0. Avrei potuto salvare due byte con .314, ma ciò avrebbe compensato i punti.

Il limite $a<6è sufficientemente esatto per 20 punti.

grafico PI esatto

174 byte per fisso n=314

imagecolorallocate($i=imagecreate(601,601),~0,~0,~0);for(;$a<314;)for($b=$a++;$b--;)imageline($i,(1+cos($a))*$r=300,$r+$r*sin($a),$r+$r*cos($b),$r+$r*sin($b),1);imagepng($i);

Usando 314 punti si ottiene un cerchio pieno in quella risoluzione (così come 136.140, ogni numero pari sopra quello e tutto sopra 317).

— Titus
fonte
1
Buona risposta, ma sembra che tu abbia codificato 20 invece di prenderlo come input?
— Riking
1
@Riking: True. Ma non vedo alcuna richiesta nella sfida di parametrizzarla.
— Tito
4

R, 127 123 byte

plot((e=cbind(sin(t<-seq(0,2*pi,l=(n=21)))*2,cos(t)*2)));for(i in 2:n)for(j in 1:i)lines(c(e[i,1],e[j,1]),c(e[i,2],e[j,2]))

Produce:

Le etichette dell'asse piacevole eh?

-4 byte grazie a @Titus!

— Frédéric
fonte
1
Non più corto, ma potrebbe essere più veloce con for(i in 2:n){for(j in 1:i)...}. Non Rrichiede le parentesi graffe?
— Tito
@Titus Hai ragione! E no, non sono necessarie parentesi graffe lì. Grazie !
— Frédéric,
3

BBC BASIC, 98 caratteri ASCII

Dimensione file con token 86 byte

r=600V.5142;29,r;r;:I.n:t=2*PI/n:F.i=1TOn*n:a=i DIVn*t:b=i MODn*t:L.r*SINa,r*COSa,r*SINb,r*COSb:N.

Scarica l'interprete su http://www.bbcbasic.co.uk/bbcwin/bbcwin.html

Non c'è niente di sbagliato nel disegnare ogni linea due volte, l'aspetto è identico :-P

Ungolfed

  r=600                              :REM Radius 600 units. 2 units per pixel, so 300 pixels
  VDU5142;29,r;r;                    :REM Set mode 20 (600 pixels high) and move origin away from screen corner
  INPUTn                             :REM Take input.
  t=2*PI/n                           :REM Step size in radians.
  FORi=1TOn*n                        :REM Iterate through all combinations.
    a=i DIVn*t                       :REM Get two angles a and b
    b=i MODn*t                       :REM by integer division and modlo
    LINEr*SINa,r*COSa,r*SINb,r*COSb  :REM calculate cartesian coordinates and draw line
  NEXT

Uscita n = 21

Sembra molto meglio nel rendering originale che nel browser.

<code> inserisci qui la descrizione dell'immagine </code>

— Level River St
fonte
Grazie per avermi ricordato della LINEfunzione. Batte DRAW...
— Steenbergh,
3

Ottava, 50 48 46 45 byte

@(N)gplot((k=0:2*pi/N:N)+k',[cos(k);sin(k)]')

Questa è una funzione qualunque che traccia il grafico che stiamo cercando.

Spiegazione:

(k=0:2*pi/N:N)+k'N+1 x N+1Crea una matrice di adozione completa e definisce contemporaneamente il vettore kdegli angoli, per il quale utilizziamo quindi [cos(k);sin(k)]', una matrice di coordinate in cui è posizionato ciascun nodo del grafico. gplottraccia semplicemente il grafico che vogliamo.

Per N = 29noi otteniamo:

inserisci qui la descrizione dell'immagine

— flawr
fonte
2

JavaScript (ES5) / SVG (HTML5), 181 byte

document.write('<svg viewBox=-1e3,-1e3,2e3,2e3><path stroke=#000 fill=none d=M1e3,0')
with(Math)for(i=37;--i;)for(j=37;j--;)document.write('L'+1e3*cos(a=i*j*PI*2/37)+','+1e3*sin(a))
Espandi frammento

Funziona solo con numeri primi, come il suggerimento originale di 37. È possibile dimezzare (arrotondando per eccesso) il valore iniziale di iper ottenere un'immagine più debole. Puoi anche regolare costantemente gli 1e3,2e3altri valori a piacere (ho iniziato con 300,600ma ho deciso che era troppo grossolano).

— Neil
fonte
2

MATLAB, 36 byte

@(n)plot(graph(ones(n),'Om'),'La','c')

Questa è una funzione anaudita che crea la trama.

@(n)                                     Define an anonymous fuction of 𝘯
               ones(n)                   Create an 𝘯×𝘯 matrix of ones
         graph(       ,'Om')             Create a graph object with that adjacency
                                         matrix, omitting self-loops
    plot(                   ,'La','c')   Plot the graph with a circular layout

Esempio:

inserisci qui la descrizione dell'immagine

inserisci qui la descrizione dell'immagine

— Luis Mendo
fonte
Sono sorpreso che graphnon faccia parte della cassetta degli attrezzi bioinformatica ... non sapevo nemmeno che esistesse ... Bello :)
— Stewie Griffin,
1

QBasic 4.5, 398 271 byte

CLS:SCREEN 11:DEFSTR M-Z:DEFDBL A-L
INPUT"N",A:I=(360/A)*.0175:J=230
Q=",":FOR E=0 TO A
FOR F=E TO A
M=x$(COS(I*E)*J+J):N=x$(SIN(I*E)*J+J):O=x$(COS(I*F)*J+J):P=x$(SIN(I*F)*J+J):DRAW "BM"+M+Q+N+"M"+O+Q+P
NEXT:NEXT
FUNCTION x$(d):x$=LTRIM$(STR$(CINT(d))):END FUNCTION

Lo schermo in QBasic può essere solo 640x480, quindi il cerchio ha un raggio di soli 230 px, sfortunatamente. Inoltre, ci sono alcuni artefatti a causa della perdita di precisione float-to-int. Assomiglia a questo per N=36: inserisci qui la descrizione dell'immagine

EDIT: non avevo bisogno dell'archiviazione, della dichiarazione del tipo e di tutti i cicli. Il calcolo di tutti i cartesiani dalle polari in atto è più economico del 50% nel conteggio dei byte ...

— steenbergh
fonte
1

QBIC , 98 94 byte

$SCREEN 11|:i=6.3/a j=230[0,a|[b,a|line(cos(b*i)*j+j,sin(b*i)*j+j)-(cos(c*i)*j+j,sin(c*o)*j+j)

Ho convertito la mia risposta QBasic originale alla risposta di @LevelRiverSt in QBIC. Ho pensato che questo sarebbe dipeso troppo dalle funzioni che non sono integrate in QBIC per essere fattibile, ma a quanto pare, salva altri 90 byte. La sostituzione di DRAWper LINEconsente di risparmiare altri 80 byte. Sapevo di dimenticare qualcosa di semplice ...

Quando eseguito con un parametro della riga di comando di 36, è simile al seguente:

inserisci qui la descrizione dell'immagine

— steenbergh
fonte
1

Elaborazione, 274 byte (239 + sizechiamata e chiamata di funzione)

void d(int s){float a=2*PI/s,x=0,y=-400,m,n;float[][]p=new float[2][s];translate(400,400);for(int i=0;i<s;i++){m=x*cos(a)-y*sin(a);n=x*sin(a)+y*cos(a);x=m;y=n;p[0][i]=x;p[1][i]=y;for(int j=0;j<i;j++)line(p[0][j],p[1][j],p[0][i],p[1][i]);}}
void setup(){size(800,800);d(50);}

Onestamente non so perché, ma dovevo setupessere in seconda linea. Ho usato https://en.wikipedia.org/wiki/Rotation_matrix per aiutarmi a calcolare i calcoli matematici per la rotazione. Questo programma calcola i punti e li spinge in un array, con il quale stiamo usando per disegnare le linee.

Ecco l'immagine di un poligono con 50 spigoli (quello a 100 spigoli era quasi completamente nero)

50 punti

È possibile aggiungere stroke(0,alpha);per avere bordi trasparenti, dov'è alphal'opacità della linea. Ecco lo stesso poligono di alphaof 20.

inserisci qui la descrizione dell'immagine

— Kritixi Lithos
fonte
1

Bash + Jelly + GraphViz, 52 caratteri, 52 o 63 byte

Dato che i programmi in questione non sono d'accordo su quale codifica dei caratteri utilizzare, il programma è pieno di caratteri di controllo. Ecco come appare sotto xxd, nella codifica Latin-1 (che rappresenta ogni carattere in un byte):

00000000: 6a65 6c6c 7920 6520 2793 5213 636a 0c8e  jelly e '.R.cj..
00000010: 2d2d 59fe 9a3f 1d15 dc65 34d3 8442 7f05  --Y..?...e4..B..
00000020: 1172 80cf fb3b ff7d 277c 6369 7263 6f20  .r...;.}'|circo 
00000030: 2d54 7073                                -Tps

In realtà non sono riuscito a far funzionare il programma, senza convertire l'input in UTF-8 per qualche motivo (il che lo renderebbe lungo 63 byte). Logicamente dovrebbe funzionare come Latin-1 - nessuno dei caratteri è al di fuori dell'intervallo da 0 a 255 - ma continuo a ricevere errori "indice stringa fuori intervallo", indipendentemente da come configuro le variabili di ambiente di codifica dei caratteri. Quindi questo dovrà essere conteggiato come 63 byte a meno che qualcuno non riesca a trovare un modo per eseguirlo senza ricodificarlo.

Il programma potrebbe essere leggermente più leggibile se lo interpretiamo nella codifica di Jelly:

jelly e 'ƓRŒcj€⁾--Y“Ȥ?øßṇe4ạ⁴B¶¦×r°Ẇ»;”}'|circo -Tps

Il programma prende il numero di punti sull'input standard e genera un'immagine PostScript sull'output standard. (Può essere banalmente adattato all'output in qualsiasi formato supportato da GraphViz cambiando il -Tpsalla fine; è solo che PostScript ha il nome più breve. Probabilmente, puoi salvare cinque caratteri rimuovendo il -Tps, ma poi ottieni l'output nel formato di immagine interno di GraphViz che nient'altro supporta, che probabilmente non conta ai fini della domanda.)

Fondamentalmente, questo è solo un programma Jelly che chiama GraphViz per fare il disegno; tuttavia, Jelly non sembra avere alcuna capacità per eseguire programmi esterni, quindi ho dovuto usare bash per collegarli insieme. (Ciò significa anche che è più economico fare in modo che Jelly richieda l'input manualmente da stdin; normalmente richiede input dalla riga di comando, ma ciò significherebbe byte extra nel wrapper bash.) circoSistemerà automaticamente tutti i punti che viene chiesto di disegnare in un cerchio , quindi il codice Jelly deve solo chiedergli di disegnare un elenco di punti, tutti collegati tra loro. Ecco come funziona:

ƓRŒcj€⁾--Y“Ȥ?øßṇe4ạ⁴B¶¦×r°Ẇ»;”}
Ɠ                               read number from stdin
 R                              produce range from 1 to that number
                                (here used to produce a list with
                                that many distinct elements)
  Œc                            select all unordered pairs from that
      ⁾--                       a string consisting of two hyphens
    j€                          join each pair via the string
         Y                      join on newlines
                            ;   prepend (in this context)
          “Ȥ?øßṇe4ạ⁴B¶¦×r°Ẇ»    "graph{node[shape=point]"
                             ”} follow output with a "}" character

L'uso di Jelly ci consente di comprimere leggermente la stringa che configura l'output di GraphViz tramite il suo dizionario integrato. Il dizionario ha graph, nodee point. Stranamente, non ha shape(ha SHAPE, ma GraphViz fa distinzione tra maiuscole e minuscole), quindi dobbiamo codificare quel carattere per carattere.

Ecco l'output per input 21 (con una leggera modifica al programma per renderlo output in un formato che può essere caricato su Stack Exchange):

grafico completo su 21 punti

0

PHP + HTML SVG, 316 263 byte

Versione golfizzata con npunti hardcoded e nessun nparametro di input :

<svg height="610" width="610"><?for($i=1;$i<33;$i++){$x[]=300*sin(2*M_PI/32*$i)+305;$y[]=300*cos(2*M_PI/32)+305;}foreach($x as$j=>$w){foreach($y as$k=>$z){echo'<line x1="'.$x[$j].'" y1="'.$y[$j].'" x2="'.$x[$k].'" y2="'.$y[$k].'" style="stroke:red;"/>';}}?></svg>

Versione precedente giocata a golf con parametro di input per npunti, 316 byte:

<svg height="610" width="610"><?$n=$_GET[n];$d=2*M_PI/$n;$r=300;$o=305;for($i=1;$i<=$n;$i++){$x[]=$r*sin($d*$i)+$o;$y[]=$r*cos($d*$i)+$o;}foreach($x as$j=>$w){foreach($y as$k=>$z){echo'<line x1="'.$x[$j].'" y1="'.$y[$j].'" x2="'.$x[$k].'" y2="'.$y[$k].'" style="stroke:rgba(0,0,0,.15);stroke-width:1;" />';}}?></svg>

Utilizzo: salva in un file e chiama dal browser: 

http://localhost/codegolf/circle.php?n=32

Versione non golfata con parametro di input per npunti e CSS:

<style>
line {
    stroke: rgba(0,0,0,.15);
    stroke-width:1;
}
</style>
<svg height="610" width="610">
<?php
$n=$_GET[n]; // number of points
$d=2*M_PI/$n; // circle parts
$r=300; // circle radius
$o=305; // offset x,y
for ($i=1;$i<=$n;$i++){
    $x[]=$r*sin($d*$i)+$o; // store x,y coordinates in array
    $y[]=$r*cos($d*$i)+$o;
}
foreach($x as $j => $w){ // iterate all x,y points and connect to each other
    foreach($y as $k => $z) {
        echo '<line x1="'.$x[$j].'" y1="'.$y[$j].'" x2="'.$x[$k].'" y2="'.$y[$k].'" />'."\n";   
    }
}
?>
</svg>

Impossibile allegare uno snippet completamente funzionale a 32 punti a causa del limite di 30k caratteri per un singolo post. Ecco uno screenshot:

inserisci qui la descrizione dell'immagine

Lo snippet allegato è limitato a 18 punti a causa del limite di 30k per posta singola.

Mostra snippet di codice

— Mario
fonte
0

R, 108 byte

plot(x<-cos(t<-seq(0,2*pi,l=21)),y<-sin(t),as=1);apply(expand.grid(1:21,1:21),1,function(e)lines(x[e],y[e]))

Potrei radere 5 byte se mi sbarazzassi dell'argomento ,as=1che forza un rapporto di aspetto di 1. Usa expand.gridper creare una matrice con tutte le possibili coppie di punti e usa applyper farla passare.

N = 21

R + igraph, 87 byte

Un'altra soluzione che utilizza il pacchetto igraph.

library(igraph);plot(make_full_graph(21),layout=cbind(cos(t<-seq(0,2*pi,l=21)),sin(t)))

N = 21

— plannapus
fonte
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.