산탄 총 숫자는 오히려 간단한 정의하지만, 몇 가지 흥미로운 구조의 순서입니다. 자연수로 시작하십시오.

1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, ...

이제 2 로 나눌 수있는 인덱스의 모든 숫자 를 쌍으로 묶고 각 쌍의 숫자를 바꾸십시오.

1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, ...
   ^     ^     ^     ^      ^       ^       ^  
    <--->       <--->        <----->         <----
1, 4, 3, 2, 5, 8, 7, 6, 9, 12, 11, 10, 13, 16, ...

지금까지 나눌 인덱스와 동일한 작업을 수행 3 :

1, 4, 3, 2, 5, 8, 7, 6, 9, 12, 11, 10, 13, 16, ...
      ^        ^        ^           ^          
       <------>          <--------->           
1, 4, 8, 2, 5, 3, 7, 6, 10, 12, 11, 9, 13, 16, ...

그리고 4 , 5 , 6 등의 경우 :

1, 4, 8, 2, 5, 3, 7, 6, 10, 12, 11, 9, 13, 16, ...
1, 4, 8, 6, 5, 3, 7, 2, 10, 12, 11, 14, 13, 16, ...
1, 4, 8, 6, 12, 3, 7, 2, 10, 5, 11, 14, 13, 16, ...
1, 4, 8, 6, 12, 14, 7, 2, 10, 5, 11, 3, 13, 16, ...
...

이러한 단계 k를 수행 한 후 첫 번째 k + 1 숫자가 고정됩니다. 그래서 우리는 k 를 무한 대로하게하는 한계로 Shotgun 수의 무한 시퀀스를 정의 할 수 있습니다 . 처음 66 개의 숫자는 다음과 같습니다.

1, 4, 8, 6, 12, 14, 16, 9, 18, 20, 24, 26, 28, 22, 39, 15, 36, 35, 40, 38, 57, 34, 48, 49, 51, 44,
46, 33, 60, 77, 64, 32, 75, 56, 81, 68, 76, 58, 100, 55, 84, 111, 88, 62, 125, 70, 96, 91, 98, 95,
134, 72, 108, 82, 141, 80, 140, 92, 120, 156, 124, 94, 121, 52, 152, 145, ...

재미있는 사실 : 자연수 만 바꾸어도이 시퀀스에는 소수가 없습니다.

도전

정수가 주어지면 샷건 번호를 n > 0찾으십시오 n. STDIN (또는 가장 가까운 대안), 명령 행 인수 또는 함수 인수를 통해 입력을 받아 프로그램 또는 함수를 작성하고 출력을 리턴하거나 STDOUT (또는 가장 가까운 대안)으로 인쇄 할 수 있습니다.

이것은 코드 골프이므로 가장 짧은 제출 (바이트)이 이깁니다.

리더 보드

이것은 내가 생각했던 것보다 더 많은 답변을 얻고 있으며 같은 언어로 경쟁하는 여러 사람들이 있습니다. 다음은 정규 리더 보드와 언어 별 수상자 개요를 생성하는 스택 스 니펫입니다.

답변이 표시되도록하려면 다음 마크 다운 템플릿을 사용하여 헤드 라인으로 답변을 시작하십시오.

# Language Name, N bytes

N제출물의 크기는 어디에 있습니까 ? 당신이 당신의 점수를 향상시킬 경우에, 당신은 할 수 있습니다 를 통해 눈에 띄는에 의해, 헤드 라인에 오래된 점수를 유지한다. 예를 들어 :

# Ruby, <s>104</s> <s>101</s> 96 bytes

function answersUrl(e){return"http://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function getAnswers(){$.ajax({url:answersUrl(page++),method:"get",dataType:"jsonp",crossDomain:true,success:function(e){answers.push.apply(answers,e.items);if(e.has_more)getAnswers();else process()}})}function shouldHaveHeading(e){var t=false;var n=e.body_markdown.split("\n");try{t|=/^#/.test(e.body_markdown);t|=["-","="].indexOf(n[1][0])>-1;t&=LANGUAGE_REG.test(e.body_markdown)}catch(r){}return t}function shouldHaveScore(e){var t=false;try{t|=SIZE_REG.test(e.body_markdown.split("\n")[0])}catch(n){}return t}function getAuthorName(e){return e.owner.display_name}function process(){answers=answers.filter(shouldHaveScore).filter(shouldHaveHeading);answers.sort(function(e,t){var n=+(e.body_markdown.split("\n")[0].match(SIZE_REG)||[Infinity])[0],r=+(t.body_markdown.split("\n")[0].match(SIZE_REG)||[Infinity])[0];return n-r});var e={};var t=0,c=0,p=-1;answers.forEach(function(n){var r=n.body_markdown.split("\n")[0];var i=$("#answer-template").html();var s=r.match(NUMBER_REG)[0];var o=(r.match(SIZE_REG)||[0])[0];var u=r.match(LANGUAGE_REG)[1];var a=getAuthorName(n);t++;c=p==o?c:t;i=i.replace("{{PLACE}}",c+".").replace("{{NAME}}",a).replace("{{LANGUAGE}}",u).replace("{{SIZE}}",o).replace("{{LINK}}",n.share_link);i=$(i);p=o;$("#answers").append(i);e[u]=e[u]||{lang:u,user:a,size:o,link:n.share_link}});var n=[];for(var r in e)if(e.hasOwnProperty(r))n.push(e[r]);n.sort(function(e,t){if(e.lang>t.lang)return 1;if(e.lang<t.lang)return-1;return 0});for(var i=0;i<n.length;++i){var s=$("#language-template").html();var r=n[i];s=s.replace("{{LANGUAGE}}",r.lang).replace("{{NAME}}",r.user).replace("{{SIZE}}",r.size).replace("{{LINK}}",r.link);s=$(s);$("#languages").append(s)}}var QUESTION_ID=47338;var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe";var answers=[],page=1;getAnswers();var SIZE_REG=/\d+(?=[^\d&]*(?:&lt;(?:s&gt;[^&]*&lt;\/s&gt;|[^&]+&gt;)[^\d&]*)*$)/;var NUMBER_REG=/\d+/;var LANGUAGE_REG=/^#*\s*([^,]+)/

body{text-align:left!important}#answer-list,#language-list{padding:10px;width:290px;float:left}table thead{font-weight:700}table td{padding:5px}

<script src=https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js></script><link rel=stylesheet type=text/css href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"><div id=answer-list><h2>Leaderboard</h2><table class=answer-list><thead><tr><td></td><td>Author<td>Language<td>Size<tbody id=answers></table></div><div id=language-list><h2>Winners by Language</h2><table class=language-list><thead><tr><td>Language<td>User<td>Score<tbody id=languages></table></div><table style=display:none><tbody id=answer-template><tr><td>{{PLACE}}</td><td>{{NAME}}<td>{{LANGUAGE}}<td>{{SIZE}}<td><a href={{LINK}}>Link</a></table><table style=display:none><tbody id=language-template><tr><td>{{LANGUAGE}}<td>{{NAME}}<td>{{SIZE}}<td><a href={{LINK}}>Link</a></table>

피스, 19 22

u-G*H^_!%GH/GHrhQ2Q

@PeterTaylor의 golfscript answer의 상당히 순진한 구현 .

여기에서 온라인으로 사용해보십시오

이것은 아래의 다른 Pyth 프로그램과 같은 트릭을 사용하여 while 루프를 폴드로 변환합니다.

u+G**H!%GHty%/GH2rhQ2Q

@ Sp3000 알고리즘 의 순진한 사본이 Pyth로 번역되었습니다.

여기에서 온라인으로 시도해 볼 수 있습니다

while 루프를 에뮬레이트하기 위해 reduce (python의 fold 이름)를 사용합니다. 그것은 range(input, 2)Pyth 가 무엇을 해결 하는지를 열거 합니다 range(2, input)[::-1]. 다른 Pyth 관련 골프는 숫자 인수 값을 두 배로 늘리는 not대신 숨겨진 모드를 <2사용 y합니다.

> <>, 52 45 바이트

> <>의 Esolangs 페이지

i:&&:&1-?vn;
2*1-*+20.>:&:&%1(&:&*{:}&:1-&,2%

여러 모듈로와 곱셈 덕분에 많은 복사 및 이동 요소가 있습니다. 논리는 내 파이썬 솔루션 과 정확히 동일 합니다 .

취하고 코드 포인트를 통해 입력 예 STDIN에서 "!" = 33 -> 75.

파이썬 2, 58 바이트

i=n=input()
while~-i:n+=(n%i<1)*i*(n/i%2*2-1);i-=1
print n

대부분의 다른 답변과 마찬가지로 아이디어는 거꾸로 작동하는 것입니다.

step에서 모든 배수 가 서로 바뀌 도록 step k+1step을 호출 하십시오 . 두 가지 간단한 관찰이 필요합니다.iii

• n배열의 위치 는로 나눌 수있는 i경우 에만 단계에서 스왑 n됩니다 i.
• 스왑에서 더 낮은 숫자인지 높은 숫자인지 알려면를 참조하십시오 n/i mod 2. 이 값이 1이면 숫자가 낮고 스왑됩니다. 그렇지 않으면 숫자가 높으며 스왑됩니다.

이것은 우리에게 역행을위한 알고리즘을 제공합니다. 마지막 단계부터 시작하여 6 단계로 시도해 보겠습니다 (단계 i = 6).

Step 6: Position 6 swaps with position 12 (6 is divisible by 6, 6/6 = 1 == 1 mod 2)

이제 우리는이 숫자가 12 번 위치에서 왔다는 것을 알고 있습니다.

Step 5: No swap (12 not divisible by 5)
Step 4: Position 12 swaps with position 16 (12 is divisible by 4, 12/4 = 3 == 1 mod 2)

이제 우리는 그것이 16 살 이전에 왔다는 것을 알고 있습니다. 드디어:

Step 3: No swap (16 not divisible by 3)
Step 2: Position 16 swaps with position 14 (16 divisible by 2, 16/2 = 8 == 0 mod 2)

이것이 첫 번째 단계이기 때문에 (기억하십시오 k+1), 우리는 끝났고 6 번 위치에서 끝나는 숫자는 원래 14 번 위치에서 나왔습니다. 즉 6 번째 샷건 숫자는 14입니다.

이제 파이썬 설명에 대해 :

i=n=input()             Read input, and store into i (step) and n (position)
while~-i:               while i-1 != 0:, or since we're descending with i this is just while i>1:
  n+=                   Add to the current position...
    (n%i<1)*            1* whatever's next if n is divisible by i, otherwise 0* (i.e. nothing)
    i*                  How many positions n might go up/down
    (n/i%2*2-1)         n/i%2 tell us higher/lower, *2-1 maps 0 or 1 to -1 (down) or +1 (up)
  i-=1                  Decrement the step number
print n                 Output

하스켈, 68 바이트

n#k|mod k(2*n)<1=k-n|mod k n<1=k+n|k>0=k
s n=foldr((.).(#))id[2..n]n

아마도 더 많은 골프, 특히 첫 번째 줄. 이것은 샷건 수 s를 가져 와서 n반환 하는 함수 를 정의합니다 n.

map s [1..66]
[1,4,8,6,12,14,16,9,18,20,24,26,28,22,39,15,36,35,40,38,57,34,48,49,51,44,46,33,60,77,64,32,75,56,81,68,76,58,100,55,84,111,88,62,125,70,96,91,98,95,134,72,108,82,141,80,140,92,120,156,124,94,121,52,152,145]

설명

helper 함수 #는 두 개의 숫자 n와를 취하고 페어 스왑 작업을 모든 숫자 에 적용하여 정의 된 목록의 숫자를 k반환합니다 . 예를 들어, 처음 20 개의 숫자에 적용 하면 다음 과 같습니다.knn = 4

map (4#) [1..20]
[1,2,3,8,5,6,7,4,9,10,11,16,13,14,15,12,17,18,19,24]

결과는 숫자 와 함수 (초기 항등 함수 ) 를받는 2 차 함수로 s n목록을 축소 ( "폴딩")하여 가져 오고 반환하는 함수를 반환합니다 . 예를 들어, 목록 이를 반환 하는 함수로 축소되었습니다 . 는 단지 기본 케이스에 필요한 목록이 비어 있습니다. 마지막으로, 우리는이 함수에 input을 부여 하여 샷건 수를 얻습니다 .[2..n](.).(#)mfidkf (m # k)n = 4[2,3,4]kid (4 # (3 # (2 # k)))idn = 1k = nn

CJam, 32 바이트

사양에 따라 요점을 따르십시오. n ^번째 숫자에 영향을 미치지 않도록 더 큰 세트에서 명령 실행

ri:N)2#,:)N{))/2/{:)~\@}%:+}/N(=

여기에서 온라인으로 사용해보십시오

루비, 92 바이트

def s(d,n)
d==1?n:s(d-1,n%d==0?n+(n%(d*2)==0?-d :d):n)
end
n=ARGV[0].to_i
print s(n,n).to_s

나의 첫 번째 코드 골프 노력. 다른 답변을 기반으로하지 않습니다.

이제 다른 것들 중 일부를 살펴 보았으므로 입력을 받아들이고 출력을 생성하는 완전한 프로그램이 아니라 함수를 정의하는 것이 가장 좋습니다. OP는 입력 및 출력을 갖춘 완전한 프로그램을 요청했습니다. 그러한 요구 사항을 무시하는 것이 관례입니까?

84 바이트

n=ARGV[0].to_i
d=n
while d>1
n+=(n%d==0?(n%(d*2)==0?-d :d):0)
d-=1
end
print n.to_s

다른 답변을보고 반복 솔루션이 가능하다는 것을 깨닫고 나면.

파이썬 2, 97 79 자

g=lambda n,k:n>1and g(n-1,k-(k%n<1)*n*(-1)**(k/n%2))or k
n=input()
print g(n,n)

숫자를 거꾸로 추적하여 각 인덱스에 대해 올바른 값을 결정합니다. 알고리즘은 독립적으로 발견되었습니다.

편집 : 이제 n첫 번째 숫자 대신 th 번째 숫자 만 인쇄합니다 n. 물론 반복적 인 접근 방식은 더 짧지 만 Sp3000의 코드를 복사하고 싶지 않습니다.

하스켈, 79 바이트

1#i=i
s#i|i`mod`(2*s)==0=(s-1)#(i-s)|i`mod`s==0=(s-1)#(i+s)|1<2=(s-1)#i
p n=n#n

사용법 : p 66어떤 출력145

설명이 많지 않음 :이 함수 는 step #위치에서 샷건 수를 재귀 적으로 계산합니다 . step 위치 의 숫자를 반환합니다 .isp nnn

k, 41 바이트

{{x+$[y!x;0;$[2!_x%y;y;-y]]}/[x;|2+!x-1]}

 / apply to an int
 {{x+$[y!x;0;$[2!_x%y;y;-y]]}/[x;|2+!x-1]} 42
111
 / apply to 1 through 66
 {{x+$[y!x;0;$[2!_x%y;y;-y]]}/[x;|2+!x-1]}'1+!66
1 4 8 6 12 14 16 9 18 20 24 26 28 22 39 15 36 35 40 38 57 34 48 49 51 44 46 33 60 77 64 32 75 56 81 68 76 58 100 55 84 111 88 62 125 70 96 91 98 95 134 72 108 82 141 80 140 92 120 156 124 94 121 52 152 145

• {...} 람다, x 및 y는 암시 적 첫 번째 및 두 번째 인수입니다.
• $[b;t;f] 삼항 연산자, b를 평가 한 다음 각각 t / f를 평가합니다.
• b!a 모듈로 b
• _ 바닥, 분할 결과를 int로 캐스팅
• % 분할
• {...}/[x;y] x로 소수 {...}를 적용하고리스트 y에 적용하면 f [f [.. f [f [x; y0]; y1]; .. yn-1]; yn]과 같습니다.
• | 역
• ! iota 함수,리스트 0부터 n-1까지 생성

커먼 리스프, 113 91

(반복 : 91)

(defun s(n)(do((r n(1- r)))((= r 1)n)(if(= 0(mod n r))(incf n(* r(if(oddp(/ n r))1 -1))))))

(원본, 재귀 : 113)

(defun s(n &optional(r n))(cond((= r 1)n)((= 0(mod n r))(s(+ n(* r(if(oddp(/ n r))1 -1)))(1- r)))(t(s n(1- r)))))

예

재귀 버전으로 :

(trace s)
(s 10)

  0: (S 10)
    1: (S 20 9)
      2: (S 20 8)
        3: (S 20 7)
          4: (S 20 6)
            5: (S 20 5)
              6: (S 15 4)
                7: (S 15 3)
                  8: (S 18 2)
                    9: (S 20 1)
                    9: S returned 20
         ...
    1: S returned 20
  0: S returned 20

테스트

반복 버전 확인 및 조치 :

(let ((list '(1 4 8 6 12 14 16 9 18 20 24 26 28 22 39 15 36 35 40 38 57 34 48 49 51 44
              46 33 60 77 64 32 75 56 81 68 76 58 100 55 84 111 88 62 125 70 96 91 98 95
              134 72 108 82 141 80 140 92 120 156 124 94 121 52 152 145)))
  (time
   (loop for r in list
         for n from 1
         always (= r (s n)))))

 => T

Evaluation took:
  0.000 seconds of real time
  0.000000 seconds of total run time (0.000000 user, 0.000000 system)
  100.00% CPU
  807,160 processor cycles
  32,768 bytes consed

매스 매 티카, 53 49 바이트

(For[i=n=#,n>1,--n,If[n∣i,i+=Mod[i,2n]2-n]];i)&

참조 구현을 골프로하기로 결정했습니다. 그만큼∣ 3 바이트 "분할"및 계산을위한 유니 코드의 상징이다. 그렇지 않으면 다른 모든 사람과 동일한 알고리즘을 사용합니다.

이름없는 함수를 정의하여 n단일 매개 변수로 사용하고 n샷건 번호를 반환합니다 .

GolfScript, 27 자

~.,(~%{):i\.@%!~)1$i/?i*-}/

설명

경우 f(i, n)위치의 값입니다 n후 i-1변환, 우리는이

f(1, n) = n
f(i, n) = f(i - 1, n % i == 0 ? (((n / i - 1) ^ 1) + 1) * i : n)  for i > 1

여기서 ^비트 xor를 나타내고; 주어진 입력 n이 있으면 계산하고 싶습니다 f(n, n).

재귀 함수에서 루프로의 변환은 흥미롭지 않습니다. 흥미로운 것은

n % i == 0 ? (((n / i - 1) ^ 1) + 1) * i : n

다시 쓸 수 있습니다. 더 확실한 접근 방식은

n + (n % i == 0 ? i : 0) * g(n / i)

일부 g. 위치가 위아래로 번갈아 바뀌면서 와 g사이에서 분명히 번갈아 나타납니다. 이후로 ( 스왑하기 때문에 )1-1g(1) = 112

n + (n % i == 0 ? i : 0) * -1**(1 + n / i)

여기서 **지수를 나타냅니다. 최종 비용 절감은 이것을 다음과 같이 다시 작성함으로써 비롯됩니다

n - i * (n % i == 0 ? -1 : 0)**(n / i)

해부

~             # Evaluate input to get n
.,(~%{        # For n-1 downto 1...
  ):i         #   Let i be that value + 1, so for i = n downto 2...
  \.@%!       #   Find n % i == 0 ? 1 : 0
  ~)          #   Negate
  1$i/?       #   Raise to the power of n/i
  i*-         #   Multiply by i and subtract
}/

CJam, 24 바이트

l~__(,f-{_Imd!~)\#I*-}fI

온라인 데모

이것은 내 GolfScript 답변 의 포트로 Martin의 CJam 답변 에서 루프를 빌리고 CJam의 divmod운영자를 악용 합니다. ( 유용 할 것이라고 말했습니다 !).

줄리아, 61 57 바이트

n->(i=n;while~-i!=0 n+=(n%i<1)*i*(n÷i%2*2-1);i-=1;end;n)

단일 인수 n를 사용하여 n샷건 번호를 반환 하는 명명되지 않은 함수가 생성 됩니다. 호출하려면 이름을 지정하십시오 (예 :) f=n->(...).

예 :

julia> for i = 1:10 println(f(i)) end
1
4
8
6
12
14
16
9
18
20

현재 이것은 @ Sp3000의 멋진 Python 답변을 기반으로 합니다. Julia에서 내가 한 일보다 짧은 방법이 있어야하기 때문에 곧 다시 방문 할 것입니다. 언제나 그렇듯이 모든 의견을 환영합니다.

GML, 76 바이트

n=argument0;i=n;while~-1{n+=(n mod i<1)*i*(n/i mod 2*2-1)i--}show_message(n)

GML에 대한 정보

CJam, 28 27 바이트

그래서 이것은 약간 당혹 스럽습니다 ...이 게시물을 게시하기 전에 직접 골프를 시도하고 CJam에서 30 바이트를 얻었습니다. 기존 답변들 중 어느 것도 아직 이길 수 없었습니다. 그 동안 나는 또한 3 바이트를 더 줄였습니다. 이 인 코멘트에 짧은 Pyth 솔루션은,, 짧은 아무것도 그것이 그래서 여기에 대한 답변에 게시 없습니다. 어쩌면 APL / J 사람들이 내 대답을 받아들이 기 전에 조금 더 열심히 노력하거나 누군가가 Pyth 솔루션을 게시하도록 영감을 줄 수 있습니다. ;)

l~__(,f-{_I_+%_+I-_zI=*+}fI

여기에서 테스트하십시오.

설명

l~                          "Read input N and eval.";
  __(,                      "Duplicate twice, create range [0 1 2 ... N-2].";
      f-                    "Subtract each from N, giving [N N-1 N-2 ... 2].";
        {               }fI "For each element, storing the element in I.";
         _I_+%_+I-          "Compute 2(N % 2I)-I - the shuffling offset";
                  _zI=      "Check that this offset is ±I.";
                      *+    "Multiply the offset by this boolean and update to N.";

J, 34 32 바이트

   (]+[*(1-~2*2|%~)*0=|)/@(_1}2+i.)

   ((]+[*(1-~2*2|%~)*0=|)/@(_1}2+i.)) every 1+i.20  NB. running with inputs 1..20
1 4 8 6 12 14 16 9 18 20 24 26 28 22 39 15 36 35 40 38

좀 더 골프를 치고 나중에 설명을 추가하려고합니다.

여기에서 온라인으로 사용해보십시오.

TI 기본 83/84, 40 바이트

Input A:For(I,A,2,~1:A+(AfPart(I/2)-1)I(1>IfPart(A/I->A:End:A

TI-Basic에 관한 정보

루비, 57 47 바이트

이것은 본질적으로 SP3000 (와의 파이썬 솔루션 XNOR의 제안 루비로 번역). 그래도 몇 군데에서 골프를 칠 수 있습니다.

->n{n.downto(2).map{|i|n+=i*(n/i%2-~-n/i%2)};n}