최대 6까지의 자연 시퀀스를 고려하십시오 (1 무시) .

2,3,4,5,6

왼쪽 (이 경우 2)에서 스캔을 시작하고 2 (여기 4)로 나눌 수있는 숫자를 검색 한 다음 목록에서 두 숫자 (여기서는 2 & 4)를 제거하여 목록을 다음과 같이 줄입니다.

3,5,6

우리는 동일한 과정을 계속합니다. 여기에서 가장 왼쪽은 3이므로 3으로 나눌 수있는 숫자를 검색합니다. 6은 반드시 그 숫자이므로 3과 6은 제거됩니다.

5 

이제 더 이상 그러한 검색을 수행 할 수 없습니다. 따라서 이것은 n = 6에 대한 ALONED 번호의 목록이됩니다.

목표

1. 숫자 n이 1보다 큰 경우 해당하는 모든 홀수를 인쇄하십시오.

입력

2
6
15
20
22

산출

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

아직 다른 운동 예

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)

이것은 code-golf 이므로 바이트 단위의 가장 짧은 코드가 이깁니다.

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

파이썬 2, 90 79 73 바이트

^{xnor 덕분에 -6 바이트}

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

stdin에서 입력 번호를받습니다. 무시 했어!

설명

입력 번호로부터 초기 목록을 구성하고에 저장합니다 L. 다음으로, 마지막 숫자가 첫 번째 숫자의 2 배 이상인 동안 루프하고 목록에서 첫 번째 숫자의 2 배를 제거하십시오. 이것은 항상 다음으로 나눌 수있는 다음 숫자 L[0]입니다. L=L[1:]첫 번째 숫자도 제거합니다. 조건이 더 이상 충족되지 않으면 더 이상 제거 할 수 없으며 목록이 인쇄됩니다.

파이썬, 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된다 aloned 으로 분해 될 때, 경우 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=22의 거듭 제곱에 대한 규칙이 뒤집어집니다.

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없는지 여부를 확인 하여 최대 2의 제곱 인수를 추출한 다음 결과가 완벽한 제곱이 아닌지 확인합니다. 그런 다음 2의 완벽한 거듭 제곱이 아닌지 확인하는 또 다른 비트 트릭 입니다. 이러한 조건은 xor'ed입니다.ii = 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대신하여 홀수 위치에 넣습니다 .

그루비, 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.
}

펄, 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은 원래 계열에서 제외됨). 그러나이 방법은 다른 언어에서도 잘 작동합니다.

MATL , 18 바이트

@Emigna의 05AB1E answer 에서 "곱하기 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

하스켈, 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목록에서 제거.

Pyth-19 바이트

리팩토링 이 확실 합니다.

u?Kf!%ThGtG-tGhKGtS

테스트 스위트 .

루비, 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]는 필요에 따라 해시 값을 true / false로 설정하는 것입니다.

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 바이트 @Titus에 의해 저장 감사합니다

후행 쉼표가 허용되면 (!$a?:print"$a,");대신 9 바이트 를 줄일 수 있습니다 (!$a?:print$x?",$a":$x=$a);

자바 스크립트, 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과 wrapper () 함수는 실제로 대화식입니다.

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

자바 스크립트 (ES6), 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

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

다른 방법을 사용하여, 아마도 몇 가지 트릭이있는 배열을 사용하여 확실히 더 골프를 칠 수 있습니다. 캐스트, 중단, 유형 목록 및 if-check로 인해 예상보다 약간 길지만 작동합니다.

언 골프 및 테스트 코드 :

여기에서 시도하십시오.

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]

라켓 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))

Ungolfed ( ';'뒤에 주석) :

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