Meydan okuma

Aşağıdakilerden oluşan <ve >bir tamsayı dizisi (dizi veya dize) içeren bir girdi dizesi (veya dizisi) verildiğinde:

• çıktıdaki ardışık sayılar arasında sırayla uygulandığında operatörlerin tümü doğrudur
• tüm tamsayılar pozitif (1 veya daha büyük)
• tamsayıların toplamı matematiksel olarak mümkün olduğu kadar küçük

Girişler seçtiğiniz dilde "büyüktür" ve "küçüktür" ile eşleşebilir.

Alternatif bir çıktı olarak, çıktıdaki sayıların toplamını belirtmeniz yeterlidir. Cevap başlığınızda hangi sürümü çözdüğünüzü belirtin.

Olağan dışlamalar ve kurallar geçerlidir, en küçük bayt kazanır.

Giriş dizesinin dilinizde asla tamsayı taşmasına neden olmayacağını varsayabilirsiniz.

Örnekler

• >verir 2 1hangi miktarda3
• >>>verir 4 3 2 1hangi miktarda10
• ><verir 2 1 2hangi miktarda5
• verir 1hangi miktarda1
• >>>>>>>>>verir 10 9 8 7 6 5 4 3 2 1hangi miktarda55
• >><<>><>>> verir 3 2 1 2 3 2 1 4 3 2 1hangi miktarda24
• ><>><>><> verir 2 1 3 2 1 3 2 1 2 1hangi miktarda18
• <<<<> verir 1 2 3 4 5 1hangi miktarda16
• <<<<><<> verir 1 2 3 4 5 1 2 3 1hangi miktarda22
• >><<verir 3 2 1 2 3hangi miktarda11

Jöle , 19 bayt

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

Çevrimiçi deneyin!

Her sayı değeri maksimum ( sayısını >bunun hemen sağındaki , sayısı <bunun hemen solundaki ) + 1 .

Alternatif ...

Çevrimiçi deneyin!

> <> , 40 38 bayt

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

Çevrimiçi deneyin!

Uygun bir dil. Referansın ><>kendisi 2,1,2,1 verir.

Nasıl çalışır:

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 bayt

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

Çevrimiçi deneyin!

şifresiz:

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

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

Çevrimiçi deneyin!

açıklama

Buradaki fikir , her biri artan ve azalan aralıklarla eşleştirilen >s veya <s koşularına sahip olduğumuzdur . Bu nedenle groupdizeyi ardışık karakter gruplarına ayırmak için kullanırız . Bizim işimiz bunları uygun şekilde birleştirmektir.

Elimizdeyken <>, iki listeyi birleştirmek istiyoruz, örneğin daha büyük son değeri alarak

<<<<<<>>

Bölünmüş

<<<<<<  >>

aralıklarla eşlendi

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

Sonra diktiğimizde düşeriz 3çünkü daha küçüktür ( 3daha büyük değildir 7).

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

Elimizde >< tersini yaptığımızda, daha büyük değeri düşürürüz.

Gerçek kod bunu bir operatör yaparak elde eder %. 'Nin tanımı %oldukça karmaşıktır, ancak temel olarak soldan sağa, birbirini izleyen kaç karakterin aynı olduğunu takip eder. Bunu solda operatörün değeri vardı. Karakterlerin değiştiği bir yere vardığımızda dikişi açıkladığım gibi yapıyoruz.

Retina 0.8.2 , 36 bayt

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

Çevrimiçi deneyin! Bağlantı, test senaryolarını içerir. Açıklama:

1

Takın 1ler öncesinde, arasında ve sonrasında <s ve >s.

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

Tüm karşılaştırmalar sağlanana kadar tam sayıları art arda artırın.

1

Tam sayıları toplayın ve ondalık sayıya dönüştürün.

Java 10, 198181 bayt

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

Çevrimiçi deneyin.

Açıklama:

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 bayt

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

Çevrimiçi deneyin!

Jelly cevabımın bir limanı.

Stax , 21 bayt

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

Çalıştır ve hata ayıkla

Girdiyi kodlayan ve daha sonra oluşturulan aralıkları birleştirerek çalışır. Ambalajından çıkarılmış, golf edilmemiş ve yorum yapılmış gibi görünüyor.

|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

Bunu çalıştır

Perl 5 -p , 53 bayt

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

Çevrimiçi deneyin!

Kırmızı , 185 bayt

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

User202729'un açıklamasından sonra ...

Çevrimiçi deneyin!

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