Bei einer Länge von N Zeichenfolgen mit Vorzeichen kleiner als und größer als ( <, >) fügen Sie die Ganzzahlen 0 bis N am Anfang und am Ende sowie zwischen die einzelnen Zeichenpaare ein, sodass alle Ungleichungen erfüllt sind. Die resultierende Zeichenfolge ausgeben. Wenn es mehrere gültige Ausgaben gibt, geben Sie eine (und nur eine) davon aus.

Zum Beispiel

<<><><<

Hat 7 Zeichen, daher müssen alle Zahlen von 0 bis einschließlich 7 eingegeben werden. Eine gültige Ausgabe ist

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

weil alle Ungleichungen eines nach dem anderen genommen

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

sind wahr.

Falls gewünscht, kann die Ausgabe Leerzeichen aufweisen, die die Zeichen umgeben, z 2 < 3 < 4 > 1 < 5 > 0 < 6 < 7.

Der kürzeste Code in Bytes gewinnt.

Testfälle

Die erste Zeile nach einer Leerzeile ist die Eingabe und die nächste (n) Zeile (n) sind jeweils gültige Ausgabebeispiele.

[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

Netzhaut , 20 Bytes

Die Anzahl der Bytes setzt die Kodierung nach ISO 8859-1 voraus.

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

Probieren Sie es online! (Die erste Zeile aktiviert eine durch Zeilenvorschub getrennte Testsuite.)

Erläuterung

Eine einfache Möglichkeit, eine gültige Permutation zu finden, besteht darin, zunächst die Zahlen von 0bis Nin der richtigen Reihenfolge einzufügen und dann die Zahlen umzukehren, die die einzelnen Unterzeichenfolgen von >s umgeben. Nehmen Sie <><<>>><<als Beispiel:

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

Beide Aufgaben sind in Retina relativ einfach, obwohl wir nur mit Strings arbeiten können. Wir können ein zusätzliches Byte sparen, indem wir die Zahlen von Nunten nach unten einfügen 0und <stattdessen die umgebenden Abschnitte umkehren , aber das Prinzip ist dasselbe.

Stufe 1: Substitution

$.'

Wir beginnen damit, die Länge von $'(das Suffix, dh alles nach dem Match) in jede mögliche Position in der Eingabe einzufügen. Dies fügt die Zahlen von Nunten bis ein 0.

Stufe 2: Split

S`>

Wir teilen die Eingabe >in separate Zeilen auf, sodass jede Zeile entweder eine einzelne Zahl oder eine Liste von Zahlen ist, mit denen sie verbunden ist <.

Stufe 3: Sortieren

%O#`\d+

Innerhalb jeder Zeile ( %) sortieren ( ) wir Odie Zahlen ( \d#) nach ihrem numerischen Wert ( #). Da wir die Nummer in umgekehrter numerischer Reihenfolge eingegeben haben, werden sie dadurch umgekehrt.

Stufe 4: Substitution

¶
>

Wir verwandeln die Zeilenvorschübe >wieder in, um alles wieder zu einer einzigen Zeile zusammenzufügen. Das ist es.

Als Randnotiz wollte ich eine Möglichkeit hinzufügen %, andere Trennzeichen als Zeilenvorschübe zu verwenden. Hätte ich das schon getan, hätte diese Übermittlung 14 Bytes betragen, denn dann wären die letzten drei Stufen auf eine einzige reduziert worden:

%'>O#`\d+

> <> , 46 43 35 + 4 für  -s== 39 Bytes

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

Dies ist eine Implementierung von xnors Algorithmus in> <>.

Es nimmt die Eingabezeichenfolge auf dem Stapel ( -sFlag mit dem Standardinterpreter).

Sie können es mit dem Online-Dolmetscher ausprobieren .

> <> , 26 + 4 = 30 Bytes

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

Probieren Sie es online! +4 Bytes für das -s=Flag - Wenn dies nur -sin Ordnung ist (dies würde bedeuten, dass das Flag für leere Eingaben vollständig gelöscht werden müsste), wäre dies stattdessen +3.

Es wird davon ausgegangen, dass die STDIN-Eingabe leer ist, sodass i-1 erzeugt wird (was bei EOF der Fall ist). Das Programm versucht, -1 als Zeichen auszugeben.

Verwendet den Max-of-Num-bisher >-für-Min-of-Num-bisher-für- <Ansatz.

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

Ein Programm, das sauber beendet wird und die Annahme über STDIN nicht trifft, besteht aus 4 zusätzlichen Bytes:

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

CJam , 16 Bytes

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

Probieren Sie es online!

Ein Port meiner Retina-Antwort .

Erläuterung

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

Perl, 29 Bytes

Beinhaltet +2 für -lp

Mit Eingabe auf STDIN ausführen, z

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

Ausgabe:

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

order.pl:

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

Erläuterung

Haben Sie zwei Zähler, max beginnend mit der Zeichenkettenlänge, min beginnend mit 0. Dann an jeder Grenze (einschließlich Anfang und Ende der Zeichenkette), wenn es gerade vor a ist, <setzen Sie das Minimum dort und erhöhen Sie um 1, sonst setzen Sie das Maximum dort und verringern Sie um 1 (am Ende der Zeichenkette spielt es keine Rolle, welchen Zähler Sie nehmen, da beide gleich sind)

Python 2, 67 Bytes

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

Eine rekursive Funktion. Befriedigt jeden Bediener, indem er den kleinsten unbenutzten Wert xfür x<und den größten für einsetzt x>. Der kleinste nicht verwendete Wert wird gespeichert iund aktualisiert, und der größte nicht verwendete Wert wird aus ider verbleibenden Länge abgeleitet.

Python 2, 163 137 Bytes

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)

Mischt die Zahlen, bis die Aussage zu ausgewertet wird True.

Versuch es.

APL, 33 Bytes

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

⍋⍋ ist ungewöhnlich nützlich.

Erläuterung

⍞←(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

JavaScript (ES6), 74 56 Byte

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

Beginnt mit der Menge der Zahlen 0...N. In jeder Phase wird einfach die größte ( l) oder die kleinste ( j) der verbleibenden Zahlen genommen. Die nächste Zahl muss per definitionem kleiner oder größer sein. Bearbeiten: Dank @Arnauld wurden massive 18 Bytes gespeichert.

Pyth - 19 Bytes

Ein Hoch auf die Vergleichsverkettung!

!QZhv#ms.idQ.p`Mhl

Funktioniert aus Sicherheitsgründen nicht online.

2sable , 20 Bytes

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

Erläuterung

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

Probieren Sie es online!

Für N <10 könnte dies 14 Bytes gewesen sein:

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

C # 102 99 Bytes

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

Java 8, 126 125 Bytes

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

Ich glaube nicht, dass das funktioniert, hehe

Ungolfed Testprogramm

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(">><><>>"));
}

Jelly , 27 14 12 Bytes

Port von @Martin Enders CJam Lösung
-2 Bytes dank @Dennis

żJ0;µFṣ”<Uj”<

Testen Sie es bei TryItOnline

Wie?

ż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"

Vorherige Methode war mathematisch interessant, aber nicht so golfen ...

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

Hierbei wird das faktorielle Basissystem verwendet, um einen Index der Permutationen von [0, N] zu finden, der die Gleichung erfüllt.

Clojure, 152 132 126 Bytes

(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))))

Habe eine ganze Menge Bytes gespart, indem ich so viel Leerzeichen wie möglich entfernt habe. Ich habe festgestellt, dass Leerzeichen nicht erforderlich sind, um eine Klammer von einem anderen Zeichen zu trennen.

Grundsätzlich eine Clojure-Portierung von @ Scepheos Antwort. Arbeitet identisch.

Diese recurAnrufe sind Killer! Ich nehme an, ich hätte Atome verwenden können, um es zu säubern. Die swap!Aufrufe, die erforderlich sind, um zur Anzahl hinzugefügte Atome zu verwenden: /

Vielen Dank an @amalloy, dass du mir ein paar Bytes gespart hast.

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

Haskell, 162 Bytes

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

Das ist verdammt lang.

Perl (107 + 1 für -p) 108

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

Algorithmus aus Martin Enders Antwort gestohlen

Ruby, 135 Bytes

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

Hinweis: Die zeitliche Komplexität ist groß (O (n!)).

Python 2, 176 172 Bytes

Es ist nicht sehr kurz im Vergleich zu den anderen, aber ich bin froh, dass ich es so schnell gelöst habe.

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

Probieren Sie es online aus

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

Probieren Sie es online aus

PHP, 190 Bytes

Zufälliges Mischen, bis eine gültige Lösung vorliegt

$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 Bytes erhalten alle Lösungen und wählen eine aus

<?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)];