"সাব-ভেক্টর রিভার্সাল" ব্যবহার করে বাছাইকরণ অনুকূলিত করুন

এটি কয়েকটি সর্বাধিক ক্রিয়াকলাপের চ্যালেঞ্জ যেখানে উদ্দেশ্য হ'ল কোনও ভেক্টরকে সর্বাধিক বিপরীতমুখী ব্যবহার করে আরোহী ক্রমানুসারে বাছাই করা। তোমার অ্যালগরিদম করতে শুধুমাত্র সাজানোর ব্যবহার "উপ-ভেক্টর রদবদল" ভেক্টর ¹ , কিন্তু এটা গাণিতিক অপারেশন, loops জন্য অন্যান্য অপারেশন ব্যবহার করতে পারেন, চেক যদি এটা সাজানো ইত্যাদি উপ-ভেক্টরের নম্বর আপনার অ্যালগরিদম সঞ্চালিত রদবদল তার স্কোর হল।

¹এ "সাব-ভেক্টর রিভার্সাল":

ভেক্টরে সংখ্যার একটি ব্যাপ্তি নির্বাচন করুন এবং সেই ব্যাপ্তির উপাদানগুলিকে বিপরীত করুন।

একটি সাধারণ উদাহরণ দেওয়ার জন্য, আপনি যদি ভেক্টর দিয়ে শুরু করেন {4,3,2,1}, তবে আপনি এটিকে বিভিন্ন উপায়ে বাছাই করতে পারেন:

সম্পূর্ণ ভেক্টরকে বিপরীত করুন। এটি স্পষ্টতই সংক্ষিপ্ততম পদ্ধতির কারণ এটির জন্য কেবল একটি বিপরীতের প্রয়োজন:{4,3,2,1} -> {1,2,3,4}
আপনি বুদ্বুদ সাজানোর একটি সংস্করণ করতে পারেন, যার জন্য 6 টি বিপরীতের দরকার: {4,3,2,1} -> {3,4,2,1} -> {3,2,4,1} -> {2,3,4,1} -> {2,3,1,4} -> {2,1,3,4} -> {1,2,3,4}
আপনি প্রথম 3 টি উপাদান দিয়ে শুরু করতে পারেন, তারপরে তিনটি শেষ এবং শেষ পর্যন্ত দুটি প্রথম এবং দুটি শেষ, যার জন্য 4 টি অদলবদল প্রয়োজন: {4,3,2,1} -> {2,3,4,1} -> {2,1,4,3} -> {1,2,4,3} -> {1,2,3,4}
... ইত্যাদি। অসীম পরিমাণে অপশন উপলব্ধ রয়েছে (আপনি যদি চান তবে যে কোনও অপারেশন পুনরাবৃত্তি করতে পারেন)।

বিধি এবং প্রয়োজনীয়তা:

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

উদাহরণ:

4 1 23 21 49 2 7 9 2 | প্রাথমিক ভেক্টর / তালিকা
4 1 2 9 7 2 49 21 23 23 | (2, 8) (সূচক 2 এবং 8 এর মধ্যে উপাদানগুলি ফ্লিপ করেছে)
4 1 2 2 7 9 49 21 23 | (3, 5)
4 1 2 2 7 9 23 21 49 | (6, 8)
4 1 2 2 7 9 21 23 49 | (6, 7)
 2 2 1 4 7 9 21 23 49 | (0, 3)
 1 2 2 4 7 9 21 23 49 | (0, 2)

স্কোরটি 6 হবে, যেহেতু আপনি 6 টি বিপরীত করেছেন। আপনার অবশ্যই ডানদিকে তালিকাভুক্ত সূচকগুলি উপযুক্ত বিন্যাসে সংরক্ষণ করতে হবে যা যাচাইকরণের জন্য সহজেই মুদ্রণ / আউটপুট করা যায়।

পরীক্ষা ভেক্টর:

133, 319, 80, 70, 194, 333, 65, 21, 345, 142, 82, 491, 92, 167, 281, 386, 48, 101, 394, 130, 111, 139, 214, 337, 180, 24, 443, 35, 376, 13, 166, 59, 452, 429, 406, 256, 133, 435, 446, 304, 350, 364, 447, 471, 236, 177, 317, 342, 294, 146, 280, 32, 135, 399, 78, 251, 467, 305, 366, 309, 162, 473, 27, 67, 305, 497, 112, 399, 103, 178, 386, 343, 33, 134, 480, 147, 466, 244, 370, 140, 227, 292, 28, 357, 156, 367, 157, 60, 214, 280, 153, 445, 301, 108, 77, 404, 496, 3, 226, 37

468, 494, 294, 42, 19, 23, 201, 47, 165, 118, 414, 371, 163, 430, 295, 333, 147, 336, 403, 490, 370, 128, 261, 91, 173, 339, 40, 54, 331, 236, 255, 33, 237, 272, 193, 91, 232, 452, 79, 435, 160, 328, 47, 179, 162, 239, 315, 73, 160, 266, 83, 451, 317, 255, 491, 70, 18, 275, 339, 298, 117, 145, 17, 178, 232, 59, 109, 271, 301, 437, 63, 103, 130, 15, 265, 281, 365, 444, 180, 257, 99, 248, 378, 158, 210, 466, 404, 263, 29, 117, 417, 357, 44, 495, 303, 428, 146, 215, 164, 99

132, 167, 361, 145, 36, 56, 343, 330, 14, 412, 345, 263, 306, 462, 101, 453, 364, 389, 432, 32, 200, 76, 268, 291, 35, 13, 448, 188, 11, 235, 184, 439, 175, 159, 360, 46, 193, 440, 334, 128, 346, 192, 263, 466, 175, 407, 340, 393, 231, 472, 122, 254, 451, 485, 257, 67, 200, 135, 132, 421, 205, 398, 251, 286, 292, 488, 480, 56, 284, 484, 157, 264, 459, 6, 289, 311, 116, 138, 92, 21, 307, 172, 352, 199, 55, 38, 427, 214, 233, 404, 330, 105, 223, 495, 334, 169, 168, 444, 268, 248

367, 334, 296, 59, 18, 193, 118, 10, 276, 180, 242, 115, 233, 40, 225, 244, 147, 439, 297, 115, 354, 248, 89, 423, 47, 458, 64, 33, 463, 142, 5, 13, 89, 282, 186, 12, 70, 289, 385, 289, 274, 136, 39, 424, 174, 186, 489, 73, 296, 39, 445, 308, 451, 384, 451, 446, 282, 419, 479, 220, 35, 419, 161, 14, 42, 321, 202, 30, 32, 162, 444, 215, 218, 102, 140, 473, 500, 480, 402, 1, 1, 79, 50, 54, 111, 189, 147, 352, 61, 460, 196, 77, 315, 304, 385, 275, 65, 145, 434, 39

311, 202, 126, 494, 321, 330, 290, 28, 400, 84, 6, 160, 432, 308, 469, 459, 80, 48, 292, 229, 191, 240, 491, 231, 286, 413, 170, 486, 59, 54, 36, 334, 135, 39, 393, 201, 127, 95, 456, 497, 429, 139, 81, 293, 359, 477, 404, 129, 129, 297, 298, 495, 424, 446, 57, 296, 10, 269, 350, 337, 39, 386, 142, 327, 22, 352, 421, 32, 171, 452, 2, 484, 337, 359, 444, 246, 174, 23, 115, 102, 427, 439, 71, 478, 89, 225, 7, 118, 453, 350, 109, 277, 338, 474, 405, 380, 256, 228, 277, 3

আমি মোটামুটি নিশ্চিত যে একটি অনুকূল সমাধান সন্ধান করা এনপি-হার্ড (যেহেতু নিয়মিত প্যানকেক বাছাই করা হয়)।

_{² হ্যাঁ, এক মিনিটের সময়সীমার কারণে খুব দ্রুত কম্পিউটারের লোকেরা কোনও উপকার পেতে পারে। অনেক আলোচনার পরে আমি বুঝতে পেরেছি যে যদি সবার নিজের বেঞ্চমার্কিং হয় তবে এটি কোনও দ্রুততম কোড চ্যালেঞ্জ নয়।}

sorting optimization fewest-operations

— স্টিও গ্রিফিন
সূত্র

কিছুটা সম্পর্কিত ।

— স্টিভি গ্রিফিন

সর্বোত্তম সমাধানটি সর্বাধিক বিপরীত সংখ্যার মধ্যে সন্নিবেশ সাজানোর সমতুল্য হওয়া উচিত, প্রতিটি বিপরীত একটি একক সংখ্যা রাখতে পারে place

— fəˈnɛtɪk

এটি প্যানকেক উল্টানো নয় (যা কেবলমাত্র এক অবস্থান থেকে শেষ অবধি উল্টাতে পারে)। বাছাই বাছাইটি হ'ল (এন) এবং এন -1 অদলবদল ব্যবহার করে। এমন খারাপ পরিস্থিতি রয়েছে যেখানে এন -1 অদলবদল প্রয়োজন। বাছাই বাছাই অসম্পূর্ণভাবে অনুকূল।

— orlp

1. ইনপুটটি কি পূর্ণসংখ্যার একটি তালিকা / ভেক্টর? ২. প্রোগ্রামটির আউটপুট কী হওয়া উচিত? ৩. প্রোগ্রামটি কীভাবে ভেক্টর বা এর অংশগুলি বাছাই করতে পারে, একাধিকবার, সম্ভবত বিভিন্ন পদ্ধতি (যেমন কুইকোর্ট) ব্যবহার করে, কীভাবে অপারেশনকে অনুকূল করতে হবে তা নির্ধারণ করতে, যতক্ষণ না এটি উপ-ভেক্টরটি ইনপুটটির বিপরীত সাজানোর কাজ করে as ভেক্টর (অনুরোধ হিসাবে) শেষে?

— aditsu

@orlp আপনি কি প্রমাণ করতে পারবেন যে ফ্লিপগুলির ক্ষেত্রে সবচেয়ে খারাপ পরিস্থিতি রয়েছে n-1? আমি কেবল প্রায় 50

— টির

উত্তর:

জাভা, জেনেটিক-ইশ আলগোরিদিম, 80 + 81 + 79 + 78 + 80 = 398 (পূর্বে 418 )

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

"রান" বলতে আমার বোঝা যাচ্ছে সর্বাধিক সাবারিগুলি যা সাজানো অ্যারেতে হুবহু বা বিপরীত প্রদর্শিত হয়। মূলত এগুলি সর্বাধিক বাছাই করা সাববারি হয়, তবে পুনরাবৃত্ত উপাদানগুলির ক্ষেত্রে, মাঝখানে উপাদানগুলির সংখ্যাটি মেলানো উচিত। যেমন যদি সাজানো অ্যারের হয় 2, 2, 3, 3, 4, 4তারপর 4, 3, 3, 2একটি রান কিন্তু 2, 2, 3, 4(এবং তন্ন তন্ন নয় 2, 3, 2)।

এই সংস্করণে আমি অ্যালগরিদমকে কেবলমাত্র রান সীমানায় বিপরীত করতে অনুকূলিত করেছিলাম এবং কেবল যদি একটি বিপরীত রান সদ্য-সংলগ্ন রানের সাথে যুক্ত হতে পারে। এছাড়াও, পরিবর্তিত অ্যারে থেকে পুনরায় গণনা এড়াতে রানগুলি সামঞ্জস্য করা হয় এবং প্রতিটি পদক্ষেপে যোগদান করা হয়। এটি আমাকে "জনসংখ্যার আকার" 30 থেকে প্রায় 3000 বাড়িয়ে এবং বিভিন্ন আকারে একাধিক সিমুলেশন চালানোর অনুমতি দেয় allowed

import java.io.*;
import java.util.*;

public class SubReversal {
    static int n;
    static int[] a;
    static int[] srt;
    static List<int[]> rev;
    static Map<Integer, Integer> idx;
    static Map<Integer, Integer> count;

    static final int NB = 2000;
    static State[] best = new State[NB + 1];
    static int ns;

    static class Run {
        int start;
        int end;
        int dir;
        int nstart = 1;
        int nend = 1;

        Run(final int start) {
            this.start = start;
        }

        Run(final Run r) {
            start = r.start;
            end = r.end;
            dir = r.dir;
            nstart = r.nstart;
            nend = r.nend;
        }

        Run copy() {
            return new Run(this);
        }

        Run reverse() {
            int t = start;
            start = end;
            end = t;
            t = nstart;
            nstart = nend;
            nend = t;
            dir = -dir;
            return this;
        }

        boolean canJoin(final Run r) {
            if (dir * r.dir == -1) {
                return false;
            }
            final int t = idx.get(a[r.start]) - idx.get(a[end]);
            if (Math.abs(t) > 1) {
                return false;
            }
            if (t != 0 && dir + r.dir != 0 && t != dir && t != r.dir) {
                return false;
            }
            if (t == 0) {
                if (dir * r.dir == 0) {
                    return true;
                }
                return nend + r.nstart == count.get(a[end]);
            }
            return (dir == 0 || nend == count.get(a[end])) && (r.dir == 0 || r.nstart == count.get(a[r.start]));
        }

        Run join(final Run r) {
            if (a[start] == a[r.start]) {
                nstart += r.nstart;
            }
            if (a[end] == a[r.end]) {
                nend += r.nend;
            }
            else {
                nend = r.nend;
            }
            end = r.end;
            if (dir == 0) {
                dir = r.dir;
            }
            if (dir == 0 && a[start] != a[end]) {
                dir = idx.get(a[end]) - idx.get(a[start]);
            }
            return this;
        }

        @Override
        public String toString() {
            return start + "(" + nstart + ") - " + end + '(' + nend + "): " + dir;
        }
    }

    static class State implements Comparable<State> {
        int[] b;
        int[] rv;
        State p;
        List<Run> runs;

        public State(final int[] b, final int[] rv, final State p, final List<Run> runs) {
            this.b = Arrays.copyOf(b, b.length);
            this.rv = rv;
            this.p = p;
            this.runs = runs;
        }

        @Override
        public int compareTo(final State o) {
            return runs.size() - o.runs.size();
        }

        @Override
        public String toString() {
            return Arrays.toString(b) + " - " + Arrays.toString(rv) + " - " + runs.size();
        }

        int getCount() {
            return p == null ? 0 : p.getCount() + 1;
        }
    }

    static void reverse(int x, int y) {
        while (x < y) {
            int t = a[x];
            a[x] = a[y];
            a[y] = t;
            x++;
            y--;
        }
    }

    static List<Run> runs() {
        final List<Run> l = new ArrayList<>();
        Run run = new Run(0);
        for (int i = 1; i < n; ++i) {
            final int t = idx.get(a[i]) - idx.get(a[i - 1]);
            if (Math.abs(t) > 1) {
                run.end = i - 1;
                l.add(run);
                run = new Run(i);
            }
            else if (t == 0) {
                run.nend++;
                if (run.dir == 0) {
                    run.nstart++;
                }
            }
            else {
                if (run.dir == 0) {
                    run.dir = t;
                }
                else if (run.dir != t || run.nend != count.get(a[i - 1])) {
                    run.end = i - 1;
                    l.add(run);
                    run = new Run(i);
                }
                run.nend = 1;
            }
        }
        run.end = n - 1;
        l.add(run);
        return l;
    }

    static void show() {
        if (!Arrays.equals(a, srt)) {
            System.out.println("bug!");
            System.out.println(Arrays.toString(a));
            throw new RuntimeException();
        }
        System.out.println("Sorted: " + Arrays.toString(a));
        System.out.println(rev.size() + " reversal(s):");
        for (int[] x : rev) {
            System.out.println(Arrays.toString(x));
        }
    }

    static void sort() {
        State bestest = null;
        final int[] a1 = Arrays.copyOf(a, n);
        final int[] sizes = {10, 20, 30, 50, 100, 200, 300, 500, 1000, 2000};

        for (int nb : sizes) {
            System.arraycopy(a1, 0, a, 0, n);
            ns = 1;
            best[0] = new State(a, null, null, runs());
            while (best[0].runs.size() > 1) {
                final State[] s = Arrays.copyOf(best, ns);
                ns = 0;
                for (State x : s) {
                    System.arraycopy(x.b, 0, a, 0, n);
                    final int m = x.runs.size();
                    for (int i = 0; i < m; ++i) {
                        for (int j = i; j < m; ++j) {
                            boolean b = false;
                            if (i > 0) {
                                final Run r = x.runs.get(j);
                                r.reverse();
                                b = x.runs.get(i - 1).canJoin(r);
                                r.reverse();
                            }
                            if (!b && j < m - 1) {
                                final Run r = x.runs.get(i);
                                r.reverse();
                                b = r.canJoin(x.runs.get(j + 1));
                                r.reverse();
                            }
                            if (!b) {
                                continue;
                            }
                            final List<Run> l = new ArrayList<>(x.runs);
                            final int rstart = l.get(i).start;
                            final int rend = l.get(j).end;
                            final int t = rstart + rend;
                            reverse(rstart, rend);
                            for (int k = i; k <= j; ++k) {
                                final Run r = x.runs.get(i + j - k).copy().reverse();
                                r.start = t - r.start;
                                r.end = t - r.end;
                                l.set(k, r);
                            }
                            if (j < m - 1 && l.get(j).canJoin(l.get(j + 1))) {
                                l.get(j).join(l.get(j + 1));
                                l.remove(j + 1);
                            }
                            if (i > 0 && l.get(i - 1).canJoin(l.get(i))) {
                                l.set(i - 1, l.get(i - 1).copy().join(l.get(i)));
                                l.remove(i);
                            }

                            if (ns < nb || l.size() < best[ns - 1].runs.size()) {
                                best[ns++] = new State(a, new int[]{rstart, rend}, x, l);
                                Arrays.sort(best, 0, ns);
                                if (ns > nb) {
                                    ns = nb;
                                }
                            }
                            reverse(rstart, rend);
                        }
                    }
                }

                if (ns == 0) {
                    for (State x : s) {
                        System.arraycopy(x.b, 0, a, 0, n);
                        final List<Run> l = new ArrayList<>(x.runs);
                        final int rstart = l.get(0).start;
                        final int rend = l.get(0).end;
                        final int t = rstart + rend;
                        reverse(rstart, rend);
                        final Run r = x.runs.get(0).copy().reverse();
                        r.start = t - r.start;
                        r.end = t - r.end;
                        l.set(0, r);

                        best[ns++] = new State(a, new int[]{rstart, rend}, x, l);
                        reverse(rstart, rend);
                    }
                    Arrays.sort(best, 0, ns);
                }
            }
            State r = null;
            for (int i = 0; i < ns; ++i) {
                if (Arrays.equals(best[i].b, srt)) {
                    r = best[i];
                    break;
                }
            }
            if (r == null) {
                final State x = best[0];
                System.arraycopy(x.b, 0, a, 0, n);
                reverse(0, n - 1);
                r = new State(a, new int[]{0, n - 1}, x, runs());
            }
            if (!Arrays.equals(r.b, srt)) {
                throw new RuntimeException("bug");
            }

            if (bestest == null || r.getCount() < bestest.getCount()) {
                bestest = r;
            }
        }

        while (bestest.p != null) {
            rev.add(bestest.rv);
            bestest = bestest.p;
        }
        Collections.reverse(rev);
        a = a1;
        for (int[] x : rev) {
            reverse(x[0], x[1]);
        }
        if (!Arrays.equals(a, srt)) {
            throw new RuntimeException("bug");
        }
    }

    static void init(final String s) {
        final String[] b = s.split(s.contains(",") ? "," : " ");
        n = b.length;
        a = new int[n];
        count = new HashMap<>();
        for (int i = 0; i < n; ++i) {
            a[i] = Integer.parseInt(b[i].trim());
            final Integer x = count.get(a[i]);
            count.put(a[i], x == null ? 1 : x + 1);
        }
        srt = Arrays.copyOf(a, n);
        Arrays.sort(srt);
        idx = new HashMap<>();
        int j = 0;
        for (int i = 0; i < n; ++i) {
            if (i == 0 || srt[i] != srt[i - 1]) {
                idx.put(srt[i], j++);
            }
        }
        rev = new ArrayList<>();
    }

    static void test5() {
        final String[] t = {"133, 319, 80, 70, 194, 333, 65, 21, 345, 142, 82, 491, 92, 167, 281, 386, 48, 101, 394, 130, 111, 139, 214, 337, 180, 24, 443, 35, 376, 13, 166, 59, 452, 429, 406, 256, 133, 435, 446, 304, 350, 364, 447, 471, 236, 177, 317, 342, 294, 146, 280, 32, 135, 399, 78, 251, 467, 305, 366, 309, 162, 473, 27, 67, 305, 497, 112, 399, 103, 178, 386, 343, 33, 134, 480, 147, 466, 244, 370, 140, 227, 292, 28, 357, 156, 367, 157, 60, 214, 280, 153, 445, 301, 108, 77, 404, 496, 3, 226, 37",
                "468, 494, 294, 42, 19, 23, 201, 47, 165, 118, 414, 371, 163, 430, 295, 333, 147, 336, 403, 490, 370, 128, 261, 91, 173, 339, 40, 54, 331, 236, 255, 33, 237, 272, 193, 91, 232, 452, 79, 435, 160, 328, 47, 179, 162, 239, 315, 73, 160, 266, 83, 451, 317, 255, 491, 70, 18, 275, 339, 298, 117, 145, 17, 178, 232, 59, 109, 271, 301, 437, 63, 103, 130, 15, 265, 281, 365, 444, 180, 257, 99, 248, 378, 158, 210, 466, 404, 263, 29, 117, 417, 357, 44, 495, 303, 428, 146, 215, 164, 99",
                "132, 167, 361, 145, 36, 56, 343, 330, 14, 412, 345, 263, 306, 462, 101, 453, 364, 389, 432, 32, 200, 76, 268, 291, 35, 13, 448, 188, 11, 235, 184, 439, 175, 159, 360, 46, 193, 440, 334, 128, 346, 192, 263, 466, 175, 407, 340, 393, 231, 472, 122, 254, 451, 485, 257, 67, 200, 135, 132, 421, 205, 398, 251, 286, 292, 488, 480, 56, 284, 484, 157, 264, 459, 6, 289, 311, 116, 138, 92, 21, 307, 172, 352, 199, 55, 38, 427, 214, 233, 404, 330, 105, 223, 495, 334, 169, 168, 444, 268, 248",
                "367, 334, 296, 59, 18, 193, 118, 10, 276, 180, 242, 115, 233, 40, 225, 244, 147, 439, 297, 115, 354, 248, 89, 423, 47, 458, 64, 33, 463, 142, 5, 13, 89, 282, 186, 12, 70, 289, 385, 289, 274, 136, 39, 424, 174, 186, 489, 73, 296, 39, 445, 308, 451, 384, 451, 446, 282, 419, 479, 220, 35, 419, 161, 14, 42, 321, 202, 30, 32, 162, 444, 215, 218, 102, 140, 473, 500, 480, 402, 1, 1, 79, 50, 54, 111, 189, 147, 352, 61, 460, 196, 77, 315, 304, 385, 275, 65, 145, 434, 39",
                "311, 202, 126, 494, 321, 330, 290, 28, 400, 84, 6, 160, 432, 308, 469, 459, 80, 48, 292, 229, 191, 240, 491, 231, 286, 413, 170, 486, 59, 54, 36, 334, 135, 39, 393, 201, 127, 95, 456, 497, 429, 139, 81, 293, 359, 477, 404, 129, 129, 297, 298, 495, 424, 446, 57, 296, 10, 269, 350, 337, 39, 386, 142, 327, 22, 352, 421, 32, 171, 452, 2, 484, 337, 359, 444, 246, 174, 23, 115, 102, 427, 439, 71, 478, 89, 225, 7, 118, 453, 350, 109, 277, 338, 474, 405, 380, 256, 228, 277, 3"};
        int r = 0;
        for (String s : t) {
            init(s);
            sort();
            System.out.println(rev.size());
            r += rev.size();
        }
        System.out.println("total: " + r);
    }

    public static void main(final String... args) throws IOException {
        System.out.print("Input: ");
        final BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        final String s = br.readLine();
        final long t = System.currentTimeMillis();
        if (s.isEmpty()) {
            System.out.println("Running tests");
            test5();
        }
        else {
            init(s);
            sort();
            show();
        }
        System.out.println("Time: " + (System.currentTimeMillis() - t + 500) / 1000 + " sec");
    }
}

ইনপুট হ'ল কমা এবং / অথবা স্থান দ্বারা পৃথক সংখ্যার একটি তালিকা (স্টিডিন থেকে)। যদি ইনপুটটি খালি থাকে তবে প্রোগ্রামটি 5 টি পরীক্ষা চালায়। প্রত্যেকে এখানে প্রায় 40 সেকেন্ড সময় নেয়।

— aditsu
সূত্র

আকর্ষণীয় যে 5 তম পরীক্ষার ক্ষেত্রে বিপরীতে সংখ্যাটি নতুন সংস্করণে উন্নত হয়নি। অন্যরাও অনেক উন্নতি করে। আমি আনন্দিত যে আপনি এটিকে আবার যাওয়ার সিদ্ধান্ত নিয়েছেন :)

— স্টিভি গ্রিফিন

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

— aditsu

একটি পদক্ষেপের ফলশ্রুতি তারপর নির্বাচনের ধরণ (এছাড়াও নিষ্পাপ সমাধান), 90 + 89 + 88 + 87 + 89 = 443 পদক্ষেপ

let doReverse = (a, l, r) => {
  a.splice(l, r - l, ...a.slice(l, r).reverse());
};
let selectSubVectorReverseSort = a => {
  let log = [];

  for (let i = 0, l = a.length; i < l; i++) {
    let j, p = i;
    for (j = i; j < l; j++) {
      if (a[j] < a[p]) p = j;
    }
    if (p === i) continue;
    log.push([i, p + 1]);
    doReverse(a, i, p + 1);
  }
  return log;
};

let a = JSON.parse(`[${readline()}]`);
let copiedArray = a => a.map(x => x);
let minLog = selectSubVectorReverseSort(copiedArray(a));
for (let i = 0, l = a.length; i < l; i++) {
  for (let j = i + 1; j < l; j++) {
    let b = copiedArray(a);
    doReverse(b, i, j + 1);
    let log = [[i, j + 1], ...selectSubVectorReverseSort(b)];
    if (log.length < minLog.length) minLog = log;
  }
}

print(minLog.length);

প্রতিটি সম্ভাব্য প্রথম পদক্ষেপের জন্য, চেষ্টা করে দেখুন এবং তারপরে একটি নির্বাচনের বাছাই করুন।

হ্যাঁ, এটি আর একটি নিষ্পাপ সমাধান।

আমি নিশ্চিত নই যে এটি কোনও সম্পাদনা বা অন্য কোনও পোস্ট হওয়া উচিত, তবে মনে হয় সমাধানটি খুব সহজ, তাই সম্পাদনাটি বেছে নেওয়া হয়েছে।

নির্বাচনের বাছাই করুন (নিষ্পাপ সমাধান), 92 + 93 + 95 + 93 + 96 = 469 পদক্ষেপ

let log = [];
let doReverse = (a, l, r) => {
  log.push([l, r]);
  a.splice(l, r - l, ...a.slice(l, r).reverse());
}

let a = JSON.parse(`[${readline()}]`);
for (let i = 0, l = a.length; i < l; i++) {
  let j, p = i;
  for (j = i; j < l; j++) {
    if (a[j] < a[p]) p = j;
  }
  if (p === i) continue;
  doReverse(a, i, p + 1);
}
print(log.length)

একটি নিষ্পাপ সমাধান ব্যবহারের বাছাই করুন।

সেখানে হবে কিছু ভালো সমাধান হতে, কিন্তু এই পোষ্ট থেকে আমি একটা ভাল এক (বলপূর্বক অনুসন্ধান ছাড়াই) খুঁজে পান না।

(উপরে কোডটি জাভাস্ক্রিপ্ট শেল )

— TSH
সূত্র