किसी चीज से कम से ज्यादा बड़ा

Question

कम-से-अधिक और अधिक-से-अधिक संकेतों ( <, >) की लंबाई एन स्ट्रिंग को देखते हुए , शुरुआत और अंत में एन के माध्यम से पूर्णांक 0 डालें और संकेतों की प्रत्येक जोड़ी के बीच ऐसा करें कि सभी असमानताएं संतुष्ट हों। परिणामी स्ट्रिंग को आउटपुट करें। यदि कई वैध आउटपुट हैं, तो उनमें से किसी एक (और सिर्फ एक) को आउटपुट करें।

उदाहरण के लिए

<<><><<

7 वर्ण हैं, इसलिए 0 से 7 तक की सभी संख्याओं को सम्मिलित किया जाना चाहिए। एक वैध आउटपुट है

2<3<4>1<5>0<6<7

क्योंकि सभी असमानताएं एक समय में एक हो जाती हैं

2<3
3<4
4>1
1<5
5>0
0<6
6<7

सच हैं।

यदि वांछित है, तो आउटपुट में संकेतों के आसपास के स्थान हो सकते हैं, जैसे 2 < 3 < 4 > 1 < 5 > 0 < 6 < 7।

बाइट्स में सबसे छोटा कोड जीतता है।

परीक्षण के मामलों

खाली लाइन के बाद पहली पंक्ति इनपुट है और अगली पंक्ति (एस) प्रत्येक मान्य आउटपुट उदाहरण हैं।

[empty string]
0

<
0<1

>
1>0

<<
0<1<2

<>
1<2>0

><
1>0<2
2>0<1

>>
2>1>0

<<<
0<1<2<3

><>
1>0<3>2

>><
3>2>0<1
3>1>0<2
2>1>0<3

>>>
3>2>1>0

>>><<<
3>2>1>0<4<5<6
6>3>1>0<2<4<5
4>2>1>0<3<5<6
4>3>1>0<2<5<6

<<><><<
2<3<4>1<5>0<6<7

>><><>>
7>6>0<5>1<4>3>2

<<<<<<<<<<<<<<
0<1<2<3<4<5<6<7<8<9<10<11<12<13<14

>><<<<><>><><<
6>5>4<7<8<9<10>3<11>2>1<12>0<13<14
14>5>4<7<8<9<10>3<11>2>1<12>0<13<6

Comments

क्या हमेशा एक मान्य आउटपुट होगा?

— mbomb007 21

@ mbomb007 हां। हमेशा कम से कम एक होता है।

— केल्विन के शौक 21

मैं इसे> <> में किसी को देखना चाहता हूँ! यह भयानक होगा (और विडंबना मुझे लगता है?)

— सोरेन

यह वास्तव में मजेदार था, लेकिन केवल चुनौती थी, धन्यवाद ऑप

— शॉन वाइल्ड

Answer 1

रेटिना , 20 बाइट्स

बाइट गिनती आईएसओ 8859-1 एन्कोडिंग मानती है।

$.'
S`>
%O#`\d+
¶
>

इसे ऑनलाइन आज़माएं! (पहली पंक्ति एक लाइनफ़ीड-अलग-किए गए परीक्षण-सूट को सक्षम करती है।)

व्याख्या

एक वैध क्रमचय खोजने के लिए एक आसान तरीका से संख्या डालने से शुरू करने के लिए है 0करने के लिए Nआदेश में, और उसके बाद से प्रत्येक सबस्ट्रिंग आसपास संख्या को उल्टा करने के >रों। <><<>>><<एक उदाहरण के रूप में लें :

0<1>2<3<4>5>6>7<8<9
  ---   -------      these sections are wrong, so we reverse them
0<2>1<3<7>6>5>4<8<9

उन दोनों कार्यों को रेटिना में काफी सरल है, भले ही हम वास्तव में तार के साथ काम कर सकते हैं। हम एक अतिरिक्त बाइट को Nनीचे की ओर से संख्याओं को सम्मिलित करके 0और <इसके बजाय आसपास के खंडों को उलट कर बचा सकते हैं , लेकिन सिद्धांत समान है।

चरण 1: प्रतिस्थापन

$.'

हम इनपुट में हर संभव स्थिति में लंबाई $'(प्रत्यय, यानी मैच के बाद सब कुछ ) सम्मिलित करके शुरू करते हैं। यह Nनीचे से संख्याओं को सम्मिलित करता है 0।

स्टेज 2: विभाजन

S`>

हम इनपुट >को अलग-अलग लाइनों में विभाजित करते हैं, इसलिए प्रत्येक पंक्ति या तो एक व्यक्तिगत संख्या होती है या संख्याओं की एक सूची होती है <।

चरण 3: क्रमबद्ध करें

%O#`\d+

प्रत्येक पंक्ति के भीतर ( %) हम Oसंख्याओं ( \d#) को उनके संख्यात्मक मान ( #) द्वारा क्रमबद्ध करते हैं । चूंकि हमने संख्या को उल्टा संख्यात्मक क्रम में डाला है, इसलिए यह उन्हें उलट देता है।

चरण 4: प्रतिस्थापन

¶
>

हम >एक ही लाइन में सब कुछ वापस शामिल करने के लिए लाइनफीड को फिर से चालू करते हैं । बस।

एक साइड नोट के रूप में, मुझे %लाइनफीड्स की तुलना में अन्य सीमांकक पर लागू करने का एक तरीका जोड़ना है । अगर मैंने पहले ही ऐसा कर लिया होता, तो यह सबमिशन 14 बाइट्स का होता, क्योंकि तब पिछले तीन चरणों को घटाकर एक सिंगल कर दिया गया होगा:

%'>O#`\d+

Comments

एक आकार मेरे आकार की तरह कैसे है? अच्छा काम।

— थ्री एफएक्स

@ThreeFx क्योंकि मैं जानवर बल का उपयोग नहीं करता। ;) एक मिनट में आने वाला स्पष्टीकरण।

— मार्टिन एंडर

Answer 2

> <> , 46 43 35 + 4  -s== 39 बाइट्स के लिए

0&l?!v:3%?\&:n1+$o!
+nf0.>&n; >l&:@

यह xnor के एल्गोरिथ्म में> <> का कार्यान्वयन है ।

यह स्टैक पर इनपुट स्ट्रिंग लेता है ( -sमानक दुभाषिया के साथ झंडा)।

आप इसे ऑनलाइन दुभाषिया पर आज़मा सकते हैं ।

Comments

> <> इस चुनौती के लिए एक उपयुक्त भाषा की तरह लगता है।

— anaximander

Answer 3

> <> , 26 + 4 = 30 बाइट्स

l22pirv
1+$2po>:3%::2g:n$-

इसे ऑनलाइन आज़माएं! -s=झंडे के लिए +4 बाइट्स - अगर बस -sठीक है (इसका मतलब होगा कि ध्वज को खाली इनपुट के लिए पूरी तरह से गिरा देना होगा), तो इसके बजाय +3 होगा।

मान लेता है कि एसटीडीआईएन इनपुट खाली है, जिससे i-1 (जो ईओएफ पर होता है) का उत्पादन होता है। इस कार्यक्रम को एक चार्ट के रूप में छापने की कोशिश कर रहा है।

अधिकतम-से-अंक-अब तक-के लिए उपयोग करता है >, न्यूनतम-अंकों-इसलिए-दूर-के लिए- <दृष्टिकोण।

[Setup]
l22p         Place (length of stack) = (length of input) into position (2, 2) of
             the codebox. Codebox values are initialised to 0, so (0, 2) will
             contain the other value we need.
i            Push -1 due to EOF so that we error out later
r            Reverse the stack
v            Move down to the next line
>            Change IP direction to rightward

[Loop]
:3%          Take code point of '<' or '>' mod 3, giving 0 or 2 respectively
             (call this value c)
:            Duplicate
:2g          Fetch the value v at (c, 2)
:n           Output it as a number
$-1+         Calculate v-c+1 to update v
$2p          Place the updated value into (c, 2)
o            Output the '<' or '>' as a char (or error out here outputting -1)

एक प्रोग्राम जो सफाई से बाहर निकलता है और एसटीडीआईएन के बारे में धारणा नहीं बनाता है वह 4 अतिरिक्त बाइट्स हैं:

l22p0rv
p:?!;o>:3%::2g:n$-1+$2

Answer 4

सीजेएम , 16 बाइट्स

l_,),.\'</Wf%'<*

इसे ऑनलाइन आज़माएं!

मेरे रेटिना उत्तर का एक बंदरगाह ।

व्याख्या

l    e# Read input.
_,   e# Duplicate, get length N.
),   e# Get range [0 1 2 ... N].
.\   e# Riffle input string into this range.
'</  e# Split around '<'.
Wf%  e# Reverse each chunk.
'<*  e# Join with '<'.

Answer 5

पर्ल, 29 बाइट्स

के लिए +2 शामिल है -lp

STDIN पर इनपुट के साथ चलाएं, जैसे

order.pl <<< "<<><><<"

आउटपुट:

0<1<7>2<6>3<4<5

order.pl:

#!/usr/bin/perl -lp
s%%/\G</?$a++:y///c-$b++%eg

व्याख्या

दो काउंटर हैं, जो स्ट्रिंग की लंबाई के साथ शुरू होते हैं, न्यूनतम 0. मिनट से शुरू होते हैं। फिर प्रत्येक सीमा पर (स्ट्रिंग की शुरुआत और अंत सहित) अगर यह एक <पुट के ठीक पहले हो और 1 से बढ़े, अन्यथा अधिकतम वहीं डालें और घटायें 1 से (स्ट्रिंग के अंत में यह कोई फर्क नहीं पड़ता कि आप कौन सा काउंटर लेते हैं क्योंकि वे दोनों समान हैं)

Comments

s{}{/\G/...}मैंने पहले कभी नहीं देखा, यह शानदार है।

— प्राइमो

Answer 6

पायथन 2, 67 बाइट्स

f=lambda s,i=0:s and`i+len(s)*(s>'=')`+s[0]+f(s[1:],i+(s<'>'))or`i`

एक पुनरावर्ती कार्य। छोटी से छोटी अप्रयुक्त मूल्य रख कर संतुष्ट बदले में प्रत्येक ऑपरेटर xके लिए x<और के लिए सबसे बड़ा x>। सबसे छोटी अप्रयुक्त मान को संग्रहीत iऔर अद्यतन किया जाता है, और सबसे बड़ा अप्रयुक्त मूल्य से iऔर शेष लंबाई का अनुमान लगाया जाता है ।

Comments

मुझे लगता है कि आप बाइट को बचाने के (s>'=')बजाय कर सकते हैं (s>='>')?

— मैथमैनंदन

@mathmandan धन्यवाद! यह अजीब है <और >लगातार कोडपॉइंट नहीं हैं।

— 19

माना! लेकिन मुझे लगता है कि मैं देख सकता हूँ कि यह कैसे भावना होने की बनाना होगा =के बीच <और >।

— मैथमैनंदन

Answer 7

पायथन 2, 163 137 बाइट्स

from random import*
def f(v):l=len(v)+1;N=''.join(sum(zip(sample(map(str,range(l)),l),v+' '),()));return N if eval(N)or len(v)<1else f(v)

जब तक स्टेटमेंट नहीं बनता है, तब तक संख्या को फेरबदल करें True।

कोशिश करो।

Comments

यह स्पष्ट रूप से सभी उत्तरों में सबसे समझदार है।

— moopet

Answer 8

एपीएल, 33 बाइट्स

⍞←(S,⊂''),.,⍨-1-⍋⍋+\0,1-2×'>'=S←⍞

⍋⍋ असामान्य रूप से उपयोगी है।

व्याख्या

⍞←(S,⊂''),.,⍨-1-⍋⍋+\0,1-2×'>'=S←⍞
                                   ⍞ read a string from stdin      '<<><><<'
                                 S←   store it in variable S
                             '>'=     test each character for eq.   0 0 1 0 1 0 0
                         1-2×         1-2×0 = 1, 1-2×1 = ¯1         1 1 ¯1 1 ¯1 1 1
                                      (thus, 1 if < else ¯1)
                       0,             concatenate 0 to the vector   0 1 1 ¯1 1 ¯1 1 1
                     +\               calculate its running sum     0 1 2 1 2 1 2 3
                   ⍋                 create a vector of indices    1 2 4 6 3 5 7 8
                                      that sort the vector in
                                      ascending order
                 ⍋                   do it again: the compound ⍋⍋ 1 2 5 3 6 4 7 8
                                      maps a vector V to another
                                      vector V', one permutation of
                                      the set of the indices of V,
                                      such that
                                            V > V  => V' > V'.
                                             i   j     i    j
                                      due to this property, V and V'
                                      get sorted in the same way:
                                          ⍋V = ⍋V' = ⍋⍋⍋V.
              -1-                     decrement by one              0 1 4 2 5 3 6 7
      ⊂''                            void character vector         ⊂''
    S,                                concatenate input string     '<<><><<' ⊂''
   (     ),.,⍨                       first concatenate each        0 '<' 1 '<' 4 '>' 2 \
                                     element of the result vector  '<' 5 '>' 3 '<' 6 '<' \
                                     with the cordisponding        7 ⊂''
                                     element in the input string,
                                     then concatenate each result
⍞←                                  write to stdout

Comments

क्रिसमस के पेड़ ( ⍋⍋) क्या करते हैं?

— कॉनर ओ'ब्रायन

⍋ग्रेड अप है, जो क्रमबद्ध क्रम में संकेत देता है। दो बार करने से, आपको वह 1जगह मिलती है जहां सबसे छोटी संख्या थी, 2जहां अगली सबसे छोटी संख्या थी, ect।

— ज़ेविए

@ ConorO'Brien ने संक्षिप्त विवरण के साथ संपादन किया।

— ओबेरॉन

हाँ, बहुत कम ।_

— कॉनर ओ'ब्रायन

Answer 9

जावास्क्रिप्ट (ईएस 6), 74 56 बाइट्स

s=>s.replace(/./g,c=>(c<'>'?j++:l--)+c,j=0,l=s.length)+j

संख्या के सेट से शुरू होता है 0...N। प्रत्येक चरण में बस शेष संख्याओं में से सबसे बड़ा ( l) या कम से कम ( j) लेता है ; अगली संख्या को परिभाषा से कम या उससे अधिक होना चाहिए। संपादित करें: @Arnauld के लिए बड़े पैमाने पर 18 बाइट्स सहेजे गए।

Comments

क्या आप उपयोग कर सकते हैं replace? हो सकता हैs=>s.replace(/./g,c=>(c<'>'?j++:l--)+c,j=0,l=s.length)+j

— अरनुलद

@Arnauld ... और मुझे लगा कि मैं अपनी पहली कोशिश में अच्छा कर रहा हूं (जो कि replace)४ बाइट्स में बदलने के लिए उत्तरदायी नहीं था ) ...

— 748

Answer 10

पायथ - 19 बाइट्स

तुलना जंजीर के लिए हुर्रे!

!QZhv#ms.idQ.p`Mhl

Eval सुरक्षा के ऑनलाइन cuz काम नहीं करता है।

Answer 11

2sable , 20 बाइट्स

gUvy'<Qi¾¼ëXD<U}y}XJ

व्याख्या

gU                     # store input length in variable X
  v              }     # for each char in input
   y'<Qi               # if current char is "<"
        ¾¼             # push counter (initialized as 0), increase counter
          ëXD<U}       # else, push X and decrease value in variable X
                y      # push current char
                  XJ   # push the final number and join the stack

इसे ऑनलाइन आज़माएं!

के लिए एन <10 इस 14 बाइट्स हो सकता था:

ÎvyN>}J'<¡í'<ý

Answer 12

सी #, 102 99 बाइट्स

string f(string s){int i=0,j=s.Length;var r="";foreach(var c in s)r=r+(c<61?i++:j--)+c;return r+i;}

Ungolfed:

string f(string s)
{
    int i = 0, j = s.Length;    // Used to track the lowest and highest unused number.
    var r = "";                 // Start with the empty string.

    foreach (var c in s)        // For each character in the input string:
        r = r +                 // Append to the result:
            (c < 61             // If the current character is '<':
                ? i++           // Insert the lowest unused number,
                : j--)          // otherwise, insert the highest unused number.
            + c;                // And append the current character.

    return r + i;               // Return the result with the last unused number appended.
}

Comments

मैं थका हुआ हूं, इसलिए मुझे कुछ याद आ रहा है, लेकिन r = r +एक जोड़े को बचाने के लिए एक कंपाउंड असाइनमेंट के हिस्से को नहीं बदला जाएगा ?

— कारजेनिकेट

नहीं - r+दाईं ओर का हिस्सा कंपाइलर को बताता है कि पूरी चीज एक स्ट्रिंग है, इसलिए स्ट्रिंग प्रतिनिधित्व का cउपयोग किया जाता है। यदि मैं उपयोग करता हूं r+=, तो ?:भाग एक के लिए मूल्यांकन करेगा int, उस के क्रमिक मूल्य को cजोड़ा जाएगा और उसके बाद ही इसे अपने स्ट्रिंग प्रतिनिधित्व में बदल दिया जाएगा।

— सासेफियो

Answer 13

जावा 8, 126 125 बाइट्स

s->{int t=s.replaceAll("<","").length(),y=t-1;String r=t+++"";for(char c:s.toCharArray())r+=(c+"")+(c<61?t++:y--);return r;};

मुझे नहीं लगता कि यह भी काम करता है

अनगढ़ परीक्षण कार्यक्रम

public static void main(String[] args) {
    Function<String, String> function = s -> {
        int t = s.replaceAll("<", "").length(), y = t - 1;
        String r = t++ + "";
        for (char c : s.toCharArray()) {
            r += (c + "") + (c < 61 ? t++ : y--);
        }
        return r;
    };

    System.out.println(function.apply("<<><><<"));
    System.out.println(function.apply(">>><<<"));
    System.out.println(function.apply(">>>"));
    System.out.println(function.apply("<<<"));
    System.out.println(function.apply(">><><>>"));
}

Comments

5 बाइट्स सहेजने के लिए आप कोष्ठक .replaceAllको बदल सकते हैं .replaceऔर निकाल सकते हैं (c+"")।

— केविन क्रूज़सेन

@ केविनक्रूजसेन ने 5 बाइट हाहा के बारे में नहीं बताया।

— शॉन वाइल्ड

एक उचित गोल्फ भाषा का उपयोग करते समय, 5 बाइट्स 5 वें और 2 वें स्थान के बीच का अंतर है। जावा के साथ यह अंतिम स्थान के बीच का अंतर है।

— शॉन वाइल्ड

जावा लगभग हमेशा कोड-गोल्फिंग चुनौतियों के साथ अंतिम होगा, लेकिन जिस कारण से हम जावा उत्तर को शुरू करने के लिए पोस्ट करते हैं, वह जितना संभव हो उतना कम लिखने के लिए है। मैं व्यक्तिगत रूप से पहले से ही खुश हूं अगर मेरा जावा कोड बाइट के मामले में 500 से 499 हो जाता है। ; पी

— केविन क्रूज़सेन

हम मूल रूप से सभी प्रतियोगियों की उपेक्षा करते हैं और सिर्फ जावा / सी # सबमिशन आदि के साथ प्रतिस्पर्धा करते हैं।

— शॉन वाइल्ड

Answer 14

जेली , 27 14 12 बाइट्स

पोर्ट ऑफ @ मर्टिन सीजेएम समाधान
-2 बाइट्स @ डेंस के लिए धन्यवाद

żJ0;µFṣ”<Uj”<

यह TryItOnline पर परीक्षण करें

कैसे?

żJ0;Fṣ”<Uj”< - main link takes an argument, the string, e.g. ><>
 J           - range(length(input)), e.g. [1,2,3]
  0          - literal 0
   ;         - concatenate, e.g. [0,1,2,3]
ż            - zip with input, e.g. [[0],">1","<2",">3"]
    F        - flatten, list, e.g. "0>1<2>3"
      ”<  ”< - the character '<'
     ṣ       - split, e.g. ["0>1","2>3"]
        U    - upend (reverse) (implicit vectorization), e.g. ["1>0","3>2"]
         j   - join, e.g. "1>0<3>2"

पिछला तरीका गणितीय रूप से दिलचस्प था, लेकिन इतना गोल्फ नहीं ...

=”>U
LR!×ÇĖP€S‘
L‘ḶŒ!ị@ÇðżF

यह तथ्यात्मक आधार प्रणाली का उपयोग करता है [0, N] के क्रमपरिवर्तन के सूचकांक को खोजने के लिए जो समीकरण को संतुष्ट करेगा।

Comments

Uसदिश करता है, इसलिए आपको जरूरत नहीं है €। żJ0;एक और बाइट बचाता है।

— डेनिस

Answer 15

क्लोजर, 152 132 126 बाइट्स

(defn f[s](loop[l 0 h(count s)[c & r]s a""](if c(case c\<(recur(inc l)h r(str a l c))(recur l(dec h)r(str a h c)))(str a l))))

मैंने जितने व्हाट्सएप को खत्म किया, उतनी ही अच्छी संख्या में बाइट्स बचाए। मुझे एहसास हुआ कि एक अन्य चरित्र से एक कोष्ठक को अलग करने के लिए व्हाट्सएप आवश्यक नहीं है।

मूल रूप से @ Scepheo के जवाब का एक क्लोजर पोर्ट। पहचान का काम करता है।

वो recurकॉल किलर हैं! मुझे लगता है कि मैं इसे साफ करने के लिए परमाणुओं का इस्तेमाल कर सकता था। swap!उपयोग परमाणुओं के लिए आवश्यक कॉल संख्या में जुड़: /

कुछ बाइट्स बचाने के लिए @amalloy को धन्यवाद।

Ungolfed:

(defn comp-chain [chain-str]
  (loop [l 0 ; Lowest number
         h (count chain-str) ; Highest number
         [c & cr] chain-str ; Deconstruct the remaining list
         a ""] ; Accumulator
    (if c ; If there's any <>'s left
      (if (= c \<) ; If current char is a <...
        (recur (inc l) h cr (str a l c)) ; Add l to a, and inc l
        (recur l (dec h) cr (str a h c))) ; Add h to a, and dec h
      (str a l)))) ; Add on the remaining lowest number, and return

Comments

साइट पर आपका स्वागत है!

— DJMcMayhem

@DJMcMayhem धन्यवाद उम्मीद है कि अगली बार मैं किसी अन्य उत्तर को पोर्ट करने के बजाय अपने स्वयं के समाधान के साथ आ सकूंगा।

— 16

आप loopपहले sऔर बाद में, बंधन में दो और स्थान बचा सकते हैं a। तुम भी बदल कर एक सा दाढ़ी सकता है ifएक साथ पेड़ case: (case c \< (recur ...) nil (str ...) (recur ...))। और निश्चित रूप crसे एक छोटा नाम हो सकता है।

— अमल्ल

@amalloy अच्छा अंक, धन्यवाद। मेरे लैपटॉप पर मिलने पर मैं अपडेट करूंगा।

— कारजीनिकेट

Answer 16

हास्केल, 162 बाइट्स

import Data.List
(a:b)%(c:d)=show c++a:b%d
_%[x]=show x
f l=map(l%).filter(l#)$permutations[0..length l]
(e:f)#(x:y:z)=(e!x)y&&f#(y:z)
_#_=0<1
'>'!x=(>)x
_!x=(<)x

यह फ्रिंजिन लंबा है।

Answer 17

पर्ल (107 + 1-पी के लिए) 108

for$c(split''){$s.=$i++.$c;}
for$b(split'<',$s.$i){$h[$j]=join'>',reverse split'>',$b;$j++;}
$_=join'<',@h;

मार्टिन एंडर के जवाब से एल्गोरिथ्म चोरी हो गया

Answer 18

रूबी, 135 बाइट्स

g=gets
puts g.nil?? 0:[*0..s=g.size].permutation.map{|a|a.zip(g.chars)*""if s.times.map{|i|eval"%s"*3%[a[i],g[i],a[i+1]]}.all?}.compact

नोट: समय जटिलता बड़ी है (ओ (एन!))।

Answer 19

पायथन 2, 176 172 बाइट्स

यह दूसरों की तुलना में बहुत छोटा नहीं है, लेकिन मुझे खुशी है कि मैंने इसे इतनी जल्दी हल कर लिया।

from itertools import*
def f(s):
 for p in permutations(range(len(s)+1)):
    n=list(s);p=list(p);t=[p.pop()]+list(chain(*zip(n,p)));r="".join(map(str,t))
    if eval(r):return r

इसे ऑनलाइन आज़माएं

Ungolfed:

from itertools import*
def f(s):
    n=list(s);R=range(len(s)+1)
    for p in permutations(R):
        p=list(p)
        r=[p.pop()]
        t=n+p
        t[::2]=n
        t[1::2]=p
        r="".join(map(str,r+t))
        if eval(r):return r

इसे ऑनलाइन आज़माएं

Comments

जिल्द हिस्सा बहुत कम के माध्यम से किया जा सकता हैzip

— माल्टीसेन

@ माल्टेनसेन एक टन छोटा नहीं है, क्योंकि सूचियां समान लंबाई (मुझे अभी भी pop) नहीं हैं, लेकिन यह थोड़ा छोटा है। अगर N<10, मैं कम से कम सख्त बना सकता है।

— mbomb007

Answer 20

PHP, 190 बाइट्स

एक वैध समाधान मौजूद होने तक यादृच्छिक फेरबदल

$x=range(0,$l=strlen($q=$argv[1]));while(!$b){$b=1;$t="";shuffle($x);for($i=0;$i<$l;){$t.=$x[$i].$q[$i];if(($q[$i]==">"&$x[$i]<$x[$i+1])|($q[$i]=="<"&$x[$i]>$x[1+$i++]))$b=0;}}echo$t.$x[$i];

381 बाइट्स सभी समाधान प्राप्त करते हैं और एक को चुनते हैं

<?php $d=range(0,strlen($q=$argv[1]));echo $q."\n";$e=[];function f($t=""){global$e,$d,$q;foreach($d as$z){preg_match_all("#\d+#",$t,$y);if(in_array($z,$y[0]))continue;$p=preg_match_all("#[<>]#",$t);$g="";if(preg_match("#\d+$#",$t,$x)){if(($q[$p]==">"&$x[0]<$z)|($q[$p]=="<"&$x[0]>$z))continue;$g=$q[$p];}strlen($q)==$p+1|!$q?$e[]=$t.$g.$z:f($t.$g.$z);}}f();echo$e[array_rand($e)];