Sierpinski üçgeni Çizim olmuştur yapılan ölüm . Bununla birlikte yapabileceğimiz başka ilginç şeyler var. Üçgende yeterince sert kesilirse, baş aşağı üçgenleri fraktal grafiğin düğümleri olarak görebiliriz. Bu grafikte yolumuzu bulalım!

İlk önce, her düğüme bir sayı atayalım. En büyük baş aşağı üçgeni sıfır düğüm olacak ve daha sonra sol üst sağdaki sıraya ardışık sayılar vererek, katman katman katman aşağı iniyoruz.

^{Küçük sayıların biraz daha az bulanık olduğu daha büyük sürüm için tıklayın.}

Numaralandırma tanımlamak için başka bir yol merkez düğüm endeksi olmasıdır (Elbette, bu deseni. Mavi üçgen içindeki sonsuza devam eder) 0ve düğümün çocukları i(bir sonraki-küçük ölçekli komşu üçgenler) indeksleri var 3i+1, 3i+2ve 3i+3.

Bu grafiğin etrafında nasıl hareket ederiz? Herhangi bir üçgenden bir adım atabileceğiniz altı doğal adım vardır:

• Bir kişi daima kenarlardan birinin ortasındaki noktadan, mevcut düğümün üç çocukundan birine hareket edebilir. Biz bu hamle tayin edeceğiz N, SWve SE. Biz düğüm üzerinde şu anda eğer Örneğin 2, bu düğümlerin yol açacak 7, 8, 9sırasıyla. Kenarlardaki (dolaylı torunları) diğer hareketlere izin verilmez.
• Ayrıca, üçgenin birinden, üçgenin kenarına temas etmemek koşuluyla, doğrudan ebeveyne veya iki dolaylı atadan birine hareket edebilir. Biz bu hamle tayin edeceğiz S, NEve NW. Biz düğüm üzerinde şu anda eğer Örneğin 31, Syol açacağını 10, NEgeçersiz olacak ve NWyol açacak 0.

Meydan okuma

İki negatif olmayan tam sayı göz önüne alındığında xve y, bir kısa yol bulmak xiçin ysadece altı hareket yukarıda tarif edilen kullanılarak,. Birkaç kısa yol varsa, bunlardan herhangi birini yazdırın.

Kodunuzun, yukarıdaki şemada gösterilen 5 seviyeden daha fazlası için çalışması gerektiğini unutmayın. Bunu varsayabilirsin x, y < 1743392200. Bu, 32 bit işaretli bir tamsayı içine sığmalarını sağlar. Bunun ağacın 20 seviyesine karşılık geldiğine dikkat edin.

Kodunuz, herhangi bir geçerli girişi 5 saniyeden daha kısa sürede işlemelidir . Bu bir kaba kuvvet genişlemesi ilk aramayı hariç tutarken, oldukça gevşek bir kısıtlama olmalıdır - referans uygulamam, yarım saniyede 1000 derinlik için rasgele girdiler kullanır (bu, düğümler için ~ 480 basamaklı sayılardır).

STDIN (veya en yakın alternatif), komut satırı argümanı veya işlev argümanı yoluyla giriş alarak ve sonucu STDOUT (veya en yakın alternatif), fonksiyon dönüş değeri veya function (out) parametresi ile çıktı alarak bir program veya işlev yazabilirsiniz.

Çıkış dizeleri düz, açık liste olmalı N, S, NE, NW, SE, SW, herhangi makul bir ayırıcı kullanılarak (boşluk, linefeeds, virgül ","...).

Standart kod-golf kuralları geçerlidir.

Test Kılıfları

İlk birkaç test durumu yukarıdaki şema kullanılarak elle yapılabilir. Diğerleri cevapların yeterince verimli olmasını sağlar. Bunlar için listelenmemiş aynı uzunlukta başka çözümler olabilir.

0 40                    => N N N N
66 67                   => S SW N N N
30 2                    => NW NW -or- NE SW
93 2                    => NE SW
120 61                  => NW NW NW NW N SE SW N
1493682877 0            => S S NW NW
0 368460408             => SW SW N N SW SW SE SW SW N SE N N SW SW N SE SE
1371432130 1242824      => NW NW NE NW N SE SW SW SW SE SE SW N N N N SW
520174 1675046339       => NE NW NE NE SE SE SW SW N SE N SW N SW SE N N N N SE SE SW SW
312602548 940907702     => NE NW S SW N N SW SE SE SE SW SE N N SW SE SE SE SW
1238153746 1371016873   => NE NE NE SE N N SW N N SW N SE SE SW N SW N N SE N SE N
547211529 1386725128    => S S S NE NW N N SE N SW N SE SW SE SW N SE SE N SE SW SW N
1162261466 1743392199   => NE NE NE NE NE NE NE NE NE NE NE NE NE NE NE NE NE NE NE SE SE SE SE SE SE SE SE SE SE SE SE SE SE SE SE SE SE SE

Ruby, 195 194 190 184 bayt

Orijinal: için özür ile Ell Buna esasen onların cevap ve birçok sayesinde bir liman olarak, kapı tokmağı bu cevabı ayıklama katkılarından dolayı. Muhtemelen bu problem için başka bir algoritma daha vardır - bununla bir ilgisi var *f[x[0,**however far x matches with y**],y]- ama bunu başka bir zaman için saklayacağım.

a=->n{n<1?[]:a[~-n/3]+[-n%3]}
f=->x,y{j=x.size
(Array===x)?x==y[0,j]?y[j..-1].map{|m|%w[SE SW N][m]}:x.uniq.map{|m|[%w[NW NE S][m],*f[x[0,x.rindex(m)],y]]}.min_by(&:size):f[a[x],a[y]]}

EDIT: Açgözlü algoritma işe yaramaz h[299792458, 1000000]. Algoritmamı bir kez daha tamir ederken bayt sayısını 195'e döndürdüm. Yalnızca bayt sayısının 203'e yükselmesi düzeltildi.

Yapım aşamasında: Bu program ortak ataları bulmak için açgözlü bir algoritma kullanır x[0,j]==y[0,j](not: birkaç ortak ata olabilir). Algoritma, Ell'in özyinelemeli atalarının araştırmasına oldukça gevşek bir şekilde dayanıyor . Ortaya çıkan talimatların ilk yarısı bu ortak ataya nasıl ulaşılacağı, ikinci yarının ise y'ye dayanması y[j..-1].

Not: a[n]burada , bunun yerine rakamları kullanarak bir base-3 bijective döndürür .2,1,01,2,3

Örnek olarak, f[59,17]veya ile geçelim f[[2,0,2,1],[2,1,1]]. Burada j == 1. Almak için x[0,j], 0ya gideriz NW. Sonra ygitmek, gitmek [1,1]veyaSW SW

a=->n{n<1?[]:a[~-n/3]+[-n%3]}
h=->m,n{x=a[m];y=a[n];c=[];j=x.size
(j=x.uniq.map{|m|k=x.rindex(m);x[0..k]==y[0..k]?j:k}.min
c<<%w[NW NE S][x[j]];x=x[0,j])until x==y[0,j]
c+y[j..-1].map{|m|%w[SE SW N][m]}}

Python 2, 208 205 200 bayt

A=lambda n:n and A(~-n/3)+[-n%3]or[]
f=lambda x,y:f(A(x),A(y))if x<[]else["SSNEW"[m::3]for m in
y[len(x):]]if x==y[:len(x)]else min([["NNSWE"[m::3]]+f(x[:~x[::-1].index(m)],y)for
m in set(x)],key=len)

Bir fçift ​​düğüm numarası alarak ve en kısa yolu dizge listesi olarak döndüren bir işlev .

açıklama

Üçgenler için farklı bir adresleme şeması kullanarak başlarız; Her üçgenin adresi aşağıdaki gibi tanımlanmış bir dizedir:

• Merkez üçgenin adresi boş dizedir.

• Kuzey, güney-batı ve her üçgenin güneydoğu çocukların adresleri ekleyerek oluşturulur 0, 1ve 2üçgenin adrese sırasıyla.

Temel olarak, her üçgenin adresi, orta üçgenden ona (en kısa) yolu kodlar. Programımızın yaptığı ilk şey giriş üçgeni numaralarını ilgili adreslere çevirmektir.

^{Daha büyük versiyonu için resimin üzerine tıkla.}

Her üçgenin muhtemel hareketleri adresden kolayca belirlenir:

• Biz sadece ekleme, kuzey, güney-batı ve güney-doğu çocuklara taşımak için 0, 1ve 2adrese, sırasıyla.

• Kuzey-doğu, güney taşımak ve kuzey-batı ataları, biz son (en sağdaki) tekrarlamasını bulmak için 0, 1ve 2bunun sola adresini sırasıyla ve kırpın. Hiçbir yoksa 0, 1ya da 2konuşmasında, daha sonra ilgili atası yok. Örneğin, kuzey-batı atası geçmek için 112(yani üst), biz son tekrarlamasını bulmak 2içinde 112bize veren o sola adresini son karakteridir, ve Döşeme 11; kuzey-doğu atası geçmek için, biz son tekrarlamasını bulmak 1içinde 112ikinci bir karakterdir, ve bizi vererek ondan sola adresini Döşeme 1; ancak, 112güney atası yok, çünkü yok0 adresinde.

Bir çift adresle ilgili birkaç şeyi not edin xve y:

• Eğer xbir ilk alt olup y, daha sonra ybir soyundan x, ve bu nedenle en kısa yolu xiçin ysadece arasında her üçgen karşılık gelen çocuk aşağıda xve y; başka bir deyişle, her yerini alabilir 0, 1ve 2de y[len(x):]birlikte N, SWve SEsırasıyla.

• Aksi halde, ve iarasındaki ilk uyuşmazlığın indeksi olsun . Hiçbir yol yoktur için bu geçmez (aynı olan birinci ortak atası, yani,) ve . Dolayısıyla, herhangi bir yol ile ulaşması gerekmektedir , ya da atalarından birinin, bunu üçgen diyelim ve ardından devam ve . Bu noktadan gelmek için ataları yukarıda anlatıldığı gibi takip ediyoruz. En kısa yolu için önceki madde alanına göre verilmiştir.xyxyx[:i]y[:i]xyxyx[:i]zyxzzy

Eğer xbir ilk alt olduğu ysonra en kısa yolu, xiçin ykolayca yukarıdaki ilk madde alanına göre verilmiştir. Aksi takdirde, bırakıldığında yukarı json olaylardan endekslerinin en küçük olacak 0, 1ve 2de x. Eğer jbüyükse veya karşı eşit arasındaki ilk uyuşmazlığı endeks xve y, ibiz sadece ilgili hamleyi (ekle S, NEveya NWyola sırasıyla), Döşeme xsolunda jve devam edin. İşler daha jazsa daha hileli olur i, o zamandan beri doğrudan yortak ataya yükselip x[:j]doğrudan aşağı inerek en hızlı şekilde gidebiliriz.yveya farklı bir ortak ataya ulaşabiliriz xve ybu da sağındaki yfarklı bir ataya yükselip, oradan daha hızlı bir şekilde atarak yakınlaşır . Örneğin, almak için inmek sonra en kısa yol (adres boş bir dize olan) merkez üçgenin ilk yükselmek etmektir, ve yani, ilk hareket uyuşmazlığı noktasının sol götürüyor. Ancak almak için , en kısa yol yükselmek olduğunu ve daha sonra yani, ilk hareket uyuşmazlığı noktasının sağındaki bizi tutar.xiy12221112221212212

Peki en kısa yolu nasıl buluruz? “Resmi” program, herhangi xbir ilk temeli olmadığında , atalardan herhangi birine olası tüm hareketleri denemek için kaba kuvvet-kuvvet yaklaşımı kullanır y. Bu göründüğü kadar kötü değil! Tüm test durumlarını bir veya iki saniye içinde birleştirerek çözer.

Ama sonra, yine, daha iyisini yapabiliriz: Eğer uyuşmazlık noktasının solunda doğrudan ulaşılabilir birden fazla ata varsa, sadece en sağdaki kişiyi test etmemiz gerekir ve eğer birden fazla doğrudan erişilebilen ata varsa uyumsuzluk noktasının sağında, sadece en soldaki testi denememiz gerekir. Bu x, çok daha büyük test senaryoları arasında zum yapan (yani kaynak üçgenin derinliği veya kaynak üçgeni sayısının logaritması ile orantılı bir süre) uzunluğu olan doğrusal bir zaman algoritması verir . Aşağıdaki program, bu algoritmayı, en azından özünde, golf oynamaktan ötürü, karmaşıklığı, aslında lineerden daha kötüdür, ancak hala çok hızlıdır.

Python 2, 271 266 261 bayt

def f(x,y):
 exec"g=f;f=[]\nwhile y:f=[-y%3]+f;y=~-y/3\ny=x;"*2;G=["SSNEW"[n::3]for
n in g];P=G+f;p=[];s=0
 while f[s:]:
    i=len(f)+~max(map(f[::-1].index,f[s:]));m=["NNSWE"[f[i]::3]]
    if f[:i]==g[:i]:P=min(p+m+G[i:],P,key=len);s=i+1
    else:p+=m;f=f[:i]
 return P

Daha kısa versiyondan farklı olarak, bu versiyonun girdi değerlerinin karşılık gelen adreslerine dönüştürülmesinde özyinelemeyi kullanmamak için özel olarak yazıldığını, böylece yığının taşması olmadan çok büyük değerleri işleyebileceğini unutmayın.

Sonuçlar

Her iki sürümde de testleri çalıştırmak ve sonuçları üretmek için aşağıdaki kod parçası kullanılabilir:

def test(x, y, length):
    path = f(x, y)
    print "%10d %10d  =>  %2d: %s" % (x, y, len(path), " ".join(path))
    assert len(path) == length

#         x           y        Length
test(          0,          40,    4   )
test(         66,          67,    5   )
test(         30,           2,    2   )
test(         93,           2,    2   )
test(        120,          61,    8   )
test( 1493682877,           0,    4   )
test(          0,   368460408,   18   )
test( 1371432130,     1242824,   17   )
test(     520174,  1675046339,   23   )
test(  312602548,   940907702,   19   )
test( 1238153746,  1371016873,   22   )
test(  547211529,  1386725128,   23   )
test( 1162261466,  1743392199,   38   )

Golf Sürümü

         0         40  =>   4: N N N N
        66         67  =>   5: S SW N N N
        30          2  =>   2: NE SW
        93          2  =>   2: NE SW
       120         61  =>   8: NW NW NW NW N SE SW N
1493682877          0  =>   4: S S NW NW
         0  368460408  =>  18: SW SW N N SW SW SE SW SW N SE N N SW SW N SE SE
1371432130    1242824  =>  17: NW NW NE NW N SE SW SW SW SE SE SW N N N N SW
    520174 1675046339  =>  23: NE NE NE NE SE SE SW SW N SE N SW N SW SE N N N N SE SE SW SW
 312602548  940907702  =>  19: NE NW S SW N N SW SE SE SE SW SE N N SW SE SE SE SW
1238153746 1371016873  =>  22: NE NE NE SE N N SW N N SW N SE SE SW N SW N N SE N SE N
 547211529 1386725128  =>  23: S S S S NW N N SE N SW N SE SW SE SW N SE SE N SE SW SW N
1162261466 1743392199  =>  38: NE NE NE NE NE NE NE NE NE NE NE NE NE NE NE NE NE NE NE SE SE SE SE SE SE SE SE SE SE SE SE SE SE SE SE SE SE SE

Verimli sürüm

         0         40  =>   4: N N N N
        66         67  =>   5: S SW N N N
        30          2  =>   2: NW NW
        93          2  =>   2: NE SW
       120         61  =>   8: NW NW NW NW N SE SW N
1493682877          0  =>   4: NE S NW NW
         0  368460408  =>  18: SW SW N N SW SW SE SW SW N SE N N SW SW N SE SE
1371432130    1242824  =>  17: NW NW NE NW N SE SW SW SW SE SE SW N N N N SW
    520174 1675046339  =>  23: NE NW NE NE SE SE SW SW N SE N SW N SW SE N N N N SE SE SW SW
 312602548  940907702  =>  19: NE NW S SW N N SW SE SE SE SW SE N N SW SE SE SE SW
1238153746 1371016873  =>  22: NE NE NE SE N N SW N N SW N SE SE SW N SW N N SE N SE N
 547211529 1386725128  =>  23: S S S S NW N N SE N SW N SE SW SE SW N SE SE N SE SW SW N
1162261466 1743392199  =>  38: NE NE NE NE NE NE NE NE NE NE NE NE NE NE NE NE NE NE NE SE SE SE SE SE SE SE SE SE SE SE SE SE SE SE SE SE SE SE

APL (Dyalog Unicode) , 144 132 129 118 133 133 130 130 124 117 bayt ^SBCS

APL dilini öğrenmek için harika bir yer olan The APL Orchard'da golf oynamadaki yardımları için Ven ve ngn'e çok teşekkür ederiz . ⎕IO←0. Golf önerileri kabul edilir.

Düzenleme: -12 bayt Ven ve ngn sayesinde nasıl ntanımlandığını değiştirerek ve 1 indekslemeden 0 indekslemeye geçerek değiştirir. -3, her şeyin 0 indekslemeye alınmadığı bir hatayı düzelttiği için. -11 bayt nasıl değiştiğine Pve nasıl Qtanımlandığına bağlı. +15 bayt, algoritmamın yanlış olduğu bir sorunu çözdüğümden dolayı ngn sayesinde bölümün şekillendirilmesine yardım etti s[⊃⍋|M-s]. -2 byte geri izleme yolunu bulma yöntemini ve +1 byte'ı hata düzeltmeye yeniden düzenleme. Adám sayesinde -2 byte tanımını yeniden düzenledi I. -6 bayt, ngn tanımının yeniden düzenlenmesi 'S' 'NE' 'NW' 'N' 'SW' 'SE've nasıl ttanımlandığı yeniden düzenlenmesi sayesinde (artık ayrı bir değişken değildir) sayesinde. -7 bayt ile ngn sayesinde golf nasıl stanımlanır.

{M←⊃⍸≠⌿↑1+P Q←⍵{(⍵/3)⊤⍺-+/3*⍳⍵}¨⌊3⍟1+⍵×2⋄(∪¨↓6 2⍴'SSNENWNNSWSE')[P[I],3+Q↓⍨⊃⌽I←⍬{M≥≢⍵:⍺⋄(⍺∘,∇↑∘⍵)s[⊃⍋|M-s←⌽⊢.⊢⌸⍵]}P]}

Çevrimiçi deneyin!

Algoritmadaki hatanın açıklaması

Temel sorun, en kısa yolun doğrudan ortak atadan geçtiğini ve aslında ortak ataların atalarından geçemediğini düşünmemdi. Aşağıdaki örnekler gösterdiği gibi bu yanlıştır.

66 - 5

66 → 0 2 2 2 → 0 2 2 2
5  → 0 1     → 0 1
      ↑ common ancestor

The two ancestors of 0 2 2 2 are:
0 2 2
(empty)

(empty) has the shorter path back to 0 1 as it only needs two forward moves,
while 0 2 2 requires two more backtracks and one more forward move.

299792458 - 45687

299792458 → 0 2 1 1 0 1 1 2 1 1 1 2 1 0 2 2 2 0
45687     → 0 2 1 1 0 1 1 1 2 2
                         ↑ common ancestor

The three ancestors of 299792458 are:
0 2 1 1 0 1 1 2 1 1 1 2 1 0 2 2 2
0 2 1 1 0 1 1 2 1 1 1 2            ← choose this one
0 2 1 1 0 1 1 2 1 1 1 2 1 0 2 2

And the three ancestors of 0 2 1 1 0 1 1 2 1 1 1 2 are:
0 2 1 1
0 2 1 1 0 1 1 2 1 1
0 2 1 1 0 1 1 2 1 1 1

0 2 1 1 0 1 1 1 2 2    ← 45687 for reference
             ↑ common ancestor

While it seems like `0 2 1 1` is the shorter path,
it actually results in a path that is 8 steps long
(2 backtracks, 6 forward steps to 45687).

Meanwhile, `0 2 1 1 0 1 1 2 1 1` is at an equal distance
to the common ancestor and has the following ancestors:
0 2 1 1
0 2 1 1 0 1 1 2 1
0 2 1 1 0 1 1

0 2 1 1 0 1 1 1 2 2    ← 45687 for reference
             ↑ common ancestor

Clearly, this is the superior path, as with three backtracks, we have reached
the point of the common ancestor. With 3 backtracks and 3 forward moves,
we have a path that is 6 steps long.

Kodun açıklaması

                       ⍝ ⍵ should be an array of 2 integers, x y
SierpinskiPath←{⎕IO←0  ⍝ 0-indexing
        ⍝ P Q←{...}¨⍵  ⍝ First, the bijective base-3 numeration of x and y
    P Q←{
        n←⌊3⍟1+⍵×2  ⍝ The number of digits in the numeration
        z←+/3*⍳⍵    ⍝ The number of numerations with ≤ n digits
        (n/3)⊤⍵-z   ⍝ And a simple decode ⊤ (base conversion) of ⍵-z
    }¨⍵             ⍝ gets us our numerations, our paths

    A←↑1+P Q      ⍝ We turn (1+P Q) into an 2-by-longest-path-length array 
                  ⍝ ↑ pads with 0s and our alphabet also uses 0s
                  ⍝ So we add 1 first to avoid erroneous common ancestor matches
    Common←⊃⍸≠⌿A  ⍝ We find the length of the common ancestor, Common

        ⍝ I←⍬{...}P  ⍝ Now we get the shortest backtracking path from P
    I←⍬{
        Common=≢⍵:⍺       ⍝ If P is shorter than Common, return our backtrack path
        s←⌽⊢.⊢⌸⍵          ⍝ Get the indices of the most recent N SW SE
        t←s[⊃⍋|Common-s]  ⍝ and keep the index that is closest to Common
                          ⍝ and favoring the ancestors to the right of
                          ⍝ Common in a tiebreaker (which is why we reverse ⊢.⊢⌸⍵)
        (⍺,t)∇t↑⍵         ⍝ Then repeat this with each new index to backtrack
    }P                    ⍝ and the path left to backtrack through

    Backtrack←P[I]   ⍝ We get our backtrack directions
    Forward←(⊃⌽I)↓Q  ⍝ and our forward moves to Q
                     ⍝ starting from the appropriate ancestor
    (∪¨↓6 2⍴'SSNENWNNSWSE')[Backtrack,Forward]    ⍝ 'S' 'NE' 'NW' 'N' 'SW' 'SE'
}                    ⍝ and return those directions

Dyalog Extended ve dfns kullanarak alternatif çözüm

Kullandığımız takdirde ⎕CY 'dfns''in adicfonksiyonu, bu çok daha az bayt için (sürüm I kullanımı için ilham kaynağı oldu) bizim bijective baz-n sayılmasını uygular. Dyalog Extended'a geçmek aynı zamanda oldukça fazla bayt tasarrufu sağlar ve işte buradayız. Adám'a, golf oynamadaki yardımları için çok teşekkürler. Golf önerileri hoş geldiniz!

Düzenleme: -8 bayt nasıl Pve nasıl Qtanımlandığını değiştirerek . -Dyalog Extended'a geçiş nedeniyle 14 bayt. -2 dfn dirseklerini çıkarmak için tam bir program kullanılmasından kaynaklanmaktadır {}. +17 bayt, algoritmamın yanlış olduğu bir sorunu çözdüğümden dolayı ngn sayesinde bölümün şekillendirilmesinde yardımcı oldu s[⊃⍋|M-s]. +1 bayt hata düzeltme. Adám sayesinde -2 bayt, golf tanımımı I her iki çözüme koymayı da hatırlamıyor ve tanımını yeniden düzenledi . Kardinal yönün jenerasyonunu yeniden düzenleyerek ngn sayesinde -3 bayt, buggy golfünü düzelterek +1 byte ve nasıl ttanımlandığını yeniden düzenleyerek ngn sayesinde -3 bayt (artık ayrı bir değişken değildir). -7 bayt, ngn sayesinde nasıl stanımlandığını yeniden düzenleyerek verir .

APL (Genişletilmiş Dyalog) , 123 115 101 99 116 117 114 109 102 bayt

M←⊃⍸≠⌿↑1+P Q←(⍳3)∘⌂adic¨⎕⋄(∪¨↓6 2⍴'SSNENWNNSWSE')[P[I],3+Q↓⍨⊃⌽I←⍬{M≥≢⍵:⍺⋄(⍺∘,∇↑∘⍵){⍵[⊃⍋|M-⍵]}⌽⊢.⊢⌸⍵}P]

Çevrimiçi deneyin!