Betrachten Sie die natürliche Reihenfolge bis 6 (ignorieren Sie 1) :

2,3,4,5,6

Wir scannen von links (in diesem Fall von 2), suchen nach einer durch 2 teilbaren Zahl (hier 4) und entfernen dann beide Zahlen aus der Liste (hier 2 & 4), sodass die Liste sich auf Folgendes reduziert:

3,5,6

Wir setzen den gleichen Prozess fort, hier ganz links ist 3, also suchen wir nach einer durch 3 teilbaren Zahl. 6 ist mit Sicherheit diese Zahl und somit werden 3 und 6 entfernt.

5 

Nun können keine weiteren derartigen Suchvorgänge durchgeführt werden. Somit wird dies die Liste von ALONED-Zahlen für n = 6.

ZIELSETZUNG

1. Wenn n größer als 1 ist, drucken Sie alle entsprechenden Alone-Nummern.

EINGANG

2
6
15
20
22

AUSGABE

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

NOCH EIN ANDERES AUSGEARBEITETES BEISPIEL

Für n = 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)

Das ist Code-Golf , also gewinnt der kürzeste Code in Bytes.

05AB1E , 22 17 15 14 Bytes

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

Probieren Sie es online!

Erläuterung

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

Python 2, 90 79 73 Bytes

^{-6 Bytes dank xnor}

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

Nimmt die eingegebene Nummer auf stdin. Ideone es!

Erläuterung

Wir konstruieren die Anfangsliste aus der eingegebenen Nummer und speichern sie in L. Schleifen Sie als nächstes, während die letzte Zahl größer oder gleich dem Zweifachen der ersten Zahl ist, und entfernen Sie das Zweifache der ersten Zahl aus der Liste. Dies ist immer die nächste Zahl, die durch teilbar ist L[0]. L=L[1:]nimmt auch die erste Nummer ab. Wenn die Bedingung nicht mehr erfüllt ist, können keine weiteren Entfernungen vorgenommen werden, und die Liste wird gedruckt.

Python, 61 Bytes

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

Es ist ein bisschen einfacher, diesen weniger Golf-Code zu verstehen:

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

Dies nutzt eine direkte Charakterisierung von Aloned Numbers:

Eine Zahl iwird aloned wenn bei Verwendung als zerlegt i = a * 2^bmit bungerader entweder

• a>1und bist gerade, oder
• a==1und bist komisch

Die Aloned-Nummern für nsind alle Aloned-Nummern iim Intervall n/2 + 1 <= i <= n.

Warum gilt das? Wenn Sie den Vorgang für nausführen, sagen wir, wir entfernen eine ungerade Zahl ain der unteren Hälfte ( 1bis)n/2 ). Dann 2*awird entfernt, egal wo in der Liste es ist. Also 4*ableibt (wenn es existiert). Wenn es sich jedoch in der unteren Hälfte befindet, gelangt der Löschvorgang dorthin und entfernt beide 4*aund 8*a. So sehen wir , dass eine obere Hälfte Nummer entfernt wird , wenn es von Form ist 2*a, 8*a... mit ungeraden c, aber bleibt , wenn es Form hat a, 4*a, 8*a, ...

Die Ausnahme ist für a=1, die nicht in der Liste beginnt und so nicht entfernt wird. Infolgedessen beginnt die Entfernungskette mit a=2und die Regel für Zweierpotenzen wird umgedreht.

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

In dem obigen Code, (i&-i)**.5%1>0ob Kontrollen ifehlen die Form i = a * 2^bmit bungeraden, durch den Bit-Trick , um den größten Macht-of-Zwei - Faktor, zu extrahieren 2^b = i&-i, dann überprüft , ob das Ergebnis nicht ein perfekter Platz. Dann i&~-i>0ist ein weiterer Trick, um zu überprüfen, ob ikeine perfekte Potenz von 2 vorliegt. Diese Bedingungen werden dann korrigiert.

Hier gibt es noch einige Verbesserungen

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

Zuerst verschieben wir den Index für den Bereich 1 nach unten, um ihn auf zu verkürzen range(n/2,n) vonrange(n/2+1,n+1) und kompensieren dies, indem alle idurch i+1(oder ~-i) ersetzen .

Ob eine Potenz von 2 ist die Nummer eine Potenz von 4(2 ^ bmit bselbst) durch und-ing mit geprüft werden , 2**c/3für einige große c. Dies liegt daran, dass 2**c/3eine binäre Darstellung 10101...101mit Einsen in den geradzahlig positionierten Bits vorliegt. Mit c=2*ngenügt. Ergebnis zu negieren, wenni eine Potenz von 2 ist, halbieren wir diese Zahl in diesem Fall, indem wir 1stattdessen die ungeraden Positionen verwenden.

Groovy, 65 58 Bytes

Algorithmusidee von DSLoc , der gemerkt hat, dass man nur die entfernen muss.

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

Hier ist eine Aufschlüsselung:

{
    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.
}

Perl, 53 49 45 44 Bytes

Beinhaltet +1 für -n

Geben Sie die Eingangsnummer für STDIN ein:

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

aloned.pl:

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

Die direkte Überprüfung der möglichen Nummern ist länger:

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

Dies überprüft alle Zahlen im oberen Bereich. Behalten Sie Zahlen mit einer geraden Zahl von 2 als Primfaktoren bei, es sei denn, die Zahl ist eine Potenz von 2 und dann ungerade (da 1 nicht in der ursprünglichen Reihe enthalten ist). Diese Methode sollte jedoch für andere Sprachen gut funktionieren.

MATL , 18 Bytes

Ausgeliehene Idee "Multiplizieren mit 2" aus @ Emignas Antwort 05AB1E .

q:Qt"t1)tEhym?6MX-

Probieren Sie es online!

Erläuterung

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

Haskell, 71 69 62 56 Bytes

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

Anwendungsbeispiel: q 22-> [12,13,15,17,19,20,21].

Wenn es ein Vielfaches der ersten Zahl gibt a, dann ist es 2*a. Behalten Sie bei, awenn 2*anicht in der Liste und fügen Sie einen rekursiven Anruf hinzu aund 2*aentfernen Sie ihn aus der Liste.

Pyth - 19 Bytes

Wird definitiv umgestalten.

u?Kf!%ThGtG-tGhKGtS

Test Suite .

Ruby, 124

Der Vergleich von Punktzahlen mit anderen Antworten ist offensichtlich der falsche Ansatz:

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

Das etwas clevere Bit hier ist, a[g[0]]=a[g[1]]=!g[1]das die Hash-Werte nach Bedarf auf wahr / falsch setzt.

PHP, 98 Bytes

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 Bytes sparen durch @Titus Danke

Wenn ein nachlauf Komma erlaubt wird , dann kann es 9 Bytes verkürzen (!$a?:print"$a,");statt(!$a?:print$x?",$a":$x=$a);

Javascript, 149 Bytes

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

Hier ist ein funktionierendes Beispiel. Alle HTML- und wrapper () -Funktionen sind nur so, dass sie tatsächlich interaktiv sind.

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

Dieses Code-Snippet enthält einige Kommentare und ermöglicht es Ihnen, die Schritte für eine bestimmte Eingabe interaktiv anzuzeigen.

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

JavaScript (ES6), 92 Byte

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

Ich dachte, ich hätte das gestern gepostet, aber offensichtlich nicht ...

Hier ist eine andere Version:

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

Java 7, 210 Bytes

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

Kann definitiv mit einem anderen Ansatz, wahrscheinlich mit einem Array mit einigen Tricks, noch mehr Golf gespielt werden. Aufgrund der Besetzung, der Unterbrechung, der getippten Liste und der If-Checks ist es etwas länger als erwartet, aber es funktioniert.

Ungolfed & Testcode:

Probieren Sie es hier aus.

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

Ausgabe:

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

Schläger 191 Bytes

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

Ungolfed (Kommentare nach ';'):

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

Testen:

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

Ausgabe:

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