Soit une chaîne de longueur N de signes inférieur et supérieur ( <, >), insérez les nombres entiers de 0 à N au début et à la fin et entre chaque paire de signes de sorte que toutes les inégalités soient satisfaites. Affiche la chaîne résultante. S'il existe plusieurs sorties valides, indiquez-en une (et une seule).

Par exemple

<<><><<

a 7 caractères donc tous les nombres de 0 à 7 inclus doivent être insérés. Une sortie valide est

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

parce que toutes les inégalités prises un à la fois

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

sont vrai.

Si vous le souhaitez, la sortie peut comporter des espaces entourant les signes, par exemple 2 < 3 < 4 > 1 < 5 > 0 < 6 < 7.

Le code le plus court en octets gagne.

Cas de test

La première ligne après une ligne vide correspond à l'entrée et les lignes suivantes sont chacune des exemples de sortie valides.

[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

Rétine , 20 octets

Le nombre d'octets suppose un codage ISO 8859-1.

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

Essayez-le en ligne! (La première ligne active une suite de tests séparée par saut de ligne.)

Explication

Un moyen simple de trouver une permutation valide consiste à commencer par insérer les nombres de 0à Ndans l'ordre, puis à inverser les nombres entourant chaque sous-chaîne de >s. Prenons <><<>>><<comme exemple:

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

Ces deux tâches sont relativement simples dans Retina, même si nous ne pouvons vraiment travailler qu'avec des chaînes. Nous pouvons enregistrer un octet supplémentaire en insérant les nombres de Nbas en bas 0et en inversant les sections environnantes <, mais le principe est le même.

Étape 1: substitution

$.'

Nous commençons par insérer la longueur de $'(le suffixe, c'est-à-dire tout ce qui suit le match) dans toutes les positions possibles de l'entrée. Cela insère les nombres de Nbas en 0.

Étape 2: Split

S`>

Nous >séparons les entrées en lignes distinctes. Chaque ligne est donc un numéro individuel ou une liste de nombres associés <.

Étape 3: Trier

%O#`\d+

Dans chaque ligne ( %), nous trions ( O) les nombres ( \d#) par leur valeur numérique ( #). Puisque nous avons inséré le nombre dans l'ordre numérique inverse, cela les inverse.

Étape 4: substitution

¶
>

Nous reconvertissons les sauts de ligne >afin de tout relier en une seule ligne. C'est ça.

En passant, j'ai voulu ajouter un moyen de l'appliquer %à d'autres délimiteurs que les sauts de ligne. Si j'avais déjà fait cela, cette soumission aurait été de 14 octets, car alors les trois dernières étapes auraient été réduites à une seule:

%'>O#`\d+

> <> , 46 43 35 + 4 pour  -s== 39 octets

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

Ceci est une implémentation de l'algorithme de xnor dans> <>.

Il prend la chaîne d'entrée sur la pile ( -sindicateur avec l'interpréteur standard).

Vous pouvez l'essayer sur l' interprète en ligne .

> <> , 26 + 4 = 30 octets

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

Essayez-le en ligne! +4 octets pour le -s=drapeau - si cela vous -sconvient (cela voudrait dire que le drapeau devra être entièrement supprimé pour une entrée vide), il s'agira plutôt de +3.

Suppose que l'entrée STDIN est vide, ce qui iproduit -1 (ce qui est le cas avec EOF). Le programme fait une erreur en essayant d’imprimer ce -1 en tant que caractère.

Utilise l'approche max-of-nums-so-far-for- >, min-num-of-nums-so-far-for- <.

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

Un programme qui se termine proprement et ne part pas de l'hypothèse à propos de STDIN est de 4 octets supplémentaires:

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

CJam , 16 octets

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

Essayez-le en ligne!

Un port de ma rétine répond .

Explication

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 octets

Comprend +2 pour -lp

Exécuter avec une entrée sur STDIN, par exemple

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

Sortie:

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

order.pl:

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

Explication

Avoir deux compteurs, max commençant par la longueur de la chaîne, min commençant par 0. Puis à chaque limite (y compris le début et la fin de la chaîne) s'il se trouve juste avant une valeur <minimum et augmenter de 1, sinon placer le maximum et diminuer par 1 (à la fin de la chaîne, le compteur que vous prenez n'a pas d'importance, car ils sont identiques)

Python 2, 67 octets

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

Une fonction récursive. Chaque opérateur répond à son tour en mettant la plus petite valeur non utilisée xpour x<et le plus grand pour x>. La plus petite valeur inutilisée est stockée iet mise à jour, et la plus grande valeur inutilisée est déduite de ila longueur restante.

Python 2, 163 137 octets

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)

Mélange les chiffres jusqu'à ce que la déclaration soit évaluée à True.

Essayez-le

APL, 33 octets

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

⍋⍋ est inhabituellement utile.

Explication

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

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

Commence avec l'ensemble des nombres 0...N. À chaque étape, prend simplement le plus grand ( l) ou le plus petit ( j) des nombres restants; le nombre suivant doit par définition être inférieur ou supérieur à celui. Edit: Sauvegardé un énorme 18 octets grâce à @Arnauld.

Pyth - 19 octets

Hourra pour la comparaison chaînage!

!QZhv#ms.idQ.p`Mhl

Ne fonctionne pas en ligne car de sécurité eval.

2sable , 20 octets

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

Explication

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

Essayez-le en ligne!

Pour N <10, cela aurait pu être 14 octets:

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

C #, 102 à 99 octets

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 octets

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

Je ne pense pas que cela fonctionne même hehe

Programme de test non-golfé

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 de la solution CJam de @Martin Enders
-2 octets grâce à @Dennis

żJ0;µFṣ”<Uj”<

Testez-le sur TryItOnline

Comment?

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

La méthode précédente était intéressante du point de vue mathématique, mais pas si géniale ...

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

Ceci utilise le système de base factorielle pour trouver un index des permutations de [0, N] qui satisfera l’équation.

Clojure, 152 132 126 octets

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

J'ai économisé un bon nombre d'octets en éliminant autant d'espaces que possible. J'ai réalisé que les espaces ne sont pas nécessaires pour séparer une parenthèse d'un autre personnage.

Fondamentalement, un portage Clojure de la réponse de @ Scepheo. Fonctionne de manière identique.

Ces recurappels sont tueurs! Je suppose que j'aurais pu utiliser des atomes pour le nettoyer. Les swap!appels nécessaires pour utiliser les atomes ajoutés au compte: /

Merci à @amalloy de m'avoir économisé quelques octets.

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 octets

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

C'est friggin 'long.

Perl (107 + 1 pour -p) 108

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

Algorithme volé à la réponse de Martin Ender ♦

Ruby, 135 octets

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

Remarque: la complexité temporelle est grande (O (n!)).

Python 2, 176 172 octets

Ce n'est pas très court comparé aux autres, mais je suis heureux de l'avoir résolu si rapidement.

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

Essayez-le en ligne

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

Essayez-le en ligne

PHP, 190 octets

mélange aléatoire jusqu'à ce qu'une solution valide existe

$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 octets ont toutes les solutions et en choisissent une

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