Номери дробовика - це послідовність із досить простим визначенням, але деякою цікавою структурою. Почніть з натуральних чисел:

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 числа. Таким чином, ми можемо визначити нескінченну послідовність чисел Shotgun як межу відпуску k до нескінченності. Перші 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, знайдіть номер nth Shotgun. Ви можете написати програму або функцію, взявши введення через STDIN (або найближчу альтернативу), аргумент командного рядка або аргумент функції і повернути вихідний результат або роздрукувати його в STDOUT (або найближчій альтернативі).

Це код гольфу, тому виграє найкоротше подання (у байтах).

Табло лідерів

Це отримує більше відповідей, ніж я думав, а також кілька людей, які змагаються однією мовою. Отже, тут є фрагмент стека для створення як звичайного табло, так і огляду переможців за мовою.

Щоб переконатися, що ваша відповідь відображається, будь ласка, почніть свою відповідь із заголовка, використовуючи наступний шаблон Markdown:

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

Спробуйте його онлайн тут

При цьому використовуються ті ж хитрощі, щоб перетворити цикл часу в складку, як це робить інша програма Pyth нижче.

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

Наївна копія алгоритму @ Sp3000, перекладена на Pyth.

Ви можете спробувати онлайн тут

Використовує скорочення (ім'я пітона для fold), щоб імітувати цикл while. Він перераховує те, над range(input, 2)чим працює Pyth range(2, input)[::-1]. Інші гольфи, пов'язані з Pyth, передбачають використання notзамість <2та використання yприхованого режиму подвоєння значення числових аргументів.

> <>, 52 45 байт

Сторінка Esolangs для> <>

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

Завдяки декількома необхідними модулями та множеннями існує багато елементів копіювання та переміщення. Логіка точно така ж, як і моє рішення Python .

Здійснює введення через кодову точку від STDIN, наприклад "!" = 33 -> 75.

Python 2, 58 байт

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

Як і більшість інших відповідей, ідея полягає в тому, щоб працювати назад.

Назвемо крок k+1крок i, так що на кроці будуть замінені iвсі кратні iзнаки. Нам потрібні два простих спостереження:

• Позиція 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.

Отже, для пояснення Python:

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]

Пояснення

Допоміжна функція #приймає два числа nі k, і повертає kth число у списку, визначеному, застосовуючи операцію заміни пари до кожного nth числа. Наприклад, застосувавши його до перших 20 чисел із результатами n = 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]

Результат s nотримується шляхом зменшення ("складання") списку [2..n]функцією другого порядку (.).(#), яка приймає число mі функцію f(спочатку функцію ідентичності id) і повертає функцію, яка приймає kі повертає f (m # k). Наприклад, у випадку, n = 4коли список [2,3,4]зводиться до функції, яка приймає kта повертає id (4 # (3 # (2 # k))). idПотрібно лише для базового випадку n = 1, коли список порожній. Нарешті, ми даємо цій функції на вхід k = n, отримуючи nth число рушниці.

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

Моє перше зусилля з гольфовим кодом. Не ґрунтується на жодній іншій відповіді.

Тепер, коли я переглянув деякі інші, я помітив, що більшість просто визначають функцію, а не повну програму, яка приймає введення та виробляє вихід. ОП попросило провести повну програму з введенням і виходом. Чи прийнято ігнорувати такі вимоги?

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число, а не перші 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

Не так багато для пояснення: Функція #рекурсивно обчислює кількість рушниці в положенні iкроку s. p nповертає число в позиції nкроку n.

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 - неявні 1-й та 2-й аргументи
• $[b;t;f] потрійний оператор, оцінює b з наступним t / f відповідно
• b!a модуль b
• _ пол, кидає результат поділу на цілий
• % поділ
• {...}/[x;y] prime {...} з x і застосовується над списком y, еквівалентно f [f [.. f [f [x; y0]; y1]; .. yn-1]; yn]
• | реверс
• ! функція iota, генеруйте список від 0 до n-1

Common Lisp, 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)&

Я вирішив пограти в моє рефератне рішення. ∣Символ Unicode для «вододілів», і розраховує на 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і -1, оскільки позиції міняються поперемінно вгору і вниз; оскільки g(1) = 1(тому що 1поміняється 2) ми маємо

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 , запозичив цикл у відповіді Мартіна CJam та використовуючи divmodоператора CJam . ( Я сказав, що це буде корисно!).

Джулія, 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

В даний час це засновано на дивовижній відповіді Python @ Sp3000 . Я незабаром перегляну це, бо в Джулії має бути коротший шлях, ніж те, що я тут зробив. Будь-який вклад вітається, як завжди.

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 байт

Тож це трохи бентежить ... перед тим, як опублікувати це, я сам спробував займатися гольфом і дістався до 30 байт у CJam. Жодна з існуючих відповідей поки що не перемогла. Тим часом мені також вдалося відголити ще три байти. У коментарі є коротше рішення 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-Basic 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 байт

По суті це рішення Python Sp3000 (з пропозицією xnor ), перекладене на Ruby. Я, мабуть, міг би гольфувати його в кількох місцях, хоча.

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