পূর্ণসংখ্যার সাজানো তালিকা থেকে ভারসাম্যপূর্ণ বিএসটি তৈরি করুন

Question

পূর্ণসংখ্যার একটি অনন্য, বাছাই করা তালিকা দেওয়া হয়েছে, পুনরাবৃত্তি না করে একটি অ্যারে হিসাবে উপস্থাপিত একটি ভারসাম্য বাইনারি-অনুসন্ধান গাছ তৈরি করুন।

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

func( [1,2,3,5,8,13,21] ) => [5,2,13,1,3,8,21]

আমরা শুরু করার আগে, একটি ইঙ্গিত: আমরা এই সমস্যাটি এক টন আরও সহজ করতে পারি যাতে আমাদের আসলে ইনপুট পূর্ণসংখ্যাগুলি (বা matter বিষয়টির জন্য কোনও তুলনামূলক অবজেক্ট!) সম্পর্কে ভাবতে হবে না।

আমরা যদি জানতে পারি যে ইনপুট তালিকাটি ইতিমধ্যে সাজানো হয়েছে তবে এর সামগ্রীগুলি অপ্রাসঙ্গিক। মূল অ্যারেতে সূচকগুলির ক্ষেত্রে আমরা কেবল এটি সম্পর্কে ভাবতে পারি।

ইনপুট অ্যারের অভ্যন্তরীণ উপস্থাপনা তখন হয়:

func( [0,1,2,3,4,5,6] ) => [3,1,5,0,2,4,6]

এর অর্থ তুলনাযোগ্য বস্তুগুলির সাথে ডিল করতে হবে এমন কিছু লেখার চেয়ে বরং আমাদের কেবল একটি ফাংশন লিখতে হবে যা [0, n) এর পরিসীমা থেকে ফলাফলের অ্যারেতে মানচিত্র করে। আমাদের কাছে নতুন অর্ডার হয়ে গেলে, আমরা সহজেই ফিরে আসা অ্যারে তৈরি করতে ইনপুটটিতে মানগুলিতে ফিরে ম্যাপিং প্রয়োগ করতে পারি।

বৈধ সমাধান অবশ্যই:

• শূন্য-উপাদান অ্যারে গ্রহণ করুন এবং একটি খালি অ্যারে ফিরিয়ে দিন।
• দৈর্ঘ্যের n এর একটি পূর্ণসংখ্যা অ্যারে গ্রহণ করুন এবং পূর্ণসংখ্য অ্যারেটি ফেরত দিন
  • N এবং পরবর্তী সর্বোচ্চ 2 বিয়োগের দৈর্ঘ্যের দৈর্ঘ্য 1 (উদাহরণস্বরূপ, ইনপুট আকারের জন্য 13 13 এবং 15 এর মধ্যে যে কোনও জায়গায় ফিরে আসে)।
  • অ্যারে যা একটি বিএসটি উপস্থাপন করে যেখানে মূল নোড 0 অবস্থান এবং উচ্চতা লগ (এন) এর সমান যেখানে 0 অনুপস্থিত নোডকে উপস্থাপন করে (বা nullযদি আপনার ভাষা অনুমতি দেয় তবে একটি-পছন্দ মান)। খালি নোডগুলি যদি উপস্থিত থাকে তবে অবশ্যই গাছের শেষে অবশ্যই উপস্থিত থাকতে হবে (উদাঃ [2,1,0])

ইনপুট পূর্ণসংখ্যার অ্যারেতে নিম্নলিখিত গ্যারান্টি রয়েছে:

• মানগুলি 32-বিট স্বাক্ষরিত পূর্ণসংখ্যা শূন্যের চেয়ে বড়।
• মানগুলি অনন্য।
• মানগুলি শূন্য অবস্থান থেকে আরোহী ক্রমে।
• মানগুলি বিচ্ছিন্ন হতে পারে (অর্থাত্ একে অপরের সংলগ্ন নয়)।

আসকি চরিত্রের গণনা দ্বারা সর্বাধিক ক্ষুদ্র কোড জিততে পারে তবে আমি কোনও নির্দিষ্ট ভাষার জন্য মার্জিত সমাধানগুলি দেখতে আগ্রহী।

পরীক্ষার মামলা

সহজ ধারণকারী অ্যারে জন্য আউটপুট 1করতে nবিভিন্ন জন্য n। উপরে বর্ণিত হিসাবে, পিছনের 0গুলি al চ্ছিক।

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

Comments

এই সাইটের সমস্ত প্রশ্নের, কোনও প্রোগ্রামিং ধাঁধা বা কোড গল্ফ, এর উদ্দেশ্যগত প্রাথমিক বিজয়ী মানদণ্ড হওয়া উচিত, যাতে কোন প্রবেশিকাটি জিততে হবে তা নির্বিচারে সিদ্ধান্ত নেওয়া সম্ভব।

— হাওয়ার্ড

টুইটার বিজয়ীর জন্য নির্দিষ্ট মানদণ্ডের সাথে আপডেট হয়েছে।

— জ্যাক ওয়ার্টন

কিছু সহজ পরীক্ষার কেসগুলি (যা বর্তমানে উপস্থিত রয়েছে) কেবলমাত্র সহজতম অবস্থার চেয়ে কঠিন কেসগুলিকে আবৃত করা খুব কার্যকর হবে।

— পিটার টেলর

পুনরাবৃত্তি বাতিল করার কোনও কারণ আছে? এমন নয় যে আমি পুনরাবৃত্তির সমাধানটি দেখছি, তবে এটি কৃত্রিম এবং অপ্রয়োজনীয় উভয়ই বলে মনে হচ্ছে।

— ডিএমকেকে --- প্রাক্তন মডারেটর বিড়ালছানা 16'14

কেউ কী ব্যাখ্যা করতে পারে যে কীভাবে তালিকাটি একটি বিএসটি উপস্থাপন করে?

— justinpc

Answer 1

রুবি , 143

s=ARGV.size;r,q=[],[[0,s]];s.times{b,e=q.shift;k=Math::log2(e-b).to_i-1;m=(e-b+2)>(3<<k)?b+(2<<k)-1:e-(1<<k);r<<ARGV[m];q<<[b,m]<<[m+1,e]};p r

এটি নিম্নলিখিত কোডের একটি (looseিলে .ালা) সংক্ষেপিত সংস্করণ যা মূলত গাছের উপর একটি বিএফএস করে।

def l(n)
    k = Math::log2(n).to_i-1
    if n+2 > (3<<k) then
        (2<<k)-1
    else
        n-(1<<k) 
    end
end

def bfs(tab)
  result = []
  queue = [[0,tab.size]]
  until queue.empty? do
    b,e = queue.shift
    m = b+l(e-b)
    result << tab[m]
    queue << [b,m] if b < m
    queue << [m+1,e] if m+1 < e
  end
  result
end

p bfs(ARGV)

এছাড়াও, এটি ডিএফএস নয়, বিএফএসের কারণে, অ-পুনরাবৃত্ত সমাধানের প্রয়োজনীয়তা তাত্পর্যপূর্ণ নয় এবং এটি কিছু ভাষা অসুবিধায় ফেলেছে।

সম্পাদনা: স্থির সমাধান, তার মন্তব্যের জন্য @ পিটারটেলরকে ধন্যবাদ!

Comments

@ পিটারটেলর উদ্দেশ্য ছিল 4 এর বাম দিকে 3 রাখা, কিন্তু কোনও ফাঁকা স্থান নেই, তাই এটি ভুল। যে ইশারা জন্য ধন্যবাদ!

— dtldarek

@ পিটারটেলর মধ্যাহ্নভোজন স্থির, এখনই এটি কাজ করা উচিত।

— dtldarek

Answer 2

জাভা , 252

ঠিক আছে, এখানে আমার চেষ্টা। আমি বিট অপারেশন নিয়ে ঘুরে বেড়াচ্ছি এবং বিএসটি-তে কোনও উপাদানের সূচককে মূল অ্যারেতে সূচক থেকে গণনা করার এই প্রত্যক্ষ পদ্ধতি নিয়ে এসেছি।

সংক্ষিপ্ত সংস্করণ

public int[]b(int[]a){int i,n=1,t;long x,I,s=a.length,p=s;int[]r=new int[(int)s];while((p>>=1)>0)n++;p=2*s-(1l<<n)+1;for(i=0;i<s;i++){x=(i<p)?(i+1):(p+2*(i-p)+1);t=1;while((x&1<<(t-1))==0)t++;I=(1<<(n-t));I|=((I-1)<<t&x)>>t;r[(int)I-1]=a[i];}return r;}

দীর্ঘ সংস্করণ নীচে অনুসরণ করা হয়।

public static int[] makeBst(int[] array) {
  long size = array.length;
  int[] bst = new int[array.length];

  int nbits = 0;
  for (int i=0; i<32; i++) 
    if ((size & 1<<i)!=0) nbits=i+1;

  long padding = 2*size - (1l<<nbits) + 1;

  for (int i=0; i<size; i++) {
    long index2n = (i<padding)?(i+1):(padding + 2*(i-padding) + 1);

    int tail=1;
    while ((index2n & 1<<(tail-1))==0) tail++;
    long bstIndex = (1<<(nbits-tail));
    bstIndex = bstIndex | ((bstIndex-1)<<tail & index2n)>>tail;

    bst[(int)(bstIndex-1)] = array[i];
  }
 return bst;
}

Comments

আপনার একটি অক্ষর গণনা প্রয়োজন, এবং এটি বর্তমানে গল্ফ হয় না।

— dmckee --- সাবেক মডারেটরের বিড়ালছানা

@dmckee আমি পোস্ট সম্পাদনা করেছেন একটি সংকুচিত সংস্করণ এবং একটি অক্ষর গণনা অন্তর্ভুক্ত করা

— মিকাইল শেখ

ভাল প্রদর্শনী. আমি বাজি ধরব যে এই জায়গাগুলির কিছু অপ্রয়োজনীয়। সি int[] b(int[] a)হিসাবে , হিসাবে ভাল হিসাবে প্রকাশিত হয় int[]b(int[]a)।

— ডিএমকেই --- প্রাক্তন-মডারেটর বিড়ালছানা

আপনার কাছে a.lengthঅ্যারে বরাদ্দ হবে। এটিতে পরিবর্তন করুন s। for (একাধিক বারের মধ্যে স্থান থেকে মুক্তি পান । লুপের জন্য প্রতিটি একটি int i=0এবং তৈরি করে int t=0। n( int n=0,i,t;) দিয়ে তৈরি করুন এবং তারপরে কেবল i=0লুপগুলিতে এবং t=1ভিতরে। অভ্যন্তরীণটি long xএবং এর long Iসাথে ঘোষণা করুন sএবং কেবল লুপটিতে ( long s=a.length,I,x;এবং x=../ I=..) আরম্ভ করুন। বাইনারি AND এর চারপাশে আপনার ফাঁকা স্থানের দরকার নেই &।

— জ্যাক ওয়ার্টন

এছাড়াও, I=I|..লেখা যেতে পারেI|=..

— জেক ওয়ার্টন

Answer 3

def fn(input):
    import math
    n = len(input)
    if n == 0:
        return []
    h = int(math.floor(math.log(n, 2)))
    out = []
    last = (2**h) - 2**(h+1) + n

    def num_children(level, sibling, lr):
        if level == 0:
            return 0
        half = 2**(level-1)
        ll_base = sibling * 2**level + lr * (half)
        ll_children = max(0, min(last, ll_base + half - 1) - ll_base + 1)
        return 2**(level-1) - 1 + ll_children

    for level in range(h, -1, -1):
        for sibling in range(0, 2**(h-level)):
            if level == 0 and sibling > last:
                break
            if sibling == 0:
                last_sibling_val = num_children(level, sibling, 0)
            else:
                last_sibling_val += 2 + num_children(level, sibling - 1, 1) \
                    + num_children(level, sibling, 0)
            out.append(input[last_sibling_val])
    return out

Answer 4

খালি নোডগুলি আপনার গাছের শেষ প্রান্তে থাকা প্রয়োজনের সাথে খাপ খায় এবং এটি অবশ্যই বংশবৃদ্ধির জন্য কোনও পুরস্কার জিততে পারে না তা নিশ্চিত নয় তবে আমি মনে করি এটি সঠিক এবং এটির পরীক্ষার কেস রয়েছে :)

public class BstArray {
    public static final int[] EMPTY = new int[] { };
    public static final int[] L1 = new int[] { 1 };
    public static final int[] L2 = new int[] { 1, 2 };
    public static final int[] L3 = new int[] { 1, 2, 3 };
    public static final int[] L4 = new int[] { 1, 2, 3, 5 };
    public static final int[] L5 = new int[] { 1, 2, 3, 5, 8 };
    public static final int[] L6 = new int[] { 1, 2, 3, 5, 8, 13 };
    public static final int[] L7 = new int[] { 1, 2, 3, 5, 8, 13, 21 };
    public static final int[] L8 = new int[] { 1, 2, 3, 5, 8, 13, 21, 35 };
    public static final int[] L9 = new int[] { 1, 2, 3, 5, 8, 13, 21, 35, 56 };
    public static final int[] L10 = new int[] { 1, 2, 3, 5, 8, 13, 21, 35, 56, 91 };

    public static void main(String[] args) {
        for (int[] list : Arrays.asList(EMPTY, L1, L2, L3, L4, L5, L6, L7, L8, L9, L10)) {
            System.out.println(Arrays.toString(list) + " => " + Arrays.toString(bstListFromList(list)));
        }
    }

    private static int[] bstListFromList(int[] orig) {
        int[] bst = new int[nextHighestPowerOfTwo(orig.length + 1) - 1];

        if (orig.length == 0) {
            return bst;
        }

        LinkedList<int[]> queue = new LinkedList<int[]>();
        queue.push(orig);

        int counter = 0;
        while (!queue.isEmpty()) {
            int[] list = queue.pop();
            int len = list.length;

            if (len == 1) {
                bst[counter] = list[0];
            } else if (len == 2) {
                bst[counter] = list[1];
                queue.add(getSubArray(list, 0, 1));
                queue.add(new int[] { 0 });
            } else if (len == 3) {
                bst[counter] = list[1];
                queue.add(getSubArray(list, 0, 1));
                queue.add(getSubArray(list, 2, 1));
            } else {
                int divide = len / 2;
                bst[counter] = list[divide];
                queue.add(getSubArray(list, 0, divide));
                queue.add(getSubArray(list, divide + 1, len - (divide + 1)));
            }
            counter++;
        }

        return bst;
    }

    private static int nextHighestPowerOfTwo(int n) {
        n--;
        n |= n >> 1;
        n |= n >> 2;
        n |= n >> 4;
        n |= n >> 8;
        n |= n >> 16;
        n++;

        return n;
    }

    private static int[] getSubArray(int[] orig, int origStart, int length) {
        int[] list = new int[length];
        System.arraycopy(orig, origStart, list, 0, length);
        return list;
    }
}

Answer 5

গল্ফস্ক্রিপ্ট ( 99 89)

~]:b[]:^;{b}{{:|.,.2base,(2\?:&[-)&2/]{}$0=&(2/+:o[=]^\+:^;|o<.!{;}*|o)>.!{;}*}%:b}while^p

মূলত আমার পাইথন সমাধানের একটি সোজা বন্দর, একইভাবে কাজ করে।

আরও বেশি "গল্ফিজম" এর সাথে সম্ভবত কিছুটা উন্নতি করা যেতে পারে, ইতিমধ্যে @ পিটারটায়লারের ইনপুট দিয়ে 10 টি অক্ষর দ্বারা উন্নত করা হয়েছে :)

Comments

আমি মনে করি এটি 70 এর বেশি হওয়া সম্ভব নয়, যদিও আমি এখনও আমার গল্ফস্ক্রিপ্ট উত্তরটি পুরোপুরি শেষ করতে পারি নি। যদিও আপনার কিছু সহজ উন্নতি হয়েছে। ফিরে আসতে গ্যারান্টি বা কারণ !{;}{}ifহতে পারে । আপনি ভেরিয়েবল জন্য অ বর্ণানুক্রমিক টোকেন ব্যবহার করতে পারেন তাই যদি আপনি ব্যবহার করেন, পরিবর্তে , পরিবর্তে , পরিবর্তে যে সকল বস্তু হোয়াইটস্পেস বাদ দিতে পারে। !{;}*!01^r|x&y

— পিটার টেলর

@PeterTaylor ধন্যবাদ, অ আলফানিউমেরিক ভেরিয়েবল, এখনও খুব golfscript করার :) নতুন সম্পর্কে জানেন না

— জোয়াকিম Isaksson

Answer 6

জাভা 192

আউটপুট ইনডেক্স ইনপুট মানচিত্র সূচক

int[]b(int[]o){int s=o.length,p=0,u=s,i=0,y,r[]=new int[s],c[]=new int[s];while((u>>=1)>0)p++;for(int x:o){y=p;u=i;while(u%2>0){y--;u/=2;}r[(1<<y)-1+c[y]++]=x;i+=i>2*s-(1<<p+1)?2:1;}return r;}

দীর্ঘ সংস্করণ:

static int[] bfs(int[] o) {
  int rowCount = 32 - Integer.numberOfLeadingZeros(o.length); // log2
  int slotCount = (1<<rowCount) - 1; // pow(2,rowCount) - 1

  // number of empty slots at the end
  int emptySlots = slotCount - o.length;
  // where we start to be affected by these empty slots
  int startSkippingAbove = slotCount - 2 * emptySlots; // = 2 * o.length - slotCount

  int[] result = new int[o.length];
  int[] rowCounters = new int[rowCount]; // for each row, how many slots in that row are taken
  int i = 0; // index of where we would be if this was a complete tree (no trailing empty slots)
  for (int x : o) {
    // the row (depth) a slot is in is determined by the number of trailing 1s
    int rowIndex = rowCount - Integer.numberOfTrailingZeros(~i) - 1;
    int colIndex = rowCounters[rowIndex]++; // count where we are
    int rowStartIndex = (1 << rowIndex) - 1; // where this row starts in the result array

    result[rowStartIndex + colIndex] = x;

    i++;
    // next one has to jump into a slot that came available by not having slotCount values
    if (i > startSkippingAbove) i++;
  }

  return result;
}

Answer 7

ওল্ফ্রাম ম্যাথেমেটিকা ​​11, 175 বাইট

g[l_]:=(x[a_]:=Floor@Min[i-#/2,#]&@(i=Length[a]+1;2^Ceiling@Log2[i]/2);Join@@Table[Cases[l//.{{}->{},b__List:>(n[Take[b,#-1],b[[#]],Drop[b,#]]&@x[b])},_Integer,{m}],{m,x[l]}])

ফাংশনটি g[l]একটি ইনপুট হিসাবে নেয় List(যেমন l={1,2,3,4,...}) এবং Listপছন্দসই ফর্মটি দেয়। এটি নিম্নলিখিত হিসাবে কাজ করে:

• x[a_]:=Floor@Min[i-#/2,#]&@(i=Length[a]+1;2^Ceiling@Log2[i]/2) একটি তালিকা নেয় এবং সম্পর্কিত বিএসটির মূল আবিষ্কার করে।
  • i=Length[a]+1 তালিকার দৈর্ঘ্যের জন্য শর্টকাট
  • 2^Ceiling@Log2[i]/2 মূলের উপরের উপরের আবদ্ধ
  • Min[i-#/2,#]&@(...)দুটি আর্গুমেন্টের সর্বনিম্ন যেখানে #inside-এর ভিতরে রয়েছে for(...)
• l//.{...} প্রতিস্থাপনের নিয়ম অনুসরণ করে বারবার প্রয়োগ করুন l
• {}->{} কিছুই করার নেই (এটি অসীম লুপ এড়াতে প্রান্তের কেস)
• b__List:>(n[Take[b,#-1],b[[#]],Drop[b,#]]&@x[b])একটি Listমধ্যে বিভক্ত{{lesser}, root, {greater}}
• Cases[...,_Integer,{m}] স্তর (গভীরতা) এ সমস্ত পূর্ণসংখ্যা নিন m
• Table[...,{m,1,x[l]}]সব জন্য mপর্যন্ত x[l](যা চেয়ে বেশি প্রয়োজনীয় আসলে)।

এটি চালিয়ে পরীক্ষা করা যেতে পারে

Table[g[Range[a]], {a, 0, 15}]//MatrixForm

এই বাস্তবায়নে পিছনের জিরো অন্তর্ভুক্ত নয়।

Answer 8

পাইথন ( 175 171)

মোটামুটি ঘনীভূত, এখনও যথেষ্ট পাঠযোগ্য;

def f(a):
 b=[a]
 while b:
  c,t=((s,2**(len(bin(len(s)))-3))for s in b if s),[]
  for x,y in c:
   o=min(len(x)-y+1,y/2)+(y-1)/2
   yield x[o]
   t+=[x[:o],x[o+1:]]
  b=t

এটি ফলাফলটি ফিরিয়ে দেয়, যাতে আপনি এটির উপর লুপ করতে পারেন বা (প্রদর্শনের উদ্দেশ্যে) এটি তালিকা হিসাবে মুদ্রণ করতে পারেন;

>>> for i in range(1,17): print i-1,list(f(range(1,i)))
 0 []
 1 [1]
 2 [2, 1]
 3 [2, 1, 3]
 4 [3, 2, 4, 1]
 5 [4, 2, 5, 1, 3]
 6 [4, 2, 6, 1, 3, 5]
 7 [4, 2, 6, 1, 3, 5, 7]
 8 [5, 3, 7, 2, 4, 6, 8, 1]
 9 [6, 4, 8, 2, 5, 7, 9, 1, 3]
10 [7, 4, 9, 2, 6, 8, 10, 1, 3, 5]
11 [8, 4, 10, 2, 6, 9, 11, 1, 3, 5, 7]
12 [8, 4, 11, 2, 6, 10, 12, 1, 3, 5, 7, 9]
13 [8, 4, 12, 2, 6, 10, 13, 1, 3, 5, 7, 9, 11]
14 [8, 4, 12, 2, 6, 10, 14, 1, 3, 5, 7, 9, 11, 13]
15 [8, 4, 12, 2, 6, 10, 14, 1, 3, 5, 7, 9, 11, 13, 15]

Comments

@dtldarek তার মন্তব্য মুছে ফেলা হয়েছে বলে মনে হচ্ছে, তবে এটি এখন পরীক্ষার কেসগুলিতে উত্তীর্ণ বলে মনে হচ্ছে।

— জোচিম ইসাকসন 21

আমি আমার মন্তব্যটি মুছে ফেললাম পাছে কেউ কেউ @dtldarek এর উত্তরকে অগ্রাহ্য করা থেকে বিরত থাকবেন বলে মন্তব্য করার কারণে এটি বগী ছিল।

— পিটার টেলর

@ পিটারটেলর ভাল, আপনার বিবেচনার জন্য আপনাকে ধন্যবাদ ;-)

— dtldarek

Answer 9

জাভা

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

import java.util.Arrays;

public class SortedArrayToBalanceBinarySearchTreeArray
{
    public static void main(String... args)
    {
        System.out.println(Arrays.toString(binarySearchTree(19)));
    }

    public static int[] binarySearchTree(int m)
    {
        int n = powerOf2Ceiling(m + 1);
        int[] array = new int[n - 1];

        for (int k = 1, index = 1; k < n; k *= 2)
        {
            for (int i = 0; i < k; ++i)
            {
                array[index - 1] = (int) (.5 + ((float) (m)) / (n - 1)
                        * (n / (2 * k) * (1 + 2 * index) - n));
                ++index;
            }
        }

        return array;
    }

    public static int powerOf2Ceiling(int n)
    {
        n--;
        n |= n >> 1;
        n |= n >> 2;
        n |= n >> 4;
        n |= n >> 8;
        n |= n >> 16;
        n++;

        return n;
    }

}

এখানে আরও ঘনীভূত সংস্করণ রয়েছে (কেবলমাত্র ফাংশন এবং নামগুলি যুক্ত করা হয়েছে)। এটি এখনও সাদা স্থান পেয়েছে, তবে আমি জয়ের বিষয়ে চিন্তিত নই। এছাড়াও এই সংস্করণটি আসলে একটি অ্যারে নেয়। অন্যটি সবে সর্বাধিক সূচক জন্য একটি int নেওয়া।

public static int[] b(int m[])
{
    int n = m.length;
    n |= n >> 1;
    n |= n >> 2;
    n |= n >> 4;
    n |= n >> 8;
    n |= n >> 16;
    n++;

    int[] a = new int[n - 1];

    for (int k = 1, j = 1, i; k < n; k *= 2)
    {
        for (i = 0; i < k; ++i)
        {
            a[j - 1] = m[(int) (.5 + ((float) m.length) / (n - 1)
                    * (n / (2 * k) * (1 + 2 * j) - n)) - 1];
            ++j;
        }
    }

    return a;
}

Comments

যেহেতু এটি কোড-গল্ফ তাই আপনার পদ্ধতি / নাম / ইত্যাদি সংক্ষিপ্ত করে সংক্ষিপ্ত করুন; সমস্ত সাদা স্থান (এবং অপ্রয়োজনীয় পদ্ধতি / উপাদান) সরান, এবং অক্ষর গণনা প্রবেশ করান। অন্যথায়, আপনার দুর্দান্ত কাজ।

— জাস্টিন 6

@ জেক ওয়ার্টন আমি আপনার সরাসরি ম্যাপিং সমাধানটি দেখতে চাই। আমি কোনও 100% নিশ্চিত নই যে খনিটি খুব বড় অ্যারেগুলির জন্য কাজ করে কারণ এটি একটি অবিচ্ছিন্ন গাণিতিক ম্যাপিংয়ের উপর নির্ভর করে যার মানগুলি গোল হয়ে যায়। এটি অবশ্যই কাজ করছে বলে মনে হচ্ছে তবে কীভাবে এটি প্রমাণ করতে হবে তা সম্পর্কে আমি নিশ্চিত নই।

— ই

Answer 10

গল্ফস্ক্রিপ্ট ( 77 77 77 70 টি অক্ষর)

যেহেতু প্রশ্নের উদাহরণটি কোনও ফাংশন ব্যবহার করে, তাই আমি এটি একটি ফাংশন করেছি। সরানো হচ্ছে {}:f;একটি অভিব্যক্তি যা স্ট্যাক স্ট্যাক ইনপুট নেয় এবং বিএসটি ছেড়ে ছেড়ে 5 অক্ষর সংরক্ষণ করবে।

{[.;][{{.!!{[.,.)[1]*{(\(@++}@(*1=/()\@~]}*}%.{0=}%\{1>~}%.}do][]*}:f;

অনলাইন ডেমো (দ্রষ্টব্য: অ্যাপটি কিছুটা উষ্ণায়িত হতে পারে: 3 সেকেন্ডে চালানোর আগে এটি আমার জন্য দু'বার সময়সীমা শেষ হয়েছিল)।

কাঠামোটি দেখানোর জন্য সাদা স্থান সহ:

{
    # Input is an array: wrap it in an array for the working set
    [.;]
    [{
        # Stack: emitted-values working-set
        # where the working-set is essentially an array of subtrees
        # For each subtree in working-set...
        {
            # ...if it's not the empty array...
            .!!{
                # ...gather into an array...
                [
                    # Get the size of the subtree
                    .,
                    # OEIS A006165, offset by 1
                    .)[1]*{(\(@++}@(*1=
                    # Split into [left-subtree-plus-root right-subtree]
                    /
                    # Rearrange to root left-subtree right-subtree
                    # where left-subtree might be [] and right-subtree might not exist at all
                    ()\@~
                ]
            }*
        }%
        # Extract the leading element of each processed subtree: these will join the emitted-values
        .{0=}%
        # Create a new working-set of the 1, or 2 subtrees of each processed subtree
        \{1>~}%
        # Loop while the working-set is non-empty
        .
    }do]
    # Stack: [[emitted values at level 0][emitted values at level 1]...]
    # Flatten by joining with the empty array
    []*
}:f;

Answer 11

জে , 52 বাইট

t=:/:(#/:@{.(+:,>:@+:@i.@>:@#)^:(<.@(2&^.)@>:@#`1:))

ফাংশন একটি বাছাই করা তালিকা নেয় এবং বাইনারি ট্রি ক্রমে ফিরে আসে

লক্ষ্য করুন যে গাছগুলির অভিন্ন আকার রয়েছে তবে নীচের স্তরটি সংক্ষিপ্ত করা হয়েছে

• `1: 1 দিয়ে শুরু করুন
• <.@(2&^.)@>:@# লগ 2 এর তল দ্বারা পুনরাবৃত্তি করুন (দৈর্ঘ্য + 1)
• +: , >:@+:@i.@>:@# লুপ: বিজোড় সংখ্যা 1,3 .. 2 * দৈর্ঘ্য + 1 সহ শেষ ভেক্টরের দ্বিগুণ সংযোজন করে
• # /:@{. কেবলমাত্র প্রয়োজনীয় সংখ্যক আইটেম নিন এবং তাদের সাজানোর সূচকগুলি পান
• /: প্রদত্ত ইনপুটগুলিতে সেই ধরণের সূচকগুলি প্রয়োগ করুন

Tio

Answer 12

পাইথন 2 , 107 বাইট

জোয়াকিম ইসাকসনের উত্তরের গল্ফ , ইনপুটটি তালিকাভুক্ত একটি সিঙ্গলটন।

def f(a):
 for x in a:
	if x:w=len(x);y=1<<len(bin(w))-3;o=min(w-y+1,y/2)+~-y/2;yield x[o];a+=x[:o],x[o+1:]

এটি অনলাইন চেষ্টা করুন!