I numeri del fucile sono una sequenza con una definizione piuttosto semplice ma con una struttura interessante. Inizia con i numeri naturali:

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

Ora prendi tutti i numeri in indici divisibili per 2 , raggruppali in coppie e scambia i numeri in ciascuna coppia:

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

Ora fai lo stesso con gli indici divisibili per 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, ...

E poi per 4 , 5 , 6 e così via:

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

Dopo k tali passaggi, verranno fissati i primi k + 1 numeri. Quindi possiamo definire la sequenza infinita di numeri di Fucile a pompa come limite per lasciare k all'infinito. I primi 66 numeri sono:

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

Curiosità: nonostante sia ottenuto solo permutando i numeri naturali, questa sequenza non contiene numeri primi.

La sfida

Dato un numero intero n > 0, trova il nnumero del fucile. È possibile scrivere un programma o una funzione, prendendo l'input tramite STDIN (o l'alternativa più vicina), l'argomento della riga di comando o l'argomento della funzione e restituendo l'output o stampandolo su STDOUT (o l'alternativa più vicina).

Questo è il golf del codice, quindi vince l'invio più breve (in byte).

Classifiche

Questo sta ottenendo più risposte di quanto pensassi, oltre a diverse persone che competono nella stessa lingua. Quindi ecco uno snippet di stack per generare sia una classifica regolare che una panoramica dei vincitori per lingua.

Per assicurarti che la tua risposta venga visualizzata, ti preghiamo di iniziare la risposta con un titolo, usando il seguente modello Markdown:

# Language Name, N bytes

dov'è Nla dimensione del tuo invio. Se si migliora il punteggio, è possibile mantenere i vecchi punteggi nel titolo, colpendoli. Per esempio:

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

Pyth, 19 22

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

Un'implementazione abbastanza ingenua della risposta di golfscript di @ PeterTaylor .

Provalo online qui

Questo usa gli stessi trucchi per convertire un ciclo while in una piega come fa l'altro programma Pyth qui sotto.

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

Una copia ingenua dell'algoritmo di @ Sp3000 tradotto in Pyth.

Puoi provarlo online qui

Usa la riduzione (nome di Python per piega) per emulare il ciclo while. Enumera su range(input, 2)quale in Pyth risolve range(2, input)[::-1]. Gli altri campi da golf relativi a Pyth implicano l'uso notanziché <2e l'utilizzo ydella modalità nascosta per raddoppiare il valore degli argomenti numerici.

> <>, 52 45 byte

Pagina Esolangs per> <>

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

Ci sono molti elementi di copia e spostamento in giro, grazie ai numerosi moduli e alle moltiplicazioni necessarie. La logica è esattamente la stessa della mia soluzione Python .

Riceve input tramite un punto di codice da STDIN, ad es "!" = 33 -> 75.

Python 2, 58 byte

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

Come la maggior parte delle altre risposte, l'idea è di lavorare all'indietro.

Chiamiamo step k+1step i, in modo che al step itutti i multipli di ivengano scambiati. Abbiamo bisogno di due semplici osservazioni:

• La posizione nnell'array viene scambiata al passaggio solo ise nè divisibile per i,
• Per sapere se sei il numero più basso o il numero più alto nello scambio, guarda n/i mod 2. Se questo è 1 sei il numero più basso (e cambierà in alto), altrimenti sei il numero più alto (e cambierà in basso).

Questo ci dà un algoritmo per lavorare all'indietro. Proviamo con 6, a partire dall'ultimo passaggio (passaggio i = 6):

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

Quindi ora sappiamo che il numero proviene dalla posizione 12. Quindi:

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)

Quindi ora sappiamo che è arrivato da 16 prima. Finalmente:

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)

Dato che questo è il primo passo (ricorda, k+1), abbiamo finito e il numero che finisce nella posizione 6 originariamente proveniva dalla posizione 14, cioè il sesto numero di fucile è 14.

Quindi ora per la spiegazione di 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

Haskell, 68 byte

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

Probabilmente più golfabile, in particolare la prima fila. Questo definisce una funzione sche accetta ne restituisce il nnumero del fucile.

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]

Spiegazione

La funzione helper #accetta due numeri ne k, e restituisce il knumero th nella lista definito applicando l'operazione di scambio di coppia ad ogni nnumero th. Ad esempio, applicandolo ai primi 20 numeri con si n = 4ottiene questo:

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

Il risultato di s nsi ottiene riducendo ("piegando") l'elenco [2..n]con la funzione del secondo ordine (.).(#), che accetta un numero me una funzione f(inizialmente la funzione identità id) e restituisce una funzione che accetta ke restituisce f (m # k). Ad esempio, nel caso in cui n = 4l'elenco [2,3,4]venga ridotto a una funzione che accetta ke restituisce id (4 # (3 # (2 # k))). È idnecessario solo per il caso base n = 1, in cui l'elenco è vuoto. Infine, diamo a questa funzione l'ingresso k = n, ottenendo il nnumero del fucile.

CJam, 32 byte

Basta seguire le specifiche al punto. Esecuzione delle istruzioni su un set più grande in modo da non influenzare l' ^ennesimo numero.

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

Provalo online qui

Rubino, 92 byte

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

Il mio primo sforzo per il golf del codice. Non basato su altre risposte.

Ora che ho visto alcuni degli altri, noto che la maggior parte definisce una funzione, non un programma completo che accetta input e produce output. L'OP ha richiesto un programma completo con input e output. È consuetudine ignorare tali requisiti?

84 byte

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

Dopo aver esaminato altre risposte e aver realizzato che è possibile una soluzione iterativa.

Python 2, 97 79 caratteri

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)

Determina per ciascun indice il valore corretto inseguendo ricorsivamente il numero all'indietro. L'algoritmo è stato scoperto in modo indipendente.

modifica: ora stampa solo il nnumero th anziché i primi nnumeri. Ovviamente un approccio iterativo sarebbe più breve, ma non voglio copiare il codice di Sp3000.

Haskell, 79 byte

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

Utilizzo: p 66quali output145

Non c'è molto da spiegare: la funzione #calcola ricorsivamente il numero del fucile nella posizione idel passo s. p nrestituisce il numero nella posizione ndel passaggio n.

k, 41 byte

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

• {...} lambda, xey sono l'argomento implicito 1o e 2o
• $[b;t;f] operatore ternario, valuta b seguito rispettivamente da t / f
• b!a a modulo b
• _ piano, lancia il risultato della divisione in un int
• % divisione
• {...}/[x;y] prime {...} con x e si applicano sull'elenco y, equivale a f [f [.. f [f [x; y0]; y1]; .. yn-1]; yn]
• | inverso
• ! funzione iota, genera l'elenco da 0 a n-1

Lisp comune, 113 91

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

(originale, ricorsivo: 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)))))

Esempio

Con la versione ricorsiva:

(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

test

Controlli e misure per la versione iterativa:

(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

Mathematica, 53 49 byte

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

Ho deciso di golf la mia implementazione di riferimento. Il ∣è il simbolo Unicode per "divide", e conta per 3 byte. In caso contrario, utilizza lo stesso algoritmo di tutti gli altri.

Definisce una funzione senza nome che accetta ncome singolo parametro e restituisce il nnumero del fucile.

GolfScript, 27 caratteri

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

Spiegazione

Se f(i, n)è il valore in posizione ndopo le i-1trasformazioni, abbiamo

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

dove ^denota xor bit a bit; dato input n, vogliamo calcolare f(n, n).

La conversione da una funzione ricorsiva a un ciclo non è interessante; ciò che è interessante è il modo in cui

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

può essere riscritto. L'approccio più ovvio è dire che deve essere

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

per alcuni g. Ovviamente si galterna tra 1e -1, man mano che le posizioni si alternano su e giù; poiché g(1) = 1(perché si 1scambia fino a 2), abbiamo

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

dove **indica esponenziazione. Il risparmio finale deriva dalla riscrittura di questo

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

Dissezione

~             # 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 byte

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

Demo online

Questa è una porta della mia risposta GolfScript , prendendo in prestito il loop dalla risposta CJam di Martin e sfruttando l' divmodoperatore di CJam . ( Ho detto che sarebbe utile!).

Julia, 61 57 byte

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

Questo crea una funzione senza nome che prende un singolo argomento ne restituisce il nnumero di fucile esimo. Per chiamarlo, dagli un nome, ad es f=n->(...).

Esempi:

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

Attualmente si basa sulla fantastica risposta Python di @ Sp3000 . Lo rivedrò presto perché a Julia ci deve essere un modo più breve di farlo rispetto a quello che ho fatto qui. Qualsiasi input è il benvenuto, come sempre.

GML, 76 byte

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

Informazioni su GML

CJam, 28 27 byte

Quindi questo è leggermente imbarazzante ... prima di pubblicare questo, ho provato a giocare a golf da solo e sono arrivato a 30 byte in CJam. Nessuna delle risposte esistenti lo ha ancora battuto. Nel frattempo sono anche riuscito a radere altri tre byte. V'è una soluzione Pyth più corto in un commento, ma nulla più breve è stata pubblicata in una risposta, ecco che è. Forse ispira le persone APL / J a provare un po 'di più (o qualcuno in realtà pubblica la soluzione Pyth), prima che io debba accettare la mia risposta. ;)

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

Provalo qui.

Spiegazione

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 byte

   (]+[*(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

Proverò a giocare un po 'di più e aggiungerò qualche spiegazione in seguito.

Provalo online qui.

TI-Basic 83/84, 40 byte

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

Informazioni su TI-Basic

Rubino, 57 47 byte

Questo è essenzialmente SP3000 soluzione pitone s'(con suggerimento di XNOR ) tradotto a rubino. Probabilmente potrei giocare a golf in alcuni punti però.

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