एन तक की नकल

Question

एक संख्या को देखते हुए n >= 2, सभी पॉजिटिव पूर्णांकों को nजहां gcd(n, k) == 1( kआउटपुट नंबरों में से किसी एक के साथ) से कम आउटपुट मिलता है। इस तरह की संख्या एक दूसरे के लिए सहानुभूति है।

उदाहरण: 10आउटपुट देता है [1, 3, 7, 9](किसी भी रूप में आपको पसंद है, जब तक कि संख्याओं को अस्पष्ट रूप से अलग किया जाता है और किसी प्रकार की सूची में)। सूची में डुप्लिकेट प्रविष्टियाँ नहीं हो सकती हैं और उन्हें क्रमबद्ध नहीं करना है।

अधिक परीक्षण के मामले:

2 -> [1]
3 -> [1, 2]
6 -> [1, 5]
10 -> [1, 3, 7, 9]
20 -> [1, 3, 7, 9, 11, 13, 17, 19]
25 -> [1, 2, 3, 4, 6, 7, 8, 9, 11, 12, 13, 14, 16, 17, 18, 19, 21, 22, 23, 24]
30 -> [1, 7, 11, 13, 17, 19, 23, 29]

हम भी ऊपर की संख्या की गिनती नहीं कर रहे हैं nजो nपूरी तरह से क्योंकि मैं निश्चित रूप से अनंत समाधान कर रहा हूँ, के लिए मुकाबला कर रहे हैं।

यह भी ध्यान दें: एक दूसरे के प्रति सहानुभूति रखने वाले संख्याओं को एक दूसरे के लिए अपेक्षाकृत प्रमुख या पारस्परिक रूप से प्रमुख भी कहा जाता है।

Comments

1\n3\nवैध उत्पादन के रूप में तारों (जैसे ) की गिनती करें?

— devRicher

@devRicher जो काम करता है, निश्चित है।

— R

N के ऊपर अनंत संख्या में होने के बारे में अंतर्ज्ञान जो मुझे n को सही लगता है। असीम रूप से कई प्राइम हैं, और इसके नीचे प्रत्येक संख्या के साथ एक प्राइम पुलिस होगी। इसलिए, n (जिनमें से कई असीम रूप से बहुत से हैं) से बड़ा हर प्राइम भी कॉपरेम सूची का हिस्सा है।

— ब्रायन जे

@BrianJ सिर्फ इतना ही नहीं। यदि c और n कोप्रेम हैं, तो c + kn और n भी coprimes हैं, सभी पूर्णांक k के लिए ।

— डेनिस

मजेदार तथ्य: इन्हें योगात्मक कहा जाता है ।

— वोजू

Answer 1

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

gÐṂ

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

यह कैसे काम करता है?

g - (मोनडिक) पूरा कार्यक्रम।

जी - महानतम सामान्य भाजक।
 Elements - न्यूनतम लिंक मान वाले तत्वों को रखें (अर्थात GCD == 1 वाले)
       ध्यान दें कि यह स्वचालित रूप से रेंज [1, इनपुट] (समावेशी) बनाता है।

वैधता का प्रमाण

चूँकि हम कोपर्स को केवल निकालना चाहते हैं, इसलिए काम करने की ट्रिक के लिए ग्रेटेस्ट-कॉमन-डिवाइडर लिस्ट का न्यूनतम मूल्य 1 होना चाहिए ÐṂ। आइए साबित करते हैं कि (दो अलग-अलग तरीकों में):

1. अनुमानित रूप से उत्पन्न सीमा, में और । सबसे बड़ा सामान्य भाजक हमेशा एक कड़ाई से सकारात्मक पूर्णांक होता है, इसलिए की गारंटी है और हमेशा न्यूनतम मूल्य होगा।१ gcd ( १ , x ) = $[1, \text{input}]$$1$$\gcd(1, x) = 1\:\:\forall\:\:x \in \mathbb{Z}^{*}$$1$

2. दो लगातार पॉजिटिव पूर्णांक हमेशा कॉपीराइड होते हैं। पर विचार करें , साथ । फिर हम एक और सकारात्मक पूर्णांक लेते हैं, जैसे कि और । y = एक्स + 1 कश्मीर कश्मीर | x कश्मीर | $x, y \in \mathbb{Z}^{*}$$y = x + 1$$k$$k \mid x$$k \mid y$

   इसका मतलब है कि , इसलिए , इस प्रकार । केवल सकारात्मक पूर्णांक विभाजित करने के लिए है तो यह सूची में प्रदर्शित करने के गारंटी है और हमेशा न्यूनतम मूल्य होगा ही,।कश्मीर | ( एक्स + 1 - एक्स ) कश्मीर | 1 1 $k \mid (y - x)$$k \mid (x + 1 - x)$$k \mid 1$$1$$1$

Comments

आपने 9 महीने के बाद अपनी भाषा में डेनिस को बाहर कर दिया!

— एडम सिप

@ Adám मुझे यकीन नहीं है कि क्या ÐṂवापस अस्तित्व में है, वैसे भी मैं इस एक से काफी संतुष्ट हूं।

— श्री एक्सकोडर

रिकॉर्ड के लिए, DṂअस्तित्व में था, लेकिन यह केवल भिक्षुओं के लिए काम करता था। प्रतिबद्ध लागू किया Þ, ÐṂ, ÐṀdyads के लिए 9 मई, 2017 दिनांकित है

— डेनिस

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

— श्री एक्सकोडर

Answer 2

पायथन 2 , 61 47 बाइट्स

lambda n:[k/n for k in range(n*n)if k/n*k%n==1]

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

पृष्ठभूमि

अंगूठी पर विचार करें । हालांकि यह अंगूठी आमतौर पर अवशेष वर्गों modulo उपयोग से परिभाषित की जाती है , इसे के सेट के रूप में भी सोचा जा सकता है , जहां जोड़ और गुणा संचालक द्वारा परिभाषित किए जाते हैं और , जहाँ सामान्य जोड़ को निरूपित करते हैं, पूर्णांक पर गुणा, और मोडुलो ऑपरेटर।n Z n = { 0 , … , n - 1 } a + n b = ( a + b $(Z_n, +_n, \cdot_n)$$n$$Z_n = \{0, \dots, n - 1\}$एक ⋅ n ख = एक ⋅ $a +_n b = (a + b)\:\%\: n$+ $a \cdot_n b = a \cdot b\:\%\: n$$+,\:\cdot\text{, and } \%$

दो तत्वों और के आपसी कहा जाता है गुणक प्रतिलोम सापेक्ष यदि । ध्यान दें कि जब भी ।बी जेड एन एन ए ⋅ एन बी = $a$$b$$Z_n$$n$$a \cdot_n b = 1\:\%\:n$n > $1\:\%\:n = 1$$n > 1$

फिक्स और जाने की एक coprime हो में । यदि के लिए दो तत्व और की , हमारे पास है कि । इसका तात्पर्य यह है कि , और हम उस का अनुसरण करते हैं , अर्थात, समान रूप से विभाजित करता । चूंकि साथ कोई प्राइम डिवाइडर नहीं , इसका मतलब यह है कि । अंत में, क्योंकिएक एन जेड एन एक ⋅ एन एक्स = एक ⋅ n y एक्स वाई जेड एन एक ⋅ $n > 1$$a$$n$$Z_n$$a \cdot_n x = a \cdot_n y$$x$$y$$Z_n$एक ⋅ ( एक्स - y $a \cdot x\:\%\:n = a \cdot y\:\%\:n$एन | एक ⋅ ( एक्स - y ) n एक ⋅ ( एक्स - y ) n एक n | एक्स - वाई - n < एक्स - y < n एक्स = y एक ⋅ एन 0 , ... , एक ⋅ n ( n ( १ ) जेड एन जेड एन एन १ बी $a \cdot (x - y)\:\%\:n = a \cdot x\:\%\:n - a \cdot y\:\%\:n = 0$$n \mid a \cdot (x - y)$$n$$a \cdot (x - y)$$n$$a$$n \mid x - y$$-n < x - y < n$ , हम उस निष्कर्ष निकालते हैं । इससे पता चलता है कि उत्पाद सभी विभिन्न तत्व हैं । चूंकि में बिल्कुल तत्व हैं, इसलिए उन उत्पादों में से एक (और वास्तव में एक) बराबर होना चाहिए , अर्थात, में एक अद्वितीय है जैसे कि ।$x = y$$a \cdot_n 0, \dots, a \cdot_n (n - 1)$$Z_n$$Z_n$$n$$1$ $b$ ए ⋅ एन बी = $Z_n$$a \cdot_n b = 1$

इसके विपरीत, ठीक और जाने का एक तत्व हो कि है नहीं करने के लिए coprime । इस स्थिति में, एक प्रमुख ऐसा है जो और । यदि प्रतिलोम प्रतिलोम स्वीकार करते हैं (चलो इसे कहते हैं ), तो हमारे पास , जिसका अर्थ है कि और इसलिए, , इसलिए । बाद से , हम उसका अनुसरण करते हैंएक जेड एन एन पी पी | एक पी | n एक n ख एक ⋅ n ख = 1 एक ⋅ $n > 1$$a$$Z_n$$n$$p$$p \mid a$$p \mid n$$a$$n$$b$$a \cdot_n b = 1$( एक ⋅ ख - 1 $a \cdot b\:\%\:n = 1$एन | एक ⋅ ख - 1 पी | एक पी | एक ⋅ ख पी | एन पी | एक ⋅ ख - 1 $(a \cdot b - 1)\:\%\:n = a \cdot b\:\%\:n - 1 = 0$$n \mid a \cdot b - 1$$p \mid a$$p \mid a \cdot b$ । दूसरी ओर, बाद से , हम उस का भी अनुसरण करते हैं । इस तरह, , जो इस धारणा का खंडन करता है कि एक अभाज्य संख्या है।$p \mid n$$p \mid a \cdot b - 1$$p \mid (a \cdot b) - (a \cdot b - 1) = 1$$p$

यह सिद्ध करता है कि निम्न कथन समतुल्य हैं ।$n > 1$

• $a$ और सहगल हैं।$n$

• $a$ गुणक व्युत्क्रम modulo स्वीकार करता है ।$n$

• $a$ अद्वितीय गुणात्मक व्युत्क्रम modulo स्वीकार करता है ।$n$

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

में पूर्णांक और के प्रत्येक जोड़े के लिए , पूर्णांक अद्वितीय है; वास्तव में, और भागफल और के शेष हैं से विभाजित , यानी, यह देखते हुए , हम ठीक हो सकता है और , जहां अर्थ है पूर्णांक विभाजन। अंत में, चूंकि, और , का एक तत्व है ; वास्तव में, fact ।ख जेड एन कश्मीर : = एक ⋅ n + ख एक ख कश्मीर n k एक = कश्मीर / n ख = $a$$b$$Z_n$$k := a \cdot n + b$$a$$b$$k$$n$$k$$a = k/n$/ एक ≤ n - 1 ख ≤ n - 1 कश्मीर जेड एन 2 कश्मीर ≤ ( n - 1 ) ⋅ एन + ( n - 1 ) = n 2 - $b = k\:\%\: n$$/$$a ≤ n - 1$$b ≤ n - 1$$k$$Z_{n^2}$$k ≤ (n - 1) \cdot n + (n - 1) = n^2 - 1$

जैसा कि ऊपर उल्लेख किया गया है, यदि और सहानुभूति है, तो एक विशिष्ट जो कि , अर्थात, एक अद्वितीय जैसे और , इसलिए उत्पन्न सूची में बार शामिल होगा ।n ख एक ⋅ $a$$n$$b$$a \cdot b\:\%\:n = 1$कश्मीर / n = एक कश्मीर / n ⋅ $k$$k / n = a$$k / n \cdot k\:\%\:n = (k / n) \cdot (k\:\%\:n)\:\%\:n = 1$$a$

इसके विपरीत, यदि और रहे हैं नहीं coprime, हालत के सभी मानों के लिए झूठी हो जाएगा ऐसी है कि , इसलिए उत्पन्न सूची जाएगा नहीं होते हैं ।$a$कश्मीर / n ⋅ $n$k a $k / n \cdot k\:\%\:n = 1$$k$$a = k / n$$a$

यह साबित होता है कि सूची लैम्ब्डा रिटर्न के सभी शामिल होंगे में की coprimes ठीक एक बार।जेड $n$$Z_n$

Comments

"जीसीडी! हम कहां जा रहे हैं, हमें जीसीडी की जरूरत नहीं है।"

— R

ओह। यही सब मैं लिखना चाहता था, लेकिन जाहिर तौर पर मुझे 15 किरदारों की जरूरत थी। फिर भी, वाह। अच्छा काम।

— एरिक लैगरग्रेन 8

Answer 3

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

gRỊT

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

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

gRỊT  Main link. Argument: n

 R    Range; yield [1, ..., n].
g     Compute the GCD of n and each k in [1, ..., n].
  Ị   Insignificant; return 1 for GCDs less or equal to 1.
   T  Truth; yield the indices of all truthy elements.

Comments

इस भाषा में कोडिंग कुछ लेता हैgRỊT

— ETHproductions

मैं (एबी) 3 बाइट्सÐṂ प्राप्त करने के लिए "न्यूनतम लिंक मूल्य" त्वरित ( ) का उपयोग करने में कामयाब रहा ।

— मिस्टर एक्सकोडर

Answer 4

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

Range@#~GCD~#~Position~1&

थोड़ा अजीब आउटपुट स्वरूप, जहां प्रत्येक परिणाम एक अलग सूची में लिपटे हुए है, उदाहरण के लिए {{1}, {3}, {7}, {9}}। यदि यह ठीक नहीं है, तो मुझे 30 बाइट्स में दो समाधान मिले हैं:

Select[Range[x=#],#~GCD~x<2&]&
#&@@@Range@#~GCD~#~Position~1&

गणितज्ञों के पास वास्तव में CoprimeQबहुत लंबा रास्ता है।

Comments

में क्या Qमतलब है CoprimeQ?

— कॉनर ओ'ब्रायन

@ ConorO'Brien "सवाल" मुझे लगता है। सभी निर्णय समस्या क्यू में निर्मित अंत जैसे EvenQ, PrimeQया SubsetQ।

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

Answer 5

2sable , 4 बाइट्स

कोड:

ƒN¿–

स्पष्टीकरण:

ƒ       # For N in the range [0, input]..
 N¿     #   Compute the GCD of N and the input
   –    #   If 1, print N with a newline

CP-1252 एन्कोडिंग का उपयोग करता है । इसे ऑनलाइन आज़माएं!

Comments

अच्छी नौकरी (लगभग) डेनिस की पिटाई। (हालांकि कुछ मिनट देर से)।

— जकार्इ

Answer 6

पायथन, 93 82 74 बाइट्स

f=lambda a,b:f(b,a%b)if b else a<2
lambda c:[i for i in range(c)if f(i,c)]

fपुनरावर्ती तौर पर कोप्राइम के लिए जाँच करता है, और दूसरा लैम्ब्डा उन्हें उत्पन्न करता है। एक सूची को आउटपुट करता है।

Answer 7

दरअसल , 8 बाइट्स

;╗R`╜┤`░

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

स्पष्टीकरण:

;╗R`╜┤`░
  R`  `░  elements of range(1, n+1) where
;╗  ╜     n and the element
     ┤    are coprime

Comments

मेरा मानना ​​है range(1, n)कि अगर आप किसी भी बाइट को बचाता है तो आप बस कर सकते हैं ।

— ETHproductions

@ETHproductions यह नहीं है। दो विकल्प हैं R( range(1, n+1)) और r( range(n))। चूंकि वे समतुल्य हैं, मैंने चुना R(क्योंकि कोड लिखते समय मैंने गलती से कैप लॉक मारा था)।

— मेगो

हाँ, यही मैंने सोचा है। मुझे ऐसा कोई निर्देश नहीं मिला जो वेतन वृद्धि के लिए समर्पित लगता हो, लेकिन मुझे लगा कि हो सकता है कि कोई भी हो

— ETHproductions

Answer 8

MATL , 7 बाइट्स

:GZd1=f

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

Answer 9

MATLAB / ऑक्टेव, 22 बाइट्स

@(n)find(gcd(1:n,n)<2)

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

Answer 10

जावास्क्रिप्ट (ईएस 6), 64 61 बाइट्स

सहेजे गए 3 बाइट @ user81655 के लिए धन्यवाद

n=>[...Array(n).keys()].filter(b=>(g=a=>b?g(b,b=a%b):a<2)(n))

टेस्ट स्निपेट

f=n=>[...Array(n).keys()].filter(b=>(g=a=>b?g(b,b=a%b):a<2)(n))

for(var i = 2; i < 50; i++) console.log(i + ":", `[${ f(i) }]`);

Comments

आप के a==साथ स्वैप नहीं कर सकते a<2?

— R

@EasterlyIrk निश्चित नहीं है, aकुछ बिंदु पर 0 हो सकता है। मुझे चेक करना होगा

— ETHproductions

आप पैरामीटर filterप्राप्त करने की आवश्यकता को दूर करने के लिए GCD फ़ंक्शन को स्थानांतरित कर सकते हैं b:...keys()].filter(b=>(g=a=>b?g(b,b=a%b):a<2)(n))

— user81655

@ user81655 यह बहुत अच्छा है, धन्यवाद! :-)

— ETHproductions

Answer 11

जेलिफ़िश , 19 18 बाइट्स

p
[#
`B
&~xr1
NnEi

यह सीमा में हर संख्या के प्रमुख गुणन की गणना करके काम करता है और यह जाँचता है कि क्या यह इनपुट के अंतर को दर्शाता है (जेलिफ़िश के पास अभी तक कोई LCD बिल्ड नहीं है)। गोल्फिंग कारणों से, उत्पादन अवरोही क्रम में है। इसे ऑनलाइन आज़माएं!

व्याख्या

सबसे पहले, iमूल्यांकन किया गया इनपुट है; इनपुट के लिए 10, i-सेल का मूल्य है 10।

r1
i

यहां r(श्रेणी) इनपुट पर लागू किया गया है और 1. क्योंकि इनपुट 1 से अधिक है, सीमा अवरोही क्रम में है; इनपुट के लिए 10, यह देता है [9 8 7 6 5 4 3 2 1]।

[#
`B
&~x
Nn

यह हिस्सा एक बड़ा कार्य है, जिसका मूल्यांकन iऊपर की सीमा पर किया जाता है।

~x
n

चौराहे ( nप्रधानमंत्री कारकों में से) ( x)।

&~x
Nn

क्या यह खाली है? ( N)

`
&~x
Nn

स्तर 0 के लिए धागा, रेंज के प्रत्येक तत्व के लिए परीक्षण।

[#
`B
&~x
Nn

फ़िल्टर ( #) बुलियन की इस सूची के संबंध में सीमा। द्वारा उत्पादित फ़ंक्शन [तर्क को #अपने तर्क के रूप में उपयोग करना चाहता है , इसलिए हम किसी भी तर्क को प्राप्त Bकरने से रोकते हैं #। अन्यथा, ~-सेल का मान बड़े फ़ंक्शन के तर्क के रूप में उपयोग किया जाएगा। अंत में, pपरिणाम प्रिंट करता है।

Answer 12

स्टैक्ड, नॉन-कम्यूटिंग, 24 21 बाइट्स

बोरशूनो के माणिक से प्रेरित, 3 बाइट्स सहेजे गए । ( 1 eqको 2<)

{!n:>1+:n gcd 2<keep}

यहाँ यह कोशिश करो!

यह एक एन-लैम्ब्डा है जो एकल तर्क लेता है और सरणी उत्पन्न करता है।

{!n:>1+:n gcd 2<keep}
{!                  }  n-lambda
  n                    push n
   :>                  range [0, n)
     1+                range [1, n]
       :               duplicate
        n gcd          element-wise gcd with n
              2<       element-wise equality with 1
                       this yields the range [1, n] and a boolean mask of coprime numbers
                keep   then, we simply apply the mask to the range and keep coprimes.

Comments

यह गैर-समझौता क्यों है?

— ज़ाचारि

@ZacharyT मुख्य रूप से keepअच्छी तरह से काम नहीं कर रहा था।

— कॉनर ओ'ब्रायन

Answer 13

CJam , 14 बाइट्स

{:X{Xmff%:*},}

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

व्याख्या

हम के सभी संभव divisors की जाँच करने की जरूरत नहीं है aऔर bपरीक्षण करने के लिए है कि क्या वे coprime कर रहे हैं। यह देखने के लिए पर्याप्त है कि क्या bविभाजन के प्रमुख कारक हैं a।

:X     e# Store the input in X.
{      e# Filter the list [0 1 ... X-1] by the results of this block...
  Xmf  e#   Get the prime factors of X.
  f%   e#   Take the current value modulo each of those prime factors.
  :*   e#   Multiply the results. Iff any of them divide the current
       e#   value, there's a 0 in the list, and the result of the product
       e#   is also 0, dropping the value from the resulting list.
},

Answer 14

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

Pick[r=Range@#,r~GCD~#,1]&

Comments

ओह, मैं पिक की तरह कुछ देख रहा हूँ। मुझे लगता है कि अब मुझे खुशी है कि मुझे यह नहीं मिला, हालांकि। ;) लेकिन यह भविष्य की चुनौतियों के लिए बहुत उपयोगी होना चाहिए।

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

Answer 15

पर्ल 6 , 20 बाइट्स

{grep 2>* gcd$_,^$_}

Answer 16

ब्रेकीलॉग , 16 13 बाइट्स

>.$p'(e:A*?),

यह एक ऐसा फंक्शन है जो N को इनपुट के रूप में लेता है , और सभी पूर्णांकों को इससे कम और खसरे से उत्पन्न करता है।

इसे ऑनलाइन आज़माएं! जैसा कि अक्सर ब्रैचीलॉग में होता है, यह एक पूर्ण कार्यक्रम में फ़ंक्शन बनाने के लिए अतिरिक्त कोड जोड़ा गया है; ब्रेकीलॉग दुभाषिया, अगर एक पूर्ण कार्यक्रम के बजाय एक फ़ंक्शन दिया जाता है, तो इसे चलाया जाएगा लेकिन आउटपुट प्रिंट नहीं किया जाएगा, जिसका अर्थ है कि आप वास्तव में इसके कामकाज का निरीक्षण नहीं कर सकते।

स्पष्टीकरण:

एक ब्रैचीलॉग कार्यक्रम बाधाओं की एक श्रृंखला है; आमतौर पर, एक बाधा का एलएचएस अगले का आरएचएस होता है।

>.$p'(e:A*?),
>              The input is greater than
 .             the output, whose
  $p           prime factorisation does
    '(     )   not obey the following constraint:
      e        it has an element which
       :A*     can be multiplied by something to
          ?    produce the input.
            ,  (This comma turns off an unwanted implicit constraint.)

यह देखने के लिए कि सामान्य कारक (जो पहले से ही आउटपुट का प्रमुख कारक माना जाता है) इनपुट का एक मुख्य कारक है, यह देखने के लिए जांच करने का कोई कारण नहीं है । हम पहले से ही जानते हैं कि यह प्रमुख है, इसलिए हम जांच कर सकते हैं कि क्या यह एक कारक है। मैं यहाँ सुखद आश्चर्यचकित हूँ कि :A*?दुभाषिया को अनंत लूप में नहीं भेजता है और ए के लिए एक गैर-पूर्णांक मान की अनुमति नहीं देता है , लेकिन जैसा कि दुभाषिया मुझे चाहता है, मैं उसे ले लूंगा।

Answer 17

Dyalog एपीएल, 10 बाइट्स ।

0~⍨⍳×1=⊢∨⍳

स्पष्टीकरण (इनपुट n):

0~⍨⍳×1=⊢∨⍳
         ⍳ - 1 ... n (Thus, ⎕IO is 1)
       ⊢∨  - Each GCD'd by n
     1=    - Test equality with 1 on each element
   ⍳×      - multiplied by its index
0~⍨        - without 0.

Comments

जिस तरह से आप इसे पढ़ते हैं, वैसा ही एपीएल कोड आपको दिखता है। ⍨

— DJMcMayhem

हां, और यह लगभग हर कोड-गोल्फ-उन्मुख भाषा को ध्वस्त नहीं करता है। :)।

— Zacharý

केवल "काम" क्यों हो सकता है?

— R

मैं सिर्फ यह मानकर चल रहा हूं कि यह काम करेगा।

— ज़ाचारि

@ZacharyT आप इसका परीक्षण क्यों नहीं कर सकते? जब मैं इसे try-apl.org में पेस्ट करता हूं, तो यह अमान्य टोकन के साथ त्रुटि करता है।

— R

Answer 18

Japt -f , 9 8 5 2 बाइट्स

jN

कोशिश करो

• 2 बाइट्स ने ईटीएच को एक ब्रेनफार्ट को इंगित करने के लिए धन्यवाद बचाया , जिसके कारण एक और बाइट बच गई।

Comments

आप कर सकते हैंo f_jU

— ETHproductions

धन्यवाद, @ETHproductions पता नहीं मैं यहाँ क्या सोच रहा था! जब मैं भूल jजाता हूं तो उन (कई) क्षणों में से एक का उपयोग किया जाना चाहिए, यदि 2 नंबर सह-प्रधान हैं।

— झबरा

Answer 19

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

xSelect[Range@x,x~CoprimeQ~#&]

इसमें U + F4A1 शामिल है

Comments

क्या अनुचित है?

— R

@EasterlyIrk एक नामांकित तर्क के साथ एक अनाम फ़ंक्शन का परिचय देता है। यह मम्मा में एक तीर के रूप में प्रदान किया गया है।

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

@MartinEnder ओह, कूल।

— R

U + F4A1 एक निजी उपयोग का पात्र है। जैसा कि मार्टिन ने कहा, यह गणितज्ञ के तीर के रूप में प्रस्तुत किया गया है।

— जकार्इ

Answer 20

हास्केल, 27 बाइट्स

f n=[k|k<-[1..n],gcd n k<2]

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

Answer 21

जूलिया 0.5 , 23 बाइट्स

!n=1÷gcd.(1:n,n)|>find

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

Answer 22

मेमे , 11 बाइट्स गैर-प्रतिस्पर्धी , पुरानी

STDIN की पुनरावृत्ति के रूप में गैर-प्रतिस्पर्धा नया है। UTF-8 एन्कोडिंग का उपयोग करता है।

d`}}]i=1?ip

स्पष्टीकरण:

d     Set program to not output result
`}    Loop next input-times
}]i   GCD of input and loop index
=1?   Is it equal to 1? If yes,
ip    Print out loop index

}अगले इनपुट आइटम तक पहुँचता है, लेकिन जब दिया जाता है तो अंतिम इनपुट के माध्यम से लूप किया जाता है, इसलिए इनपुट करने के 6परिणामस्वरूप 6 6 6 6 6 ...STDIN होगा, जिससे एक से दो आउटपुट पढ़ने के लिए संभव होगा।

Comments

क्या आपने आज ही इस लंग को बनाया है? यदि यह चुनौती से पहले बना है, तो इसे गैर-प्रतिस्पर्धात्मक होना चाहिए।

— R

@EasterlyIrk यह 3 दिन पहले बनाया गया था, इस पर लगातार काम कर रहे थे। इसके अलावा, मुझे लगता है कि आप के बाद मतलब है ?

— devRicher

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

— R

@EasterlyIrk मैं देखता हूं, उस स्थिति में मुझे अपना उत्तर संपादित करना होगा।

— devRicher

हाँ क्षमा करें। : /

— R

Answer 23

05AB1E , 3 बाइट्स

Lʒ¿

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

नई विशेषताएं हैं।

Answer 24

रूबी, ३६ ३४

->n{n.times{|i|p i if i.gcd(n)<2}}

बेशक, यह बहुत ही प्रेरित जवाब नहीं है।

2 बाइट्स ने कॉनर ओ'ब्रायन को धन्यवाद दिया।

Comments

आप कोष्ठक को हटाकर दो बाइट्स निकाल सकते हैं(n)

— कॉनर ओ'ब्रायन

Answer 25

पायथन 3 , 60 बाइट्स

इसके लिए एक नया लैम्ब्डा लिखने के बजाय gcd आयात करें। गोल्फ सुझाव का स्वागत करते हैं। इसे ऑनलाइन आज़माएं!

import math
lambda c:[i for i in range(c)if math.gcd(c,i)<2]

Comments

मुझे नहीं लगता कि आप इसे और अधिक बढ़ा सकते हैं । एमसीडी बाइट्स के रूप में सीधे जीडीपी आयात करना या गणित करना।

— R

Answer 26

जूलिया, 30 बाइट्स

n->filter(x->(gcd(n,x)<2),1:n)

अनाम फ़ंक्शन। filterएक सूची से तत्वों को हटाता है जो एक फ़ंक्शन के अनुसार सत्य नहीं है।

इस मामले में, फ़ंक्शन है x->(gcd(n,x)<2)(इनपुट और सूची तत्व के gcd 2 से कम होने पर सच है)। सूची श्रेणी है 1:n।

Answer 27

PARI / GP , 27 बाइट्स

n->[k|k<-[1..n],gcd(k,n)<2]

यह संस्करण 2.6.0 (2013) में पेश किए गए सेट-नोटेशन का उपयोग करता है। पहले के संस्करणों में, चार और बाइट्स की आवश्यकता थी:

n->select(k->gcd(k,n)<2,[1..n])

जरूरत होगी।

Comments

यह कैसे काम करता है?

— R

@EasterlyIrk इनमें से अधिकांश सबमिशन के समान हैं - 1 से n तक सीमा बनाएं ( [1..n]), चेक करें कि क्या gcd 1 है ( gcd(n,k)<2), इस प्रॉपर्टी के साथ नंबर लौटाएं। ->समारोह / बंद अंकन, सामान्य कार्य सिंटेक्स की तुलना में 2 बाइट्स से कम है और [...|...<-...,...]सेट अंकन जवाब (उपयोगकर्ता के मैनुअल में खंड 2.3.14 देखते हैं, या के लिए खोज में विस्तार से बताया है <-)।

— चार्ल्स

Answer 28

05AB1E , 4 बाइट्स

GN¿–

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

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

     # implicit input
G    # for N in range(1..input)
 N   # push N
  ¿  # gcd(input, N)
   – # if 1, print N

Answer 29

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

k;f(n){for(k=0;++k/n<n;k/n*k%n-1||printf("%u ",k/n));}

यह मेरे पायथन उत्तर का एक बंदरगाह है ।

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

Answer 30

अजगर , 5 बाइट्स

x1iLQ

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

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

ध्यान दें कि पायथ 0-इंडेक्सिंग का उपयोग करता है।

x1iLQ   Q = eval(input())

x1iLQQ  implicit Q at the end
  iLQQ  [gcd(Q,0), gcd(Q,1), ..., gcd(Q,Q-1)]
x1      all occurences of 1 in the above list (return their indices)