보다 작거나 큰 부호 ( <, >) 의 길이 N 문자열이 주어지면 시작과 끝에서 각 부호 쌍 사이에 0에서 N까지의 정수를 삽입하여 모든 부등식이 만족되도록하십시오. 결과 문자열을 출력합니다. 유효한 출력이 여러 개인 경우 그 중 하나만 출력하십시오.

예를 들어

<<><><<

7자를 포함하므로 0에서 7까지의 모든 숫자를 삽입해야합니다. 유효한 출력은

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

모든 불평등은 한 번에 하나씩

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

사실이다.

원하는 경우, 출력은 예를 들어 표지판을 둘러싸는 공간을 가질 수있다 2 < 3 < 4 > 1 < 5 > 0 < 6 < 7.

바이트 단위의 가장 짧은 코드가 이깁니다.

테스트 사례

빈 줄 뒤의 첫 번째 줄은 입력이고 다음 줄은 각각 유효한 출력 예입니다.

[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

레티 나 , 20 바이트

바이트 수는 ISO 8859-1 인코딩을 가정합니다.

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

온라인으로 사용해보십시오! 첫 번째 줄은 줄 바꿈으로 구분 된 테스트 스위트를 활성화합니다.

설명

유효한 순열을 찾을 수있는 간단한 방법은 숫자를 삽입함으로써 시작하는 0행 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

Retina에서는이 두 가지 작업이 모두 간단하지만 실제로 작업 할 수있는 것은 모두 문자열입니다. 우리는 숫자를 N아래 에서 아래로 삽입하고 대신 0섹션을 뒤집어 추가 바이트를 절약 할 수 <있지만 원칙은 동일합니다.

1 단계 : 대체

$.'

입력의 가능한 모든 위치에 길이 $'(접미사, 즉 일치 후의 모든 것 )를 삽입하여 시작 합니다. 숫자를 N아래 에서 로 삽입합니다 0.

2 단계 : 스플릿

S`>

입력 >을 별도의 줄로 나누 므로 각 줄은 개별 번호 또는로 연결된 숫자 목록입니다 <.

3 단계 : 정렬

%O#`\d+

각 줄 ( %) 내 O에서 숫자 ( \d#)를 숫자 값 ( #)으로 정렬 ( )합니다 . 숫자를 역순으로 삽입했기 때문에 숫자가 역순입니다.

4 단계 : 교체

¶
>

>모든 줄을 한 줄로 다시 연결하기 위해 줄 바꿈을 다시 설정합니다. 그게 다야.

참고로, %줄 바꿈 이외의 다른 구분 기호 에 적용 할 수있는 방법을 추가하려고했습니다 . 내가 이미 그렇게 한 경우이 제출은 14 바이트 였을 것입니다 . 왜냐하면 마지막 3 단계가 단일 단계로 축소 되었기 때문입니다.

%'>O#`\d+

> <> , 46 43 35 + 4  -s== 39 바이트

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

이것은 > <> 의 xnor 알고리즘 을 구현 한 것입니다 .

스택에 입력 문자열을 사용합니다 ( -s표준 인터프리터가있는 플래그).

온라인 통역사 에서 시험해 볼 수 있습니다 .

> <> , 26 + 4 = 30 바이트

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

온라인으로 사용해보십시오! -s=플래그에 +4 바이트 -그냥 -s괜찮 으면 (빈 입력을 위해 플래그를 완전히 삭제해야 함을 의미) 대신 +3이됩니다.

STDIN 입력이 비어있어 i-1 (EOF에서 수행) 을 생성 한다고 가정합니다 . 이 -1을 문자로 인쇄하려고하면 프로그램 오류가 발생합니다.

max-of-nums-so-far-for- >, min-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)

깨끗하게 종료되고 STDIN에 대해 가정하지 않는 프로그램은 4 개의 추가 바이트입니다.

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

CJam , 16 바이트

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

온라인으로 사용해보십시오!

나의 Retina 답변 의 포트 .

설명

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

펄, 29 바이트

에 +2 포함 -lp

STDIN에서 입력으로 실행

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

산출:

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

order.pl:

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

설명

최대 길이는 문자열 길이로 시작하고 최소값은 0으로 시작하는 두 개의 카운터를가집니다. 그런 다음 <최소값 바로 앞에 있고 1 씩 증가하는 경우 각 경계 (문자열의 시작 및 끝 포함) 에서 1을 증가 시키거나 그렇지 않으면 최대 값을 줄이고 감소시킵니다 1만큼 (문자열의 끝에서 두 카운터가 모두 같기 때문에 어떤 카운터를 사용하든 상관 없습니다)

파이썬 2, 67 바이트

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

재귀 함수 에 대해 사용되지 않은 가장 작은 값 과 가장 큰 값 x을 넣어 각 연산자를 차례로 만족 시킵니다. 사용되지 않은 가장 작은 값이 저장 및 업데이트되고 사용되지 않은 가장 큰 값이 나머지 길이 에서 추론됩니다 .x<x>ii

파이썬 2, 163137 바이트

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)

문이로 바뀔 때까지 숫자를 섞습니다 True.

시도 해봐.

APL, 33 바이트

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

⍋⍋ 매우 유용합니다.

설명

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

자바 스크립트 (ES6), 74 56 바이트

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

숫자 집합으로 시작합니다 0...N. 각 단계 에서 나머지 숫자 l중 가장 큰 j숫자 ( ) 또는 가장 적은 숫자 ( )를 취합니다 . 다음 숫자는 정의상 그 숫자보다 작거나 커야합니다. 편집 : @Arnauld 덕분에 대량의 18 바이트가 절약되었습니다.

Pyth-19 바이트

비교 체인을위한 Hooray!

!QZhv#ms.idQ.p`Mhl

평가판 안전에 대한 온라인 퀴즈는 작동하지 않습니다.

2sable , 20 바이트

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

설명

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

온라인으로 사용해보십시오!

들어 N <10 이 14 바이트 수 있었다 :

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

C #, 102 99 바이트

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

언 골프 드 :

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

자바 8, 126125 바이트

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

나는 이것이 hehe를 작동한다고 생각하지 않는다

언 골프 테스트 프로그램

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

젤리 , 27 14 12 바이트

@Dennis
덕분에 @Martin Enders CJam 솔루션 -2 바이트 포트

żJ0;µFṣ”<Uj”<

TryItOnline 에서 테스트

어떻게?

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

이전의 방법은 수학적으로 흥미로 웠지만 그렇게 골프는 아니었다 ...

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

이것은 계승 기본 시스템을 사용하여 방정식을 만족시킬 [0, N]의 순열 인덱스를 찾습니다.

Clojure에서, 152 (132) 126 바이트

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

가능한 한 많은 공백을 제거하여 상당한 수의 바이트를 절약했습니다. 괄호를 다른 문자와 구분하기 위해 공백이 필요하지 않다는 것을 깨달았습니다.

기본적으로 @Scepheo의 답변 Clojure 포트. 동일하게 작동합니다.

그 recur전화는 살인자입니다! 원자를 사용하여 정리할 수 있다고 생각합니다. swap!사용 원자에 필요한 통화 카운트에 추가 : /

몇 바이트를 절약 해 주신 @amalloy에게 감사드립니다.

언 골프 드 :

(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

하스켈, 162 바이트

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

이건 너무 길어

펄 (-p의 경우 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 ♦의 답변 에서 도난당한 알고리즘

루비, 135 바이트

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

참고 : 시간 복잡도가 큽니다 (O (n!)).

파이썬 2, 176 172 바이트

다른 것에 비해 매우 짧지는 않지만 너무 빨리 해결하게되어 기쁩니다.

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

온라인으로 사용해보십시오

언 골프 드 :

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

온라인으로 사용해보십시오

PHP, 190 바이트

유효한 솔루션이 존재할 때까지 무작위 셔플

$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 바이트는 모든 솔루션을 얻고 하나를 선택

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