"सब-वेक्टर रिवर्सल" का उपयोग करके छँटाई का अनुकूलन करें

Question

यह एक सबसे कम-संचालन चुनौती है जहां उद्देश्य सबसे कम उलटफेर का उपयोग करके एक वेक्टर को आरोही क्रम में क्रमबद्ध करना है। आपका एल्गोरिथ्म केवल "सब-वेक्टर रिवर्सल" ¹ का उपयोग करके वेक्टर को सॉर्ट कर सकता है , लेकिन यह अंकगणितीय ऑपरेशनों, लूप्स, चेकिंग के लिए अन्य ऑपरेशंस का उपयोग कर सकता है यदि यह सॉर्ट किया गया है आदि । सब-वेक्टर रिवर्सल की संख्या जो आपके एल्गोरिदम निष्पादित करता है, उसका स्कोर है।

---

¹ एक "उप-वेक्टर उत्क्रमण":

• वेक्टर में संख्याओं का चयन करें, और उस श्रेणी के तत्वों को उल्टा करें।

एक सरल उदाहरण देने के लिए, यदि आप वेक्टर से शुरू करते हैं {4,3,2,1}, तो आप इसे कई तरीकों से सॉर्ट कर सकते हैं:

1. पूरे वेक्टर को उलट दें। यह स्पष्ट रूप से सबसे छोटा दृष्टिकोण है क्योंकि इसके लिए केवल एक उलट की आवश्यकता होती है:{4,3,2,1} -> {1,2,3,4}
2. आप बबल सॉर्ट का एक संस्करण कर सकते हैं, जिसमें 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. आप पहले 3 तत्वों के साथ शुरू कर सकते हैं, फिर तीन अंतिम, और अंत में दो पहले और दो अंतिम, जिसमें 4 स्वैप की आवश्यकता होती है: {4,3,2,1} -> {2,3,4,1} -> {2,1,4,3} -> {1,2,4,3} -> {1,2,3,4}
4. ... और इसी तरह। उपलब्ध विकल्पों की एक अनंत राशि है (यदि आप चाहें तो किसी भी ऑपरेशन को दोहरा सकते हैं)।

---

नियम और आवश्यकताएं:

• 100 नंबर वाली सूची के लिए आपका कोड एक मिनट से भी कम समय में समाप्त होना चाहिए। आप स्वयं इसे समय दे सकते हैं, लेकिन कृपया मेला ² खेलें ।

• आपको अपने द्वारा किए गए सभी स्वैप के आरंभ और अंत सूचक को संग्रहीत करना होगा, ताकि समाधान सत्यापित हो सके। (मैं समझाता हूं कि इसका क्या मतलब है नीचे)।

• कोड निर्धारक होना चाहिए।

• आप अपने इच्छित फॉर्मेट पर इनपुट ले सकते हैं: न्यूमेरिक वेक्टर, लिंक्ड-लिस्ट, लंबाई के साथ एरे ... जो भी आपको पसंद हो।

• आप वेक्टर की एक कॉपी पर जो चाहें कर सकते हैं । जिसमें अलग-अलग उलटने का प्रयास करना और जांचना शामिल है जो सबसे अधिक कुशल है। ब्रूट-फोर्सिंग पूरी तरह से ठीक है, लेकिन समय सीमा के लिए छड़ी।

• स्कोर 5 टेस्ट वैक्टर के लिए फ़्लिप की कुल संख्या है। टाई-ब्रेकर की तारीख पर मुहर लगेगी।

---

उदाहरण:

4 1 23 21 49 2 7 9 2 | प्रारंभिक वेक्टर / सूची
4 1 2 9 7 2 49 21 23 | (2, 8) (सूचक 2 और 8 के बीच तत्वों को फ़्लिप किया)
4 1 2 2 7 9 49 21 23 | (३, ५)
4 1 2 2 7 9 23 21 49 | (६,,)
4 1 2 2 7 9 21 23 49 | (६, 49 )
 २ २ १ ४ 2 ९ २१ २३ ४ ९ | (०, ३)
 १ २ २ ४ 1 ९ २१ २३ ४ ९ | (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

मुझे पूरा यकीन है कि एक इष्टतम समाधान एनपी-हार्ड है (चूंकि नियमित पैनकेक छँटाई है)।

_{² हाँ, एक मिनट की समय सीमा के कारण बहुत तेज़ कंप्यूटर वाले लोगों को लाभ हो सकता है। बहुत चर्चा के बाद मुझे लगा कि अगर हर कोई अपनी बेंचमार्किंग करता है तो यह सबसे तेज़ कोड चुनौती नहीं है।}

Comments

कुछ हद तक संबंधित ।

— स्टीवी ग्रिफिन

अधिकतम विलयन को अधिकतम विलयन की संख्या में सम्मिलन के समतुल्य होना चाहिए, प्रत्येक उत्क्रमण एक एकल संख्या को रख सकता है।

— f --n 22tɪk

यह पैनकेक फ़्लिपिंग नहीं है (जो अंत तक केवल एक स्थान से फ्लिप कर सकता है)। चयन प्रकार O (n) है और n-1 स्वैप का उपयोग करता है। ऐसे सबसे खराब मामले हैं जिनमें n-1 स्वैप आवश्यक है। चयन प्रकार विषमतम रूप से इष्टतम है।

— 19

1. क्या इनपुट पूर्णांक की एक सूची / वेक्टर है? 2. कार्यक्रम का आउटपुट क्या होना चाहिए? 3. क्या प्रोग्राम वेक्टर या इसके कुछ हिस्सों को क्रमबद्ध कर सकता है, कई बार, शायद विभिन्न तरीकों (जैसे क्विकॉर्ट) का उपयोग करके, यह निर्धारित करने के लिए कि परिचालन को कैसे अनुकूलित किया जाए, जब तक कि यह एक सब-वेक्टर रिवर्सल प्रकार इनपुट नहीं करता है। वेक्टर (अनुरोध के अनुसार) आखिर में?

— aditsu 16

@orlp क्या आप यह साबित कर सकते हैं कि फ्लिप्स के साथ सबसे खराब मामले हैं n-1? मैं केवल 50 के निचले हिस्से को साबित कर सकता हूं।

— उपयोगकर्ता 202729

Answer 1

जावा, आनुवंशिक-ईश एल्गोरिथ्म, 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 करने और विभिन्न आकारों में कई सिमुलेशन चलाने की अनुमति दी।

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 सेकंड लगते हैं।

Comments

दिलचस्प है कि 5 वें परीक्षण मामले में उलटफेर की संख्या में नए संस्करण के साथ सुधार नहीं हुआ। दूसरे काफी सुधार करते हैं। मुझे खुशी है कि आपने इसे एक और जाने का फैसला किया :)

— स्टीवी ग्रिफिन

@StewieGriffin धन्यवाद, आपने मुझे पिछले 20k को उड़ाने में मदद की :) मुझे लगता है कि मुझे पिछले मामले के साथ थोड़ा भाग्यशाली मिला। एक यादृच्छिक दृष्टिकोण शायद बेहतर परिणाम भी देगा।

— 16

Answer 2

एक चाल ब्रूट-फोर्स फिर सेलेक्शन सॉर्ट (भी भोली समाधान), 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);

हर संभव पहले कदम के लिए, यह कोशिश करो, और फिर, एक चयन प्रकार करें।

हां, यह एक और भोला समाधान है।

मुझे यकीन नहीं है कि यह एक संपादन या कोई अन्य पोस्ट होना चाहिए, लेकिन ऐसा लगता है कि समाधान बहुत सरल है, इसलिए संपादन चुना गया है।

---

चयन सॉर्ट (Naive Solution), 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)

एक अनुभवहीन समाधान चयन प्रकार का उपयोग करता है।

वहाँ कुछ बेहतर समाधान होना चाहिए , लेकिन इस पोस्ट के बाद से मैं एक बेहतर एक (जानवर बल खोज के बिना) नहीं मिला।

(उपरोक्त कोड जावास्क्रिप्ट शेल है )