Bir uzunluk N dize göz önüne alındığında Küçüktür ve büyüktür işaretleri ( <, >), bütün eşitsizlikler yerine getirdiğinin tür işaretler her çifti arasında başında ve sonunda N ile tamsayılar 0 insert ve. Ortaya çıkan dize çıktı. Birden fazla geçerli çıktı varsa, bunlardan herhangi birini (ve yalnızca birini) çıkartın.

Örneğin

<<><><<

7 karakter içerdiğinden, 0 ila 7 arasındaki tüm sayılar girilmelidir. Geçerli bir çıktı

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

çünkü bütün eşitsizlikler bir seferde bir defa alındı

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

Doğrudur.

İstenirse, çıktı işaretleri çevreleyen boşluklara sahip olabilir, örn 2 < 3 < 4 > 1 < 5 > 0 < 6 < 7.

Bayt cinsinden en kısa kod kazanır.

Test Kılıfları

Boş bir satırdan sonraki ilk satır giriş ve sonraki satır (lar) her biri geçerli çıktı örnekleridir.

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

Bayt sayısı, ISO 8859-1 kodlamasını varsayar.

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

Çevrimiçi deneyin! (İlk satır, satır besleme ile ayrılmış bir test takımı sağlar.)

açıklama

Geçerli bir permütasyon bulmak için basit bir yolu numaraları ekleyerek başlamaktır 0için Nher alt dize çevreleyen numaraları ters ardından sırayla ve >s. Örnek <><<>>><<olarak alı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

Bu görevlerin ikisi de Retina'da oldukça basittir, gerçekte çalışabileceğimiz tek şey dizgedir. Rakamları Naşağıdan aşağıya yerleştirerek ve bunun yerine 0çevreleyen bölümleri tersine çevirerek ek bir bayt kaydedebiliriz <, ancak prensip aynıdır.

Aşama 1: Değiştirme

$.'

Girdide mümkün olan her pozisyonun uzunluğunu $'(son ek, yani maçtan sonraki her şey ) girerek başlarız . Bu sayıları Naşağıdan aşağıya ekler 0.

2. Aşama: Bölünmüş

S`>

Girdiyi >ayrı satırlara böldüğümüz için her bir satır ya tek bir numara ya da birleştirilmiş bir numaralar listesidir <.

Aşama 3: Sırala

%O#`\d+

Her satırın içinde %( O) sayıları ( \d#) sayısal değerlerine göre sıralarız ( #). Sayıyı ters sayısal sırayla girdiğimiz için bu durum onları tersine çevirir.

Aşama 4: İkame

¶
>

Her >şeyi tek bir satırda birleştirmek için satır beslemelerini tekrar ele alıyoruz . Bu kadar.

Yan not olarak, %satır sınırlayıcılardan başka sınırlayıcılara başvurmanın bir yolunu eklemeye başladım . Bunu çoktan yapsaydım, bu gönderim 14 bayt olurdu , çünkü son üç aşama tek bir taneye indirgenecekti:

%'>O#`\d+

> <> , = 43 bayt için 46 43 35 + 4 -s=

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

Bu, < nor > 'da xnor algoritmasının bir uygulamasıdır .

Yığındaki giriş dizesini alır ( -sstandart tercümanla işaretleyin).

Online tercüman üzerinde deneyebilirsiniz .

> <> , 26 + 4 = 30 bayt

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

Çevrimiçi deneyin! -s=Bayrak için +4 bayt - sadece -ssorun yok ise (bayrağın boş girdi için tamamen bırakılması gerektiği anlamına gelir), o zaman bunun yerine +3 olur.

STDIN girişinin boş olduğunu ve böylelikle i-1 ( EOF'de yaptığı) olduğunu varsayar . Program, bu -1 'i char olarak basmaya çalışırken hata veriyor.

Yaklaşım için maksimum sayı, maksimum sayı için yaklaşılmış >sayı kullanır <.

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

Temiz bir şekilde çıkan ve STDIN ile ilgili varsayımda bulunmayan bir program 4 ekstra bayttır:

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

CJam , 16 bayt

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

Çevrimiçi deneyin!

Retina cevabımın bir limanı .

açıklama

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 bayt

İçin +2 içerir -lp

STDIN'deki giriş ile çalıştırın, örn.

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

Çıktı:

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

order.pl:

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

açıklama

İki sayacı var, maks. Dize uzunluğundan başlayarak, en az 0 ile başlayınız. Sonra, her sınırda (dizgenin başlangıcı ve bitişi dahil) <minimum değeri koymadan hemen önce varsa ve 1 ile artarsanız, aksi takdirde maksimum sayıyı koyup düşürün. 1'e kadar (dizenin sonunda, her ikisi de aynı olduğu için hangi sayacı aldığınız önemli değildir)

Python 2,67 bayt

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

Özyinelemeli bir işlev. En küçük kullanılmayan değerini koyarak tatmin sırayla her operatöre xiçin x<ve için en büyük x>. Kullanılmayan en küçük değer saklanır ive güncellenir, kullanılmayan en büyük değer ise ikalan uzunluktan çıkarılır .

Python 2, 163 137 bayt

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)

İfade gelene kadar sayıları karıştırır True.

Dene.

APL, 33 bayt

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

⍋⍋ alışılmadık yararlıdır.

açıklama

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

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

Sayılar kümesi ile başlar 0...N. Her aşamada , kalan sayıların en büyüğünü ( l) veya en azını ( ) alır j; sonraki sayı, tanım gereği, bundan daha küçük veya daha büyük olmalıdır. Düzenleme: @Arnauld sayesinde büyük bir 18 bayt kaydedildi.

Pyth - 19 bayt

Karşılaştırma zincirleme için yaşasın!

!QZhv#ms.idQ.p`Mhl

Online değerlendirme güvenliği nedeniyle çalışmaz.

2sable , 20 bayt

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

açıklama

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

Çevrimiçi deneyin!

İçin N <10 bu 14 byte olabilirdi:

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

C #, 102 99 bayt

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 bayt

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

Bunun bile işe yaradığını sanmıyorum.

Ungolfed test programı

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

Jöle , 27 14 12 bayt

@Martin Enders Limanı @Dennis
sayesinde -2 baytlık çözüm çözümü

żJ0;µFṣ”<Uj”<

TryItOnline'da test edin

Nasıl?

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

Önceki yöntem matematiksel olarak ilginçti, ama çok golf gibi değildi ...

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

Bu, denklemi karşılayacak [0, N] permütasyonlarının bir indeksini bulmak için faktoring taban sistemini kullanır.

Clojure, 152 132 126 bayt

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

Olabildiğince fazla boşluk kaldırarak adil sayıda bayt kurtardı. Bir parantezi başka bir karakterden ayırmak için boşluk gerekmediğini fark ettim.

Temel olarak @ Scepheo'nun cevabının Clojure limanı. Aynı şekilde çalışır.

Bu recuraramalar katil! Sanırım temizlemek için atomları kullanabilirdim. swap!Kullanım atomu için gerekli aramaları sayısına eklenir: /

Beni birkaç bayttan kurtardığı için @ amalloy'e teşekkür ederim.

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 bayt

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

Bu çok uzun sürüyor.

Perl (-p için 107 + 1) 108

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

Martin Ender'in cevabından çalınan algoritma

Ruby, 135 bayt

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

Not: Zaman karmaşıklığı çok büyük (O (n!)).

Python 2, 176 172 bayt

Diğerlerine göre çok kısa değil, ama çok çabuk çözdüğüm için mutluyum.

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

Çevrimiçi deneyin

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

Çevrimiçi deneyin

PHP, 190 Bayt

geçerli bir çözüm bulunana kadar rastgele karıştırma

$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 Bayt tüm çözümleri alır ve birini seçer

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