सर्कल, एन अंक ऊपर लाइन में खड़ा

39

nएक सर्कल में व्यवस्थित किए गए बिंदुओं के लिए अलग-अलग बिंदुओं की प्रत्येक जोड़ी के बीच की रेखाएं बनाएं , जो नीचे दिए गए परिणाम की तरह कुछ का निर्माण करते हैं। सबसे छोटा कोड (बाइट्स में) जीतता है! आपकी लाइनों को पारदर्शी होने की ज़रूरत नहीं है, लेकिन यह इस तरह से बेहतर है। आउटपुट एक वेक्टर ग्राफ़िक होना चाहिए, या 600 पिक्सेल (या तो फ़ाइल में सहेजा गया या स्क्रीन पर प्रदर्शित) द्वारा कम से कम 600 पिक्सेल की छवि होनी चाहिए। चुनौती को पूरा करने के लिए आपको कम से कम 20 ड्रा करना होगा।

यहाँ छवि विवरण दर्ज करें

code-golf  kolmogorov-complexity  graphical-output 
— जे। एंटोनियो पेरेज़
स्रोत
7
यदि आपको एक संख्या में लेना है nऔर nबिंदुओं के लिए रेखाएँ खींचनी हैं तो यह अच्छा होगा ।
— योडल
2
मैं यह विचार दूसरा। किसी को पहला जवाब मिलने से पहले इसे बदल दें।
— शौकी
2
@shooie तब शीर्षक तब तक समझ में नहीं आएगा, जब तक कि मॉड द्वारा संपादित नहीं किया जा सकता है?
— योदले
2
मुझे नहीं लगता कि 37 को मनमाने ढंग से बदलने nसे चुनौती बहुत बढ़ जाएगी क्योंकि मुझे उम्मीद है कि किसी भी संख्या के साथ काम करने के लिए सबसे अधिक समाधान होगा, खासकर क्योंकि 37 विषम है और इसलिए कोई दर्पण समरूपता नहीं है।
— लकोनी
3
क्या हम nइनपुट के रूप में लेते हैं या सिर्फ n20 से अधिक की मनमानी करते हैं?
— R

जवाबों:

26

गणितज्ञ, १३ बाइट्स

CompleteGraph

लाइन-अप सर्कल-37-अंक

ऐसा लगता है कि इसके लिए केवल एक परिपत्र एम्बेड देने में विफल रहता है n=4, लेकिन प्रश्न कहता हैn>=20

— ngenisis
स्रोत
1
... और मुझे लेने के लिए एक समारोह बनाने का सही तरीका खोजने की कोशिश कर nरहा था (मेरे पास तय 37 से जवाब तैयार था) :(
— जोनाथन एलन
6
@carusocomputing इस फ़ंक्शन का प्लॉटिंग के अर्थ में "ग्राफिंग" से कोई लेना-देना नहीं है। मैथमैटिका ग्राफ सिद्धांत की समस्याओं के लिए भी बहुत अच्छा है और एक पूर्ण ग्राफ बनाने के लिए बिल्ट-इन होने से ऐसा लगता है कि अगर मैं अपनी भाषा में ग्राफ़ के लिए समर्थन जोड़ देता हूं तो पहली चीज़ मैं जोड़ दूंगा। इस चुनौती के लिए उपयोगी होने के लिए एकमात्र कारण यह है कि पूर्ण रेखांकन डिफ़ॉल्ट रूप से एक सर्कल में व्यवस्थित सभी कोने के साथ प्रदान किया गया है।
— मार्टिन एंडर
2
यदि आप ग्राफ़ का समर्थन करने जा रहे हैं, तो आपके पास बेहतर पूर्ण ग्राफ़ फ़ंक्शन, IMO है।
— ngenisis
2
@carusocomputing Mathematica में आपका स्वागत है, वह भाषा जिसमें हर मौजूदा फ़ंक्शन के लिए अंतर्निहित है। :-P
— हाइपरनेट्रोइनो
1
मैं नेटलोगो को डाउनलोड कर रहा था क्योंकि मुझे लगा कि "मल्टी-टर्टल इस का छोटा काम बना देगा!" तब आपको याद आया कि गणितज्ञ बड़े हो चुके संस्करण का उपयोग कर रहे हैं।
— wyldstallyns
13

MATL , 16 14 बाइट्स

जैसा कि मैं MATL के साथ बहुत धाराप्रवाह नहीं हूं, मुझे उम्मीद है कि यह कुछ हद तक गोल्फ है। (कम से कम मातमटिका को हराकर अच्छा लगेगा :-) I फ्लिप फ्लिप wइष्टतम नहीं है, इसे शायद टाला जा सकता है ...

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

इसे ऑनलाइन टेस्ट करें! (इस सेवा के लिए @ @ धन्यवाद, -2 बाइट्स के लिए @DrMcMoylex धन्यवाद।)

स्पष्टीकरण (के लिए 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

यह ध्यान देने योग्य है कि एन-वें एकता की जड़ों पैदा करने के लिए आप सूत्र का उपयोग कर सकते हैं लायक है exp(2*pi*i*k/N)के लिए k=1,2,3,...,N। लेकिन चूंकि exp(pi*i/2) = iआप भी लिख सकता है i^(4*k/N)के लिए k=1,2,3,...,Nजो मैं यहाँ क्या कर रहा है।

— flawr
स्रोत
1
आप बदल सकते हैं XH:Hकरने के लिए:G
— DJMcMayhem
1
आआहह मैं Gआपका शुक्रिया अदा करना भूल गया !
— दोष
11

PICO-8 , 131 बाइट्स

मुझे वास्तव में यकीन नहीं था कि मैं कोई नियम तोड़ूंगा, लेकिन मैंने इसे वैसे भी किया!

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 पागलपन

PICO-8 एक Lua आधारित फंतासी कंसोल है जिसका मूल रिज़ॉल्यूशन 128x128 है। मैंने जितना बड़ा सर्कल बनाया उतना ही ...

— टायलर मैकडोनेल
स्रोत
9

गणितज्ञ, 42 बाइट्स

एक सर्कल में व्यवस्थित 37 बिंदुओं का एक सेट बनाता है, और फिर दो बिंदुओं के सभी संभावित सबसेट के बीच लाइनें खींचता है। किसी ने एक छोटा सा जवाब पोस्ट किया जो कि FullGraph का लाभ उठाता है, लेकिन मेरा मानना ​​है कि यह FullGraph पर भरोसा करने वालों की तुलना में सबसे छोटा है।

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

यहाँ छवि विवरण दर्ज करें

— जे। एंटोनियो पेरेज़
स्रोत
3
एक बिंदु से खुद को रेखाओं से बचने की कोई आवश्यकता नहीं है, इसलिए आप 3 बाइट्स का उपयोग करके बचा सकते हैं Tuple। आपको मनमाने ढंग से स्वीकार करने के लिए इसे अपडेट करने की भी आवश्यकता है n, लेकिन आसानी से आपको किसी भी बाइट का खर्च नहीं करना पड़ेगा।
— ngenisis
1
कहने का मतलब हैTuples
— ngenisis
9

HTML + JS (ES6), 34 + 177 164 162 = 196 बाइट्स

एचटीएमएल 5 कैनवस एपीआई का उपयोग करना ।

इसे 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>
स्निपेट का विस्तार करें

-13 बाइट्स : हटाया closePath(), stroke()अंदर ले जाया गयाbeginPath()

-2 बाइट्स : aअंदर परिभाषित चरrotate()

— darrylyeo
स्रोत
8

जावा, 346 338 322 301 बाइट्स

यह समाधान सभी के लिए काम करता है n>1, भले ही मूल पद की आवश्यकता न हो, लेकिन यह करता है।

मेरा पसंदीदा है n=5, यह न पूछें कि, यदि आप कूलर GUI का उपयोग करना चाहते हैं, तो भी:

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

हार्ड-कोडेड 300 के स्थान पर, यह फ्रेम की चौड़ाई या ऊंचाई को व्यास के रूप में उपयोग करेगा।

शौकी की बदौलत 8 बाइट्स बचाए। सहेजे गए 21 बाइट्स जियोबिट्स की बदौलत।

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

इसके लिए आउटपुट n=37:

यहाँ छवि विवरण दर्ज करें

— जादू ऑक्टोपस Urn
स्रोत
आप ड्रॉप कर सकते हैं Frame x=और final(मुझे लगता है?)
— shooqie
@shooqie उफ़, Frame xएक अन्य समाधान से था जिसमें एक धागा शामिल था। आपको फाइनल की आवश्यकता है, क्योंकि यह मालिक वर्ग में एक बाहरी चर के लिए एक आंतरिक वर्ग का संदर्भ है।
— मैजिक ऑक्टोपस Urn
यह मेरी मशीन पर ठीक काम करता है। BTW मुझे लगता है कि आप छोरों के intबाहर घोषणाओं को आगे बढ़ाते हुए कुछ बाइट्स काट सकते हैंfor
— shooqie
Java 6 में @shooqie यह कह रहा है कि "समय-समय पर एनकोडिंग क्षेत्र में गैर-अंतिम स्थानीय चर n का उल्लेख नहीं किया जा सकता है"।
— मैजिक ऑक्टोपस Urn
इसने मेरे लिए जावा 8 पर काम किया, लेकिन आपके पोस्ट को संपादित करने के बाद मुझे केवल सफेद स्क्रीन मिल रही है।
— शौकी
7

पायथन 2, 258 235 229 बाइट्स

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

के लिए आउटपुट n=37
एन = 37

— छड़ी
स्रोत
1
from PIL import*कम नहीं होगा ?
— रोमन ग्रैफ
@ रोमनग्रफ पीआईएल एक अजीब पैकेज है, आप इसे import *स्थापित नहीं कर सकते, आप कैसे पीआईएल को छोड़ सकते हैं और इमेज / इमेजड्राइव को सीधे आयात कर सकते हैं
— रॉड
6

ऑक्टेव, 88 69 बाइट्स

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

इसके लिए आउटपुट N=37:

यहाँ छवि विवरण दर्ज करें

इसके लिए आउटपुट N=19:

यहाँ छवि विवरण दर्ज करें

— स्टीवी ग्रिफिन
स्रोत
ओह, मैंने यह भी नहीं देखा कि पहले से ही एक और ऑक्टेव उत्तर था :)
— दोष
फिर भी, बीट :-)
— दोष
एक मील तक! मेरा पहला विचार gplotभी था , लेकिन मैंने इसे कम करने के लिए प्रबंधन नहीं किया ...
— Stewie Griffin
6

पर्ल, 229 बाइट्स

यह अधिकांश भाषाओं के समान सूत्र का उपयोग करता है जिनके पास इस चुनौती के लिए सुविधाजनक बिल्टइन नहीं है (भले ही मैंने इसे खोजने के लिए उन्हें नहीं देखा था, लेकिन यह सूत्र खोजने के लिए काफी आसान है)। इसलिए बहुत दिलचस्प नहीं है, लेकिन आमतौर पर इस तरह की चुनौतियों के लिए बहुत सारे पर्ल जवाब नहीं हैं, इसलिए मैं सिर्फ एक प्रस्ताव करना चाहता था।

$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")

और आपको -MImager(9 बाइट्स), -MMath::Trig(प्रदान करना pi, 13 बाइट्स), और -n(1 बाइट) ==> + 23 बाइट्स की आवश्यकता होगी।

इसे चलाने के लिए:

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

यह एक फाइल बनाएगा जिसका नाम t.pngइमेज होगा।

आपको Imagerहालांकि स्थापित करना होगा , लेकिन कोई चिंता नहीं है, यह काफी आसान है:

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

( echoयदि आपने पहले कभी इसका इस्तेमाल नहीं किया है, तो एस आपको कॉन्फ़िगर करेगा। (वास्तव में यह तभी काम करेगा जब आपका पर्ल हाल ही में पर्याप्त हो, मुझे लगता है कि आप में से अधिकांश के लिए यह होगा, और मुझे दूसरों के लिए खेद है!)। ।

और अधिक पठनीय संस्करण (हाँ, यह पर्ल स्क्रिप्ट के लिए काफी पठनीय है!):

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

यहाँ छवि विवरण दर्ज करें

-1 टाइटस को धन्यवाद।

— बापू
स्रोत
क्या पर्ल को सिंगल कमांड के आसपास ब्रेसिज़ की आवश्यकता है?
— टाइटस
@ टिट्स यदि आप forछोरों के बाद ब्रेसिज़ का उल्लेख करते हैं , तो हाँ, वे अनिवार्य हैं।
— दादा
इससे पहले खाली y2। मुझे यकीन है कि आप की जरूरत नहीं है। और क्या आप STDOUT को लिख सकते हैं?
— तैतस
@ टिट्स हम्म, वास्तव में, धन्यवाद। मुझे लगता है कि मैंने अपने टर्मिनल को यहां एक नई रेखा डाल दी, इसलिए मैंने अंतरिक्ष नहीं देखा।
— दादा
5

जप , 92 बाइट्स

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

प्रत्येक पंक्ति को अलग से इनपुट बार में दर्ज किया जाता है। यहाँ एक gif निष्पादन दिखा रहा है:

क्रियान्वयन

यह काम किस प्रकार करता है

polygonआदेश में आधारभूत का कोने के साथ, एक 20-पक्षीय बहुभुज बनाता है (0,0)और (1,0)। अगला आदेश तब सूचकांक के साथ बहुभुज के प्रत्येक शीर्ष पर पुनरावृत्त होता है i, sequenceऔर vertexकमांड के साथ प्रत्येक शीर्ष के लिए, और सूचकांक के साथ प्रत्येक शीर्ष के लिए i, कमांड jका उपयोग करके सूचकांक के साथ हर दूसरे शीर्ष पर एक पंक्ति खंड खींचता है segment।

— TheBikingViking
स्रोत
4

PHP, 186 184 196 बाइट्स

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

छवि को STDOUT में लिखते हैं

टूट - फूट

// 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 बाइट तय के लिए n=20

बदलें $p=2*M_PIके साथ 6(-8), /=$argv[1]के साथ =M_PI/10(-2), और $b>0साथ $b(-2)

सटीक PI / 10 चोट का उपयोग नहीं कर रहा है। इसके साथ .3142, पैराड्राइज्ड संस्करण से राउंडिंग त्रुटियां बनी रहीं, लेकिन M_PI/10वे गायब हो गए और मैं $bइसके बजाय (<> 0) जांच कर सकता हूं $b>0। मैं के साथ दो बाइट्स बचा सकता था .314, लेकिन वह अंक निर्धारित करेगा।

सीमा $a<620 बिंदुओं के लिए पर्याप्त रूप से सटीक है।

सटीक PI ग्राफ़

तय के लिए 174 बाइट्स 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);

उस रिज़ॉल्यूशन में भरे हुए सर्कल में 314 अंक का उपयोग करना (जैसा कि 136,140 करते हैं, उससे ऊपर भी हर संख्या और 317 से ऊपर सब कुछ)।

— टाइटस
स्रोत
1
अच्छा जवाब, लेकिन ऐसा लगता है कि आपने इनपुट के रूप में लेने के बजाय 20 हार्डकोड किया है?
— 23
1
@ बाइकिंग: सच। लेकिन मैं इसे पैरामीट्रिक के लिए चुनौती में कोई मांग नहीं देख सकता।
— टाइटस
4

आर, 127 123 बाइट्स

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

उत्पादन:

अच्छा अक्ष 'लेबल उह?

-4 बाइट्स @ धन्यवाद के लिए धन्यवाद!

— फ़्रेडरिक
स्रोत
1
छोटा नहीं है, लेकिन इसके साथ तेज हो सकता है for(i in 2:n){for(j in 1:i)...}। करता है Rब्रेसिज़ की आवश्यकता होती है?
— टाइटस
@ टिट्स तुम सही हो! और नहीं, कोई ब्रेसिज़ की ज़रूरत नहीं है। धन्यवाद !
— Frédéric
3

बीबीसी बेसिक, 98 अस्सी चरित्र

टोकनशीट 86 बाइट्स को फाइल करती है

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.

Http://www.bbcbasic.co.uk/bbcwin/bbcwin.html पर Dowload दुभाषिया

प्रत्येक पंक्ति को दो बार खींचने में कुछ भी गलत नहीं है, उपस्थिति समान है :-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

आउटपुट n = 21

यह ब्राउज़र की तुलना में मूल रेंडरिंग में बहुत बेहतर लगता है।

<कोड> यहां छवि विवरण दर्ज करें </ कोड>

— स्तर नदी सेंट
स्रोत
मुझे LINEफंक्शन की याद दिलाने के लिए धन्यवाद । बीट्स DRAW...
— steenbergh
3

ऑक्टेव, 50 48 46 45 बाइट्स

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

यह एक सामयिक कार्य है जो हम जिस ग्राफ को खोज रहे हैं उसे प्लॉट करते हैं।

स्पष्टीकरण:

(k=0:2*pi/N:N)+k'एक पूर्ण N+1 x N+1आसंजन मैट्रिक्स बनाता है और साथ ही साथ kकोणों के वेक्टर को परिभाषित करता है , जिसे हम तब उपयोग करते हैं [cos(k);sin(k)]', निर्देशांक का एक मैट्रिक्स जहां प्रत्येक ग्राफ़ नोड को तैनात किया जाता है। gplotबस हम चाहते हैं कि ग्राफ भूखंडों।

हमारे N = 29लिए:

यहाँ छवि विवरण दर्ज करें

— flawr
स्रोत
2

जावास्क्रिप्ट (ईएस 5) / एसवीजी (एचटीएमएल 5), 181 बाइट्स

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))
स्निपेट का विस्तार करें

केवल प्रमुख संख्याओं के लिए काम करता है, जैसे कि 37 का मूल सुझाव। आप iएक बेहोश छवि प्राप्त करने के लिए प्रारंभिक मूल्य (आधा कर सकते हैं) । आप 1e3,2e3स्वाद के लिए अन्य मूल्यों के साथ लगातार तालमेल बिठा सकते हैं (मैंने शुरुआत की 300,600लेकिन फैसला किया कि यह बहुत कठिन था)।

— नील
स्रोत
2

MATLAB, 36 बाइट्स

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

यह एक एनोयमस फ़ंक्शन है जो प्लॉट बनाता है।

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

उदाहरण:

यहाँ छवि विवरण दर्ज करें

यहाँ छवि विवरण दर्ज करें

— लुइस मेंडो
स्रोत
मुझे आश्चर्य graphहै कि बायोइनफॉरमैटिक टूलबॉक्स का हिस्सा नहीं है ... यह भी नहीं पता था कि यह अस्तित्व में था ... अच्छा :)
— स्टिव ग्रिफिन
1

QBasic 4.5, 398 271 बाइट्स

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

QBasic में स्क्रीन 640x480 पर हो सकती है, इसलिए सर्कल में दुर्भाग्यवश 230 px का त्रिज्या है। इसके अलावा, फ्लोट-टू-इंट सटीक नुकसान के कारण कुछ विरूपण साक्ष्य हैं। इस तरह दिखता है N=36: यहाँ छवि विवरण दर्ज करें

संपादित करें: मुझे भंडारण, प्रकार की घोषणा और सभी लूपिंग की आवश्यकता नहीं थी। जगह-जगह पोलर से सभी कार्थेसियन की गणना बाइट काउंट में 50% सस्ती है ...

— steenbergh
स्रोत
1

QBIC , 98 94 बाइट्स

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

मैंने अपने मूल QBasic उत्तर को @LevelRiverSt के QBIC के उत्तर में बदल दिया है। मैंने सोचा था कि यह उन कार्यों पर बहुत अधिक निर्भर करेगा जो QBIC में संभव नहीं हैं, लेकिन जैसा कि यह पता चला है, यह एक और 90 बाइट्स बचाता है। के DRAWलिए प्रतिस्थापन LINEएक और 80 बाइट्स बचाता है। मुझे पता था कि मैं कुछ सरल भूल रहा था ...

जब 36 की कमांड लाइन पैरामीटर के साथ चलाया जाता है, तो यह इस तरह दिखता है:

यहाँ छवि विवरण दर्ज करें

— steenbergh
स्रोत
1

प्रसंस्करण, 274 बाइट्स (239 + sizeकॉल और फ़ंक्शन कॉल)

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

मैं ईमानदारी से नहीं जानता कि क्यों, लेकिन setupदूसरी पंक्ति में होना चाहिए था। रोटेशन के लिए गणित की गणना करने में मेरी मदद करने के लिए मैंने https://en.wikipedia.org/wiki/Rotation_matrix का उपयोग किया । यह कार्यक्रम अंकों की गणना करता है और उन्हें एक सरणी में धकेलता है, जिसके साथ हम लाइनों को खींचने के लिए उपयोग कर रहे हैं।

यहां 50 किनारों के साथ एक बहुभुज की एक तस्वीर है (100 किनारों वाला लगभग पूरी तरह से काला था)

50 अंक

आप stroke(0,alpha);पारदर्शी किनारों को जोड़ सकते हैं , जहां alphaलाइन की अपारदर्शिता है। यहाँ के साथ एक ही बहुभुज alphaहै 20।

यहाँ छवि विवरण दर्ज करें

— क्रिकटी लिथोस
स्रोत
1

बैश + जेली + ग्राफविज़, 52 अक्षर, 52 या 63 बाइट्स

यह देखते हुए कि प्रश्न में प्रोग्राम किस चरित्र का उपयोग करने के लिए एन्कोडिंग से असहमत हैं, प्रोग्राम नियंत्रण वर्णों से भरा है। यहां बताया गया है उसके तहत आने वाले की तरह लग रहा है xxd, लैटिन -1 एन्कोडिंग (जो एक बाइट में प्रत्येक चरित्र का प्रतिनिधित्व करता है) में:

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

मैं वास्तव में कार्यक्रम को चलाने के लिए नहीं मिल सका, हालांकि, किसी कारण के लिए UTF-8 में इनपुट को परिवर्तित किए बिना (जो इसे 63 बाइट्स लंबा कर देगा)। तार्किक रूप से इसे लैटिन -1 के रूप में काम करना चाहिए - वर्णों में से कोई भी 0 से 255 की सीमा के बाहर नहीं है - लेकिन मैं "स्ट्रिंग इंडेक्स ऑफ रेंज" त्रुटियों को जारी रखता हूं चाहे मैं वर्ण एन्कोडिंग वातावरण चर को कैसे कॉन्फ़िगर करूं। इसलिए इसे 63 बाइट्स के रूप में गिना जाएगा जब तक कि कोई इसे फिर से एनकोड करने के बिना इसे चलाने का तरीका नहीं निकाल सकता।

यदि हम इसे जेली के एन्कोडिंग में व्याख्या करते हैं तो कार्यक्रम थोड़ा और पठनीय हो सकता है:

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

कार्यक्रम मानक इनपुट पर अंकों की संख्या लेता है और मानक आउटपुट पर पोस्टस्क्रिप्ट छवि को आउटपुट करता है। (यह किसी भी प्रारूप में आउटपुट के लिए अनुकूलित किया जा सकता है ग्राफविज -Tpsअंत में बदलकर समर्थन करता है ; यह सिर्फ इतना है कि पोस्टस्क्रिप्ट में सबसे छोटा नाम है। संभवतः, आप इसे हटाकर पांच वर्णों को बचा सकते हैं -Tps, लेकिन फिर आपको ग्राफविज़ के आंतरिक छवि प्रारूप में आउटपुट मिलता है। और कुछ भी समर्थन नहीं करता है, जो शायद सवाल के प्रयोजनों के लिए नहीं गिनता है।)

मूल रूप से, यह केवल एक जेली कार्यक्रम है जो ड्राइंग करने के लिए ग्राफविज़ में कॉल करता है; हालाँकि, जेली के पास बाहरी कार्यक्रमों को चलाने की कोई क्षमता नहीं है, इसलिए मुझे उन्हें एक साथ जोड़ने के लिए बैश का उपयोग करना पड़ा। (इसका मतलब यह भी है कि स्टड से मैन्युअल रूप से जेली अनुरोध इनपुट करना सस्ता है; आम तौर पर यह कमांड लाइन से इनपुट लेता है, लेकिन इसका मतलब है कि बैश रैपर में अतिरिक्त बाइट्स circoहोगा ।) स्वचालित रूप से एक सर्कल में ड्रा करने के लिए कहा गया सभी बिंदुओं को व्यवस्थित करेगा । , इसलिए जेली कोड को इसे केवल अंकों की एक सूची बनाने के लिए कहना है, जो सभी एक दूसरे से जुड़े हुए हैं। यहां देखिए यह कैसे काम करता है:

Ɠ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

जेली का उपयोग हमें अपने अंतर्निहित शब्दकोश के माध्यम से ग्राफविज़ आउटपुट को कॉन्फ़िगर करने वाले स्ट्रिंग को थोड़ा संकुचित करने देता है। शब्दकोश है graph, nodeऔर point। अनायास, shapeयह नहीं है (यह है SHAPE, लेकिन ग्राफविज़ केस-संवेदी है), इसलिए हमें उस चरित्र-चरित्र को एनकोड करना होगा।

यहां इनपुट 21 के लिए आउटपुट है (इसे एक प्रारूप में आउटपुट करने के लिए प्रोग्राम में थोड़ा संशोधन के साथ स्टैक एक्सचेंज पर अपलोड किया जा सकता है):

21 बिंदुओं पर पूरा ग्राफ

0

PHP + HTML SVG, 316 263 बाइट्स

हार्डकोड कोड nऔर कोई इनपुट nपैरामीटर के साथ गोल्फ संस्करण :

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

nअंक के लिए इनपुट पैरामीटर के साथ पिछला गोल्फ संस्करण , 316 बाइट्स:

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

उपयोग: एक फ़ाइल में सहेजें और ब्राउज़र से कॉल करें: 

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

nअंक और सीएसएस के लिए इनपुट पैरामीटर के साथ Ungolfed संस्करण :

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

एक एकल पद के लिए 30k वर्ण सीमा के कारण 32 अंक पूरी तरह कार्यात्मक स्निपेट संलग्न नहीं कर सके। यहाँ एक स्क्रीनशॉट है:

यहाँ छवि विवरण दर्ज करें

संलग्न स्निपेट 30k एकल पोस्ट सीमा के कारण 18 अंक तक सीमित है।

कोड स्निपेट दिखाएं

— मारियो
स्रोत
0

आर, 108 बाइट्स

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

अगर मैं तर्क से छुटकारा पा लेता हूं ,as=1जो 5 बाइट्स को काट सकता है, तो 1. का एक पहलू अनुपात मजबूर करता expand.gridहै, सभी संभावित जोड़ी के साथ एक मैट्रिक्स बनाने के लिए उपयोग करता है, और applyइसके माध्यम से लूप का उपयोग करता है।

एन = 21

आर + आईग्राफ, 87 बाइट्स

पैकेज का उपयोग कर एक और समाधान igraph।

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

एन = 21

— plannapus
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.