El reto

Dada una cadena de entrada (o matriz) que consta de <y >, genera una secuencia (matriz o cadena) de enteros de manera que:

• todos los operadores son correctos cuando se aplican en orden entre números consecutivos en la salida
• todos los enteros son positivos (1 o mayor)
• la suma de los enteros es tan pequeña como es matemáticamente posible

Las entradas pueden variar para coincidir con "mayor que" y "menor que" en el idioma elegido.

Como salida alternativa, solo especifique la suma de los números en la salida. Indique qué versión está resolviendo en su título de Respuesta.

Se aplican las exclusiones y reglas habituales, gana los bytes más pequeños.

Puede suponer que la cadena de entrada nunca conducirá a un desbordamiento de enteros en su idioma, si eso ayuda.

Ejemplos

• >da 2 1qué sumas a3
• >>>da 4 3 2 1qué sumas a10
• ><da 2 1 2qué sumas a5
• da 1qué sumas a1
• >>>>>>>>>da 10 9 8 7 6 5 4 3 2 1qué sumas a55
• >><<>><>>>da 3 2 1 2 3 2 1 4 3 2 1qué sumas a24
• ><>><>><>da 2 1 3 2 1 3 2 1 2 1qué sumas a18
• <<<<>da 1 2 3 4 5 1qué sumas a16
• <<<<><<>da 1 2 3 4 5 1 2 3 1qué sumas a22
• >><<da 3 2 1 2 3qué sumas a11

Jalea , 19 bytes

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

Pruébalo en línea!

El valor de cada número es max ( número de> inmediatamente a su derecha , número de <inmediatamente a su izquierda ) + 1 .

Alternativamente...

Pruébalo en línea!

> <> , 40 38 bytes

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

Pruébalo en línea!

Un lenguaje apropiado. Para referencia><> sí mismo rinde 2,1,2,1.

Cómo funciona:

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 bytes

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

Pruébalo en línea!

Descifrado:

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

Haskell , 119 bytes

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

Pruébalo en línea!

Explicación

La idea aquí es que tenemos carreras de cualquiera de >s o <s, que cada mapa para ascender y descender rangos. Entonces usamosgroup para dividir la cadena en grupos de caracteres consecutivos. Nuestro trabajo es unirlos de la manera adecuada.

Cuando tengamos <>, queremos unir las dos listas, tomando el valor final más grande, por ejemplo

<<<<<<>>

se divide

<<<<<<  >>

mapeado a rangos

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

Luego, cuando cosimos, lo dejamos caer 3porque es más pequeño ( 3no es más grande que 7).

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

Cuando tenemos ><que hacemos lo contrario, soltamos el valor más grande.

El código real logra esto haciendo un operador %. La definición de %es bastante compleja, pero básicamente se lee de izquierda a derecha haciendo un seguimiento de cuántos caracteres consecutivos son iguales. Hace esto a la izquierda tenía valor del operador. Cuando llegamos a un lugar donde los personajes cambian, realizamos la costura como describí.

Retina 0.8.2 , 36 bytes

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

Pruébalo en línea! El enlace incluye casos de prueba. Explicación:

1

Inserte 1s antes, entre y después de <s y >s.

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

Incremente repetidamente los enteros hasta que se satisfagan todas las comparaciones.

1

Suma los enteros y convierte a decimal.

Java 10, 198181 bytes

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

Pruébalo en línea.

Explicación:

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 bytes

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

Pruébalo en línea!

Un puerto de mi respuesta Jelly.

Stax , 21 bytes

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

Ejecutar y depurarlo

Funciona mediante la codificación de la longitud de ejecución y luego concatenando los rangos generados juntos. Desempaquetado, sin golf y comentado, se ve así.

|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

Ejecute este

Perl 5 -p , 53 bytes

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

Pruébalo en línea!

Rojo , 185 bytes

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

Después de la explicación del usuario 202729 ...

Pruébalo en línea!

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