Data una stringa N di lunghezza minore di e maggiore di segni ( <, >), inserire gli interi da 0 a N all'inizio e alla fine e tra ogni coppia di segni in modo tale da soddisfare tutte le disuguaglianze. Emette la stringa risultante. Se sono presenti più output validi, emettere uno qualsiasi (e solo uno) di essi.

Per esempio

<<><><<

ha 7 caratteri, quindi tutti i numeri da 0 a 7 inclusi devono essere inseriti. Un output valido è

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

perché tutte le disuguaglianze sono state prese una alla volta

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

sono vere

Se lo si desidera, l'output può contenere spazi attorno ai segni, ad es 2 < 3 < 4 > 1 < 5 > 0 < 6 < 7.

Vince il codice più breve in byte.

Casi test

La prima riga dopo una riga vuota è l'input e le righe successive sono esempi di output validi.

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

Il conteggio dei byte presuppone la codifica ISO 8859-1.

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

Provalo online! (La prima riga abilita una suite di test separata da avanzamento riga.)

Spiegazione

Un modo semplice per trovare una permutazione valida è iniziare inserendo i numeri da 0a Nin ordine e quindi invertire i numeri che circondano ciascuna sottostringa di >s. Prendi <><<>>><<come esempio:

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

Entrambi questi compiti sono abbastanza semplici in Retina, anche se tutto ciò con cui possiamo davvero lavorare sono stringhe. Possiamo salvare un byte aggiuntivo inserendo i numeri da Nverso il basso 0e invertendo invece le sezioni circostanti <, ma il principio è lo stesso.

Fase 1: sostituzione

$.'

Iniziamo inserendo la lunghezza di $'(il suffisso, cioè tutto dopo la corrispondenza) in ogni posizione possibile nell'input. Ciò inserisce i numeri da Ngiù a 0.

Fase 2: divisione

S`>

Dividiamo l'input >in righe separate, quindi ogni riga è un singolo numero o un elenco di numeri uniti <.

Fase 3: ordinamento

%O#`\d+

All'interno di ogni riga ( %) ordiniamo ( O) i numeri ( \d#) in base al loro valore numerico ( #). Poiché abbiamo inserito il numero in ordine numerico inverso, ciò li inverte.

Fase 4: sostituzione

¶
>

Trasformiamo >nuovamente i feed di linea per unire nuovamente tutto in un'unica riga. Questo è tutto.

Come nota %a margine, intendevo aggiungere un modo per applicare ad altri delimitatori oltre agli avanzamenti di riga. Se l'avessi già fatto, questo invio sarebbe stato di 14 byte, perché le ultime tre fasi sarebbero state ridotte a una sola:

%'>O#`\d+

> <> , 46 43 35 + 4 per  -s== 39 byte

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

Questa è un'implementazione dell'algoritmo di xnor in> <>.

Prende la stringa di input nello stack ( -sflag con l'interprete standard).

Puoi provarlo sull'interprete online .

> <> , 26 + 4 = 30 byte

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

Provalo online! +4 byte per il -s=flag - se solo -sva bene (significherebbe che il flag dovrebbe essere eliminato interamente per input vuoto), invece sarebbe +3.

Presuppone che l'input STDIN sia vuoto in modo da iprodurre -1 (cosa che fa su EOF). Il programma si interrompe tentando di stampare questo -1 come carattere.

Utilizza l'approccio max-of-nums-so-far-for- >, min-of-nums-so-far-for-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 programma che esce in modo pulito e non presuppone STDIN è di 4 byte extra:

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

CJam , 16 byte

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

Provalo online!

Una porta della mia risposta Retina .

Spiegazione

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 byte

Include +2 per -lp

Esegui con input su STDIN, ad es

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

Produzione:

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

order.pl:

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

Spiegazione

Hanno due contatori, massimo che inizia con la lunghezza della stringa, minimo che inizia con 0. Quindi ad ogni limite (incluso l'inizio e la fine della stringa) se è appena prima di <mettere il minimo lì e aumentare di 1, altrimenti mettere il massimo lì e diminuire di 1 (alla fine della stringa non importa quale contatore prendi poiché sono entrambi uguali)

Python 2, 67 byte

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

Una funzione ricorsiva. Soddisfa ogni operatore a sua volta mettendo il più piccolo valore inutilizzato xper x<e più grande per x>. Il valore inutilizzato più piccolo viene archiviato ie aggiornato e viene dedotto il valore inutilizzato più grande ie la lunghezza rimanente.

Python 2, 163 137 byte

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)

Mescola i numeri fino a quando l'istruzione non viene valutata True.

Provalo.

APL, 33 byte

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

⍋⍋ è insolitamente utile.

Spiegazione

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

Inizia con l'insieme dei numeri 0...N. In ogni fase prende semplicemente il massimo ( l) o il minimo ( j) dei numeri rimanenti; il numero successivo deve essere per definizione minore o maggiore di quello. Modifica: salvato un enorme 18 byte grazie a @Arnauld.

Pyth - 19 byte

Evviva per il concatenamento comparativo!

!QZhv#ms.idQ.p`Mhl

Non funziona online perché di eval safety.

2 file , 20 byte

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

Spiegazione

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

Provalo online!

Per N <10 questo avrebbe potuto essere 14 byte:

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

C #, 102 99 byte

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 byte

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

Non penso che questo funzioni anche hehe

Programma di test non golfato

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

Gelatina , 27 14 12 byte

Port of @Martin Enders soluzione CJam
-2 byte grazie a @Dennis

żJ0;µFṣ”<Uj”<

Provalo su TryItOnline

Come?

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

Il metodo precedente era matematicamente interessante, ma non così da golf ...

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

Questo utilizza il sistema di base fattoriale per trovare un indice delle permutazioni di [0, N] che soddisferà l'equazione.

Clojure, 152 132 126 byte

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

Ho salvato un discreto numero di byte eliminando quanto più spazio bianco possibile. Ho capito che lo spazio bianco non è necessario per separare una parentesi da un altro personaggio.

Fondamentalmente una porta Clojure della risposta di @ Scepheo. Funziona in modo identico.

Quelle recurchiamate sono killer! Suppongo che avrei potuto usare gli atomi per ripulirlo. Le swap!chiamate richieste per usare gli atomi sono state aggiunte al conteggio: /

Grazie a @amalloy per avermi salvato qualche byte.

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 byte

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

Questo è molto lungo.

Perl (107 + 1 per -p) 108

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

Algoritmo rubato dalla risposta di Martin Ender ♦

Rubino, 135 byte

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: la complessità temporale è grande (O (n!)).

Python 2, 176 172 byte

Non è molto breve rispetto agli altri, ma sono felice di averlo risolto così 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

Provalo 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

Provalo online

PHP, 190 byte

shuffle casuale fino a quando non esiste una soluzione valida

$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 byte ottengono tutte le soluzioni e scegline una

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