Giriş (yok sayılabilir)

Tüm pozitif tam sayıları düzenli sıraya koymak (1, 2, 3, ...) biraz sıkıcı, değil mi? İşte burada, tüm pozitif tamsayıların permütasyonları (değişiklik) etrafında bir dizi zorluk var. Bu, bu dizideki altıncı mücadeledir ( birinci , ikinci , üçüncü , dördüncü ve beşinci mücadeleye bağlantılar).

Bu meydan okuma hafif bir Paskalya temasına sahiptir (çünkü Paskalya'dır). İlhamımı bu çok süslü (ve kişisel görüşüme göre oldukça çirkin) kaz yumurtasından aldım.

Bana tüm pozitif tamsayıların saat yönünün tersine bir spirale yerleştirildiği Ulam spiralini hatırlattı . Bu spiralin asal sayılarla ilgili bazı ilginç özellikleri vardır, ancak bu bu zorluk için geçerli değildir.

Ulam spiralindeki sayıları alır ve 1'den başlayarak saat yönünde dönen bir spiralde tüm tamsayıları izlersek, bu zorluğun pozitif tamsayıların permütasyonuna ulaşırız . Bu şekilde:

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

Her iki spirali de çizerseniz, bir çeşit sonsuz örgü (yumurta kabuğu) spiral elde edersiniz ( oradaki Yeni Sipariş referansını not edin ).

$a(n)$$n$$a(n)$

Görev

$n$$a(n)$$a(n)$

$a(0) = 1; a(1) = 6$

Test senaryoları

Input | Output
---------------
1     |  1
5     |  3
20    |  10
50    |  72
78    |  76
123   |  155
1234  |  1324
3000  |  2996
9999  |  9903
29890 |  29796

kurallar

• Giriş ve çıkış tamsayılardır.
• Programınız en az 1 ila 32767 aralığındaki girişi desteklemelidir).
• Geçersiz giriş (0, kayan nokta, dize, negatif değerler vb.) Öngörülemeyen çıktılara, hatalara veya (tanımlanmamış) davranışa neden olabilir.
• Varsayılan I / O kuralları geçerlidir.
• Varsayılan boşluklar yasaktır.
• Bu kod golfü , bu yüzden bayttaki en kısa cevaplar kazanıyor

Jöle ,  16 14 11 10 9  8 bayt

-1 Lynn sayesinde (model-2, mantıksal değil, self eklenti: Ḃ¬+-> bit düzeyinde veya 1: |1)

|1×r)ẎQi

Bir tamsayıyı kabul eden ve bir tamsayı nveren monadik bir Bağlantı a(n).

$\lceil\frac n2\rceil$

½‘|1×rƲ€ẎQi$\lceil\frac{\lfloor\sqrt n\rfloor+1}2\rceil$

Nasıl?

Permütasyon, doğal sayıları ters uzunlukta dilimler halinde almaktır [1,5,3,11,5,17,7,23,9,29,11,35,13,...]- beş modulo altıya uygun pozitif tamsayılarla serpiştirilmiş tek pozitif tamsayılar, yani [1, 2*3-1, 3, 4*3-1, 5, 6*3-1, 7, 8*3-1, 9, ...].

Bu ters aralıkları tekilleştirerek sonra birleştirerek ve aynı [1..x]yerde bir x- (diğer bir deyişle, her bir dilimin maksimum) Bu dilim uzunluklarının kümülatif toplamları olan [1,6,9,20,25,42,49,72,81,110,121,156,169,...], tek tamsayı kendileri artırılır ile, yani katlanırken numaraları ile serpilmiş karesi olan [1*1, 2*3, 3*3, 4*5, 5*5, 6*7, 7*7,...].

Farklılıkların 1'den büyük olması nedeniyle [x..k], doğrudan aralıkları oluşturarak bir bayt (tersine çevirme) kaydedebiliriz , burada kdilimin 1 dizinli dizini.

$P(n) = v \iff P(v) = n$n|1×r)ẎQị@n|1×r)ẎQi

|1×r)ẎQi - Link: integer, n       e.g. 10
    )    - for each k in [1..n]:  vs = [ 1, 2, 3, 4, 5, 6, 7, 8, 9,10]
|1       -   bitwise-OR (k) with 1     [ 1, 3, 3, 5, 5, 7, 7, 9, 9,11]
  ×      -   multiply (by k)           [ 1, 6, 9,20,25,42,49,72,81,110]
   r     -   inclusive range (to k)    [[1],[6..2],[9..3],[20..4],...,[110..10]]
     Ẏ   - tighten                     [1,6,5,4,3,2,9,8,7,6,5,4,3,20,...,4,......,110,...,10]
      Q  - de-duplicate                [1,6,5,4,3,2,9,8,7,20,...,10,......,110,...82]
       i - first index with value (n)  20

JavaScript (ES7),  46 45  41 bayt

0 endeksli.

n=>((x=n**.5+1&~1)*2-(n<x*x+x)*4+3)*x+1-n

Çevrimiçi deneyin!

Nasıl?

Bu, A090861'in örnek programlarında kullanılan 1 dizinli formüle dayanmaktadır .

$x_n$$0$

Çevrimiçi deneyin!

$k_n$$6$$-2$

Çevrimiçi deneyin!

$a_n$

Çevrimiçi deneyin!

Hangi dile çevrilebilir:

n=>8*(x=(n-1)**.5+1>>1)*x+(n<=4*x*x+2*x?-2:6)*x+2-n

0 dizinli hale getirmek hemen 5 bayt tasarruf sağlar:

n=>8*(x=n**.5+1>>1)*x+(n<4*x*x+2*x?-2:6)*x+1-n

Formül aşağıdakiler kullanılarak daha da basitleştirilebilir:

hangi olarak ifade edilebilir:

x=n**.5+1&~1

giden:

n=>2*(x=n**.5+1&~1)*x+(n<x*x+x?-1:3)*x+1-n

ve sonunda:

n=>((x=n**.5+1&~1)*2-(n<x*x+x)*4+3)*x+1-n

Wolfram Dili (Mathematica) , 60 bayt

8(s=⌊(⌊Sqrt[#-1]⌋+1)/2⌋)^2-#+2+If[#<=4s^2+2s,-2,6]s&

Çevrimiçi deneyin!

MATL , 12 11 bayt

Eq1YL!tPG=)

Çevrimiçi deneyin!

Bellek yetersiz. Hazırlık daha verimliX^k hale getirir .

C # (Visual C # Etkileşimli Derleyici) , 67 bayt

n=>8*(x=(int)Math.Sqrt(--n)+1>>1)*x+(n<4*x*x+2*x?-2:6)*x+1-n;int x;

Çevrimiçi deneyin!

Python 3.8, 104 74 65 60 57 bayt

lambda n:(-2,6)[n>4*(x:=(n**.5+1)//2)*x+2*x]*x+2+~n+8*x*x

Düzenleme: 74 ila 57 bayt aldığı için Johnathan Allan'a teşekkürler!

Bu çözüm 0 tabanlı indeksleme kullanır.

Python 3.8 (ön sürüm) , 53 bayt

Arnauld'un JavaScript cevabının doğrudan bir limanı , bunu oylayın ve / veya J42161217'nin Mathematica cevabı ve / veya Kapocsi'nin Python cevabı :)

lambda n:((x:=int(n**.5+1)&-2)*2-(n<x*x+x)*4+3)*x+1-n

0 endeksli.

Çevrimiçi deneyin!

Befunge, 67 57 bayt

Bu çözüm, giriş değerleri için 0 tabanlı indekslemeyi varsayar.

p&v-*8p00:+1g00:<
0:<@.-\+1*g00+*<|`
0g6*\`!8*2+00g4^>$:0

Çevrimiçi deneyin!

açıklama

N girişinin bir döngü ile bulunduğu "yarıçapı" hesaplayarak başlıyoruz :

radius = 0
while n > 0
  radius += 1
  n -= radius*8

Döngünün sonunda, önceki n değeri o yarıçaptaki spirale ofsettir:

offset = n + radius*8

Daha sonra spiralin üst veya alt kısmında olup olmadığımızı aşağıdaki gibi belirleyebiliriz:

bottom = offset >= radius*6

Ve tüm bu ayrıntılara sahip olduğumuzda, spiral değer şu şekilde hesaplanır:

value = ((bottom?10:2) + 4*radius)*radius + 1 - offset

Yarıçap, "değişken" olarak depolamamız gereken tek değerdir ve Befunge-93'te maksimum 127 değeriyle sınırlandırdığından, bu algoritma 65024'e kadar girişleri işleyebilir.

Japt , 15 bayt

Bağlantı noktası Jonathan'ın Jelly çözümü. 1 endeksli.

gUòȲ+X*v)õÃcÔâ

Dene

gUòȲ+X*v)õÃcÔâ     :Implicit input of integer U
g                   :Index into
 Uò                 :  Range [0,U]
   È                :  Map each X
    ²               :    Square X
     +X*            :    Add X multiplied by
        v           :    1 if X is divisible by 2, 0 otherwise
         )          :    Group result
          õ         :    Range [1,result]
           Ã        :  End map
            c       :  Flatten
             Ô      :    After reversing each
              â     :  Deduplicate

C ++ (gcc) , 88 bayt

#import<cmath>
int a(int n){int x=(sqrt(n-1)+1)/2;return x*(8*(x+(n>4*x*x+2*x))-2)+2-n;}

1 endeksli; OEIS sayfasındaki formülü kullanır, ancak birkaç bayt kaydetmek için değiştirilir.

Çevrimiçi deneyin!