21

प्राकृतिक अनुक्रम 6 पर विचार करें (1 की अवहेलना) :

2,3,4,5,6

हम बाईं ओर से स्कैनिंग शुरू करते हैं (2 से इस मामले में), 2 (यहां 4) द्वारा विभाज्य संख्या की खोज करें और फिर सूची से दोनों संख्याओं को हटा दें (यहां 2 और 4), जैसे कि सूची को कम करता है:

3,5,6

हम एक ही प्रक्रिया जारी रखते हैं, यहाँ बायीं ओर 3 है, इसलिए हम 3 से विभाज्य संख्या खोजते हैं। 6 निश्चित रूप से वह संख्या है और इस प्रकार 3 और 6 को हटा दिया जाता है,

अब, इस तरह की कोई और खोज नहीं की जा सकती है। इस प्रकार, यह n = 6 के लिए ALONED संख्याओं की सूची बन जाती है।

उद्देश्य

1 से अधिक संख्या n को देखते हुए, सभी संगत संख्याओं को प्रिंट करें।

इनपुट

आउटपुट

2
5
8,9,11,12,13,15
11,12,13,15,17,19,20
12,13,15,17,19,20,21

हाँ, उदाहरण के लिए काम किया

एन = 22 के लिए

=>2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22
=>3,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22 (remove 2 & 4)
=>5,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22 (remove 3 & 6)
=>7,8,9,11,12,13,14,15,16,17,18,19,20,21,22 (remove 5 & 10)
=>8,9,11,12,13,15,16,17,18,19,20,21,22 (remove 7 & 14)
=>9,11,12,13,15,17,18,19,20,21,22 (remove 8 & 16)
=>11,12,13,15,17,19,20,21,22 (remove 9 & 18)
=>12,13,15,17,19,20,21 (remove 11 & 22) (OUTPUT)

यह कोड-गोल्फ है , इसलिए बाइट्स में सबसे छोटा कोड जीत जाता है।

code-golf number

— officialaimm
स्रोत

7

बस आपको पता है, हमारे पास एक सैंडबॉक्स है जहां आप मुख्य साइट पर पोस्ट करने से पहले फीडबैक के लिए अधूरी चुनौतियों का सामना कर सकते हैं।

— DJMcMayhem

4

क्या हमें आरोही क्रम में संख्याओं की एक सूची वापस करनी होगी या एक अनियंत्रित सूची या एक सेट स्वीकार्य होगा?

— डेनिस

आरोही क्रम में होना चाहिए।

— आधिकारिक

5

05AB1E , 22 17 15 14 बाइट्स

L¦¹F¬·©¹›_i¦®K

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

व्याख्या

L¦               # push the list [2..input]
  ¹F             # input nr of times do:
          i      # if
    ¬·©          # the first element in the list * 2
       ¹›_       # is less than or equal to input
                 # then
           ¦     # remove first element of list
            ®K   # and remove it's multiple

— Emigna
स्रोत

6

पायथन 2, 90 79 73 बाइट्स

^{-6 बाइट्स एक्सनोर के लिए धन्यवाद}

L=range(2,input()+1)
while L[0]*2<=L[-1]:L.remove(L[0]*2);L=L[1:]
print L

स्टड पर इनपुट नंबर लेता है। Ideone यह!

व्याख्या

हम इनपुट नंबर से प्रारंभिक सूची बनाते हैं और इसे स्टोर करते हैं L। अगला, लूप जबकि अंतिम संख्या पहली संख्या से 2 गुना या उससे अधिक है और सूची से पहली संख्या को 2 गुना हटा दें। यह हमेशा अगले नंबर से विभाज्य होगा L[0]। L=L[1:]पहला नंबर भी बंद कर देता है। जब हालत अब सच नहीं है, तो कोई और निष्कासन नहीं किया जा सकता है, और सूची मुद्रित की जाती है।

— DLosc
स्रोत

पायथन 2 में, rangeपहले से ही एक सूची देता है।

— xnor

@xnor धन्यवाद! उसके बारे में भूल गए।

— DLosc

5

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

lambda n:[i+1for i in range(n/2,n)if-~i&~i&4**n/3>>(-~i&i<1)]

इस कम गोल्फ वाले कोड को समझना थोड़ा आसान है:

lambda n:[i for i in range(n/2+1,n+1)if((i&-i)**.5%1>0)^(i&~-i>0)]

यह अलोन किए गए नंबरों के प्रत्यक्ष लक्षण वर्णन का उपयोग करता है:

एक संख्या iको अलोन किया जाता है यदि, जब i = a * 2^bसाथ विघटित होb विषम के , या तो

a>1 तथा b सम, या है

a==1 तथा b विषम है

के लिए अलोन किए गए नंबर अंतराल में nसभी अलोन किए गए नंबर iहैंn/2 + 1 <= i <= n ।

यह पकड़ क्यों है? जब के लिए प्रक्रिया कर रही है n, हम एक विषम संख्या को दूर कहना a(निचले आधे हिस्से में 1करने के लिए n/2)। फिर, 2*aकोई फर्क नहीं पड़ता कि सूची में यह कहाँ है। तो, 4*aबनी हुई है (यदि यह अस्तित्व में है)। लेकिन अगर यह निचले आधे हिस्से में है, तो हटाने की प्रक्रिया इसे प्राप्त करेगी और दोनों को हटा देगी 4*aऔर 8*a। तो, हम देखते हैं कि ऊपरी-आधा संख्या निकाल दी जाती है यदि यह फ़ॉर्म का है 2*a, 8*a... विषम के साथ c, लेकिन यह रहता है कि यह फ़ॉर्म है a,4*a , 8*a, ...

अपवाद के लिए है a=1, जो सूची में शुरू नहीं होता है और इसलिए हटाया नहीं जाता है। नतीजतन, हटाने की श्रृंखला के साथ शुरू होता है a=2, और 2 की शक्तियों के लिए नियम फ़्लिप किया जाता है।

lambda n:[i for i in range(n/2+1,n+1)if((i&-i)**.5%1>0)^(i&~-i>0)]

ऊपर दिए गए कोड में, (i&-i)**.5%1>0जाँचता है कि क्या बिट के साथ iफॉर्म की कमी है, बिट-ट्रिक द्वारा सबसे बड़ी पावर-ऑफ-टू फैक्टर निकालने के लिए , फिर चेक करें कि क्या परिणाम एक सही वर्ग नहीं है। फिर, यह जांचने के लिए एक और बिट चाल है कि क्या एक सही शक्ति नहीं है 2. ये स्थितियाँ तब xor'ed हैं।i = a * 2^bb2^b = i&-ii&~-i>0i

यहाँ कुछ और सुधार हैं

lambda n:[i+1for i in range(n/2,n)if-~i&~i&4**n/3>>(-~i&i<1)]

सबसे पहले, हम करने के लिए नीचे करने के लिए छोटा करने के लिए सीमा 1 सूचकांक बदलाव range(n/2,n)से range(n/2+1,n+1), सभी जगह करके क्षतिपूर्ति iके साथ i+1(या ~-i)।

2 के एक शक्ति चाहे संख्या का एक शक्ति है 4(2 ^ bसाथ bभी) के साथ और-इंग द्वारा जाँच की जा सकती है 2**c/3कुछ बड़े के लिए c। इसका कारण यह है कि सम-स्थिति बिट्स में 2**c/3बाइनरी प्रतिनिधित्व है 10101...101। c=2*nप्रत्ययों का उपयोग करना । i2 की शक्ति होने पर परिणाम को नकारने के लिए , हम इस संख्या को आधा कर देते हैं, वह स्थिति है, 1इसके बजाय विषम स्थिति में।

— XNOR
स्रोत

4

ग्रूवी, 65 58 बाइट्स

DSLoc से एल्गोरिथम विचार , जिसने देखा कि आपको केवल डबल्स निकालने की आवश्यकता है।

{n->a=(2..n);(2..(n/2)).each{if(it in a){a-=[it,it*2]}};a}

यहाँ एक ब्रेकडाउन है:

{
    n->
    a=(2..n);             // Store [2,...,n].
    (2..(n/2)).each {     // From 2 to half of n.
        if(it in a){      // If it's there...
            a-=[it,it*2]  // Remove it and its double, store in a.
        }
    };
    a                     // Return a.
}

— जादू ऑक्टोपस Urn
स्रोत

4

पर्ल, 53 49 45 44 बाइट्स

के लिए +1 शामिल है -n

STDIN पर इनपुट नंबर दें:

perl -M5.010 aloned.pl <<< 22

aloned.pl:

#!/usr/bin/perl -n
@F[$F[$_*2]/2,$_*2,1]=0,$_&&say for@F=0..$_

संभावित संख्याओं की सीधे जाँच करना लंबा है:

map{/$/;$_/=4until$_%4;$_%2^$_<3&&say$`}$_/2+1..$_

यह ऊपरी आधी सीमा में सभी नंबरों की जांच करता है। उन संख्याओं को रखें जिनमें 2 की एक समान संख्या होती है, जैसे कि यदि संख्या 2 की शक्ति है तो विषम (क्योंकि मूल श्रृंखला से 1 शेष है) को छोड़कर। हालाँकि इस पद्धति को अन्य भाषाओं के लिए अच्छा काम करना चाहिए।

— टन हास्पेल
स्रोत

3

MATL , 18 बाइट्स

@ Emigna के 05AB1E उत्तर से "2 से गुणा" विचार उधार लिया ।

q:Qt"t1)tEhym?6MX-

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

व्याख्या

q:Q        % Input n implicitly. Push [2 3 ... n]
t"         % Duplicate. For each: repeat n-1 times
  t1)      %   Duplicate. Get first element from current array, say k
  tEh      %   Append twice that value: gives array [k 2*k]
  y        %   Push another copy of current array
  m?       %   If both k and 2*k are members of the array 
    6M     %     Push [k 2*k] again
     X-    %     Set difference: remove from current array
           %   End if implicitly
           % End for each implicitly
           % Display implicitly

— लुइस मेंडो
स्रोत

आपको केवल यह जांचने की आवश्यकता है कि क्या k एक सदस्य है, नहीं जानता कि क्या आपको बाइट्स बचाता है या नहीं।

— मैजिक ऑक्टोपस Urn

@carusocomputing धन्यवाद! मैंने शुरू में केवल 2 * k की जाँच की (यदि आपका मतलब है)। फिर मैंने k को वहां जोड़ा क्योंकि बाद में मैंने दोनों एरे के तत्वों को पुन: उपयोग किया दोनों को सामान्य एरे से निकालने के लिए

— लुइस मेंडो

3

हास्केल, 71 69 62 56 बाइट्स

g(a:b)|s<-filter(/=2*a)b=[a|s==b]++g s
g x=x
q n=g[2..n]

प्रयोग उदाहरण: q 22-> [12,13,15,17,19,20,21]।

यदि पहले नंबर का एक से अधिक है a, तो यह है 2*a। रखें aयदि 2*aसूची में नहीं है और साथ एक पुनरावर्ती कॉल संलग्न aऔर 2*aसूची से हटा दिया।

— nimi
स्रोत

हे, मैं आपको बताने जा रहा था कि जीसीडी ओवरकिल थी, लेकिन आपने इसे खुद प्राप्त किया।

— मैजिक ऑक्टोपस Urn

2

पायथ - 19 बाइट्स

विल निश्चित रूप से पुनर्रचना हो।

u?Kf!%ThGtG-tGhKGtS

टेस्ट सूट ।

— Maltysen
स्रोत

2

रूबी, 124

अन्य उत्तरों की तुलना में स्कोर, यह स्पष्ट रूप से गलत दृष्टिकोण है:

->n{a={};b=[*2..n].each{|k|a[k]=7}
b.map{|i|g=b.select{|x|a[i]&&a[x]&&x%i<1}
a[g[0]]=a[g[1]]=!g[1]}
a.select{|k,v|v&k}.keys}

यहाँ कुछ हद तक होशियार सा है a[g[0]]=a[g[1]]=!g[1]जो आवश्यक के रूप में हैश के मूल्यों को सही / गलत निर्धारित करता है।

— चार्ल्स नहीं
स्रोत

2

PHP, 98 बाइट्स

foreach($r=range(2,$argv[1])as$v)$a=&$r[$v-2]&&$b=&$r[$v*2-2]?$b=$a="":(!$a?:print$x?",$a":$x=$a);

8 बाइट्स @ टिट्स द्वारा बचाते हैं थैंक यू से

यदि एक अनुगामी अल्पविराम की अनुमति है, तो इसके (!$a?:print"$a,");बजाय 9 बाइट्स को छोटा किया जा सकता है(!$a?:print$x?",$a":$x=$a);

— जार्ग हुल्सरमन
स्रोत

कोष्ठक की जरूरत है $aऔर काम नहीं $bहै? दुष्ट!

— टाइटस

ट्रेलिंग अल्पविराम के साथ -1 बाइट: (!$a?:print"$a,")-> print$a?"$a,":""। यदि आप विभाजक के रूप में अंडरस्कोर का उपयोग करते हैं तो दोनों संस्करणों के लिए -2 बाइट्स।

— टाइटस

-2 बाइट्स: foreach(... as$v)के $v-2बजाय $kऔर के $v*2-2बजाय $k*2+2।

— टाइटस

@ टिप्पणी की $a=&$r[$k]&&$b=&$r[$k*2+2]तरह मैं यह कोशिश कर चुका हूँ जब आप काम करते हैं $a=$r[$k]and$b=$r[$k*2+2]। मुझे खेद है कि मुझे कोई ऐसा पृष्ठ नहीं मिला जो संदर्भों और &&ऑपरेटर के साथ संयोजन बताता हो । लेकिन मुझे ऐसे संदर्भ चाहिए जो असाइनमेंट न हों। मुझे यकीन नहीं है कि एक अनुगामी अल्पविराम या अन्य विभाजक की अनुमति है।

— जार्ग हुल्सरमन

@ टिट्स ने पाया कि यह अब php.net/manual/en/language.operators.precedence.php & बिटवाइज़ और रेफ़रेंस एक उच्च वरीयता देता है, फिर &&ऑपरेटर

— Jörg Hülsermann

1

जावास्क्रिप्ट, 149 बाइट्स

function a(n){o=Array.from(Array((n+1)).keys());o.shift();o.shift();for(i=1;i<o.length;i++){if(o[i]%o[0]==0){o.splice(i,1);o.shift();i=0;}}return o;}

यहाँ एक काम करने का उदाहरण है। सभी HTML और आवरण () फ़ंक्शन केवल इतना है कि यह वास्तव में इंटरैक्टिव है।

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

<!DOCTYPE html>
<html lang="en">
  <head>
<meta charset="UTF-8">
<title>Aloned</title>
<script>
  function wrapper(){document.getElementById("o").innerHTML = a(parseInt(document.getElementById("i").value));}
  function a(n){o=Array.from(Array((n+1)).keys());o.shift();o.shift();for(i=1;i<o.length;i++){if(o[i]%o[0]==0){o.splice(i,1);o.shift();i=0;}}return o;}
</script>
  </head>
  <body>
<p>Enter an integer:</p>
<p><input type="text" id="i" value="5" /></p>
<p><input type="button" value="Alone It!" onclick="wrapper()" /></p>
<div id="o"></div>
  </body>
</html>

स्निपेट का विस्तार करें

इस ungolfed कोड स्निपेट में कुछ टिप्पणियां हैं और आपको किसी भी इनपुट के लिए अंतःक्रियात्मक रूप से चरण देखने की सुविधा मिलती है।

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

<!DOCTYPE html>
<html lang="en">
  <head>
<meta charset="UTF-8">
<title>Aloned</title>
<script>
  function wrapper()
  {
    document.getElementById("o").innerHTML = aloned(parseInt(document.getElementById("i").value));
  }
  function aloned(n)
  {
    // From nils peterson's comment on benmcdonald's answer
    // http://stackoverflow.com/questions/3895478
    // Creates an array from 0 to n.
    o=Array.from(Array((n+1)).keys());
    
    // Remove 0 and 1 from the start of the array.
    o.shift();
    o.shift();
    
    // s and t are just used to display the output each iteration.
    var s = String(o);
    
    // Go through every item in the array (except the first).
    for(i = 1; i < o.length; i++)
    {
      // Check for an item evenly divisible by the first item.
      if (o[i]%o[0]==0)
      {
        var t=" (remove "+o[0]+" and "+o[i]+")";
        
        // Splice removes the current item, shift removes the first item.
        o.splice(i,1);
        o.shift();
        
        // Reset the array, so we're looping from the beginning again.
        i=0;
        
        s = s + "<br />" + String(o) + t;
      }
    }
    return s + " (OUTPUT)";
  }
</script>
  </head>
  <body>
<p>Enter an integer:</p>
<p><input type="text" id="i" value="5" /></p>
<p><input type="button" value="Alone It!" onclick="wrapper()" /></p>
<div id="o"></div>
  </body>
</html>

स्निपेट का विस्तार करें

— माइकल्स
स्रोत

1

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

f=(n,R=[...Array(n-1)].map((_,i)=>i+2),[i,...r]=R)=>~r.indexOf(i*=2)?f(n,r.filter(x=>x-i)):R

मुझे लगा कि मैंने यह कल पोस्ट किया था, लेकिन स्पष्ट रूप से नहीं ...

यहाँ एक और संस्करण है:

f=(n,R=[...Array(n-1)].map((_,i)=>i+2),[i,...r]=R,q=r.filter(x=>x-i*2))=>q+""!=r+""?f(n,q):R

— ETHproductions
स्रोत

1

जावा 7, 210 बाइट्स

import java.util.*;List c(int n){List<Integer>l=new ArrayList();int i=1;for(;i++<n;l.add(i));for(i=1;i++<n;)for(int x:l)if(i!=x&x%i<1&l.indexOf(i)>=0){l.remove((Integer)i);l.remove((Integer)x);break;}return l;}

निश्चित रूप से एक अलग दृष्टिकोण का उपयोग करके कुछ और गोल किया जा सकता है, शायद कुछ चाल के साथ एक सरणी का उपयोग करके। कास्ट, ब्रेक, टाइप-लिस्ट और इफ-चेक के कारण यह उम्मीद से थोड़ा लंबा है, लेकिन यह काम करता है।

Ungolfed और परीक्षण कोड:

इसे यहाँ आज़माएँ।

import java.util.*;
class M{
  static List c(int n){
    List<Integer> l = new ArrayList();
    int i = 1;
    for(; i++ < n; l.add(i));
    for(i = 1; i++ < n;){
      for(int x : l){
        if(i != x & x%i < 1 & l.indexOf(i) >= 0){
          l.remove((Integer)i);
          l.remove((Integer)x);
          break;
        }
      }
    }
    return l;
  }

  public static void main(String[] a){
    System.out.println(Arrays.toString(c(2).toArray()));
    System.out.println(Arrays.toString(c(6).toArray()));
    System.out.println(Arrays.toString(c(15).toArray()));
    System.out.println(Arrays.toString(c(20).toArray()));
    System.out.println(Arrays.toString(c(22).toArray()));
  }
}

आउटपुट:

[2]
[5]
[8, 9, 11, 12, 13, 15]
[11, 12, 13, 15, 17, 19, 20]
[12, 13, 15, 17, 19, 20, 21]

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

1

रैकेट 191 बाइट्स

(let loop((fl(range 2(add1 n)))(fg #f))(define i(first fl))(for((j(rest fl))
#:when(= 0(modulo j i))#:final(= 0(modulo j i)))
(set! fl(remove*(list i j)fl))(set! fg #t))(if fg(loop fl #f)fl))

असंगठित ('के बाद की टिप्पणियाँ?'):

(define (f n)
  (let loop ((fl (range 2 (add1 n)))  ; create a full list of numbers
             (fg #f))                 ; flag to show if main list is modified
    (define i (first fl))
    (for ((j (rest fl)) #:when (= 0 (modulo j i))  ; test divisibility
                        #:final (= 0 (modulo j i)))
      (set! fl (remove* (list i j) fl))  ; remove these from main list
      (set! fg #t))
    (if fg (loop fl #f)              ; if main list modified, check again,
        fl)))                         ; else print modified list.

परिक्षण:

(f 2)
(f 6)
(f 15)
(f 20)
(f 22)

आउटपुट:

'(2)
'(5)
'(8 9 11 12 13 15)
'(11 12 13 15 17 19 20)
'(12 13 15 17 19 20 21)

— rnso
स्रोत

तैयार किए गए नंबरों को आउटपुट करें

05AB1E , 22 17 15 14 बाइट्स

पायथन 2, 90 79 73 बाइट्स

व्याख्या

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

ग्रूवी, 65 58 बाइट्स

पर्ल, 53 49 45 44 बाइट्स

MATL , 18 बाइट्स

व्याख्या

हास्केल, 71 69 62 56 बाइट्स

पायथ - 19 बाइट्स

रूबी, 124

PHP, 98 बाइट्स

जावास्क्रिप्ट, 149 बाइट्स

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

जावा 7, 210 बाइट्स

रैकेट 191 बाइट्स