Le défi

Étant donné une chaîne d'entrée (ou tableau) composée de <et >, sortie une séquence (tableau ou chaîne) d'entiers tels que:

• les opérateurs sont tous corrects lorsqu'ils sont appliqués dans l'ordre entre les nombres consécutifs dans la sortie
• tous les entiers sont positifs (1 ou plus)
• la somme des nombres entiers est aussi petite que possible mathématiquement

Les entrées peuvent varier pour correspondre à "supérieur à" et "inférieur à" dans la langue choisie.

Comme sortie alternative, spécifiez simplement la somme des nombres dans la sortie. Indiquez la version que vous résolvez dans le titre de votre réponse.

Les exclusions et règles habituelles s'appliquent, le plus petit octet gagne.

Vous pouvez supposer que la chaîne d'entrée ne conduira jamais à un débordement d'entier dans votre langue, si cela vous aide.

Exemples

• >donne 2 1quelles sommes3
• >>>donne 4 3 2 1quelles sommes10
• ><donne 2 1 2quelles sommes5
• donne 1quelles sommes1
• >>>>>>>>>donne 10 9 8 7 6 5 4 3 2 1quelles sommes55
• >><<>><>>>donne 3 2 1 2 3 2 1 4 3 2 1quelles sommes24
• ><>><>><>donne 2 1 3 2 1 3 2 1 2 1quelles sommes18
• <<<<>donne 1 2 3 4 5 1quelles sommes16
• <<<<><<>donne 1 2 3 4 5 1 2 3 1quelles sommes22
• >><<donne 3 2 1 2 3quelles sommes11

Gelée , 19 octets

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

Essayez-le en ligne!

La valeur de chaque nombre est max ( nombre de >immédiatement à sa droite , nombre de <immédiatement à sa gauche ) + 1 .

Alternativement ...

Essayez-le en ligne!

> <> , 40 38 octets

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

Essayez-le en ligne!

Une langue appropriée. Pour référence ><>elle-même donne 2,1,2,1.

Comment ça fonctionne:

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 octets

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

Essayez-le en ligne!

Débrouillé:

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

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

Essayez-le en ligne!

Explication

L'idée ici est que nous avons des séries de >s ou de <s, qui correspondent chacune à des plages ascendantes et descendantes. Nous utilisons donc grouppour diviser la chaîne en groupes de caractères consécutifs. Notre travail consiste ensuite à les assembler de la bonne manière.

Lorsque nous avons, <>nous voulons assembler les deux listes en prenant la plus grande valeur finale par exemple

<<<<<<>>

est divisé

<<<<<<  >>

mappé à des plages

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

Ensuite, lorsque nous cousons, nous tombons 3parce qu'il est plus petit ( 3pas plus grand que 7).

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

Lorsque nous avons, ><nous faisons le contraire, nous laissons tomber la plus grande valeur.

Le code réel y parvient en créant un opérateur %. La définition de %est assez complexe, mais fondamentalement, elle se lit de gauche à droite en gardant une trace du nombre de caractères consécutifs identiques. Il fait cela dans la gauche avait la valeur de l'opérateur. Lorsque nous atteignons un endroit où les personnages changent, nous effectuons la couture comme je l'ai décrit.

Rétine 0.8.2 , 36 octets

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

Essayez-le en ligne!Le lien inclut des cas de test. Explication:

1

Insérez 1s avant, entre et après le< s et >s.

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

Incrémentez de manière répétée les entiers jusqu'à ce que toutes les comparaisons soient satisfaites.

1

Additionnez les entiers et convertissez-les en décimal.

Java 10, 198 181 octets

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

Essayez-le en ligne.

Explication:

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 octets

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

Essayez-le en ligne!

Un port de ma réponse Jelly.

Stax , 21 octets

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

Exécuter et déboguer

Il fonctionne en codant la longueur de l'entrée, puis en concaténant les plages générées ensemble. Déballé, non golfé et commenté, il ressemble à ceci.

|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

Exécutez celui-ci

Perl 5 -p , 53 octets

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

Essayez-le en ligne!

Rouge , 185 octets

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

Après l'explication de user202729 ...

Essayez-le en ligne!

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