प्रधान समानता

Question

इस चुनौती के प्रयोजन के रेखांकन विमान है, जहां हर कदम की दिशा पर टहलने को चित्रित करने की है $k$ की primality से निर्धारित होता है $k$ और उसके द्विआधारी विस्तार की समता। विशेष रूप से,

• प्रारंभिक दिशा तय है, उत्तर कहते हैं।
• सभी चरणों की लंबाई समान है ।
• चरण k की दिशा उत्तर, पश्चिम, दक्षिण या पूर्व हो सकती है और निम्नानुसार निर्धारित की जाती है: $k$
  • यदि $k$ अभाज्य नहीं है, तो दिशा नहीं बदलती है।
  • अगर $k$ प्रधानमंत्री और की बाइनरी विस्तार $k$ वालों के सम संख्या है, सही बारी।
  • अगर $k$ प्रधानमंत्री और की बाइनरी विस्तार $k$ लोगों की एक विषम संख्या है, बाएं मुड़ें।

एक उदाहरण के रूप में , मान लें कि प्रारंभिक दिशा उत्तर है। पहले चरण हैं:

• $k=1$ अभाज्य नहीं है। इसलिए हम वर्तमान दिशा में एक कदम बढ़ाते हैं, जो उत्तर है।
• $k=2$ अभाज्य है, और इसका द्विआधारी विस्तार, है10, और विषम संख्या वाले हैं। इसलिए हम बाएं मुड़ते हैं, और अब पश्चिम का सामना कर रहे हैं। हम उस दिशा में एक कदम बढ़ाते हैं।
• $k=3$ प्रधान है, और इसका द्विआधारी विस्तार, है11, और यहां तक ​​कि लोगों की संख्या भी। इसलिए हम सही मोड़ लेते हैं, और अब उत्तर की ओर मुंह कर रहे हैं। हम उस दिशा में एक कदम बढ़ाते हैं।
• $k=4$ अभाज्य नहीं है। इसलिए हम वर्तमान दिशा में एक कदम बढ़ाते हैं, जो उत्तर है।

चुनौती

इनपुट : सकारात्मक पूर्णांक $N$ ।

आउटपुट : $N$ स्टेप वॉक की साजिश जैसा कि ऊपर परिभाषित किया गया है।

अतिरिक्त नियम

• प्रारंभिक दिशा स्वतंत्र रूप से चुने जा सकता है (जरूरी नहीं कि उत्तर), लेकिन सभी के लिए समान होना चाहिए $N$ ।
• मोड़ नियम विपरीत है कि ऊपर वर्णित है, वह यह है कि, है ना अजीब समता के लिए देते हैं और यहां तक कि के लिए छोड़ दिया हो सकता है; लेकिन यह सभी $N$ लिए समान होना चाहिए ।
• आउटपुट को वॉक का चित्रमय चित्रण होना चाहिए । उदाहरण के लिए:
  • वॉक को लाइन सेगमेंट के साथ तैयार किया जा सकता है।
  • विज़िट किए गए बिंदुओं को एक मार्कर के साथ दिखाया जा सकता है, जैसे कि डॉट; लाइन खंडों को जोड़ने के साथ या बिना।
  • एक दो-रंग की रेखापुंज छवि प्रदान की जा सकती है, जिसमें एक रंग विज़िट किए गए बिंदुओं के अनुरूप और दूसरा गैर-विज़िट के लिए है।
• क्षैतिज और ऊर्ध्वाधर कुल्हाड़ियों के तराजू को समान होने की आवश्यकता नहीं है। इसके अलावा अक्ष लेबल और समान तत्व वैकल्पिक हैं। जब तक चलना स्पष्ट रूप से देखा जा सकता है, भूखंड वैध है।
• ध्यान दें कि कुछ बिंदुओं को एक से अधिक बार दौरा किया जाता है। कथानक इसके प्रति संवेदनशील नहीं है। उदाहरण के लिए, यदि प्लॉट में लाइन सेगमेंट दिखाए जाते हैं, तो प्रत्येक यूनिट सेगमेंट को वही प्रदर्शित किया जाता है, चाहे वह कितनी बार ट्रेस किया गया हो।
• कोड को किसी Nभी असीमित संसाधनों के लिए काम करना चाहिए । यह स्वीकार्य है यदि व्यवहार में यह Nसमय, स्मृति या डेटा-प्रकार की सीमाओं के कारण बड़े समय तक विफल रहता है ।
• इनपुट और आउटपुट हमेशा की तरह लचीले होते हैं। विशेष रूप से, आउटपुट छवियों के लिए किसी भी मानक साधन का उपयोग किया जा सकता है।
• बाइट्स में सबसे छोटा कोड जीतता है।

परीक्षण के मामलों

निम्नलिखित भूखंड उत्तर दिशा को प्रारंभिक दिशा के रूप में उपयोग करते हैं; समता सही है; और वॉक को लाइन सेगमेंट के साथ दर्शाया गया है।

N = 7:

N = 3000:

N = 20000:

N = 159000:

N = 1200000:

N = 11000000:

Comments

क्या केवल कारण [graphical-output]की अनुमति है? विशेष रूप से ASCII आउटपुट को अस्वीकृत करने का कोई कारण, जैसे मेरा अब नष्ट किया गया चारकोल उत्तर?

— केविन क्रूज़सेन

@ केविन को एक बार सलाह दी गई कि दोनों को एक ही चुनौती में न मिलाएं ... दूसरे क्या सोचते हैं?

— लुइस मेंडो

खैर, मैं उस सलाह के पीछे के तर्क को समझ सकता हूं, क्योंकि आउटपुट के रूप में छवि / ग्राफ बनाम एएससीआईआई कला कुछ भाषाओं में पूरी तरह से अलग है। फिर से, मैंने ASCII- कला चुनौतियों और इसके विपरीत में ग्राफ़ आउटपुट के भार को बढ़ते हुए देखा है, इसलिए मुझे लगता है कि हर कोई इससे सहमत नहीं है। व्यक्तिगत रूप से मुझे लगता है कि यह वास्तव में चुनौती पर निर्भर करता है। इस मामले में मुझे व्यक्तिगत रूप से एक ही चुनौती में दोनों की अनुमति देने में कोई बुराई नहीं दिखती है, लेकिन शायद मैं अपने अब हटाए गए उत्तर के कारण पक्षपाती हूं। इसलिए मैं आपसे एक ही सवाल पूछूंगा: " दूसरे क्या सोचते हैं? " @ अर्नुलद शायद आपको अपने ASCII टैक्सी ड्राइवर को पोस्ट करना चाहिए;)

— केविन क्रूज़सेन

विभिन्न ओईआईएस अनुक्रमों पर इस रन को देखना दिलचस्प होगा (सच है, कुछ बस एक सीधी रेखा में चलेंगे या हलकों में चलेंगे, लेकिन कुछ काफी कुछ हो सकते हैं)।

— ड्रेक

N = 11000000 पर, यह यूरोप के नक्शे का अनुमान लगाता है।

— डिजिटल ट्रॉमा

Answer 1

स्लेजहैमर 0.4 , 22 20 बाइट्स

⢂⡐⠥⡄⠡⢒⣩⣀⣼⡝⢄⡎⣛⠅⡉⣱⡆⢀⡠⣽

इस वुल्फराम भाषा समारोह में शामिल हैं:

ListPlot[AnglePath[Array[If[PrimeQ@#, ArcSin[(-1)^ThueMorse@#], 0] &, #]]]

Ungolfed

पहले हम एक फ़ंक्शन को परिभाषित करते हैं जो प्रत्येक चरण को चालू करने के लिए कोण लौटाता है:

If[PrimeQ[#],
    ArcSin[(-1)^ThueMorse@#],
    0
]&

ThueMorseद्विआधारी अंकों के योग की समता है। हम -1^(...)इसके बजाय 2*...-1थोड़ा जटिल कारण के लिए उपयोग करते हैं : वुल्फ्राम भाषा स्वचालित रूप से अंकगणितीय अभिव्यक्तियों को स्रोत में एक विहित रूप में परिवर्तित करती है, इसलिए जैसे भाव 2/xसंग्रहीत होते हैं Times[2, Power[x, -1]]। यह Powerबहुत उच्च आवृत्ति बनाता है , और इस प्रकार यह बहुत सस्ता है।

(इससे गुणा करना Boole@PrimeQ@थोड़ा लंबा है, और Booleचुनौती के समय बूलियंस की निहित कास्टिंग लागू नहीं की गई थी।)

यहाँ से, गणितज्ञ AnglePathऔर ListPlotठीक वैसा ही करते हैं जैसा हमें चाहिए:

ListPlot[AnglePath[Array[%, #]]]&

इंटरैक्टिव ऐप में, आउटपुट एक rescalable वेक्टर ग्राफिक्स ऑब्जेक्ट है।

Comments

ठंडा! हम हमारे समाधान के संयोजन से 77 बाइट्स के लिए नीचे उतर गए। चीयर्स!

— रोमन

Answer 2

MATL , 25 24 21 बाइट्स

Q:qJyZpbB!sEq*^YpYsXG

इसे MATL पर ऑनलाइन आज़माएं

धन्यवाद @LuisMendo चैट में एक अच्छे गोल्फ सत्र के लिए जो अंततः इस 21 बाइट संस्करण का नेतृत्व करते हुए सुझाव देता है Eq*^

व्याख्या

Q:q % Push 0:n
J   % Push 1i for later use.
y   % Duplicate 0:n from below
Zp  % Vector result of isprime()
b   % Bubble 0:n from bottom of stack
B!s % Sum of bits in binary representation
Eq  % Double minus one to get an odd number
*   % Multiply by isprime result to get either zero or aforementioned odd number
^   % Exponentiate 1i by an odd number or zero to get -i, 1 or i (corresponding to left turn, straight ahead, right turn).
Yp  % Cumulative product to get a vector of directions
Ys  % Cumulative sum to get vector of positions
XG  % Plot

$k=12345$

Answer 3

सी (जीसीसी) , 179 बाइट्स

o;i;d;k;h;f(n,p)char*p;{h=2*n+1;memset(p,0,h*h);p+=h--*n+n;*p=1;for(d=k=0;k++<n;){for(i=1;k%++i%k;);for(o=k;o/2;o=o/2^o&1);i==k?d+=o*2+3:0;p+=(d%2*h+1)*((d&2)-1);*p=1;}return++h;}

इसे ऑनलाइन आज़माएं!

$4 n^2 + 4 n + 1$01

सी (जीसीसी) , 219 बाइट्स

o;i;d;k;h;f(n,p)char*p;{h=2*n+1;p+=sprintf(p,"P1 %d %d ",h,h);memset(p,48,h*h);k=h--*n+n;*(p+2*k+1)=0;p+=k;*p=49;for(d=k=0;k++<n;){for(i=1;k%++i%k;);for(o=k;o/2;o=o/2^o&1);i==k?d+=o*2+3:0;p+=(d%2*h+1)*((d&2)-1);*p=49;}}

इसे ऑनलाइन आज़माएं!

$4 n^2 + 4 n + 2 \times \lfloor log_{10}(2n+1)\rfloor + 9$

20000 के लिए फसली उत्पादन:

दोनों संस्करण पश्चिम से शुरू होते हैं और दाएं मुड़ते हैं, यहां तक ​​कि बाएं भी।

मैंने उनमें से किसी के साथ भी बड़े टेस्टकेस की कोशिश की, क्योंकि 20000 के साथ आउटपुट ~ 1.5 जीबी था, और 150000 ~ 90 जीबी होगा। यह सब मेमोरी में संग्रहीत होता है जबकि प्रोग्राम निष्पादित होता है।

ऊपरी एक की व्याख्या:

o;         /* Temporary variable for calculating parity */
i;         /* Temporary variable for primality test */
d;         /* d % 4 = direction */
k;         /* Step */
h;         /* height/width of image */
f(n,p)char*p;{ /* Function taking int and char pointer */
  h=2*n+1;     /* Image sidelength = 2 * N + 1, so N in each direction */
  memset(p,0,h*h); /* Reset buffer */
  p+=h--*n+n;  /* Position p at image center; decrement h */
  *p=1;        /* Put a dot at center */
  for(d=k=0;   /* Set direction and step to 0 */
    k++<n;){   /* Loop over [1..N] */
    for(i=1;k%++i%k;); /* Primality test */
    for(o=k;o/2;o=o/2^o&1); /* Parity test */
    i==k?d+=o*2+3:0; /* Change direction if necessary */
    p+=(d%2*h+1)*((d&2)-1); /* Move according to direction */
    *p=1; /* Set pixel to black */
  }
  return++h; /* Add 1 back to h and return */
}

Comments

मुझे नहीं लगता है कि एक आबंटित बफर को तर्क के रूप में प्रदान किए जाने की आवश्यकता है - प्रति मेटा नीति के अनुसार , कोई भी अतिरिक्त इनपुट खाली होना चाहिए (जो मैं 0C के मामले में सूचक या अशक्त सूचक की व्याख्या करूँगा )।

— दरवाज़े

मैं यह कहकर व्याख्या कर रहा हूं कि मैं इसे आवंटित किए जाने की अपेक्षा कर सकता हूं। यह कई मानक पुस्तकालय कार्यों में उपयोग किया जाने वाला एक पैटर्न भी है, जैसे स्प्रिंटफ।

— बंजर भूमि

आह ठीक है, तुम सही हो, यह समझ में आता है।

— दरवाज़े

162 बाइट्स

— छत

Answer 4

वोल्फ्राम लैंग्वेज (गणितज्ञ) , 98 96 91 77 76 63 बाइट्स

ListPlot@AnglePath@Array[Pi/2If[PrimeQ@#,2ThueMorse@#-1,0]&,#]&

-14 बाइट्स: मुझे दिखाने के लिए @lirtosiast का उपयोग करने केAnglePath लिए धन्यवाद ...

-13 बाइट्स: ... और ThueMorse!

उपयोग उदाहरण:

%[20000]

चरण-दर-चरण स्पष्टीकरण:

• If[PrimeQ@#, 2 ThueMorse@# - 1, 0] &एक ऐसा फंक्शन है जो स्टेप इंडेक्स लेता है और 0 को नॉन-प्राइम के लिए, -1 को बाइनरी प्राइम के लिए, और विषम-बाइनरी अपराधों के लिए +1 देता है। ThueMorse@#पिछले समाधान की जगह Total[#~IntegerDigits~2](जो समान है, मोडुलो 2)।

• Array[Pi/2*%,#]इस फ़ंक्शन की सूची 1 से फ़ंक्शन तर्क (उदाहरण में 20000) तक जा रही है, और इसे दिशा-परिवर्तन कोण (रेडियन) में बनाने के लिए प्रत्येक तत्व को π / 2 से गुणा करता है। अब हमारे पास गैर-अपराधों के लिए 0,-have / 2 सम-बाइनरी अपराधों के लिए, और विषम-बाइनरी अपराधों के लिए + non / 2 है।

• AnglePath[%]दिशा-परिवर्तन कोणों की इस सूची को एक पथ में परिवर्तित करता है। यह निर्देश पिछले समाधान के दोहरे उपयोग की जगह लेता है Accumulate।

• ListPlot[%]पदों की सूची को XY डॉट प्लॉट में परिवर्तित करता है। यदि एक लाइन पसंद की जाती है, तो ListLinePlotइसके बजाय उपयोग करें । प्लॉटिंग को बेहतर बनाने के लिए इन प्लॉटिंग फ़ंक्शंस में बहुत सारे विकल्प हैं।

Comments

धन्यवाद @lirtosiast! यह एक विदेशी भाषा सीखने जैसा है: हर दिन नई शब्दावली।

— रोमन

Answer 5

MATL, 31 30 28 26 बाइट्स

J4:^0i:Zpl_G:B!s^*hYs)YsXG

3 बाइट्स @LuisMendo की बदौलत बच गए

2 बाइट्स @Sanchises की बदौलत बच गए

इसे MATL ऑनलाइन पर आज़माएं

व्याख्या

यह समाधान 2 डी विमान के एक्स और वाई घटकों का प्रतिनिधित्व करने के लिए जटिल संख्याओं का उपयोग करता है

J      % Push the literal complex number 0 + 1j to the stack
4:     % Create the array [1, 2, 3, 4]
^      % Raise 0 + 1j to each power in the array, [1, 2, 3, 4]

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

अनिवार्य रूप से जिस तरह से यह काम करता है वह यह है कि हम शून्य दिशा (सरणी का 0'th तत्व जो है (-1, 0)) में शीर्षक बनाना शुरू करते हैं । प्रत्येक चरण के लिए, हमें इस शीर्षक में परिवर्तन को निर्धारित करने की आवश्यकता है। हम इस परिवर्तन को ट्रैक करने के लिए पूर्णांक का उपयोग करेंगे। यदि हम "दाएं" मुड़ना चाहते हैं, तो हम इस पूर्णांक को 1 से बढ़ाते हैं ( 4-बिंदु सरणी में अगले तत्व को संदर्भित करते हुए ) और यदि हम "बाएं" जाना चाहते हैं, तो हम इस पूर्णांक को 1 से घटाते हैं ( पिछले तत्व को संदर्भित करते हुए) 4-बिंदु सरणी)। यदि हम अपने पथ पर जारी रहना चाहते हैं, तो हम पूर्णांक मान को स्थिर रखते हैं ( उसी तत्व को 4-बिंदु सरणी में संदर्भित करते हैं )।

कोड के इस भाग को उन सभी की एक सरणी बनाता है 0, -1और 1मूल्यों।

0      % Push a literal 0 to the stack (the starting point)
i      % Explicitly grab the input (N)
:      % Create an array from 1...N
Zp     % Determine if each element is a prime (1) or not (0)
l_     % Push the literal -1 to the stack
G      % Explicitly grab the input again (N)
:      % Create an array from 1...N
B      % Convert to binary representation (each row is the binary representation of
       % each element in the vector)
!      % Transpose
s      % Sum down the columns to count number of 1's
^      % Raise the -1 to each element. For odd number of 1's in the
       % binary expansion this yields -1, and even yields 1

*      % Multiply this -1 or 1 by the result of the prime check (element-wise). 
       % For non-primes this yields a 0, for primes with an even number of 1's in 
       % the binary representation this is a 1, and for primes 
       % with an odd number of 1's in

h      % Horizontally concatenate with the initial 0

अब हमारे पास लगातार पूर्णांकों के बीच मतभेदों की एक सरणी है, इसलिए हम उन सूचकांकों को प्राप्त करने के लिए संचयी योग की गणना कर सकते हैं जिनका उपयोग हम मूल 4-तत्व सरणी में प्रत्येक चरण में दिशा देखने के लिए कर सकते हैं।

आसानी से, MATL के चारों ओर अनुक्रमण लिपटे हुए हैं, जैसे कि सूचकांक 54-तत्व सरणी की शुरुआत के चारों ओर घूमता है। हम इसका उपयोग अपने लाभ के लिए कर सकते हैं ताकि हम इस पूर्णांक को बढ़ा सकें और घटा सकें और इस तथ्य की चिंता किए बिना कि संदर्भ दिशा सरणी केवल 4 तत्व है।

Ys     % Compute the cumulative sum
)      % Use this to modularly index into the original array of four points

अब हमारे पास चरणों की दिशाओं की एक सरणी है, इसलिए हम इन दिशाओं के संचयी योग की गणना उस पथ का पता लगाने के लिए कर सकते हैं जो लिया गया था।

Ys     % Compute the cumulative sum
XG     % Plot as a 2D plot

Answer 6

पर्ल 6 , 213 182 बाइट्स

{my @p = [\ +] [\ *] ({{। is-prime ?? | base (२) .comb (~ १)% २ ?? i !! - i !! १ + ०i} (+) !! + $)} ... *) [^ $ _]; {"<svg viewBox = '{। min। xx 2, .elems xx 2}' >> >>। और {" L {.re} {.im} " }} 'भरें =' कोई नहीं 'स्ट्रोक =' काला '/> "} (minmax | @p» .reals)

{{"<svg viewBox='{{.min,.min,+$_,+$_}(.minmax)}'><path d='{"L"X~$_}' fill='none' stroke='red'/></svg>"}(([\+] [\*]({-{.is-prime*.base(2).comb(~1)R**-1||i}(++$)i}...*)[^$_])».reals)}

इसे ऑनलाइन आज़माएं!

(वास्तव में यह एक नीचे गिराने में कामयाब रहे!)

यह फ़ंक्शन SVG प्रारूप में आउटपुट करता है।

• { -{ .is-prime * .base(2).comb(~1) R** -1 || i }(++$)i } ... *प्रत्येक चरण के लिए दिशा परिवर्तन का एक अनंत क्रम है, जटिल संख्याओं के रूप में, 1जिसका अर्थ है "एक ही दिशा में जारी रखें," का iअर्थ है "बाएं मुड़ें," और -iइसका मतलब है "सही मोड़।"
• [^$_] फ़ंक्शन के तर्क के रूप में प्रदान किए गए चरणों की संख्या तक अनुक्रम को सीमित करता है।
• [\*] उस अनुक्रम को (जटिल) गुणा के साथ स्कैन करता है, सापेक्ष दिशा की सूची को पूर्ण दिशाओं की सूची में बदल देता है।
• [\+]उस अनुक्रम को (जटिल) जोड़ के साथ स्कैन करता है , जो विज़िट किए गए निर्देशांक की एक सूची तैयार करता है।
• ».reals जटिल संख्याओं की सूची को उसके वास्तविक और काल्पनिक भागों की दो-तत्व सूची में परिवर्तित करता है।

एसवीजी छवि केवल एक एकल pathतत्व है।

एन = 20000 के लिए आउटपुट (पीएनजी में परिवर्तित):

Answer 7

सी, 321 बाइट्स

a,b,A,B,k,p,e,i,t,r;g(n,c,d,x,y,X,Y){x=y=Y=r=0;X=1;for(k=0;k++<=n;){r|=x==c&y==d;a=x<a?x:a;A=x>A?x:A;b=y<b?y:b;B=y>B?y:B;for(p=1,i=k;--i;p=p*i*i%k);for(e=1,i=k;i;e=-e)i&=i-1;if(p)t=X,X=-e*Y,Y=e*t;x+=X;y+=Y;}}f(n,x,y){A=a=B=b=0;g(n);printf("P1%d %d ",A-a+1,B-b+1);for(y=b;y<=B;++y)for(x=a;x<=A;++x)g(n,x,y),putchar(48+r);}

इसे ऑनलाइन आज़माएं!

अन्य सी उत्तर पोस्ट होने से पहले मैंने इस पर काम करना शुरू कर दिया था, लेकिन मुझे लगा कि मैं वैसे भी मेरा पोस्ट कर सकता हूं। यह एक बहुत लंबा है, लेकिन यह आउटपुट छवि को स्वचालित रूप से परिणाम के आयामों तक पहुंचाता है।

समारोह के रूप में कहा जाता है f(n), और netpbm प्रारूप में आउटपुट को रोकना है।

N = 1000 के लिए उदाहरण आउटपुट:

a,b,A,B,          // used to store x range [a,A] and y range [b,B]
k,p,e,i,t,        // temp variables used in g
r;g(n,c,d,        // takes n + coordinates, sets r to whether (c,d) is visited
x,y,X,Y){         // temp variables - position (x,y) and velocity (X,Y)
x=y=Y=r=0;X=1;    // initialization
for(k=0;k++<=n;){ // loops k over the step number
r|=x==c&y==d;     // set r to 1 if current coordinate is the requested one
a=x<a?x:a;A=x>A?x:A;b=y<b?y:b;B=y>B?y:B;    // update bounds
for(p=1,i=k;--i;p=p*i*i%k);                 // prime test
for(e=1,i=k;i;e=-e)i&=i-1;                  // parity test
if(p)t=X,X=-e*Y,Y=e*t;                      // if prime, turn accordingly
x+=X;y+=Y;}}      // move position in direction of velocity
f(n,x,y){         // main function; x and y are temp variables
A=a=B=b=0;g(n);   // obtain accurate bounds
printf("P1 %d %d\n",A-a+1,B-b+1);           // output netpbm header
for(y=b;y<=B;++y)for(x=a;x<=A;++x)          // loop through all coordinates
g(n,x,y),putchar(48+r);}                    // output 1 if visited, 0 otherwise

प्राइम टेस्ट अनिवार्य रूप से लिन के जवाब में एक अलग चुनौती के लिए उपयोग किया जाता है , जो विल्सन के प्रमेय पर निर्भर करता है ।

समता परीक्षण कर्निघन की बिट-काउंटिंग पद्धति के एक अनुकूलन का उपयोग करता है ।

चूंकि प्रधान परीक्षण बहुत धीमा है, और एल्गोरिथ्म खींचा गया प्रत्येक पिक्सेल के लिए संपूर्ण पथ निर्माण फ़ंक्शन को फिर से चलाता है, कोई भी इनपुट टीआईओ पर 1000 गुना अधिक है।

Comments

308 बाइट्स

— छत

Answer 8

लोगो, 177 171 बाइट्स

to d:c
if :c%2[rt 180
make"c:c-1]if:c<1[stop]d:c/2
end
to p
if:c>1[make"f 2
repeat:c-2[if:c%:f<1[stop]make"f:f+1]rt 90
d:c]end
to g:n
make"c 1
repeat:n[p
fw 2
make"c:c+1]end

उपयोग करने के लिए, ऐसा कुछ करें :

reset
pu
fw 100
pd
g 3000

क्षमा करें, लेकिन मैं नमूना आउटपुट कैप्चर करने में सक्षम नहीं था। स्पष्टीकरण:

to d:c
if :c%2[rt 180
make"c:c-1]if:c<1[stop]d:c/2
end

यह एक पुनरावर्ती प्रक्रिया है जो अपने पैरामीटर में प्रत्येक सेट बिट के लिए 180 ° घूमती है, जो प्रभावी रूप से अपने द्विआधारी विस्तार की समता की गणना करता है।

to p
if:c>1[make"f 2
repeat:c-2[if:c%:f<1[stop]make"f:f+1]rt 90
d:c]end

यह एक बहुत ही बुनियादी मौलिकता परीक्षण है। विशेष-आवरण 1 के बाद, यदि कारक पाया जाता है, तो प्रक्रिया जल्दी लौटती है। यदि फिर भी वर्तमान मान प्रधान पाया जाता है, तो वह दाईं ओर मुड़ता है, और फिर उपरोक्त प्रक्रिया का उपयोग करके उसे बाईं ओर मोड़ता है।

to g:n
make"c 1
repeat:n[p
fw 2
make"c:c+1]end

यह केवल एक सरल लूप है जो कि सभी संख्याओं को nपरिमाण के लिए परीक्षण करने के लिए और प्रत्येक के बाद दो पिक्सेल को स्थानांतरित करने के लिए है।

Answer 9

जेली , 41 बाइट्स

B§ḂḤ’×ıµ1Ẓ?€×\ÄŻÆiZ_Ṃ$€Z‘ḞŒṬµẈḢ⁾P1,;Lṭ@FK

इसे ऑनलाइन आज़माएं!

$N$

$N=3000$

$N=300$

0000000000000000000000111110000000000
0000000000000000000000100010000000000
0000001110000000000000100010000000000
0000001010000000000000100010000000000
0000001010000000000000100010000000000
0000001010000000000000100010000000000
0000001010000000111111111010000000000
0000001010000000100000101010000000000
0000001111111110100000101010000000000
0000000000100010100000101010000000000
0000000000111111100000101010001111111
0000000000000010000000101010001000001
0000000000000011100010101010001000001
0000000000000000100010101010001000001
0000111111100000100011111111111111111
0100100000100000100010001010001000001
0110100000111111100011111111111000111
0010100000000000000010101010000000101
1111100000000000000010101110000000101
1010000000000000000010100000000000101
1010000000000000000011111111111011101
1010000000000000000000100000001010101
1110000000000000000000111111101111101
0000000000000000000000000000100010101
0000000000000000000000000000100010101
0000000000000000000000000000100010101
0000000000000000000000000000111111111
0000000000000000000000000000000010100
0000000000000000000000000000000010100
0000000000000000000000000000000010100
0000000000000000000000000000000011100

Answer 10

जावास्क्रिप्ट - 675 668 660 632 556 534 बाइट्स

कोडगॉल्फ पर पहली बार यहां, शुरू में ~ 1500 बाइट्स कोड के साथ शुरू हुआ। इसे एक तिहाई से लगभग आधे से भी कम पर गोल्फ दिया। गोल्फ जारी रखने के लिए स्वतंत्र महसूस करें। बाइट्स काउंटेड विथ: यह टूल

सिद्धांत:
इनपुट के रूप में एन और चर स्ट्रोक की लंबाई के साथ निश्चित आकार के कैनवास में खींचता है।

संपादन:

-07 बाइट्स - अगर मिस -8 बाइट्स को बदल दिया जाए तो इसे हटा दें / -28 बाइट्स में
स्विच करें
- टेनेरी में बदलाव करें यदि /
-76 बाइट्स - कम प्राइम टेस्ट (रनटाइम / 3)
-22 बाइट्स - इस प्राइम फंक्शन (रनटाइम ) का उपयोग करें * 4)

गोल्फ कोड:

function f(e,r){for(var t=0,n=0,i=950,f=450,o=document.getElementById("d").getContext("2d"),a=1;a<=e;a++){n=iP(a)?iO(a)?1:2:0;var u=i,c=f;t==0?(t=0==n?(c=f-r,0):1==n?(u=i-r,1):(u=i+r,3)):t==1?(t=0==n?(u=i-r,1):1==n?(c=f+r,2):(c=f-r,0)):t==2?(t=0==n?(c=f+r,2):1==n?(u=i+r,3):(u=i-r,1)):(t=0==n?(u=i+r,3):1==n?(c=f-r,0):(c=f+r,2));o.beginPath(),o.moveTo(i,f),o.lineTo(u,c),o.stroke(),i=u,f=c}}function iP(h){for(i=n=h;n%--i;);return(1==i)}function iO(e){for(var r=(e>>>0).toString(2),t=0,n=0;n<r.length;n++)"1"==r[n]&&t++;return t%2!=0}

व्हॉट्सएप के साथ अनगुल्ड कोड:

function f(e,r){
    for(var t=0,n=0,i=950,f=450,o=document.getElementById("d").getContext("2d"),a=1;a<=e;a++){

        // prime and odd/even check
        n=iP(a)?iO(a)?1:2:0;

        var u=i,c=f;

        t==0?(t=0==n?(c=f-r,0):1==n?(u=i-r,1):(u=i+r,3)):t==1?(t=0==n?(u=i-r,1):1==n?(c=f+r,2):(c=f-r,0)):t==2?(t=0==n?(c=f+r,2):1==n?(u=i+r,3):(u=i-r,1)):(t=0==n?(u=i+r,3):1==n?(c=f-r,0):(c=f+r,2));

        o.beginPath(),o.moveTo(i,f),o.lineTo(u,c),o.stroke(),
        i=u,f=c // renew old cords
    }
}

// check prime
function iP(h){
    for(i=n=h;n%--i;);
    return(1==i)
}

// check binary expression even/odd
function iO(e){
    for(var r=(e>>>0).toString(2),t=0,n=0;n<r.length;n++)
        "1"==r[n]&&t++;
    return t%2!=0
}

उदाहरण:

एन = 7 - लंबाई = 60

f(7, 60);
function f(e,r){for(var t=0,n=0,i=950,f=450,o=document.getElementById("d").getContext("2d"),a=1;a<=e;a++){n=iP(a)?iO(a)?1:2:0;var u=i,c=f;t==0?(t=0==n?(c=f-r,0):1==n?(u=i-r,1):(u=i+r,3)):t==1?(t=0==n?(u=i-r,1):1==n?(c=f+r,2):(c=f-r,0)):t==2?(t=0==n?(c=f+r,2):1==n?(u=i+r,3):(u=i-r,1)):(t=0==n?(u=i+r,3):1==n?(c=f-r,0):(c=f+r,2));o.beginPath(),o.moveTo(i,f),o.lineTo(u,c),o.stroke(),i=u,f=c}}function iP(h){for(i=n=h;n%--i;);return(1==i)}function iO(e){for(var r=(e>>>0).toString(2),t=0,n=0;n<r.length;n++)"1"==r[n]&&t++;return t%2!=0}

<canvas id="d" width="1900" height="900"/> 

एन = 3000 - लंबाई = 4

f(3000, 4);
function f(e,r){for(var t=0,n=0,i=950,f=450,o=document.getElementById("d").getContext("2d"),a=1;a<=e;a++){n=iP(a)?iO(a)?1:2:0;var u=i,c=f;t==0?(t=0==n?(c=f-r,0):1==n?(u=i-r,1):(u=i+r,3)):t==1?(t=0==n?(u=i-r,1):1==n?(c=f+r,2):(c=f-r,0)):t==2?(t=0==n?(c=f+r,2):1==n?(u=i+r,3):(u=i-r,1)):(t=0==n?(u=i+r,3):1==n?(c=f-r,0):(c=f+r,2));o.beginPath(),o.moveTo(i,f),o.lineTo(u,c),o.stroke(),i=u,f=c}}function iP(h){for(i=n=h;n%--i;);return(1==i)}function iO(e){for(var r=(e>>>0).toString(2),t=0,n=0;n<r.length;n++)"1"==r[n]&&t++;return t%2!=0}

<canvas id="d" width="1900" height="900"/> 

एन = 20000 - लंबाई = 2

f(20000, 2);
function f(e,r){for(var t=0,n=0,i=950,f=450,o=document.getElementById("d").getContext("2d"),a=1;a<=e;a++){n=iP(a)?iO(a)?1:2:0;var u=i,c=f;t==0?(t=0==n?(c=f-r,0):1==n?(u=i-r,1):(u=i+r,3)):t==1?(t=0==n?(u=i-r,1):1==n?(c=f+r,2):(c=f-r,0)):t==2?(t=0==n?(c=f+r,2):1==n?(u=i+r,3):(u=i-r,1)):(t=0==n?(u=i+r,3):1==n?(c=f-r,0):(c=f+r,2));o.beginPath(),o.moveTo(i,f),o.lineTo(u,c),o.stroke(),i=u,f=c}}function iP(h){for(i=n=h;n%--i;);return(1==i)}function iO(e){for(var r=(e>>>0).toString(2),t=0,n=0;n<r.length;n++)"1"==r[n]&&t++;return t%2!=0}

<canvas id="d" width="1900" height="900"/> 

एन = 159000 - लंबाई = 1

f(159000, 1);
function f(e,r){for(var t=0,n=0,i=950,f=450,o=document.getElementById("d").getContext("2d"),a=1;a<=e;a++){n=iP(a)?iO(a)?1:2:0;var u=i,c=f;t==0?(t=0==n?(c=f-r,0):1==n?(u=i-r,1):(u=i+r,3)):t==1?(t=0==n?(u=i-r,1):1==n?(c=f+r,2):(c=f-r,0)):t==2?(t=0==n?(c=f+r,2):1==n?(u=i+r,3):(u=i-r,1)):(t=0==n?(u=i+r,3):1==n?(c=f-r,0):(c=f+r,2));o.beginPath(),o.moveTo(i,f),o.lineTo(u,c),o.stroke(),i=u,f=c}}function iP(h){for(i=n=h;n%--i;);return(1==i)}function iO(e){for(var r=(e>>>0).toString(2),t=0,n=0;n<r.length;n++)"1"==r[n]&&t++;return t%2!=0}

<canvas id="d" width="1900" height="900"/> 

Comments

रंग अतिव्यापी लाइनों की मात्रा पर निर्भर करता है? ठंडा!

— वैल

मैंने स्ट्रोक शैली नहीं बदली, यह बिना पैटर्न या पारदर्शिता के डिफ़ॉल्ट रूप से काला होना चाहिए। यहां मिला । ऐसा क्यों हो सकता है कि एक रंग परिवर्तन स्ट्रोक चौड़ाई से संबंधित हो सकता है जिसे मैंने दूसरे पैरामीटर में सेट किया है जो मेरा फ़ंक्शन @val ले रहा है। शायद आपको निराश करने के लिए क्षमा करें।

— Pixma140

Answer 11

लाल , ५१५ ४ 480० 471 बाइट्स

केविन क्रूज़सेन को धन्यवाद!

func[n][a: 270 x: t: u: v: w: 0 y: 1
b: copy[line 0x0 0x1]repeat i n - 1[p: on
j: i + 1 repeat k i / 2[if j%(k + 1)= 0[p: off]]if p[s: 0
until[if j% 2 = 1[s: s + 1](j: j / 2)< 1]a: a + pick[-90 90]s% 2 + 1]append b 'line 
append b as-pair x y x: x + cosine a y: y - sine a append b as-pair x y t: min x t
u: max x u v: min y v w: max y w]c: 500 /(max u - t w - v)view[base white 502x500
draw collect[foreach k b[keep either pair? k[as-pair k/1 - t * c k/2 - v * c][k]]]]]

कोड का एक महत्वपूर्ण हिस्सा (~ 160 बाइट्स) निर्देशांक को सामान्य करने से संबंधित है ताकि ग्राफिक्स इनपुट के आकार की परवाह किए बिना पूरी तरह से कैनवास में फिट हो।

प्रारंभिक दिशा: दक्षिण।

यहाँ के लिए परिणाम है n = 3000

n = 20000

Comments

जिज्ञासा से बाहर, क्यों modulos पर if j%(k + 1)और के लिए आवश्यक किसी भी रिक्त स्थान नहीं हैं if j% 2 = 1, लेकिन अन्य ऑपरेटरों ( +और /, आदि) के लिए आवश्यक रिक्त स्थान हैं । क्या के मोडुलो पर भी जगह निकाली जा सकती है pick[-90 90]s% 2? वास्तव में, क्यों भी वहाँ नहीं किसी भी रिक्त स्थान पर आवश्यक हैं as-pair k/1 - t * c k/2 - v * cके लिए /?

— केविन क्रूज़सेन

@KevinCruijssen हाँ s% 2, धन्यवाद के लिए स्थान हटाया जा सकता है ! मुझे पता नहीं क्यों, लेकिन मोडुलो %एकमात्र ऑपरेटर है जिसके लिए इसके सामने की जगह को गिराया जा सकता है, अगर किसी शब्द (चर) से पहले। में as-pair k/1 - t * c k/2 - v * cस्लैश /पूरी तरह से अलग उद्देश्य पूरा - वे कर रहे हैं pathरों। kएक है pairऔर k/1पहला तत्व है (यह द्वारा भी चुना जा सकता है k/x, या pick k 1)। लगभग हर जगह रिक्त स्थान की आवश्यकता होती है, अपवाद चारों ओर हैं ()[]{}, मुस्कराते हुए कोई अस्पष्टता नहीं है।

— गैलेन इवानोव

@KevinCruijssen अधिकांश प्रतीकों को wordनामों में इस्तेमाल किया जा सकता है ( Redनहीं है variables, सब कुछ या तो एक wordमूल्य है (या कुछ सिंटैक्स ब्लॉक जैसे [...]या (...))। तो: a*4: 45-> एक शब्द a*4का मान 45 %है। file!डेटाटेयर के लिए एक मार्कर के रूप में उपयोग किया जाता है। और शायद इसीलिए इसे wordनामों में इस्तेमाल नहीं किया जा सकता, लेकिन अन्य अंकगणित संचालकों के लिए नियम तोड़ सकते हैं।

— गालेन इवानोव

आह ठीक है, इसका मतलब है कि /वहाँ एक अलग उद्देश्य है और प्रतीकों का उपयोग चर में रिक्त स्थान के बिना किया जा सकता है (या wordsजैसा कि वे जाहिरा तौर पर लाल के लिए कहा जाता है)। स्पष्टीकरण के लिए धन्यवाद। :) और खुशी है कि मैं (ज्यादातर गलती से) के लिए एक बाइट बचा सकता है s% 2। :)

— केविन क्रूज़सेन

Answer 12

प्रसंस्करण, 140+ बाइट्स

void f(int N){for(int x,y,i,l,d,k=d=y=x=0;k++<N;d+=i<l?0:Integer.bitCount(k)%2*2-1,d&=3,point(x-=~-d%2,y+=(d-2)%2))for(i=1,l=k;0<l%++i%l;);}

स्पष्ट रूप से देखा नहीं पूरा कर सकते हैं