Lý lịch

Ada là một ngôn ngữ lập trình không được biết đến chính xác vì sự căng thẳng của nó.

Tuy nhiên, về mặt lý thuyết, cú pháp mảng của nó có thể cho phép các đặc tả mảng khá ngắn gọn. Dưới đây là một mô tả EBNF đơn giản về cú pháp theo nghĩa đen của mảng (có thể chuyển sang dạng chailecaps.de :

array ::= positional_array | named_array
positional_array ::= expression ',' expression (',' expression)*
                   | expression (',' expression)* ',' 'others' '=>' expression
named_array ::= component_association (',' component_association)*
component_association ::= discrete_choice_list '=>' expression
discrete_choice_list ::= discrete_choice ('|' discrete_choice)*
discrete_choice ::= expression ('..' expression)? | 'others'

Chúng tôi sẽ giới hạn bản thân trong các mảng số nguyên 1 chiều cho đơn giản. Điều này có nghĩa là chúng ta sẽ chỉ sử dụng các số nguyên cho các giá trị biểu thức. Có lẽ trong một thử thách trong tương lai, chúng ta có thể thử một cái gì đó cao cấp hơn (như khai báo các biến và mảng đa chiều). Bạn không cần phải chơi golf các số nguyên .

Dưới đây là một số ví dụ về mảng chữ Ada và đại diện tương đương python-esque cho rõ ràng:

(1, 2, 3) = [1, 2, 3]
(1, others => 2) = [1, 2, 2, ..., 2]
(others => 1) = [1, 1, ..., 1]
(1 => 1, 2 => 3) = [1, 3]
(1|2 => 1, 3 => 2) = [1, 1, 2]
(1 => 1, 3 => 2, others => 3) = [1, 3, 2, 3, 3, ..., 3]

Thử thách

Mục tiêu của thử thách này là xuất ra mảng Ada đếm byte ngắn nhất cho một mảng đầu vào nhất định. Lưu ý rằng mảng Ada có thể bắt đầu từ bất kỳ chỉ mục nào mong muốn, vì vậy bạn có thể chọn những gì bạn muốn chỉ mục bắt đầu miễn là mỗi giá trị là tuần tự. Trong ví dụ này, tôi chọn bắt đầu từ 1, đó là thành ngữ cho Ada, tuy nhiên bạn có thể chọn bắt đầu ở bất kỳ số nguyên nào khác.

Đầu vào

Đầu vào của bạn sẽ bao gồm một danh sách các số nguyên, dưới mọi hình thức đều thuận tiện.

Đầu ra

Đầu ra của bạn sẽ là một chuỗi văn bản đại diện cho mảng chữ Ada hợp lệ ngắn nhất đại diện cho danh sách các số nguyên đầu vào. Bạn có thể sử dụng bất kỳ chỉ mục bắt đầu nào bạn muốn trên mảng này, nhưng lựa chọn của bạn (bất kể đó là gì) phải được chỉ định trong câu trả lời của bạn (chỉ mục bắt đầu cũng có thể là động).

Các số nguyên được biểu diễn dưới dạng số thập phân đã ký, như trong các ví dụ. Thách thức này không bao gồm việc chơi golf các giá trị nguyên.

Ví dụ

Dưới đây là một số ví dụ:

Simple: [1, 2, 3] -> (1,2,3)
Range: [1, 1, 1, 1, 1, 1, 1,] -> (1..7=>1)
Others: [1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1] -> (6=>2,others=>1)
Multiple Ranges: [1,1,1,1,1,2,2,2,2,2,1,1,1,1,1,2,2,2,2,2,1,1,1,1,1] -> (6..10|16..20=>2,others=>1)
Tiny Ranges: [1,1,2,2,1,1,1,1,1] -> (3|4=>2,others=>1)
Far Range: [[1]*5, [2]*100, [3]*5] -> (1..5=>1,6..105=>2,others=>3)
Alternation: [1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2] -> (1|3|5|7|9|11|13|15|17=>1,others=>2)
Big Number: [1234567890,1,1234567890] -> (2=>1,1|3=>1234567890)
Big-ish Number: [1234567,1,1234567] -> (1234567,1,1234567)
Solo: [-1] -> (1=>-1)
Huge Input: [[0],[1]*1000000000] -> (0,others=>1)
Positional Others: [1, 2, 3, 3, 3, 3, 3, 3] -> (1,2,others=>3)
Range and Choice, no Others: [1,1,1,12,12,3,3,3,3,3,3,3,3,3,3,4] -> (1..3=>1,4|5=>12,6..15=>3,16=>4)

Yêu cầu tối thiểu

• Hỗ trợ ít nhất 100 số và đầu vào có độ dài ít nhất 256 số.

• Tạo kết quả chính xác cho tất cả các đầu vào như vậy

  • Bao gồm đặt 'người khác' ở cuối
  • Bao gồm đặt một chỉ mục cho mảng vật phẩm đơn

• Chấm dứt (tốt nhất là trên TIO) cho mỗi đầu vào trên trong một phút.

Giải pháp ngắn nhất trong byte thắng!

Thực hiện tham khảo

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

Việc thực hiện này sử dụng đầu vào là mảng của nó, với mỗi ký tự là một số. Chữ in hoa là hằng số đặc biệt cho các giá trị lớn. Đối số chương trình là 'chỉ mục bắt đầu' để sử dụng.

Phần "mã" trong liên kết TIO là một giải pháp chính xác cho vấn đề, trong khi "tiêu đề" và "chân trang" thực hiện cấu trúc thử nghiệm.

JavaScript (ES6),  307  304 byte

Đã lưu 2 byte nhờ @KevinCruijssen

Điều này thật đáng xấu hổ ...

a=>[b=([...a,m=''].map(o=(v,i)=>(i?p==v?!++n:m=o[(o[p]=[o[p]&&o[p]+'|']+(n?i-n+(n>1?'..':'|')+i:i))[m.length]?(x=i-n,j=p):j]:1)&&(p=v,M=n=0)),Object.keys(o).map(k=>j-k|!m[6]?o[k]+'=>'+k:O,O='others=>'+j).sort()),1/a[1]?[...a]:b,j-a.pop()?b:a.slice(0,x-1)+[,O]].map(a=>M=M[(s=`(${a})`).length]||!M?s:M)&&M

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

05AB1E , 136 134 132 byte

"',ý'(ì')«ˆ"©.V"θ…ˆ†=>쪮.V"Uγ¨D€gPi˜IX.V}\ÙεQƶ0KDāαγ€g£}D2Fε¾iεнyg≠iyθyg<i'|ë„..}ý}}ë˜}'|ý„=>«Iyнн<è«}Ю.VgFDN._ć'>¡X.V}\¼}¯éIgi¦}н

EDIT: Đã sửa cho tất cả các trường hợp thử nghiệm ngay bây giờ.

Dùng thử trực tuyến hoặc xác minh tất cả các trường hợp thử nghiệm (ngoại trừ trường hợp 'Đầu vào khổng lồ', vì nó quá lớn).

Giải trình:

"',ý'(ì')«ˆ"       # Push this string (function 1), which does:
 ',ý              '#  Join a list by ","
    '(ì           '#  Prepend a "("
       ')«        '#  Append a ")"
          ˆ        #  Pop and add it to the global array
            ©      # Store this string in the register (without popping)
             .V    # And execute it as 05AB1E code on the (implicit) input-list
"θ…ˆ†=>쪮.V"      # Push this string (function 2), which does:
 θ                 #  Pop and push the last element of the list
  …ˆ†=>ì           #  Prepend dictionary string "others=>"
        ª          #  Append that to the list which is at the top of the stack
         ®.V       #  And execute function 1 from the register     
             U     # Pop and store this string in variable `X`
γ                  # Get the chunks of equal elements in the (implicit) input-list
 ¨                 # Remove the last chunk
  D                # Duplicate the list of remaining chunks
   €g              # Get the length of each
     Pi     }      # If all chunk-lengths are 1:
       ˜           #  Flatten the list of remaining chunks
        I          #  Push the input-list
         X.V       #  Execute function 2 from variable `X`
             \     # Discard the top of the stack (in case we didn't enter the if-statement)
Ù                  # Uniquify the (implicit) input-list
 ε                 # Map each unique value `y` to:
  Q                #  Check for each value in the (implicit) input-list if it's equal to `y`
                   #  (1 if truthy; 0 if falsey)
   ƶ               #  Multiply each by its 1-based index
    0K             #  Remove all 0s
      D            #  Duplicate it
       ā           #  Push a list [1, length] without popping the list itself
        α          #  Get the absolute difference at the same indices
         γ         #  Split it into chunks of the same values
          €g       #  Get the length of each
            £      #  And split the duplicated indices-list into those parts
                   # (this map basically groups 1-based indices per value.
                   #  i.e. input [1,1,2,1,1,2,2,1,1] becomes [[[1,2],[4,5],[8,9]],[[3],[6,7]]])
 }D                # After the map: duplicate the mapped 3D list
   2F              # Loop 2 times:
     ε             #  Map the 3D list of indices to:
      ¾i           #   If the counter_variable is 1:
        ε          #    Map each list `y` in the 2D inner list to:
         н         #     Leave the first value
         yg≠i      #     And if there is more than one index:
             yθ    #      Push the last value as well
             yg<i  #      If there are exactly two indices:
              '|  '#       Push string "|"
             ë     #      Else (there are more than two indices)
              „..  #       Push string ".."
             }ý    #      And join the first and last value by this string
        }}         #    Close the if-statement and map
      ë            #   Else:
       ˜           #    Flatten the 2D list
      }'|ý        '#   After the if-else: join by "|"
          „=>«     #   Append "=>"
       yнн         #   Get the very first index of this 2D list
          <        #   Decrease it by 1 to make it 0-based
      I    è       #   And index it into the input-list to get its value again
            «      #   Which is also appended after the "=>"
     }Ð            #  After the map: triplicate the result
       ®.V         #  Execute function 1 from the register
       g           #  Get the amount of items in the triplicated list
        F          #  Loop that many times:
         D         #   Duplicate the list
          N._      #   Rotate it the index amount of times
          ć        #   Extract the head; pop and push remainder and head
           '>¡    '#   Split this head by ">"
              X.V  #   And then function 2 is executed again from variable `X`
        }\         #  After the loop: discard the list that is still on the stack
          ¼        #  And increase the counter_variable by 1
   }¯              # After looping twice: push the global array
     é             # Sort it by length
      Igi }        # If the input only contained a single item:
         ¦         #  Remove the very first item
           н       # And then only leave the first item
                   # (which is output implicitly as result)

Xem 05AB1E mẹo này của tôi (phần Làm thế nào để chuỗi nén không nằm trong từ điển? ) Để hiểu tại sao …ˆ†=>là "others=>".