Dada uma cadeia N de comprimento menor que e maior que sinais ( <, >), insira os números inteiros de 0 a N no início e no final e entre cada par de sinais, para que todas as desigualdades sejam atendidas. Saída da string resultante. Se houver várias saídas válidas, produza qualquer uma (e apenas uma) delas.

Por exemplo

<<><><<

possui 7 caracteres, portanto, todos os números de 0 a 7 inclusive devem ser inseridos. Uma saída válida é

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

porque todas as desigualdades tomadas uma de cada vez

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

são verdadeiras.

Se desejado, a saída pode ter espaços ao redor dos sinais, por exemplo 2 < 3 < 4 > 1 < 5 > 0 < 6 < 7.

O código mais curto em bytes vence.

Casos de teste

A primeira linha após uma linha vazia é a entrada e as próximas linhas são exemplos de saída válidos.

[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

Retina , 20 bytes

A contagem de bytes assume a codificação ISO 8859-1.

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

Experimente online! (A primeira linha permite um conjunto de testes separado por avanço de linha.)

Explicação

Uma maneira simples de encontrar uma permutação válida é começar inserindo os números de 0para Nem ordem e, em seguida, reverter os números ao redor de cada substring de >s. Tome <><<>>><<como exemplo:

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

Ambas as tarefas são bastante simples na Retina, mesmo com as quais podemos realmente trabalhar com strings. Podemos salvar um byte adicional inserindo os números de Nbaixo para cima 0e revertendo as seções ao redor <, mas o princípio é o mesmo.

Etapa 1: Substituição

$.'

Começamos inserindo o comprimento de $'(o sufixo, ou seja, tudo após a partida) em todas as posições possíveis na entrada. Isso insere os números de Nbaixo para 0.

Etapa 2: Divisão

S`>

Dividimos a entrada >em linhas separadas, para que cada linha seja um número individual ou uma lista de números unidos <.

Etapa 3: classificação

%O#`\d+

Dentro de cada linha ( %), ordenamos ( O) os números ( \d#) pelo seu valor numérico ( #). Como inserimos o número na ordem numérica reversa, isso os reverte.

Etapa 4: Substituição

¶
>

Transformamos os feeds de linha >novamente para juntar tudo de volta em uma única linha. É isso aí.

Como uma observação lateral, pretendo adicionar uma maneira de aplicar %a outros delimitadores que não sejam feeds de linha. Se eu já tivesse feito isso, esse envio teria sido de 14 bytes, porque os três últimos estágios seriam reduzidos a um único:

%'>O#`\d+

> <> , 46 43 35 + 4 para  -s== 39 bytes

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

Esta é uma implementação do algoritmo do xnor em> <>.

Ele pega a sequência de entrada na pilha ( -ssinalize com o intérprete padrão).

Você pode experimentá-lo no intérprete online .

> <> , 26 + 4 = 30 bytes

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

Experimente online! +4 bytes para o -s=sinalizador - se -sestiver tudo bem (isso significaria que o sinalizador precisaria ser descartado inteiramente para entrada vazia), então seria +3.

Supõe que a entrada STDIN esteja vazia e iproduz -1 (o que ocorre no EOF). O programa erro ao tentar imprimir este -1 como um caractere.

Usa a abordagem max-de-nums-até-longe-para >-min-de-nums-até-longe <.

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

Um programa que sai corretamente e não assume o STDIN é de 4 bytes extras:

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

CJam , 16 bytes

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

Experimente online!

Um porto da minha resposta Retina .

Explicação

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

Inclui +2 para -lp

Execute com entrada no STDIN, por exemplo

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

Resultado:

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

order.pl:

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

Explicação

Tenha dois contadores, max começando com o comprimento da string, min começando com 0. Então, em cada limite (incluindo o início e o fim da string), se for um pouco antes de <colocar o mínimo lá e aumentar em 1, caso contrário, coloque o máximo lá e diminua por 1 (no final da sequência, não importa qual contador você tome, pois ambos são iguais)

Python 2, 67 bytes

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

Uma função recursiva. Satisfaz cada operador, por sua vez, colocando o menor valor não utilizado xpara a x<maior e mais para x>. O menor valor não utilizado é armazenado ie atualizado, e o maior valor não utilizado é deduzido ie o comprimento restante.

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)

Embaralha os números até que a instrução avance para True.

Tente.

APL, 33 bytes

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

⍋⍋ é extraordinariamente útil.

Explicação

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

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

Começa com o conjunto de números 0...N. Em cada estágio, basta pegar o maior ( l) ou o mínimo ( j) dos números restantes; o próximo número deve, por definição, ser menor ou maior que isso. Edit: salvou um enorme 18 bytes graças a @Arnauld.

Pitão - 19 bytes

Viva a comparação!

!QZhv#ms.idQ.p`Mhl

Não funciona on-line, por segurança de avaliação.

2sable , 20 bytes

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

Explicação

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

Experimente online!

Para N <10, isso poderia ter sido 14 bytes:

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

Eu acho que isso nem funciona hehe

Programa de teste ungolfed

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

Geléia , 27 14 12 bytes

Porto da solução CJam @Martin Enders
-2 bytes graças a @Dennis

żJ0;µFṣ”<Uj”<

Teste em TryItOnline

Quão?

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

O método anterior era interessante matematicamente, mas não tão ...

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

Isto usa o sistema de base fatorial para encontrar um índice das permutações de [0, N] que satisfarão a equação.

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

Economizei um número razoável de bytes, eliminando o máximo de espaço em branco possível. Percebi que espaço em branco não é necessário para separar um parêntese de outro caractere.

Basicamente, uma porta Clojure da resposta do @ Scepheo. Funciona de forma idêntica.

Essas recurchamadas são assassinas! Suponho que poderia ter usado átomos para limpá-lo. As swap!chamadas necessárias para usar átomos adicionados à contagem: /

Agradeço a @amalloy por me salvar alguns bytes.

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

Isso é muito longo.

Perl (107 + 1 para -p) 108

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

Algoritmo roubado da resposta de Martin Ender ♦

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

Nota: A complexidade do tempo é grande (O (n!)).

Python 2, 176 172 bytes

Não é muito curto comparado aos outros, mas estou feliz por ter resolvido isso tão rapidamente.

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

Experimente online

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

Experimente online

PHP, 190 bytes

aleatória até que exista uma solução válida

$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, obtenha todas as soluções e escolha uma

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