시어 핀 스키 삼각형을 그리기하는 한 짓을 죽음 . 우리가 할 수있는 다른 흥미로운 일들이 있습니다. 우리가 삼각형을 충분히 움켜 쥐면 거꾸로 된 삼각형을 프랙탈 그래프의 노드로 볼 수 있습니다. 그 그래프를 둘러 보자!

먼저 각 노드에 번호를 할당 해 봅시다. 가장 큰 거꾸로 된 삼각형은 노드 0이 될 것입니다. 그런 다음 계층별로 내려갑니다 (폭 우선), 왼쪽 위 오른쪽 순서로 연속 번호를 할당합니다.

^{작은 숫자가 약간 흐릿한 큰 버전을 보려면 클릭하십시오.}

번호 매기기를 정의하는 또 다른 방법은 중앙 노드가 인덱스를 가지고 있다는 것입니다 (물론,이 패턴은. 파란색 삼각형 내부 무한히 계속) 0하고, 노드의 자식 i(다음 - 작은 규모의 인접한 삼각형) 인덱스를 가지고 3i+1, 3i+2하고 3i+3.

이 그래프를 어떻게 이동합니까? 주어진 삼각형에서 취할 수있는 자연스런 단계는 최대 6 개입니다.

• 하나는 항상 모서리 중 하나의 중간 점을 통해 현재 노드의 세 하위 중 하나로 이동할 수 있습니다. 우리는 이러한 동작을 지정하는 것 N, SW하고 SE. 우리는 노드에서 현재 인 경우 예를 들면 2, 이러한 노드로 이어질 것이다 7, 8, 9각각. 가장자리를 통한 다른 이동 (간접 후손)은 허용되지 않습니다.
• 삼각형의 모서리에 닿지 않으면 직접 모체 또는 두 개의 간접 조상 중 하나에 세 모서리 중 하나를 이동할 수도 있습니다. 우리는 이러한 동작을 지정하는 것 S, NE하고 NW. 우리는 노드에서 현재 인 경우 예는 31, S이어질 것 10, NE잘못된 것과 NW로 이어질 것입니다 0.

도전

두 음이 아닌 정수를 부여 x하고 y, 최단 경로를 찾는 x으로 y만 이동 여섯 전술 사용. 최단 경로가 여러 개 있으면 그 중 하나를 출력하십시오.

위의 다이어그램에 묘사 된 5 개 이상의 수준에서 코드가 작동해야합니다. 당신은 그것을 가정 할 수 있습니다 x, y < 1743392200. 이를 통해 32 비트 부호있는 정수 안에 맞출 수 있습니다. 이것은 트리의 20 개 레벨에 해당합니다.

코드는 5 초 이내에 유효한 입력을 처리해야합니다 . 이것은 무차별 대입 우선 탐색을 배제하지만 상당히 느슨한 제약 조건입니다. 참조 구현은 깊이 1000에 대한 임의의 입력을 0.5 초 (노드의 ~ 480 자리 숫자)로 처리합니다.

STDIN (또는 가장 가까운 대안), 명령 행 인수 또는 함수 인수를 통해 입력을 받고 STDOUT (또는 가장 가까운 대안), 함수 리턴 값 또는 함수 (out) 매개 변수를 통해 결과를 출력하는 프로그램 또는 함수를 작성할 수 있습니다.

출력은 현 평면 모호 목록되어야한다 N, S, NE, NW, SE, SW, 임의의 적절한 세퍼레이터를 사용하여 (공백 바꿈 쉼표, ","...).

표준 코드 골프 규칙이 적용됩니다.

테스트 사례

처음 몇 가지 테스트 사례는 위의 다이어그램을 사용하여 손으로 해결할 수 있습니다. 다른 것들은 답변이 충분히 효율적임을 보장합니다. 그것들을 위해, 나열되지 않은 같은 길이의 다른 솔루션이있을 수 있습니다.

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

루비 195 194 190 184 바이트

독창적 : Ell에 사과를 드린 이유는 이것이 본질적으로 답변의 포트 이며이 답변을 디버깅하는 데 도움을 주신 Doorknob 에게 많은 감사의 말을 전합니다 . 아마도이 문제에 대한 또 다른 알고리즘이있을 것입니다. *f[x[0,**however far x matches with y**],y]하지만 관련이 있습니다.

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]]}

편집 : 욕심 많은 알고리즘이 작동하지 않습니다 h[299792458, 1000000]. 바이트 수를 195로 되돌리고 알고리즘을 다시 한 번 복구합니다. (203)로 상승 만 바이트 카운트를 고정 한숨

공사 중 : 이 프로그램은 탐욕스러운 알고리즘을 사용하여 공통 조상을 찾습니다 x[0,j]==y[0,j](참고 : 공통 조상이 여러 개있을 수 있음). 이 알고리즘은 Ell 의 재귀 적 조상 검색을 매우 느슨하게 기반으로 합니다. 결과 명령어의 전반부는이 공통 조상을 찾는 방법이며, 후반은를 기반으로 y에 도달합니다 y[j..-1].

참고 : a[n]여기서는 대신 숫자 를 사용하여 밑이 3 인 이분법을 반환합니다 .2,1,01,2,3

예를 들어,의를 통해 실행하자 f[59,17]나 f[[2,0,2,1],[2,1,1]]. 여기에, j == 1. 에 x[0,j]가려면 0또는 로 이동 NW합니다. 그런 다음에 y가려면 [1,1]또는SW 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]}}

파이썬 2, 208 205 200 바이트

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)

f노드 번호 쌍을 가져와 최단 경로를 문자열 목록으로 반환 하는 함수 .

설명

삼각형에 대해 다른 주소 지정 체계를 사용하는 것으로 시작합니다. 각 삼각형의 주소는 다음과 같이 정의 된 문자열입니다.

• 중앙 삼각형의 주소는 빈 문자열입니다.

• 북쪽, 남쪽, 서쪽, 각 삼각형의 남동 자녀의 주소는 추가 형성 0, 1그리고 2삼각형의 주소로 각각.

기본적으로 각 삼각형의 주소는 중심 삼각형에서 삼각형까지의 (가장 짧은) 경로를 인코딩합니다. 프로그램이 가장 먼저하는 일은 입력 삼각형 숫자를 해당 주소로 변환하는 것입니다.

^{더 큰 버전을 보려면 이미지를 클릭하십시오.}

각 삼각형에서 가능한 움직임은 주소에서 쉽게 결정됩니다.

• 북쪽, 남서 및 남동쪽 자녀 로 이동하려면 주소에 , 및 을 각각 추가 0하면 됩니다.12

• 북쪽 동쪽, 남쪽으로 이동하고, 북서 조상, 우리는 마지막 (가장 오른쪽) 발생을 찾으려면 0, 1그리고 2그것의 왼쪽에 주소를 각각 트림. 더가있는 경우 0, 1또는 2주소에 다음 해당 조상은 존재하지 않습니다. 예를 들어, 북서쪽 조상 112(즉, 부모) 으로 이동하기 위해 마지막 문자 인 2in 의 마지막 어커런스를 찾아서 112왼쪽에있는 주소를 잘라내어 우리에게 11; 북동쪽 조상으로 이동하기 위해, 우리는 마지막 등장 인 1in을 발견하고 112, 이것은 두 번째 문자이며, 왼쪽에있는 주소를 잘라내어 우리에게줍니다 1. 그러나 112남쪽 조상이 없습니다.0 주소에.

주소 쌍에 대해 몇 가지를 참고 x하고 y:

• 경우 x초기 스트링은 y, 다음 y의 하위이며 x, 따라서 최단 경로 x에 y단순히 사이 각 삼각형의 대응 하위 다음 x과 y; 즉, 우리는 서로 대체 할 수있는 0, 1그리고 2에서 y[len(x):]와를 N, SW그리고 SE각각.

• 그렇지 않으면,하자 i의 첫 불일치의 인덱스 수 x와 y. 로부터 경로가 없습니다 x에 y그 통과하지 않습니다 x[:i](같은되는 y[:i]첫 번째 공통의 조상, 즉,) x및 y. 따라서, 어떠한 경로 x에 y도착해야한다 x[:i], 또는 그 조상 중 하나의이 삼각형을 부르 자 z에 계속 다음,와 y. 에서 x에 도착하기 위해 z위에서 설명한대로 조상을 따릅니다. 에서 최단 경로 z로는 y이전 글 머리에 의해 주어진다.

경우 x의 초기 부분 문자열 y다음 최단 경로 x로는 y용이하게 상기 제 총알 시점으로 주어진다. 그렇지 않으면, 우리는 LET j의 마지막 발생의 인덱스의 가장 작은 수 0, 1과 2에서 x. 경우 j보다 큰지, 또는 같을 간의 제 불일치의 인덱스 x와 y, i우리는 단순히 대응하는 움직임 (ADD S, NE또는 NW경로에 각각), 트리밍 x의 좌측에 j, 그리고 계속한다. j보다 작 으면 상황이 까다로워집니다 i. 왜냐하면 y공통 조상으로 x[:j]직접 올라가서 내림차순으로 내려 가면 가장 빠를 수 있습니다.y또는 우리는 다른 공통 조상을 얻을 수있을 것 x와 y가까이의 것을 y다른 조상에 상승으로 x오른쪽에 i, 그리고 거기에서 얻을 y빠르게. 예를 들어,에서 얻을 수 1222에 1에 내려 가장 짧은 경로 (주소 빈 문자열입니다) 중앙 삼각형 첫번째 승천하는 것입니다, 그리고 1즉, 첫 번째 움직임은 불일치 점의 왼쪽으로 우리가 걸립니다. 그러나,에서 얻을 수 1222로 12, 최단 경로가 상승하는 것입니다 122, 다음에 12, 즉, 첫 번째 이동이 불일치 지점의 오른쪽에 우리를 유지합니다.

그렇다면 가장 짧은 길을 어떻게 찾습니까? "공식적인"프로그램은 무차별 접근 방식을 사용하여의 x하위 문자열이 아닐 때마다 모든 조상에게 가능한 모든 이동을 시도합니다 y. 소리만큼 나쁘지 않습니다! 1 ~ 2 초 안에 모든 테스트 사례를 결합하여 해결합니다.

그러나 다시, 우리는 훨씬 더 잘할 수 있습니다. 불일치 지점 왼쪽에 직접 도달 할 수있는 조상이 둘 이상인 경우, 가장 오른쪽에있는 조상 만 테스트하면됩니다. 불일치 지점의 오른쪽에서 가장 왼쪽 만 테스트하면됩니다. 이것은 x훨씬 더 큰 테스트 사례를 확대 하는 길이 (즉, 소스 삼각형의 깊이 또는 소스 삼각형 수의 로그에 비례하는 시간)를 가진 선형 시간 알고리즘을 생성합니다 . 다음 프로그램은 본질적으로 골프 때문에이 알고리즘을 구현합니다. 실제로는 복잡성이 선형보다 나쁘지만 여전히 매우 빠릅니다.

파이썬 2, 271 266 261 바이트

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

짧은 버전과 달리이 버전은 입력 값을 해당 주소로 변환 할 때 재귀를 사용하지 않도록 특별히 작성되었으므로 스택을 오버플로하지 않고도 매우 큰 값을 처리 할 수 ​​있습니다.

결과

다음 스 니펫을 사용하여 두 버전 중 하나에 대한 테스트를 실행하고 결과를 생성 할 수 있습니다.

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   )

골프 버전

         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

효율적인 버전

         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 유니 코드) , 144 (132) 129 118 133 132 130 124 117 바이트 ^SBCS을

APL 언어를 배우기에 좋은 장소 인 APL 오차드 에서 골프를 치는 데 도움을 주신 Ven와 ngn에게 대단히 감사합니다 . ⎕IO←0. 골프 제안을 환영합니다.

편집 : Ven 및 ngn 덕분에 n정의 방법을 변경 하고 1 인덱싱에서 0 인덱싱으로 전환 하여 -12 바이트 . 모든 것이 0 인덱싱으로 전환되지 않은 버그를 수정했기 때문에 -3입니다. 방법 P및 Q정의 변경으로 인해 -11 바이트 s[⊃⍋|M-s]섹션 을 계산하는 데 도움이되는 ngn 덕분에 알고리즘이 잘못 된 문제를 수정하여 +15 바이트 . -2 바이트는 역 추적 경로를 찾는 방법을 재정렬하고 +1 바이트는 버그를 수정합니다. 의 정의를 재정렬 한 Adám 덕분에 -2 바이트 I. ngn 덕분에 정의를 재정렬하고 정의 'S' 'NE' 'NW' 'N' 'SW' 'SE'방법 을 재정렬하여 t(더 이상 별도의 변수는 아님) 골프 s정의 에서 ngn 덕분에 -7 바이트 .

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

온라인으로 사용해보십시오!

알고리즘의 버그에 대한 설명

기본적인 문제는 내가 가장 짧은 길은 공통 조상을 통해 직접 갔다고 생각했지만 실제로는 공통 조상의 조상을 통과 할 수 없다는 것입니다. 다음 예제에서 설명하는대로 올바르지 않습니다.

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.

코드 설명

                       ⍝ ⍵ 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 및 dfn을 사용하는 대체 솔루션

우리가 사용하는 경우 ⎕CY 'dfns'의 adic기능을, 그것은 훨씬 적은 바이트 (버전 I 사용을위한 영감) 우리의 전단 사 기본-N의 기수법을 구현합니다. Dyalog Extended로 전환하면 많은 바이트가 절약되므로 여기에 있습니다. 골프에 도움을 준 Adám에게 많은 감사를드립니다. 골프 제안을 환영합니다!

편집 방법 P및 Q정의 변경으로 인해 -8 바이트 Dyalog Extended로 전환하여 -14 바이트 -2 전체 프로그램을 사용하여 dfn 브래킷을 제거하기 때문에 -2 {}. s[⊃⍋|M-s]섹션 을 계산하는 데 도움이되는 ngn 덕분에 알고리즘이 잘못 된 문제를 수정하여 +17 바이트 . 버그 수정 +1 바이트 Adám 덕분에 -2 바이트는 정의를 재정렬 I 하고 -1 바이트는 골프를 두 솔루션에 모두 넣는 것을 기억합니다 . 기본 방향 생성을 재정렬하여 ngn 덕분에 -3 바이트, 버기 골프를 수정하여 +1 바이트, ngn으로 인해 t정의 된 방법을 재정렬하여 -3 바이트 (더 이상 별도의 변수는 아님). s정의 방법을 재정렬하여 ngn 덕분에 -7 바이트

APL (Dyalog는 확장) , 123 (115) 101 99 116 117 114 109 102 바이트

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

온라인으로 사용해보십시오!