Considérez la séquence naturelle jusqu'à 6 (sans tenir compte de 1) :

2,3,4,5,6

Nous commençons à numériser à partir de la gauche (dans ce cas, à partir de 2), recherchons un nombre divisible par 2 (ici 4), puis supprimons les deux numéros de la liste (ici 2 et 4), de sorte que la liste se réduit à:

3,5,6

Nous continuons le même processus, ici le plus à gauche est 3, donc nous recherchons le nombre divisible par 3. 6 est sûrement ce nombre et donc 3 et 6 sont supprimés,

5 

Maintenant, aucune autre recherche de ce type ne peut être effectuée. Ainsi, cela devient la liste des nombres ALONES pour n = 6.

OBJECTIF

1. Étant donné un nombre n supérieur à 1, imprimez tous les nombres alonés correspondants.

CONTRIBUTION

2
6
15
20
22

PRODUCTION

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

ENCORE UN AUTRE EXEMPLE RÉALISÉ

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

Il s'agit de code-golf , donc le code le plus court en octets l'emporte.

05AB1E , 22 17 15 14 octets

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

Essayez-le en ligne!

Explication

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 octets

^{-6 octets grâce à xnor}

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

Prend le numéro d'entrée sur stdin. Ideone it!

Explication

Nous construisons la liste initiale à partir du numéro d'entrée et la stockons L. Ensuite, bouclez pendant que le dernier nombre est supérieur ou égal à 2 fois le premier nombre et supprimez 2 fois le premier nombre de la liste. Ce sera toujours le prochain nombre divisible par L[0]. L=L[1:]enlève également le premier numéro. Lorsque la condition n'est plus vraie, aucun autre retrait ne peut être effectué et la liste est imprimée.

Python, 61 octets

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

C'est un peu plus facile de comprendre ce code moins golfé:

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

Cela utilise une caractérisation directe des nombres alonnés:

Un nombre iest aloné si, lorsqu'il est décomposé comme i = a * 2^bavec bimpair, soit

• a>1et best pair, ou
• a==1et best étrange

Les nombres alonés pour nsont tous des nombres alonés idans l'intervalle n/2 + 1 <= i <= n.

Pourquoi cela tient-il? Lorsque vous effectuez le processus pour n, disons que nous supprimons un nombre impair adans la moitié inférieure ( 1à n/2). Ensuite, il 2*aest supprimé, peu importe où il se trouve dans la liste. Donc, 4*areste (s'il existait). Mais si c'est dans la moitié inférieure, le processus de suppression y parviendra et supprimera les deux 4*aet 8*a. Ainsi, nous voyons qu'un nombre la moitié supérieure se retire si elle est de la forme 2*a, 8*a... avec bizarre c, mais reste si elle a une forme a, 4*a, 8*a, ...

L'exception est pour a=1, qui ne commence pas dans la liste et n'est donc pas supprimée. En conséquence, la chaîne de retrait commence par a=2et la règle des pouvoirs de 2 est inversée.

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

Dans le code ci-dessus, (i&-i)**.5%1>0vérifie s'il imanque la forme i = a * 2^bavec bimpair, par le truc pour extraire le plus grand facteur de puissance de deux 2^b = i&-i, puis vérifie si le résultat n'est pas un carré parfait. Ensuite, i&~-i>0c'est une autre astuce pour vérifier si ce in'est pas une puissance parfaite de 2. Ces conditions sont alors xor'ed.

Il y a d'autres améliorations ici

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

En premier lieu , on décale la plage de 1 index vers le bas pour raccourcir à range(n/2,n)partir range(n/2+1,n+1), compensant en remplaçant tout iavec i+1(ou ~-i).

Si une puissance de 2 est un nombre est une puissance de 4(2 ^ bavec bpair) peut être vérifiée par et avec 2**c/3pour certains grands c. En effet, 2**c/3a une représentation binaire 10101...101avec ceux des bits pairs. Utiliser c=2*nsuffit. Pour annuler le résultat quand iest une puissance de 2, nous divisons par deux ce nombre dans ce cas, en mettant 1à la place les positions impaires.

Groovy, 65 58 octets

Idée d'algorithme de DSLoc , qui a remarqué qu'il suffit de supprimer les doubles.

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

Voici une ventilation:

{
    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 octets

Comprend +1 pour -n

Donnez le numéro d'entrée sur STDIN:

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

aloned.pl:

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

La vérification directe des numéros possibles est plus longue:

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

Cela vérifie tous les nombres dans la moitié supérieure de la plage. Conservez les nombres qui ont un nombre pair de 2 comme facteurs premiers, sauf si le nombre est une puissance de 2, puis impair (car 1 est omis de la série d'origine). Cette méthode devrait cependant bien fonctionner pour d'autres langues.

MATL , 18 octets

A emprunté l'idée "multiplier par 2" à la réponse 05AB1E de @ Emigna .

q:Qt"t1)tEhym?6MX-

Essayez-le en ligne!

Explication

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 octets

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

Exemple d'utilisation: q 22-> [12,13,15,17,19,20,21].

S'il y a un multiple du premier nombre a, alors c'est 2*a. Conservez asi 2*an'est pas dans la liste et ajoutez un appel récursif avec aet 2*asupprimé de la liste.

Pyth - 19 octets

Sera certainement refactoring.

u?Kf!%ThGtG-tGhKGtS

Suite de tests .

Rubis, 124

En comparant les scores à d'autres réponses, c'est évidemment la mauvaise approche:

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

Le morceau un peu intelligent ici est celui a[g[0]]=a[g[1]]=!g[1]qui définit les valeurs du hachage sur vrai / faux si nécessaire.

PHP, 98 octets

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 octets enregistrés par @Titus Merci

Si une virgule de fin est autorisée, elle peut être raccourcie de 9 octets (!$a?:print"$a,");au lieu de(!$a?:print$x?",$a":$x=$a);

Javascript, 149 octets

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

Voici un exemple de travail. Tout le HTML et la fonction wrapper () sont juste pour qu'ils soient réellement interactifs.

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

Cet extrait de code non golfé contient des commentaires et vous permet de voir de manière interactive les étapes d'une entrée donnée.

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

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

Je pensais l'avoir posté hier, mais évidemment pas ...

Voici une autre 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 octets

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

Peut certainement être joué au golf encore plus en utilisant une approche différente, probablement en utilisant un tableau avec quelques astuces. En raison de la distribution, de la rupture, de la liste typée et des vérifications if, c'est un peu plus long que prévu, mais cela fonctionne.

Code non testé et testé:

Essayez-le ici.

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

Sortie:

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

Raquette 191 octets

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

Non golfé (commentaires après ';'):

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

Essai:

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

Sortie:

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