Golf veren bir program veya fonksiyon yerini antilop kare başlar olan sonsuz üzerinde satranç tahtası , bir anti-saat yönünde kare spiral, antilop her ziyaret düşük numaralı kare numaralandırılmıştır henüz ziyaret etmediğine varabilir.$n^{\text{th}}$$1$

İlham: Sıkışmış Şövalye ve OEIS A316667 .

Düzenleme: Bu sıra şimdi OEIS'te A323763 olarak açık .

Kod konumunu, ilk konumunu ya da girdi almayan bir sırayı üretebilir.$n^{\text{th}}$$n$

Sonra, onun yerini vermek için ücretsiz (ya da en fazla) hisset yerine atlar, ama çok Cevabınız bu açıkça devlet memnun ve yaparsanız emin bir giriş verim (veya uygunsa).$n$$n=0$1[1]

Bu, kod golfüdür , bu nedenle amaç, seçtiğiniz dilde mümkün olduğu kadar az baytta çalışma kodu üretmektir.

Not: wildebeest tuzağa düşürülür (şövalye, konumundaki karesinde, karesinde , deve de, , karesinde ), kare . Kodunuzun davranışı, bundan daha büyük olan için tanımsız olabilir . ( Bunu bulan C ++ kodu için Deadcode sayesinde !)$2016^{\text{th}}$$2084$$3723^{\text{rd}}$$7081$$12899744968^{\text{th}}$$12851850258$$n$

detay

Yönetim Kurulu aşağıdakine benzer ve süresiz olarak devam eder:

101 100  99  98  97  96  95  94  93  92  91
102  65  64  63  62  61  60  59  58  57  90
103  66  37  36  35  34  33  32  31  56  89
104  67  38  17  16  15  14  13  30  55  88
105  68  39  18   5   4   3  12  29  54  87
106  69  40  19   6   1   2  11  28  53  86
107  70  41  20   7   8   9  10  27  52  85
108  71  42  21  22  23  24  25  26  51  84
109  72  43  44  45  46  47  48  49  50  83
110  73  74  75  76  77  78  79  80  81  82
111 112 113 114 115 116 117 118 119 120 121

Bir antilop bir "gnu" bir peri satranç parçası bir şekilde, her iki hareket edebilir bir standart olmayan satranç parçası - Knight , (a -leaper) ve bir şekilde deve , (a -leaper). Bu nedenle, bu konumlarından herhangi birine, başlangıç ​​konumundan yerini alabilir :$(1,2)$$(1,3)$
$1$

  .   .   .   .   .   .   .   .   .   .   .
  .   .   .   .  35   .  33   .   .   .   .
  .   .   .   .  16   .  14   .   .   .   .
  .   .  39  18   .   .   .  12  29   .   .
  .   .   .   .   .  (1)  .   .   .   .   .
  .   .  41  20   .   .   .  10  27   .   .
  .   .   .   .  22   .  24   .   .   .   .
  .   .   .   .  45   .  47   .   .   .   .
  .   .   .   .   .   .   .   .   .   .   .

Bunların en küçüğü ve o kareyi henüz ziyaret etmedi, bu nedenle , sekanstaki ikinci terimdir.$10$$10$

Sonra bu konumlardan birine gidebilir :$10$

  .   .   .   .   .   .   .   .   .   .   .
  .   .   .   .   .   .  14   .  30   .   .
  .   .   .   .   .   .   3   .  29   .   .
  .   .   .   .   6   1   .   .   .  53  86
  .   .   .   .   .   .   . (10)  .   .   .
  .   .   .   .  22  23   .   .   .  51  84
  .   .   .   .   .   .  47   .  49   .   .
  .   .   .   .   .   .  78   .  80   .   .
  .   .   .   .   .   .   .   .   .   .   .

Bununla birlikte, $1$ kareyi zaten ziyaret etti, bu nedenle üçüncü konumu, henüz ziyaret etmediği en düşük $3$ kareydi.

---

Erkek olmanın yolunun ilk $100$ terimi:

1, 10, 3, 6, 9, 4, 7, 2, 5, 8, 11, 14, 18, 15, 12, 16, 19, 22, 41, 17, 33, 30, 34, 13, 27, 23, 20, 24, 44, 40, 21, 39, 36, 60, 31, 53, 26, 46, 25, 28, 32, 29, 51, 47, 75, 42, 45, 71, 74, 70, 38, 35, 59, 56, 86, 50, 78, 49, 52, 80, 83, 79, 115, 73, 107, 67, 64, 68, 37, 61, 93, 55, 58, 54, 84, 48, 76, 43, 69, 103, 63, 66, 62, 94, 57, 87, 125, 82, 118, 77, 113, 72, 106, 148, 65, 97, 137, 91, 129, 85

İlk $11$ sıçrama, şövalye hareketidir, bu nedenle ilk $12$ terim A316667 ile aynıdır .

JavaScript (Node.js) ,  191 ... 166  164 bayt

@Grimy sayesinde 2 bayt kaydedildi .

İade $N$ ^inci terim.

n=>(g=(x,y)=>n--?g(Buffer('QPNP1O?O@242Q3C3').map(m=c=>g[i=4*((x+=c%6-2)*x>(y+=c%7-2)*y?x:y)**2,i-=(x>y||-1)*(i**.5+x+y)]|i>m||(H=x,V=y,m=i))&&H,V,g[m]=1):m+1)(1,2)

Çevrimiçi deneyin! veya Biçimlendirilmiş bir versiyonu görün

Nasıl?

Spiral endeksler

Koordinatları $(x,y)$ spiral indek $I$ dönüştürmek için önce $L$ katmanını şu şekilde hesaplarız :

$$L=\max(|x|,|y|)$$

Hangi verir:

$$\begin{array}{c|ccccccc} &-3&-2&-1&0&+1&+2&+3\\ \hline -3&3&3&3&3&3&3&3\\ -2&3&2&2&2&2&2&3\\ -1&3&2&1&1&1&2&3\\ 0&3&2&1&0&1&2&3\\ +1&3&2&1&1&1&2&3\\ +2&3&2&2&2&2&2&3\\ +3&3&3&3&3&3&3&3 \end{array}$$

Daha sonra katmandaki $P$ pozisyonunu şu şekilde hesaplarız :

$$P=\begin{cases} 2L+x+y&\text{if }x>y\\ -(2L+x+y)&\text{if }x\le y \end{cases}$$

Hangi verir:

$$\begin{array}{c|ccccccc} &-3&-2&-1&0&+1&+2&+3\\ \hline -3&0&1&2&3&4&5&6\\ -2&-1&0&1&2&3&4&7\\ -1&-2&-1&0&1&2&5&8\\ 0&-3&-2&-1&0&3&6&9\\ +1&-4&-3&-2&-3&-4&7&10\\ +2&-5&-4&-5&-6&-7&-8&11\\ +3&-6&-7&-8&-9&-10&-11&-12 \end{array}$$

Son endeks $I$ tarafından verilir:

$$I=4L^2-P$$

Not: Yukarıdaki formül 0 indeksli bir spiral verir.

JS kodunda aslında $4L^2$ hemen hesaplıyoruz :

i = 4 * (x * x > y * y ? x : y) ** 2

Ve sonra $P$ :

i -= (x > y || -1) * (i ** 0.5 + x + y)

Wildebeest'in hamle

Mevcut pozisyon göz önüne alındığında $(x,y)$ , en sert 16 hedef karesi aşağıdaki sırayla test edilir:

$$\begin{array}{c|cccccccc} &-3&-2&-1&x&+1&+2&+3\\ \hline -3&\cdot&\cdot&9&\cdot&11&\cdot&\cdot\\ -2&\cdot&\cdot&8&\cdot&10&\cdot&\cdot\\ -1&7&6&\cdot&\cdot&\cdot&12&13\\ y&\cdot&\cdot&\cdot&\bullet&\cdot&\cdot&\cdot\\ +1&5&4&\cdot&\cdot&\cdot&14&15\\ +2&\cdot&\cdot&2&\cdot&0&\cdot&\cdot\\ +3&\cdot&\cdot&3&\cdot&1&\cdot&\cdot \end{array}$$

16 çift imzalı değer uygulayarak onların içinden geçiyoruz $(dx,dy)$ . Her çift tek bir ASCII karakteri olarak kodlanmıştır.

 ID | char. | ASCII code | c%6-2 | c%7-2 | cumulated
----+-------+------------+-------+-------+-----------
  0 |  'Q'  |     81     |   +1  |   +2  |  (+1,+2)
  1 |  'P'  |     80     |    0  |   +1  |  (+1,+3)
  2 |  'N'  |     78     |   -2  |   -1  |  (-1,+2)
  3 |  'P'  |     80     |    0  |   +1  |  (-1,+3)
  4 |  '1'  |     49     |   -1  |   -2  |  (-2,+1)
  5 |  'O'  |     79     |   -1  |    0  |  (-3,+1)
  6 |  '?'  |     63     |   +1  |   -2  |  (-2,-1)
  7 |  'O'  |     79     |   -1  |    0  |  (-3,-1)
  8 |  '@'  |     64     |   +2  |   -1  |  (-1,-2)
  9 |  '2'  |     50     |    0  |   -1  |  (-1,-3)
 10 |  '4'  |     52     |   +2  |   +1  |  (+1,-2)
 11 |  '2'  |     50     |    0  |   -1  |  (+1,-3)
 12 |  'Q'  |     81     |   +1  |   +2  |  (+2,-1)
 13 |  '3'  |     51     |   +1  |    0  |  (+3,-1)
 14 |  'C'  |     67     |   -1  |   +2  |  (+2,+1)
 15 |  '3'  |     51     |   +1  |    0  |  (+3,+1)

En düşük karşılaşılan değeri $m$ ve karşılık gelen hücrenin koordinatlarını $(H,V)$ takip ediyoruz .

En iyi aday bulunduktan sonra, ana özyinelemeli fonksiyonumuz olan $g$ nesnesine bir bayrak koyarak ziyaret edildiğini işaretleriz .

$x=1$$y=2$$(0,0)$

Hindistan Cevizi , 337 276 bayt

import math
def g((x,y))=
 A=abs(abs(x)-abs(y))+abs(x)+abs(y)
 int(A**2+math.copysign(A+x-y,.5-x-y)+1)
def f():
 p=x,y=0,0;s={p};z=[2,3,1,1]*2
 while 1:yield g(p);p=x,y=min(((a+x,b+y)for a,b in zip((1,1,2,-2,-1,-1,3,-3)*2,z+[-v for v in z])if(a+x,b+y)not in s),key=g);s.add(p)

Bir değer üreteci döndürür. Muhtemelen daha çok golf oynayabilirdi. (Özellikle de fark tuples dizisi.) Bu matematikten alınan spiral algoritma cevabını verdi .

Çevrimiçi deneyin!

05AB1E , 77 65 58 57 52 bayt

Xˆ0UF3D(Ÿ0KãʒÄ1¢}εX+}Dε·nàDtyÆ+yO·<.±*->}D¯KßDˆkèU}¯

-6 bayt sayesinde @Arnauld formülünün bir portunu kullanıyor.

İlk çıktılar $n+1$ bir liste olarak değerler (ondalık).

Çevrimiçi deneyin ( ïalt kısımdaki .0çıktıyı daha kompakt hale getirmek için kaldırır , ancak gerçek sonucu görmek için çıkarmaktan çekinmeyin).

Kod açıklaması:

Xˆ             # Put integer 1 in the global_array (global_array is empty by default)
0U             # Set variable `X` to 0 (`X` is 1 by default)
F              # Loop the (implicit) input amount of times:
 3D(Ÿ          #  Push the list in the range [-3,3]: [-3,-2,-1,0,1,2,3]
     0K        #  Remove the 0: [-3,-2,-1,1,2,3]
       ã       #  Cartesian product with itself, creating each possible pair: [[3,3],[3,2],[3,1],[3,-1],[3,-2],[3,-3],[2,3],[2,2],[2,1],[2,-1],[2,-2],[2,-3],[1,3],[1,2],[1,1],[1,-1],[1,-2],[1,-3],[-1,3],[-1,2],[-1,1],[-1,-1],[-1,-2],[-1,-3],[-2,3],[-2,2],[-2,1],[-2,-1],[-2,-2],[-2,-3],[-3,3],[-3,2],[-3,1],[-3,-1],[-3,-2],[-3,-3]]
        ʒ   }  #  Filter this list of pairs by:
         Ä     #   Where the absolute values of the pair
          1¢   #   Contains exactly one 1
               #  (We now have the following pairs left: [[3,1],[3,-1],[2,1],[2,-1],[1,3],[1,2],[1,-2],[1,-3],[-1,3],[-1,2],[-1,-2],[-1,-3],[-2,1],[-2,-1],[-3,1],[-3,-1]])
 εX+}          #  Add the variable `X` (previous coordinate) to each item in the list
 D             #  Duplicate this list of coordinates
  ε            #  Map each `x,y`-coordinate to:
   ·           #   Double both the `x` and `y` in the coordinate
    n          #   Then take the square of each
     à         #   And then pop and push the maximum of the two
   Dt          #   Duplicate this maximum, and take its square-root
     yÆ        #   Calculate `x-y`
       +       #   And add it to the square-root
   yO          #   Calculate `x+y`
     ·         #   Double it
      <        #   Decrease it by 1
       .±      #   And pop and push its signum (-1 if < 0; 0 if 0; 1 if > 0)
   *           #   Multiply these two together
    -          #   And subtract it from the duplicated maximum
   >           #   And finally increase it by 1 to make it 1-based instead of 0-based
  }D           #  After the map: Duplicate that list with values
    ¯K         #  Remove all values that are already present in the global_array
      ß        #  Pop the list of (remaining) values and push the minimum
       Dˆ      #  Duplicate this minimum, and pop and add the copy to the global_array
         k     #  Then get its index in the complete list of values
          è    #  And use that index to get the corresponding coordinate
           U   #  Pop and store this coordinate in variable `X` for the next iteration
}¯             # After the outer loop: push the global_array (which is output implicitly)

Genel açıklama:

Tüm sonuçları (ve dolayısıyla daha önce karşılaştığımız değerleri) global_arraybaşlangıçta olduğu gibi tutarız [1].
Güncel tutarız$x,y$XBaşlangıçta olan değişkende -koordinat [0,0].

Akım bazında ulaşabileceğimiz koordinatların listesi $x,y$-koordinat:

[[x+3,y+1], [x+3,y-1], [x+2,y+1], [x+2,y-1], [x+1,y+3], [x+1,y+2], [x+1,y-2], [x+1,y-3], [x-1,y+3], [x-1,y+2], [x-1,y-2], [x-1,y-3], [x-2,y+1], [x-2,y-1], [x-3,y+1], [x-3,y-1]]

Yukarıdaki kod açıklamasında bahsettiğim liste, atlayabileceğimiz bu değerleri içerir, ardından $x,y$(değişkende saklanır X) eklenir.

Sonra bunlara dayalı spiral değerleri hesaplar $x,y$-coordinates. Bunu, verilen formül için aşağıdaki formülü kullanarak yapar.$x,y$-koordinat:

$${T = max((2 * x) ^ 2, (2 * y) ^ 2)}$$ $${R = T - (x - y + √T) * signum((x + y) * 2 - 1) + 1}$$

Hangi formül @Arnauld cevaplarında kullanıyor ancak 05AB1E'nin yerleşiklerini çift, kare, -1, +1 vb.

(Kodun yalnızca bu sarmal kısmını eylem halindeyken görmek istiyorsanız: Çevrimiçi deneyin .)

Verilen için ulaşabileceğimiz tüm değerleri aldıktan sonra $x,y$-coordinate, içinde mevcut olan tüm değerleri kaldırır global_arrayve sonra (kalan) değerlerin minimumunu elde ederiz.
Bu minimum sonra eklenir global_arrayve değişken Xdeğiştirilir$x,y$-bu minimumun koordinatı.

Kaç inputkez döngü yaptıktan sonra , program bunu global_arraysonuç olarak verir.