Các thách thức

Cho một chuỗi đầu vào (hoặc mảng) bao gồm <và >, xuất ra một chuỗi (mảng hoặc chuỗi) các số nguyên sao cho:

• Các toán tử đều đúng khi được áp dụng theo thứ tự giữa các số liên tiếp trong đầu ra
• tất cả các số nguyên đều dương (1 hoặc lớn hơn)
• tổng các số nguyên càng nhỏ càng tốt về mặt toán học

Các đầu vào có thể thay đổi để khớp với "lớn hơn" và "nhỏ hơn" trong ngôn ngữ bạn đã chọn.

Là một đầu ra thay thế, chỉ cần xác định tổng của các số trong đầu ra. Cho biết phiên bản nào bạn đang giải quyết trong tiêu đề Trả lời của bạn.

Loại trừ thông thường và quy tắc áp dụng, byte nhỏ nhất sẽ thắng.

Bạn có thể giả định rằng chuỗi đầu vào sẽ không bao giờ dẫn đến tràn số nguyên trong ngôn ngữ của bạn, nếu điều đó có ích.

Ví dụ

• >đưa ra 2 1khoản tiền nào cho3
• >>>đưa ra 4 3 2 1khoản tiền nào cho10
• ><đưa ra 2 1 2khoản tiền nào cho5
• đưa ra 1khoản tiền nào cho1
• >>>>>>>>>đưa ra 10 9 8 7 6 5 4 3 2 1khoản tiền nào cho55
• >><<>><>>>đưa ra 3 2 1 2 3 2 1 4 3 2 1khoản tiền nào cho24
• ><>><>><>đưa ra 2 1 3 2 1 3 2 1 2 1khoản tiền nào cho18
• <<<<>đưa ra 1 2 3 4 5 1khoản tiền nào cho16
• <<<<><<>đưa ra 1 2 3 4 5 1 2 3 1khoản tiền nào cho22
• >><<đưa ra 3 2 1 2 3khoản tiền nào cho11

Thạch , 19 byte

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

Hãy thử trực tuyến!

Giá trị của mỗi số là tối đa ( số >ngay bên phải của số đó , số <ngay bên trái của số đó ) + 1 .

Hoặc ...

Hãy thử trực tuyến!

> <> , 40 38 byte

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

Hãy thử trực tuyến!

Một ngôn ngữ thích hợp. Để tham khảo ><>chính nó mang lại 2,1,2,1.

Làm thế nào nó hoạt động:

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

Hãy thử trực tuyến!

Xắp xếp lại:

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

Hãy thử trực tuyến!

Giải trình

Ý tưởng ở đây là chúng ta có các >s hoặc <s, mỗi bản đồ cho các phạm vi tăng dần và giảm dần. Vì vậy, chúng tôi sử dụnggroup để chia chuỗi thành các nhóm ký tự liên tiếp. Công việc của chúng tôi là sau đó khâu chúng lại với nhau theo cách phù hợp.

Khi chúng <>tôi muốn ghép hai danh sách lại với nhau, lấy giá trị cuối lớn hơn làm ví dụ

<<<<<<>>

Bị chia

<<<<<<  >>

ánh xạ tới các phạm vi

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

Sau đó, khi chúng tôi khâu chúng tôi thả 3vì nó nhỏ hơn ( 3không lớn hơn 7).

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

Khi chúng ta có ><điều ngược lại, chúng ta bỏ giá trị lớn hơn.

Mã thực tế đạt được điều này bằng cách làm cho một toán tử %. Định nghĩa của %nó khá phức tạp, nhưng về cơ bản, nó đọc từ trái sang phải theo dõi xem có bao nhiêu ký tự liên tiếp giống nhau. Nó thực hiện điều này ở bên trái có giá trị của toán tử. Khi chúng ta đến một nơi mà các ký tự thay đổi, chúng ta thực hiện khâu như tôi đã mô tả.

Võng mạc 0.8.2 , 36 byte

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

Hãy thử trực tuyến! Liên kết bao gồm các trường hợp thử nghiệm. Giải trình:

1

Chèn 1s trước, giữa và sau <s và >s.

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

Số nguyên tăng liên tục cho đến khi tất cả các so sánh được thỏa mãn.

1

Tính tổng các số nguyên và chuyển đổi thành số thập phân.

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

Hãy thử trực tuyến.

Giải trình:

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

Hãy thử trực tuyến!

Một cổng của câu trả lời Jelly của tôi.

Stax , 21 byte

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

Chạy và gỡ lỗi nó

Nó hoạt động bằng cách mã hóa chiều dài đầu vào, và sau đó ghép các phạm vi được tạo với nhau. Giải nén, không được chỉnh sửa và nhận xét, nó trông như thế này.

|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

Chạy cái này

Perl 5 -p , 53 byte

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

Hãy thử trực tuyến!

Màu đỏ , 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""]]]

Sau lời giải thích của người dùng202729 ...

Hãy thử trực tuyến!

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