Змагання

Дано вхідний рядок (або масив), що складається з <і >виводить послідовність (масив або рядок) цілих чисел таким чином, що:

• всі оператори коректні, коли застосовуються в порядку між послідовними номерами у висновку
• всі цілі числа додатні (1 або більше)
• сума цілих чисел є якомога меншою математично можливою

Вхідні дані можуть відрізнятись відповідно до вибраної мовою "більше" та "менше".

Як альтернативний вихід, просто вкажіть суму чисел у висновку. В заголовку відповіді вкажіть, яку версію ви вирішуєте.

Звичайні виключення та правила застосовуються, виграє найменший байт.

Можна припустити, що рядок введення ніколи не призведе до переповнення цілої кількості вашої мови, якщо це допоможе.

Приклади

• >дає, 2 1які суми до3
• >>>дає, 4 3 2 1які суми до10
• ><дає, 2 1 2які суми до5
• дає, 1які суми до1
• >>>>>>>>>дає, 10 9 8 7 6 5 4 3 2 1які суми до55
• >><<>><>>>дає, 3 2 1 2 3 2 1 4 3 2 1які суми до24
• ><>><>><>дає, 2 1 3 2 1 3 2 1 2 1які суми до18
• <<<<>дає, 1 2 3 4 5 1які суми до16
• <<<<><<> дає 1 2 3 4 5 1 2 3 1які суми до22
• >><<дає, 3 2 1 2 3які суми до11

Желе , 19 байт

0;+×¥@\
=”<µCṚÇṚ»Ç‘

Спробуйте в Інтернеті!

Значення кожного числа - max ( число, >яке знаходиться праворуч від нього , число <безпосередньо зліва від нього ) + 1 .

Як варіант ...

Спробуйте в Інтернеті!

> <> , 40 38 байт

1v!rnr~<oa
?\i:0(?^3%\+$
{/?:-{:}-1/1:

Спробуйте в Інтернеті!

Відповідна мова. Для довідки ><>сама вихід 2,1,2,1.

Як це працює:

1v   Initialise the stack as 1 and enter loop
 \i:0(?^  If we're out of input, go to the first line
        3%\ Otherwise mod the input by 3, yielding 0 for < and 2 for >
        -1/Subtract 1 to get -1 and 1 respectively
    -{:}   Copy the previous number and subtract the above from it

 /?:    If the number is not 0, repeat the loop

?\        \+$  Otherwise:
                Increment each number until we reach the original 0
{/        /1:   And enter the first loop again

      ~<    When we're out of input, pop the extra -1 from EOF
   rnr      Output the first number
1v!         Push a 1 
        oa  Print a newline and repeat, popping the extra 1 each time

Python 3, 93 байти

k=0
for r in input().split('<'):p=len(r);print(max(k,p)+1,*range(p,0,-1),end=' ');k=1+(p<1)*k

Спробуйте в Інтернеті!

Нешифровано:

# offset, will be explained later
k = 0 
for run in input().split('<'):
    # p = length of sequence of '>'s, which will produce p+1 decreasing integers
    p = len(run)
    # will print:
    # p+1 p p-1 ... 1    or    k+1 p p-1 ... 1
    print(max(k, p) + 1, *range(p, 0, -1), end=' ')
    # offset of the next sequence: (i.e. -1 + the minimal value of the first integer)
    k = 1 + (k if p > 0 else 0)

Хаскелл , 119 байт

n%">"=r[1..n]
n%"<"=[1..n]
n%(c:b)|c==b!!0=(n+1)%b|a:s<-2%b,e:z<-r$n%[c]=r z++last(max:[min|c>'<'])a e:s
r=reverse
(2%)

Спробуйте в Інтернеті!

Пояснення

Ідея тут полягає в тому, що у нас є прогони або >s, або <s, які кожна карта відображає діапазони висхідних і низхідних. Таким чином ми використовуємоgroup для розділення рядка на групи послідовних символів. Наша робота полягає в тому, щоб потім зшити їх разом належним чином.

Коли ми маємо, <>ми хочемо зшити два списки разом, взявши, наприклад, велике кінцеве значення

<<<<<<>>

роздвоєний

<<<<<<  >>

нанесено на діапазони

[1,2,3,4,5,6,7] [3,2,1]

Потім, коли ми зшиваємо, ми скидаємо, 3тому що вона менша ( 3не більша, ніж 7).

 [1,2,3,4,5,6,7,2,1]

Коли ми маємо >< робимо навпаки, ми падаємо більше значення.

Фактичний код досягає цього, роблячи оператора %. Визначення %є досить складним, але в основному воно читається зліва направо, відстежуючи, скільки послідовних символів однакові. Це робить зліва значення оператора. Коли ми доходимо до місця, де змінюються персонажі, ми виконуємо зшивання, як я описав.

Сітківка 0,8,2 , 36 байт

1
{`\b(1+)>\1
1$&
}`(1+)<\1\b
$&1
1

Спробуйте в Інтернеті! Посилання включає тестові випадки. Пояснення:

1

Вставте 1s перед, між і після <s і >s.

{`\b(1+)>\1
1$&
}`(1+)<\1\b
$&1

Неодноразово збільшуються цілі числа, поки всі порівняння не будуть задоволені.

1

Підсумуйте цілі числа та перетворіть у десяткові.

Java 10, 198 181 байт

s->{var p=s.split("(?<=(.))(?!\\1)");int l=p.length,L[]=new int[l],i=l,r=0,a,b;for(;i-->0;r+=a*-~a/2-(i<l-1?p[i].charAt(0)<61?a<(b=L[i+1])?a:b:1:0))a=L[i]=p[i].length()+1;return r;}

Спробуйте в Інтернеті.

Пояснення:

s->{                      // Method with String parameter and integer return-type
  var p=s.split("(?<=(.))(?!\\1)");
                          //  Split the String into parts
                          //  (i.e. ">><<>><>>>" becomes [>>, <<, >>, <, >>>])
  int l=p.length,         //  Get the amount of parts
      L[]=new int[l],     //  Create an integer-array of the same size
      i=l,                //  Index-integer, starting at this size
      r=0,                //  Result-integer, starting at 0
      a,b;                //  Two temp integers to reduce the byte-count
  for(;i-->0;             //  Loop downwards over the array; range: (`l`,0]
      ;r+=                //    After every iteration: increase the result with:
          a*-~a/2         //     The triangle number of the current item
        -(i<l-1?          //     If it's not the last item:
           p[i].charAt(0)<61?
                          //      And the order of the current and previous is "<>":
            a<(b=L[i+1])? //       If the current item in `L` is smaller than the previous:
             a            //        Subtract the current item
            :             //       Else (the current is equal or larger than the previous):
             b            //        Subtract the previous item
           :              //      Else (the order of the two parts is "><" instead):
            1             //       Subtract 1
          :               //     Else (it's the last item in `L`):
           0))            //      Leave the result `r` unchanged
    a=L[i]=               //   Set both `a` and the current item in `L` to:
     p[i].length()+1;     //    The length of the part + 1
  return r;}              //  Return the result

Haskell , 87 байт

r=reverse
s#c=(+1).length.takeWhile(==c)<$>scanr(:)[]s
f s=zipWith max(s#'>')$r$r s#'<'

Спробуйте в Інтернеті!

Порт моєї відповіді на желе.

Стакс , 21 байт

éda╓~/└↨☺∟╒←║ç Γφ5←9h

Запустіть і налагоджуйте його

Він працює за допомогою кодування вхідної довжини, а потім об'єднання генерованих діапазонів разом. Розпакований, неозорений та коментований, це виглядає приблизно так.

|R      run-length encode
{       begin block
  H^R   range from [1 .. run length]
  _hh|1 -1 ** (character code / 2)
  *     multiply run; this will reverse it iff character is '>'
m       map runs using preceding block
O       push a 1 under the top of stack
{       begin block
  h|M   get the start of the generated range, and take max of it and top of stack
  _DE   push the rest (tail) of the generated range to the stack
F       foreach generated range
L|+     sum of all values on the stack

Виконати цей

Perl 5 -p , 53 байти

#!/usr/bin/perl -p
s//1/g;1while s/(?=\b(1+)>\1)|(1+)<\2\b\K/1/;$_=y/1//

Спробуйте в Інтернеті!

Червоний , 185 байт

func[s][repeat n 1 + length? s[l: 0 i: n - 1 while[i > 0 and(s/(i) = #"<")][i:  i - 1 l: l + 1]r: 0 i: n while[(i <= length? s)and(s/(i) = #">")][i: i + 1 r:
r + 1]prin[1 + max l r""]]]

Після пояснення користувача202729 ...

Спробуйте в Інтернеті!

f: func[s][
   repeat n 1 + length? s[
       l: 0
       i: n - 1
       while [i > 0 and (s/(i) = #"<")][ 
           i: i - 1
           l: l + 1
        ]
        r: 0
        i: n
        while [(i <= length? s) and (s/(i) = #">")][
            i: i + 1
            r: r + 1
        ]
        prin[1 + max l r ""]
    ]
]