त्रिकोणीय उलम सर्पिल

Question

हम एक मिला है जोड़ी की चुनौतियों ऊलाम सर्पिल के बारे में। लेकिन इतना ही काफी नहीं है।

इस चुनौती में हम एक त्रिकोणीय उलम सर्पिल (सामान्य, वर्ग उलम सर्पिल के विपरीत) की साजिश करेंगे। यहाँ एक स्केच है जो सर्पिल जैसा दिखता है।

जैसा कि हम जानते हैं, उलम सर्पिल एक बाहरी सर्पिल में सभी प्राकृतिक संख्याओं की व्यवस्था करता है, और केवल उन लोगों को चिह्नित करता है जो प्रमुख हैं। तो उपरोक्त स्केच में केवल वे संख्याएँ दिखाई देती हैं जो काले रंग में दिखाई देती हैं (प्रिम्स)।

चुनौती

एक नंबर N को इनपुट के रूप में स्वीकार करें और उस नंबर तक त्रिकोणीय उलम सर्पिल प्रदर्शित करें।

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

आउटपुट स्वरूप

निम्न में से कोई भी चुनें।

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

   एन = 12 के लिए एक उदाहरण आउटपुट निम्नानुसार होगा (उपरोक्त स्केच के साथ तुलना)। दूसरा प्लॉट N = 10000 के अनुरूप एक अधिक दिलचस्प उदाहरण है ।

2. उपरोक्त किसी भी छवि प्रारूप (जैसे png, tiff, bmp) के साथ एक छवि फ़ाइल का निर्माण करें ।

3. ASCII कला के रूप में सर्पिल को प्रदर्शित करें , एक ही पंक्ति में अलग-अलग पदों की संख्या के लिए रिक्त स्थान के साथ, गैर-primes के लिए primes और रिक्त स्थान के लिए अपनी पसंद का एक भी वर्ण का उपयोग करें। लीडिंग या ट्रेलिंग स्पेस या न्यूलाइन्स की अनुमति है। उदाहरण के लिए, N = 12 का उपयोग oचरित्र के रूप में किया जाएगा

                o
               · ·
              · o ·
               o · ·
              · o · o
   

   जहां निश्चित रूप से केवल oअपराधों के निशान ही वास्तव में प्रदर्शित होंगे। ·गैर अभाज्य संख्या में यहाँ केवल संदर्भ के लिए दिखाया गया है।

कसौटी जीतना

वास्तविक इनाम अपने आप को उन अद्भुत पैटर्न कोड गोल्फ के लिए देख रहा है , सबसे छोटा कोड जीतता है।

Comments

भविष्य में मैं केवल एक [ग्राफिकल-आउटपुट] और [एससीआई-आर्ट] को चुनने की सलाह दूंगा क्योंकि यह सबमिशन को एक समान बनाता है। लेकिन वैसे भी अच्छी चुनौती। :)

— एलेक्स ए।

@AlexA। धन्यवाद! मैं इसे ध्यान में रखूंगा। तो ... क्या कोई जूलिया जवाब होगा? ;-)

— लुइस मेंडो

वाह, इनाम के लिए धन्यवाद, लेकिन आपको अपना जवाब स्वीकार करना चाहिए। यह है कम से कम। :)

— मार्टिन एंडर

यह अच्छी तरह से लायक है! जवाब स्वीकार करने के लिए, चुनौती नियमों में से एक था "मैं अपना जवाब स्वीकार नहीं करूंगा"। जब मुझे लगा कि इस चुनौती को मैंने अनिवार्य रूप से अपने जटिल-संख्या और चित्रमय कार्यों के साथ MATL को ध्यान में रखा है, तो यह थोड़ा धोखा देने जैसा था :-)

— लुइस मेंडो

Answer 1

CJam, 49 42 बाइट्स

Lri{)mp0S?}%{1$,)/(a@Wf%z+\L*}h;eeSff*W%N*

STDIN में एकल पूर्णांक के रूप में इनपुट। 0प्राइम्स के लिए ASCII ग्रिड के रूप में आउटपुट । सर्पिल का रोटेशन सुसंगत नहीं है: सर्पिल की सबसे बड़ी संख्या हमेशा नीचे पंक्ति पर होगी।

इसका परीक्षण यहां करें।

व्याख्या

मूल विचार यह है कि गणना करते समय त्रिभुज 2 डी सरणी के रूप में त्रिकोण का प्रतिनिधित्व करें। आप पंक्तियों को उलट कर और बाईं ओर सभी पंक्तियों को संरेखित करके इस सरणी को प्राप्त करते हैं:

   4
  5 3
 6 1 2
7 8 9 A

के रूप में प्रतिनिधित्व किया जाएगा

[[7 8 9 A]
 [6 1 2]
 [5 3]
 [4]]

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

                                                           [[B C D E F]
[[7 8 9 A]         [[A 9 8 7]           [[A 2 3 4]          [A 2 3 4]
 [6 1 2]   reverse  [2 1 6]   transpose  [9 1 5]   prepend  [9 1 5]
 [5 3]      ---->   [3 5]      ------>   [8 6]      ---->   [8 6]
 [4]]               [4]]                 [7]]               [7]]

तो यहाँ कोड है। एक विस्तार जिस पर मैं ध्यान आकर्षित करना चाहता हूं वह है अंतिम त्रिकोणीय लेआउट। मुझे लगता है कि यह निफ्टी है। :)

L     e# Push an empty array. This will become the spiral.
ri    e# Read input and convert to integer N.
{     e# Map this block over 0 to N-1...
  )   e#   Increment to get 1 to N.
  mp  e#   Test for primality.
  0S? e#   Select 0 or a space correspondingly.
}%
{     e# While the list we just created is not empty yet...
  1$  e#   Copy the spiral so far.
  ,)  e#   Get the number of lines and increment.
  /   e#   Split the list into chunks of that size.
  (a@ e#   Pull off the first chunk, wrap it in an array, pull up the spiral.
  Wf% e#   Reverse the lines of the spiral.
  z   e#   Transpose the spiral.
  +   e#   Prepend the new line.
  \L* e#   Swap with the remaining chunks and join them back together into a single list.
}h
;     e# Discard the empty list that's left on the stack.
ee    e# Enumerate the spiral. This turns each line into a pair of 0-based index
      e# and the line itself.
Sff*  e# Multiply each element of each pair with a space. For the enumeration index i,
      e# this produces a string of i spaces - the required indentation (keeping in
      e# mind that our spiral is still upside down). For the line itself, this
      e# riffles the cells with spaces, creating the required gaps between the cells.
      e# All of this works because we always end the spiral on the bottom edge.
      e# This ensures that the left edge is always complete, so we don't need
      e# different indentation such as in the N=12 example in the challenge.
W%    e# Reverse the lines to make the spiral point upwards.
N*    e# Join the lines with linefeeds.

Comments

मुझे पता था कि आप पहले होंगे!

— लुइस मेंडो

@LuisMendo मैं वास्तव में इसे छोड़ता जा रहा था, क्योंकि मुझे लगता था कि ग्रिड इंडेक्स की गणना थकाऊ होगी, लेकिन फिर मुझे एहसास हुआ कि मैं लाइनों को जोड़ते हुए पूरे त्रिकोण को घुमा सकता हूं।

— मार्टिन एंडर

मैं हमेशा सीजेएम कार्यक्रमों के आपके स्पष्टीकरण से प्यार करता हूं क्योंकि मैं उन्हें समझ सकता हूं, और मैं आश्चर्यचकित हूं कि ये जटिल, अभी तक कैसे छोटे हैं, ये कार्यक्रम हो सकते हैं।

— ETHproductions

Answer 2

MATL , 48 36 बाइट्स

:1-H*X^.5+Y[2j3/*YP*ZeYsG:Zp)'.'2$XG

वर्तमान रिलीज़ (9.3.0) का उपयोग करता है ।

इसे ऑनलाइन आज़माएं! कोई भी विचार नहीं है कि ऑनलाइन कंपाइलर ASCII को ग्राफिक आउटपुट का अनुवाद करने का प्रबंधन कैसे करता है, लेकिन यह ऐसा करता है कि यह एक ऑक्टेव सुविधा के लिए एक अनुमानित ASCII प्लॉट का उत्पादन करता है जो ऑनलाइन कंपाइलर द्वारा समर्थित है!

संपादित करें (4 अप्रैल, 2016): समारोह Y[का नाम बदलकर k13.0.0 रिलीज कर दिया गया है । ऑनलाइन कंपाइलर का लिंक इस बदलाव को शामिल करता है, ताकि कोड का परीक्षण किया जा सके।

उदाहरण

>> matl
 > :1-H*X^.5+Y[2j3/*YP*ZeYsG:Zp)'.'2$XG
 > 
> 20000

चित्रमय आउटपुट (MATLAB संस्करण दिखाया गया है) पैदा करता है:

व्याख्या

सर्पिल के बाद पथ का पता लगाने के लिए कोड जटिल संख्याओं का उपयोग करता है। जैसा कि चुनौती में पहली आकृति से देखा जा सकता है, सर्पिल के प्रत्येक सीधे पैर में एक खंड है जिसकी लंबाई 1, 2, 3, 4 है ... और चक्रीय रूप से बढ़ती अभिविन्यास 120 डिग्री, 240 डिग्री, 0 degress, 120 degress है। ..

कोड पहले प्रत्येक पूर्णांक संख्या से अगले तक व्यक्तिगत जटिल विस्थापन उत्पन्न करता है। इन जटिल विस्थापनों में परिमाण 1 और कोण है 2*pi/3, 4*pi/3या0 (रेडियन में) है। इस प्रकार वे आसानी से काल्पनिक घातांक के रूप में उत्पन्न हो सकते हैं। उसके लिए, पूर्णांक अनुक्रम 0,1,2,3,3,3,4,4,4,4,4 ... पहले प्रयोग किया जाता है।

यह पूर्णांक अनुक्रम लगभग की तरह "n प्रकट होता है n बार" अनुक्रम (है OEIS A002024 ), और के रूप में प्राप्त किया जा सकता floor(sqrt(2*n)+.5)है, जहां n0,1,2,3 है, ...। गुणा करके 2j*pi/3, जहां jकाल्पनिक इकाई है, वांछित जटिल विस्थापन पैदा करता है।

सर्पिल में पूर्णांक संख्याओं के अनुरूप पदों की गणना करने के लिए विस्थापन जमा होते हैं। सर्पिल में पहला पूर्णांक संख्या, जो है 1, मनमाने ढंग 1से जटिल विमान में स्थिति पर स्थित है।

अंत में, गैर-अभाज्य संख्याओं के अनुरूप पदों को छोड़ दिया जाता है, और शेष को जटिल विमान में रखा जाता है।

:1-H*X^.5+Y[     % floor(sqrt(2*n)+.5) for n from 0 to N-1, where N is implicit input
2j3/*YP*Ze       % exp(2j*pi/3* ... )
Ys               % cumulative sum. Produces complex positions
G:               % vector 1,2...,N, where N is previous input
Zp               % logical index to select only prime numbers
)                % use that index to keep only complex positions of primes
'.'2$XG          % plot using marker '.'

Comments

ओओ मुझे इसे आगे पढ़ने की क्या आवश्यकता है

— ब्रेन गाइडर

यह ऑनलाइन कोशिश करता है! MATL के लिए ग्राफिकल आउटपुट का समर्थन?

— एलेक्स ए।

मैंने सोचा कि टीआईओ ने ग्राफिकल आउटपुट का समर्थन नहीं किया है? यदि ऐसा होता है, तो मैं आसानी से MATL को स्वचालित रूप से छवियों को .pngवेब पेज @AlexA

— लुइस

अरे! मैंने सरल परीक्षण किया ( plot(1:5)) और यह टेक्स्ट-ग्राफिक आउटपुट का उत्पादन करता है !! matl.tryitonline.net/#code=NTpYRw&input= @AlexA। यह कैसा है??

— लुइस मेंडो

वाह! वह तो कमाल है!

— एलेक्स ए।

Answer 3

ड्राइंग के साथ किया जाना चाहिए

LaTeX / PGF, 527 594 बाइट्स

\documentclass{standalone}\usepackage{pgf}\let\z\let\z\e\advance\z\f\ifnum\z\h\the\z\a\newcount\a\i\a\j\a\l\a\x\a\y\a\p\a\q\a\n\i=1\l=1\p=-1\q=1\def\m#1{\e\i by1\e\j by1\e\x by\h\p\e\y by\h\q\pgfmathparse{isprime(\h\i)}\f\pgfmathresult=1\pgfpathcircle{\pgfpoint{\h\x cm}{\h\y cm}}3pt\fi\f\j=\l\e\l by1\j=0\f\p=1\p=-1\q=1\else\f\p=-1\p=0\q=-1\else\p=1\q=0\fi\fi\fi\f#1>0\e#1by-1\m#1\fi}\begin{document}\begin{pgfpicture}\pgftransformcm10{cos(60)}{sin(60)}\pgfpointorigin\n=4000\m\n\pgfusepath{fill}\end{pgfpicture}\end{document}

527 बाइट्स उपरोक्त दस्तावेज है, यानी प्रस्तावना और पैरामीटर (यहां 4000, इसलिए ~ 523 बिना पैरामीटर सहित)। एक पीडीएफ फाइल तैयार करता है।

मूल विचार: ठीक है, बस आकर्षित करें। त्रिकोणीय ग्रिड के लिए मैट्रिक्स परिवर्तन का उपयोग करता है । केवल समस्या यह है कि परिवर्तन से डॉट्स भी प्रभावित होते हैं (और खिंच जाते हैं)। इसलिए मैं दीर्घवृत्त मार्करों के लिए चयन करता हूं :) मेरा मतलब है कि दूसरी छवि में स्पष्ट है (n = 250, 5pt)।

एक और चेतावनी: केवल TeX के अधिकतम स्टैक आकार के कारण 5000 से थोड़ा कम तक संभाल सकता है। पहली छवि n = 4000 के लिए है। जाहिरा तौर पर यह स्टैक आकार बढ़ाने के लिए संभव है , मैंने यह कोशिश नहीं की।

PGF का उपयोग करता है isprime()।

Ungolfed:

\documentclass[border=10cm]{standalone}

\usepackage{pgf}

\newcount\ulami
\newcount\ulamj
\newcount\ulamlen

\newcount\ulamx
\newcount\ulamy
\newcount\ulamdx
\newcount\ulamdy

\ulami=1 %
\ulamj=0 %
\ulamlen=1 %
\ulamdx=-1 %
\ulamdy=1 %
\ulamx=0 %
\ulamy=0 %

\def\ulamplot#1{%
  \advance\ulami by 1 %
  \advance\ulamj by 1 %

  \advance\ulamx by \the\ulamdx %
  \advance\ulamy by \the\ulamdy %

  \pgfpathmoveto{\pgfpoint{\the\ulamx cm}{\the\ulamy cm}}

  \pgfmathparse{isprime(\the\ulami)}
  \let\r=\pgfmathresult
  \ifnum\r=1
    \pgfpathcircle{\pgfpoint{\the\ulamx cm}{\the\ulamy cm}}{5pt}
  \fi

  \ifnum\ulamj=\the\ulamlen %
    \advance\ulamlen by 1 %
    \ulamj=0 %
    \ifnum\ulamdx=1 %
      \ulamdx=-1 %
      \ulamdy=1 %
    \else%
      \ifnum\ulamdx=-1 %
        \ulamdx=0 %
        \ulamdy=-1 %
      \else%
        \ulamdx=1 %
        \ulamdy=0 %
      \fi
    \fi
  \fi

  \ifnum#1>0 %
    \advance#1 by -1 %
    \ulamplot{#1}%
  \fi
}

\begin{document}

\begin{pgfpicture}
  \pgfmathsetmacro{\x}{cos(60)}
  \pgfmathsetmacro{\y}{sin(60)}
  \pgftransformcm{1}{0}{\x}{\y}{\pgfpointorigin}

  \pgfpathmoveto{\pgfpointorigin}
  \color{blue}
  \newcount\ulamn
  \ulamn=400
  \ulamplot{\ulamn}
  \pgfusepath{stroke,fill}
\end{pgfpicture}

\end{document}

Comments

वाह। यह मेरे लिए कभी नहीं हुआ होगा ऐसा करने के लिए LaTeX

— लुइस मेंडो

lualatexयदि मैं आपकी संगत टिप्पणी को सही ढंग से समझता हूं, तो डायनामिक रूप से आवंटित कंपाइलर का उपयोग करना या आपको स्टैक आकार को बायपास करना चाहिए। तो यह आपके जवाब की सीमा नहीं है, जहां आप इसे चलाएंगे, उनमें से अधिकांश कार्यान्वयन में से एक हैं।

— एंड्रास डेक

क्षमा करें, मैंने जाँच की है और इनपुट स्टैक आकार सीमा स्मृति आवंटन से असंबंधित है जिसे मैंने अपनी पिछली टिप्पणी में संबोधित किया है :(

— एंड्रास डीक

@AndrasDeak यह ठीक है, इसे देखने के लिए धन्यवाद। मुझे एक ऐसा तरीका मिला जो स्पष्ट रूप से स्टैक के आकार को बढ़ाता है, लेकिन इसे स्वयं (अभी तक) आज़मा कर नहीं देखा।

@CamilStaps धन्यवाद, मैंने इसी तरह के अन्य पोस्ट पाए हैं, लेकिन मैंने उन्हें कोशिश नहीं की। वैसे भी, मैं क्रिश्चियन फुएर्सनगर के पदों को कैनन के रूप में लेता हूं :)

— डीक

Answer 4

मैथेमेटिका, 94 बाइट्स

ListPlot@Accumulate[Join@@Table[ReIm@Exp[2i Pi/3I],{i,2#^.5},{i}]][[Prime@Range@PrimePi@#-1]]&

परिणाम

%[10000]

Answer 5

पायथन, 263 बाइट्स

पायथन के लिए नया होने के नाते, वहाँ निश्चित रूप से सुधार की गुंजाइश है :)

from matplotlib.pyplot import*
from math import*
def f(m):
 s=[];X=[];Y=[];i=x=y=0
 while len(s)<m:i+=1;s+=[i%3*pi*2/3]*i
 for i in range(m):
  x+=cos(s[i]);y+=sin(s[i]);j=i+2
  if all(map(lambda a:j%a>=1,range(2,int(j**.5+1)))):X+=[x];Y+=[y]
 scatter(X,Y);show()

उदाहरण:

f(100000)

Comments

आप छोटा कर सकते हैं s=[];X=[];Y=[];i=1;x=0;y=0करने के लिएs=X=Y=[];i=1;x=y=0;

— rp.beltran

अंत में उस अतिरिक्त अर्धविराम को अनदेखा करें। यह आपको 8 बाइट को छोड़ देना चाहिए।

— rp.beltran

@ rp.beltran। यह काम नहीं करता। मुझे लगता है कि यह इस तथ्य से संबंधित है कि वस्तुएं समान मूल्यों को साझा करती हैं। ही जोड़ सकता था x=y=0।

— लैंब्रुस्कोअकिडो

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

— rp.beltran

Answer 6

आर, 137 बाइट्स

केवल अंतर्निहित कार्यों का उपयोग करता है, यहां तक ​​कि अभाज्य संख्याओं के लिए भी। पुनरावृत्ति के बजाय इसके सदिश दृष्टिकोण को देखते हुए, यह तेज़ है, लेकिन बड़ी संख्या को संभाल नहीं सकता है।

golfed:

g=function(m){M=1:m;s=rep(M,M)[M]%%3*pi*2/3;k=cumsum;j=sapply(seq(s)+1,function(n)n<4|all(n%%2:n^.5>=1));plot(k(cos(s))[j],k(sin(s))[j])}

Ungolfed:

g=function(m) {
  M = 1:m
  s = rep(M,M)[M] %% 3 * pi * 2/3
  k=cumsum
  j=sapply(seq(s)+1,function(n)n<4|all(n%%2:n^.5>=1)) # primes
  plot(k(cos(s))[j],k(sin(s))[j])    # cumulated coordinates
}

उदाहरण:

g(10000)

Comments

क्या आप एक उदाहरण परिणाम जोड़ सकते हैं?

— लुइस मेंडो

@LuisMendo। ज़रूर। मुझे केवल यह पता लगाना था कि प्लॉट कैसे जोड़ा जाए।

— लैंब्रुस्कोअकिडो