Фон

Ада - мова програмування, яка точно не відома своєю строгістю.

Однак його буквальний синтаксис масиву теоретично може передбачати досить стислі специфікації масиву. Ось простий EBNF опис буквеного синтаксису масиву (прохідний до bottlecaps.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'

Ми обмежимося одновимірними масивами цілих чисел для простоти. Це означає, що ми будемо використовувати лише цілі числа для значень виразу. Можливо, у майбутньому виклику ми могли б спробувати щось більш вдосконалене (наприклад, оголошення змінних та багатовимірних масивів). Вам не доведеться грати цілі літерали .

Ось кілька прикладів лінійних масивів Ada та еквівалентного подання python-esque для наочності:

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

Виклик

Мета цього завдання - вивести найкоротший літеральний масив Ada-лічильника байтів для заданого вхідного масиву. Зауважте, що масиви Ada можуть починатися з будь-якого індексу, який бажано, тож ви можете вибрати те, що бажаєте, щоб стартовий індекс був таким довгим, поки кожне значення є послідовним. У цьому прикладі я вибираю почати з 1, що є ідіоматичним для Ада, однак ви можете почати з будь-якого іншого цілого числа.

Вхідні дані

Ваша інформація буде складатися зі списку цілих чисел у будь-якій формі, яка зручна.

Вихідні дані

Ваш вихід буде рядком тексту, що представляє найкоротший дійсний лінійний масив Ada, який представляє список цілих чисел. Ви можете використовувати будь-який початковий індекс, який хочете в цьому масиві, але ваш вибір (яким би він не був) повинен бути вказаний у вашій відповіді (початковий індекс також може бути динамічним).

Цілі числа подаються у вигляді підписаних десяткових чисел, як у прикладах. Ця задача не охоплює гольфінг цілих значень.

Приклади

Ось кілька прикладів:

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)

Мінімальні вимоги

• Підтримуйте щонайменше 100 чисел та входи довжиною принаймні 256 чисел.

• Дайте правильний результат для всіх таких входів

  • Включає в себе "інші" в кінці
  • Включає розміщення індексу для масивів одного елемента

• Завершіть (бажано на TIO) для кожного з вищевказаних входів протягом менше хвилини.

Найкоротше рішення в байтах виграє!

Довідкова реалізація

Спробуйте в Інтернеті!

Ця реалізація використовує вхід як свій масив, причому кожен символ є числом. Великі літери - це спеціальні константи для великих значень. Аргумент програми - це «індекс запуску», який слід використовувати.

Розділ «код» у посиланні TIO - це правильне рішення проблеми, тоді як «заголовок» та «колонтитул» реалізують структуру тесту.

JavaScript (ES6),  307  304 байт

Збережено 2 байти завдяки @KevinCruijssen

Це бентежно довго ...

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

Спробуйте в Інтернеті!

05AB1E , 136 134 132 байт

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

EDIT: Виправлено для всіх тестових випадків зараз.

Спробуйте в Інтернеті або перевірте всі тестові випадки (крім «Великого введення», оскільки він занадто великий).

Пояснення:

"',ý'(ì')«ˆ"       # 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)

Дивіться цей 05AB1E наконечник шахти (розділ Як стиснути рядки не частина словника? ) , Щоб зрозуміти , чому …ˆ†=>це "others=>".