Die Herausforderung

Wenn eine Eingabezeichenfolge (oder ein Array) aus <und gegeben ist >, geben Sie eine Folge (ein Array oder eine Zeichenfolge) von Ganzzahlen aus, so dass:

• Die Operatoren sind alle korrekt, wenn sie in der Reihenfolge zwischen aufeinanderfolgenden Nummern in der Ausgabe angewendet werden
• alle ganzen Zahlen sind positiv (1 oder größer)
• Die Summe der ganzen Zahlen ist so klein wie mathematisch möglich

Eingaben können variieren, um "größer als" und "kleiner als" in der von Ihnen gewählten Sprache zu entsprechen.

Als alternative Ausgabe geben Sie einfach die Summe der Zahlen in der Ausgabe an. Geben Sie an, welche Version Sie in Ihrem Antworttitel lösen.

Es gelten die üblichen Ausschlüsse und Regeln, kleinste Bytes gewinnen.

Sie können davon ausgehen, dass die Eingabezeichenfolge in Ihrer Sprache niemals zu einem Ganzzahlüberlauf führt, wenn dies hilfreich ist.

Beispiele

• >gibt 2 1welche Summen an3
• >>>gibt 4 3 2 1welche Summen an10
• ><gibt 2 1 2welche Summen an5
• gibt 1welche Summen an1
• >>>>>>>>>gibt 10 9 8 7 6 5 4 3 2 1welche Summen an55
• >><<>><>>>gibt 3 2 1 2 3 2 1 4 3 2 1welche Summen an24
• ><>><>><>gibt 2 1 3 2 1 3 2 1 2 1welche Summen an18
• <<<<>gibt 1 2 3 4 5 1welche Summen an16
• <<<<><<>gibt 1 2 3 4 5 1 2 3 1welche Summen an22
• >><<gibt 3 2 1 2 3welche Summen an11

Jelly , 19 Bytes

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

Probieren Sie es online!

Der Wert jeder Zahl ist maximal ( Anzahl >unmittelbar rechts davon , Anzahl <unmittelbar links davon) ) + 1 .

Alternative...

Probieren Sie es online!

> <> , 40 38 Bytes

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

Probieren Sie es online!

Eine passende Sprache. Als Referenz ><>ergibt sich 2,1,2,1.

Wie es funktioniert:

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

Probieren Sie es online!

Entschlüsselt:

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

Probieren Sie es online!

Erläuterung

Die Idee dabei ist, dass wir entweder >s oder <s ausführen, die jeweils auf aufsteigende und absteigende Bereiche abgebildet werden. Also benutzen wirgroup teilen die Zeichenfolge in Gruppen von aufeinanderfolgenden Zeichen auf. Unsere Aufgabe ist es, diese dann in der richtigen Weise zusammenzufügen.

Wenn wir haben <>, wollen wir die beiden Listen zusammenfügen, indem wir zum Beispiel den größeren Endwert nehmen

<<<<<<>>

ist geteilt

<<<<<<  >>

auf Bereiche abgebildet

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

Wenn wir dann nähen, fallen wir, 3weil es kleiner ist ( 3nicht größer als 7).

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

Wenn wir ><das Gegenteil tun, lassen wir den größeren Wert fallen.

Der eigentliche Code erreicht dies, indem er einen Operator erstellt %. Die Definition von %ist recht komplex, liest aber im Grunde genommen von links nach rechts und verfolgt, wie viele aufeinanderfolgende Zeichen gleich sind. Es hat dazu im linken Bereich den Wert des Betreibers gehabt. Wenn wir eine Stelle erreichen, an der sich die Zeichen ändern, führen wir die von mir beschriebenen Stiche aus.

Retina 0,8,2 , 36 Bytes

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

Probieren Sie es online! Link enthält Testfälle. Erläuterung:

1

Fügen Sie 1s vor, zwischen und nach <s und >s ein.

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

Erhöhen Sie die Ganzzahlen wiederholt, bis alle Vergleiche erfüllt sind.

1

Summieren Sie die Ganzzahlen und konvertieren Sie sie in Dezimalzahlen.

Java 10, 198 181 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;}

Probieren Sie es online aus.

Erläuterung:

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

Probieren Sie es online!

Ein Port meiner Gelee-Antwort.

Stax , 21 Bytes

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

Führen Sie es aus und debuggen Sie es

Es funktioniert, indem die Eingabe mit einer Lauflänge codiert und die generierten Bereiche miteinander verkettet werden. Ausgepackt, ungolfed und kommentiert sieht es so aus.

|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

Führen Sie dieses aus

Perl 5 -p , 53 Bytes

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

Probieren Sie es online!

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

Nach der Erklärung von user202729 ...

Probieren Sie es online!

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