แรงบันดาลใจจากคำถามนี้

อีกวิธีในการคลายภาพ 2D ลงในสาย 1D คือใช้Hilbert Curve

โค้งนี้มีหลายรุ่นขึ้นอยู่กับจำนวนการวนซ้ำที่ใช้ในขณะคำนวณ ด้านล่างติดตามตัวอย่างของ Hilbert Curves จากลำดับแรกถึงลำดับที่ห้า

วิธีการคำนวณเส้นโค้งนี้มีดังต่อไปนี้ อันดับแรกเรากำหนดคำสั่งแรกของ Hilbert Curve ตามที่แสดงในรูป (อันสำหรับ n = 1) เพื่อให้มันพอดีกับสี่เหลี่ยม 1x1 เรากว่าทำโค้งสี่ชุดนี้ให้เว้นระยะห่างในจตุรัส 4x4 เพื่อให้พวกเขาทั้งหมดนำเสนอ "เว้า" ทางด้านซ้าย จากนั้นเราพลิกทั้งสองซ้ายสุดเพื่อ 1 โค้งเพื่อให้หนึ่งเว้าด้านบนหันไปทางด้านบนในขณะที่ด้านล่างหันด้านล่าง ในที่สุดเราก็เชื่อมมุมของ Hilbert Curves ที่อยู่ติดกัน หากต้องการรับเส้นโค้ง (n + 1) เพื่อเราจะต้องทำซ้ำขั้นตอนด้วยเส้นโค้ง n-order สี่เส้น เราสามารถเห็นการสร้างภาพของกระบวนการที่นี่ (ฉันจะเพิ่มภาพรายละเอียดกระบวนการในไม่ช้า)

งานของคุณในการท้าทายนี้คือการคลี่เมทริกซ์ของจำนวนเต็มตามลำดับต่ำสุดของ Hilbert Curveสำหรับเมทริกซ์นั้น

เพื่อความง่ายเราจะมีเส้นโค้งที่เริ่มต้นจากมุมซ้ายบนของเมทริกซ์

คุณสามารถรับอินพุตเป็นรายการของจำนวนเต็มโดยที่แต่ละรายการย่อยจะแสดงแถวของเมทริกซ์

คุณสามารถสันนิษฐานได้ว่าอินพุตจะเป็นเมทริกซ์จตุรัส (n * n)

ตัวอย่างเช่น:

การป้อนข้อมูล:

[[ 1, 2,]
 [ 3, 4 ]]

เอาท์พุท:

[ 1, 2, 4, 3 ]

เนื่องจากเราใช้คำสั่งแรกของ Hilbert Curve ดังแสดงในรูป

การป้อนข้อมูล:

[[ 1, 2, 3, 4,    ]
 [ 5, 6, 7, 8,    ]
 [ 9, 10, 11, 12, ]
 [ 13, 14, 15, 16 ]]

เอาท์พุท:

[ 1, 5, 6, 2, 3, 4, 8, 7, 11, 12, 16, 15, 14, 10, 9, 13 ]

ใช้ลำดับที่สองของ Hilbert Curve

ตามปกติจะไม่อนุญาตให้มีช่องโหว่มาตรฐาน

นี่คือโค้ดกอล์ฟดังนั้นคำตอบที่สั้นที่สุดในจำนวนไบต์ชนะ

MATL , 86 85 ไบต์

วิธีการแก้ปัญหานี้อิงจากรายการแลกเปลี่ยนไฟล์ของ Jonas Lundgren ซึ่งใช้ตัวเลขที่ซับซ้อนเพื่อสร้างเส้นโค้งของฮิลแบร์ต จำนวนเชิงซ้อนเหล่านี้จะถูกแปลงเป็นค่าดัชนีเพื่อดึงองค์ประกอบของเมทริกซ์ที่ตกไปตามเส้นโค้ง

nZl2/1XLJQXH1J-XI0,1L:"XJJZj1j*XKKH-JI-JH+IK-,4$h2/]XJJ1L*XJJH+J1)-XHGHXjHYj3$)1$Xd1$

ลองออนไลน์!

คำอธิบาย

%--- Define some numbers to be used throughout ---%
n                   % Retrieve the number of elements in the input matrix
Zl2/                % Compute the order of the curve (log2(numel(i))/2)
1XL                 % Store the order in the 1L clipboard
JQ XH               % Store 1 + j in H clipboard
1J- XI              % Store 1 - j in I clipboard
0                   % Place 0 onto the stack

%--- Compute the hilbert curve ---%
1L:"                % For k = 1:order
    XJ                   % Store the top of the stack (z) in J clipboard
    JZj                  % Compute the conjugate of z (stored in J)
    1j*                  % Multiply by j to get conj(z) * j
    XK                   % Store result in K clipboard
    KH- JI- JH+ IK- 4$h  % Horizontal concatenation of K-H, J-I, J+H, and I-K
    2/                   % Divide entire array by 2
]                   % End for loop
XJ                  % Store z in J clipboard

%----- Convert complex decimal values to complex integer indices ----%
J1L*                % Multiply z by the order
XJ                  % Store result in clipboard J
JH+                 % Add 1 + j to H
J1)-                % Subtract the first element of z
XH                  % Store integer complex numbers in H

%--- Retrieve the elements from the input along the curve ---%  
G HXj HYj 3$)       % Index into input using real/imag components input(real, imag)
                    % This will yield an numel(real) x numel(imag) matrix where 
            % the diagonal values are the values we want
1$Xd                % Extract the diagonals using diag with one input
1$                   % Display only the top element on the stack

APL (Dyalog Unicode) , 41 ไบต์^SBCS

บันทึก 30 ไบต์ (!) โดยการปรึกษาภูมิปัญญาของ APL Orchard โดยเฉพาะ @ngn และ @ Sherlock9

{0::⍵⋄∊∇¨⌽∘⊖¨@4,⌽@1⊢∘⍉\⌽↑∘⍵¨∘.,⍨2 ¯2÷⍨≢⍵}

ลองออนไลน์!

คำอธิบายดังนี้:

{0::⍵⋄∊∇¨⌽∘⊖¨@4,⌽@1⊢∘⍉\⌽↑∘⍵¨∘.,⍨2 ¯2÷⍨≢⍵} ⍝ Recursive function - takes input as an
                                          ⍝ n*n square matrix
 0::⍵                                     ⍝ Our base case - this is an error guard
                                          ⍝ If there's any error, catch it and
                                          ⍝ return the function's input
                                      ≢⍵  ⍝ Find the number of rows in the input
                                2 ¯2÷⍨    ⍝ Divide the above by 2 and negative 2,
                                          ⍝ resulting in a 2-element vector
                            ∘.,⍨          ⍝ Outer product - take the above vector and
                                          ⍝ apply concatenation (,) with each element
                                          ⍝ against all elements in the vector. Since
                                          ⍝ we have a 2-element vector, this results in
                                          ⍝ a 2-by-2 matrix, e.g.
                                          ⍝ [[(2,2),(2,¯2)],[(¯2,2),(¯2,¯2)]]
                        ↑∘⍵¨              ⍝ For each element in the matrix, we apply
                                          ⍝ "take" against our original input matrix.
                                          ⍝ Take, given a negative number, will take
                                          ⍝ elements from the end of a particular rank.
                                          ⍝ With our argument above, this means that we end
                                          ⍝ up with our original original input matrix
                                          ⍝ split by quadrant into a 2-by-2 matrix.
                                          ⍝ It is also worth noting that take expects
                                          ⍝ an integer argument, so for matrices whose
                                          ⍝ rowcount divided by two results in a decimal
                                          ⍝ (i.e., 1-by-1 matrices), we throw an error
                                          ⍝ which is caught by the guard above, returning
                                          ⍝ the original input.
                       ⌽                  ⍝ Flip the above matrix about the vertical axis.
                   ⊢∘⍉\                   ⍝ Apply a "monadic transpose scan". More details
                                          ⍝ on how this works below, but for our purposes
                                          ⍝ this applies transpose to each of the two 
                                          ⍝ sub-matrices on the right half.
                ⌽@1                       ⍝ Swap the two upper sub-matrices. Given our
                                          ⍝ flip for the overall matrix above, this returns
                                          ⍝ the two upper quadrants to their original
                                          ⍝ positions.
               ,                          ⍝ Ravel: flatten the 2-by-2 matrix into a
                                          ⍝ 4-element vector
         ⌽∘⊖¨@4                           ⍝ Take the last element of the list (the lower
                                          ⍝ right quadrant originally) and flip it
                                          ⍝ along the vertical and horizontal axes. Given
                                          ⍝ the transposition above, this has the final
                                          ⍝ effect of transposition along the antidiagonal.
       ∇¨                                 ⍝ For each element in the above vector, recurse.
      ∊                                   ⍝ Recursively flatten the results into a single
                                          ⍝ vector.

รายละเอียดเพิ่มเติมเกี่ยวกับ " monadic transpose scan "

เอกสาร Dyalog ในยามผิดพลาด

Mathcad, 302 ไบต์

โปรแกรม Mathcad ด้านล่างใช้โปรแกรม @ Sherlock9 Python มันแตกต่างกันโดยการทำให้เมทริกซ์สี่เหลี่ยมโค้งโดยไม่สนใจส่วนเหล่านั้นของ Hilbert Curve ที่อยู่นอกขอบเขตเมทริกซ์ โปรดทราบว่าในขณะที่ Mathcad มีการจัดการสตริงที่ค่อนข้างแย่ฉันได้แมปสัญลักษณ์ Lindenmayer กับจำนวนเต็มในฟังก์ชัน Hilbert

Mathcad ทำงานผ่านส่วนต่อประสาน 2 มิติที่ช่วยให้ผู้ใช้สามารถวางนิพจน์ทางคณิตศาสตร์พล็อตข้อความอินพุตและเอาต์พุตทางคณิตศาสตร์ได้ ฉันได้ใส่ไบต์ไปยังการดำเนินการเทียบเท่าแป้นพิมพ์ขั้นต่ำของผู้ใช้เพื่อสร้างสัญลักษณ์ (ตัวอย่างเช่นตัวดำเนินการคำจำกัดความ (: =) ถูกป้อนโดยเพียงแค่พิมพ์:

Python 3, 327 289 275 271 239 234 ไบต์

นี่เป็นวิธีแก้ไขที่ฉันแก้ไขจากคำตอบของฉันสำหรับคำถามโค้งอีกอันของฮิลแบร์ตที่นี่ที่นี่เคล็ดลับการเล่นกอล์ฟได้รับการชื่นชม

แก้ไข:เปลี่ยนวิธีการgเพิ่มและลดลง ตอนนี้ใช้และeval() ไม่ใช้str.translatel=len(s)

def h(s):
 t=[s[0][0]];x=y=g=0;b="A"
 for j in range(len(bin(len(s)))-3):b=b.translate({65:"-BF+AFA+FB-",66:"+AF-BFB-FA+"})
 for c in b:g+=(c<"-")-(c=="-");a=c>"B";x,y=[[x,y],[[x+1-g%4,y],[x,y+g%4-2]][g%2]][a];t+=[s[x][y]]*a
 return t

Ungolfed:

# the following function is implemented in the code with b=b.translate

def hilbert(it):
    s="A"
    n=""
    for i in range(it):
        for c in s:
            if c == "A":
                n += "-BF+AFA+FB-"
            elif c == "B":
                n += "+AF-BFB-FA+"
            else:
                n += c
        s=n;n=""
    return s

def matrix_to_hilbert(mat):
    length = len(mat)       # this returns the number of rows in the matrix
    if length < 2:
        return mat
    it = len(bin(length)) - 3
    hil = hilbert(it)
    output = [mat[0][0]]    # a list that starts with the first element of the matrix
    x = 0
    y = 0
    heading = 0
    for char in hil:        # navigating the Hilbert curve
        if char == "-": heading += -1
        elif char == "+": heading += 1
        elif char == "F":
            if heading % 4 == 3: y += 1
            elif heading % 4 == 2: x -= 1
            elif heading % 4 == 1: y -= 1
            else: x += 1
            output.append(mat[x][y])
    return output

Wolfram - 233

ขึ้นอยู่กับการเป็นตัวแทนเป็นระบบ Lindenmayer :

f[m_]:=m[[Sequence@@Reverse[#+1]]]&/@DeleteDuplicates@AnglePath[Pi/2,List@@StringReplace[Last@SubstitutionSystem[{"A"->"-BF+AFA+FB-","B"->"+AF-BFB-FA+"},"A",Round@Sqrt@Length@m],{"A"|"B"->"","-"->{0,-Pi/2},"+"->{0,Pi/2},"F"->{1,0}}]]

Ruby, 224 221 216 ไบต์

คำตอบนี้จะขึ้นอยู่กับคำตอบของฉันหลาม

->s{t=[s[0][0]];x=y=g=0;b=?A;(s.size.bit_length-1).times{b=b.split("").map{|c|c==?A?"-BF+AFA+FB-":c==?B?"+AF-BFB-FA+":c}.join("")};b.each_char{|c|g+=c==?-?-1:c==?+?1:0;(g%2>0?y+=g%4-2:x+=1-g%4;t<<s[x][y])if c==?F};t}

Ungolfing:

def hilbert(mat)
  result = mat[0][0]
  x = 0
  y = 0
  heading = 0
  b = "A"
  (mat.size.bit_length-1).times do each |j| # Hilbert curve using a Lindenmayer system
    a = b.split("").map do |char|
      if char == "A"
        "-BF+AFA+FB-"
      else if char == "B"
        "+AF-BFB-FA+"
      else
        char
      end
    end
    b = a.join("")
  end
  b.each_char do |char| # navigating the matrix
    if char == "-"
      heading += -1
    else if char == "+"
      heading += 1
    else if char == "F"
      if heading % 2 == 0
        y += heading % 4 - 2
      else
        x += 1 - heading % 4
      end
      result << s[x][y]
    end
  return result
  end

CJam, 60

Lq~:A,2mL{:B1f^0B1B2B3f^]:+}*1+{AT=U=\2md'U^_~)@2*-':@+~;}%p

ลองออนไลน์

คำอธิบาย:

ฉันกำลังสร้างเศษส่วนเป็นชุดทิศทางการเคลื่อนไหว: 0 = ขวา, 1 = ลง, 2 = ซ้าย, 3 = ขึ้น

L          push an empty array (level 0 fractal)
q~:A       read the input, evaluate and store in A
,2mL       get the length (number of rows) and calculate the logarithm in base 2
            (to get the desired level)
{…}*       repeat <level> times
  :B       store the previous-level fractal in B
  1f^      XOR it with 1 (top-left part)
  0        (move right)
  B        copy the fractal (top right part)
  1        (move down)
  B        copy the fractal (bottom right part)
  2        (move left)
  B3f^     copy the fractal and XOR it with 3 (bottom left part)
  ]:+      put everything in an array and concatenate the parts
1+         add a dummy move (needed for the last step)
{…}%       apply to each direction in the array
  AT=U=    push A[T][U] (T and U are initially 0)
  \2md     bring the direction to the top and get the quotient and remainder mod 2
  'U^      XOR the 'U' character with the remainder,
            to get the variable we want to modify
  _~)      make a copy of it, then evaluate it and increment
  @2*-     bring the quotient to the top, multiply by 2 and subtract
  ':@+     concatenate ':' with the variable name
  ~;       evaluate (this updates the variable) and pop the result
p          pretty-print the resulting array