Tantangan

Diberikan string input (atau array) yang terdiri dari <dan >, output urutan (array atau string) bilangan bulat sehingga:

• semua operator benar ketika diterapkan secara berurutan antara angka berurutan dalam output
• semua bilangan bulat positif (1 atau lebih besar)
• jumlah bilangan bulat adalah sekecil mungkin secara matematis

Input dapat bervariasi untuk mencocokkan "lebih besar dari" dan "kurang dari" dalam bahasa yang Anda pilih.

Sebagai output alternatif, cukup tentukan jumlah angka dalam output. Nyatakan versi mana yang Anda selesaikan dalam judul Jawaban Anda.

Pengecualian dan aturan biasa berlaku, byte terkecil menang.

Anda dapat mengasumsikan bahwa string input tidak akan pernah mengarah ke overflow integer dalam bahasa Anda, jika itu membantu.

Contohnya

• >memberikan 2 1jumlah yang untuk3
• >>>memberikan 4 3 2 1jumlah yang untuk10
• ><memberikan 2 1 2jumlah yang untuk5
• memberikan 1jumlah yang untuk1
• >>>>>>>>>memberikan 10 9 8 7 6 5 4 3 2 1jumlah yang untuk55
• >><<>><>>>memberikan 3 2 1 2 3 2 1 4 3 2 1jumlah yang untuk24
• ><>><>><>memberikan 2 1 3 2 1 3 2 1 2 1jumlah yang untuk18
• <<<<>memberikan 1 2 3 4 5 1jumlah yang untuk16
• <<<<><<>memberikan 1 2 3 4 5 1 2 3 1jumlah yang untuk22
• >><<memberikan 3 2 1 2 3jumlah yang untuk11

Jelly , 19 byte

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

Cobalah online!

Nilai setiap angka adalah maks ( jumlah >segera di sebelah kanannya , jumlah <segera di sebelah kiri ) + 1 .

Kalau tidak...

Cobalah online!

> <> , 40 38 byte

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

Cobalah online!

Bahasa yang tepat. Untuk referensi ><>sendiri menghasilkan 2,1,2,1.

Bagaimana itu bekerja:

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 byte

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

Cobalah online!

Tidak terurai:

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

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

Cobalah online!

Penjelasan

Idenya di sini adalah bahwa kita memiliki run dari >s atau <s, yang masing-masing peta ke rentang naik dan turun. Jadi kami gunakan groupuntuk membagi string menjadi grup karakter yang berurutan. Tugas kita adalah untuk kemudian menyatukan ini dengan cara yang tepat.

Ketika kita memiliki <>kita ingin menjahit dua daftar bersama-sama mengambil nilai akhir yang lebih besar misalnya

<<<<<<>>

terpecah

<<<<<<  >>

dipetakan ke rentang

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

Kemudian ketika kita menjahit kita jatuhkan 3karena itu lebih kecil ( 3tidak lebih besar dari 7).

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

Ketika kita memiliki ><kita melakukan yang sebaliknya, kita menjatuhkan nilai yang lebih besar.

Kode aktual mencapai ini dengan membuat operator %. Definisi %ini cukup rumit, tetapi pada dasarnya terbaca dari kiri ke kanan melacak berapa banyak karakter berturut-turut yang sama. Apakah ini di sebelah kiri memiliki nilai operator. Ketika kami mencapai tempat di mana karakter berubah kami melakukan jahitan seperti yang saya jelaskan.

Retina 0.8.2 , 36 byte

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

Cobalah online! Tautan termasuk kasus uji. Penjelasan:

1

Masukkan 1s sebelum, di antara dan setelah <s dan >s.

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

Bilangan bulat berulang kali sampai semua perbandingan terpenuhi.

1

Jumlah bilangan bulat dan konversikan ke desimal.

Java 10, 198 181 byte

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

Cobalah online.

Penjelasan:

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 byte

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

Cobalah online!

Port jawaban Jelly saya.

Stax , 21 byte

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

Jalankan dan debug itu

Ini bekerja dengan run-length encoding input, dan kemudian menyatukan rentang yang dihasilkan secara bersamaan. Dibongkar, tidak diserang, dan dikomentari, sepertinya ini.

|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

Jalankan yang ini

Perl 5 -p , 53 byte

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

Cobalah online!

Merah , 185 byte

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

Setelah penjelasan user202729 ...

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