হিলবার্ট-কারভিফাই এ ম্যাট্রিক্স

Question

এই প্রশ্নের দ্বারা অনুপ্রাণিত

2D চিত্রটিকে 1D স্ট্রিংয়ে আনরোল করার আর একটি উপায় হিলবার্ট কার্ভ ব্যবহার করা ।

এই বক্ররেখার অনেকগুলি সংস্করণ রয়েছে, এটি গণনা করার সময় ব্যবহৃত পুনরাবৃত্তির সংখ্যার উপর নির্ভর করে। নীচে প্রথম অর্ডার থেকে পঞ্চম ক্রম পর্যন্ত হিলবার্ট কার্ভের উদাহরণ অনুসরণ করুন।

এই বক্ররেখার গণনা করার পদ্ধতিটি নিম্নলিখিত। প্রথমে আমরা প্রথম অর্ডার হিলবার্ট কার্ভকে চিত্রের মতো দেখানো (n = 1 এর জন্য একটি) হিসাবে সংজ্ঞায়িত করি, যাতে এটি 1x1 স্কোয়ারে ফিট হয়। আমরা এই বক্ররেখার চারটি অনুলিপি তৈরি করে এগুলি একটি 4x4 স্কোয়ারে ফাঁক করে রেখেছি, যাতে তারা সকলেই বাম পাশের "অবতল" উপস্থাপন করে। এরপরে আমরা দুটি বাম দিকের ক্রমটি 1 টি বক্ররেখা উল্টাতে পারি, যাতে উপরের দিকের একটি অবতরণ উপরের দিকে থাকে, এবং নীচের মুখটি নীচের দিকে থাকে। অবশেষে আমরা সংলগ্ন হিলবার্ট কার্ভগুলির কোণগুলি সংযুক্ত করি। যদি কোনও (এন + 1) -অর্ডার বক্ররেখা পেতে চান, আমাদের কেবলমাত্র চারটি এন-অর্ডার বক্ররেখা দিয়ে প্রক্রিয়াটি পুনরাবৃত্তি করতে হবে। আমরা এখানে প্রক্রিয়াটির একটি দৃশ্য দেখতে পাই (আমি শীঘ্রই প্রক্রিয়াটির বিশদ সম্পর্কিত একটি চিত্রও যুক্ত করব)

এই চ্যালেঞ্জটিতে আপনার কাজটি হল সেই ম্যাট্রিক্সের জন্য সর্বনিম্ন অর্ডার হিলবার্ট কার্ভ বরাবর পূর্ণসংখ্যার একটি ম্যাট্রিক্স আনলোল করা ।

সরলতার জন্য, আমাদের ম্যাট্রিক্সের উপরের বাম কোণ থেকে শুরু করে বক্ররেখা থাকবে।

আপনি পূর্ণসংখ্যার তালিকার তালিকা হিসাবে ইনপুটটি পেতে পারেন, যেখানে প্রতিটি উপ-তালিকা ম্যাট্রিক্সের একটি সারি উপস্থাপন করে।

আপনি ধরে নিতে পারেন যে ইনপুটটি একটি বর্গ ম্যাট্রিক্স (n * n) হবে।

উদাহরণ স্বরূপ:

ইনপুট:

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

আউটপুট:

[ 1, 2, 4, 3 ]

যেহেতু আমরা চিত্রটিতে প্রদর্শিত প্রথম অর্ডার হিলবার্ট কার্ভটি ব্যবহার করছি

ইনপুট:

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

দ্বিতীয় ক্রমটি হিলবার্ট কার্ভ ব্যবহার করে

যথারীতি, স্ট্যান্ডার্ড লুফোলগুলি অনুমোদিত নয়।

এটি কোড-গল্ফ, তাই বাইট জেতে সংক্ষিপ্ত উত্তর।

Comments

সম্পর্কিত।

— ইটিএইচ প্রডাকশনগুলি 17'15

@ স্টিভি গ্রিফিন নিশ্চিত, আমি এটিতে আছি

— উইজার্ডআফমেনলো

@ স্টিভি গ্রিফিন আমি একটি সংক্ষিপ্ত সংক্ষিপ্তসার যোগ করেছি, পাঠ শেষ করার পরের ঘন্টা বা আরও কিছু সময়ের মধ্যে আমি আরও বেশি কাজ করব

— উইজার্ড অফমেনলো

না কেবল ম্যাট্রিক্স চাহিদা একটি বর্গক্ষেত্র এক হতে, এটি প্রয়োজন এন এর 2. একটি শক্তি হতে

— mbomb007

Answer 1

এমএটিএল , 86 85 বাইট

এই সমাধানটি জোনাস লন্ডগ্রেনের ফাইল এক্সচেঞ্জ এন্ট্রির উপর ভিত্তি করে যা হিলবার্ট বক্ররেখা তৈরি করতে জটিল সংখ্যা ব্যবহার করে। এই জটিল সংখ্যাগুলি বক্ররেখার ম্যাট্রিক্সের উপাদানগুলি পুনরুদ্ধার করতে সূচক মানগুলিতে রূপান্তরিত হয়।

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

Comments

@ ডোনমুসলি আমি এটি পরিচালনা করার জন্য আরও ভাল পদ্ধতিতে কাজ করছি। এটি অবশ্যই মার্জিত থেকে অনেক দূরে! পয়েন্টার জন্য ধন্যবাদ। আপডেট করা হয়েছে!

— সুইভার

আমি এই নির্দিষ্ট চ্যালেঞ্জটি দেখিনি। কখনও কখনও ক্লিপবোর্ডগুলি এড়ানো যায় না

— লুইস মেন্ডো

Answer 2

এপিএল (ডায়ালগ ইউনিকোড) , 41 বাইট ^{এসবিসিএস}

এপিএল অর্চার্ডের জ্ঞানের সাথে পরামর্শ করে 30 বাইট (!) সংরক্ষণ করেছেন, বিশেষত @ জিএনএন এবং @ শার্লক 9।

{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.

" মোনাডিক ট্রান্সপোজ স্ক্যান " সম্পর্কিত আরও বিশদ ।

ত্রুটি রক্ষীদের উপর ডায়ালগ ডকুমেন্টেশন ।

Answer 3

ম্যাথক্যাড, 302 বাইট

নীচের ম্যাথক্যাড প্রোগ্রামটি @ শার্লক 9 পাইথন প্রোগ্রামের উপর ভিত্তি করে তৈরি। হিলবার্ট কার্ভের সেই অংশগুলি ম্যাট্রিক্সের সীমার বাইরে থাকা উপেক্ষা করে আয়তক্ষেত্রাকার ম্যাট্রিকগুলি বক্ররেখার দ্বারা পৃথক হয়। মনে রাখবেন যে ম্যাথক্যাডের তুলনামূলকভাবে দুর্বল স্ট্রিং হ্যান্ডলিং রয়েছে, তাই আমি হিলবার্ট ফাংশনটিতে লিন্ডমায়ার প্রতীকগুলি পূর্ণসংখ্যায় ম্যাপ করেছি।

ম্যাথক্যাড একটি 2 ডি ইন্টারফেসের মাধ্যমে কাজ করে যা ব্যবহারকারীকে গাণিতিক এক্সপ্রেশন, প্লট, পাঠ্য, ইনপুট এবং আউটপুট স্থাপন করতে দেয় (এবং অবাধে মিশ্রিত করে)। আমি একটি বাইটকে ন্যূনতম ব্যবহারকারীর কীবোর্ড সমতুল্য অপারেশনটির সাথে একটি চিহ্ন তৈরি করতে সমান করেছি (উদাহরণস্বরূপ, সংজ্ঞা অপারেটর (: =) কেবল টাইপ করে প্রবেশ করানো হয়:।

Answer 4

পাইথন 3, 327 289 275 271 239 234 বাইট

এটি এমন একটি সমাধান যা আমি আমার উত্তর থেকে অন্য হিলবার্ট বক্রতার প্রশ্নের এখানে পরিবর্তন করেছি । কোনও গল্ফিং টিপস প্রশংসা করা হয়।

সম্পাদনা: কীভাবে gবৃদ্ধি এবং হ্রাস করা যায় তা পরিবর্তন করা হয়েছে । এখন ব্যবহার eval()এবং str.translate। আর ব্যবহার হচ্ছে না l=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

Answer 5

ওল্ফ্রাম - 233

লিন্ডেনমায়ার সিস্টেম হিসাবে উপস্থাপনার ভিত্তিতে :

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

Comments

ম্যাথমেটিকা ​​নেই এমন ব্যবহারকারীদের জন্য আপনি কি এটির কিছু স্ক্রিনশট পোস্ট করতে পারেন?

— উইজার্ডআফমেনলো

"উলফরাম" ম্যাথমেটিকার চেয়ে আলাদা কি? তা না হলে এটিকে গণিত বলা উচিত।

— mbomb007

@WizardOfMenlo এখানে কাজ করছে অনলাইন

— ফিটফাট

@ সুইশ আমার মনে হয় আপনার ওয়েব অ্যাপ্লিকেশনটির অনুমতি পরিবর্তন করা দরকার, এটি অবরুদ্ধ বলে মনে হচ্ছে

— উইজার্ড অফ মেনলো

@ mbomb007 উল্ফর্যাম নাম ভাষা , ম্যাথামেটিকাল একটি IDE ভালো হয়।

— সুইশ করুন

Answer 6

রুবি, 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

Answer 7

সিজেম, 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