Hintergrund

Ada ist eine Programmiersprache, die nicht gerade für ihre Knappheit bekannt ist.

Die Array-Literal-Syntax kann jedoch theoretisch ziemlich knappe Array-Spezifikationen ermöglichen. Hier ist eine einfache EBNF-Beschreibung der Array-Literal- Syntax (passierbar für 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'

Der Einfachheit halber beschränken wir uns auf eindimensionale Arrays von ganzen Zahlen. Dies bedeutet, dass wir nur Ganzzahlen für die Ausdruckswerte verwenden. Vielleicht könnten wir in einer zukünftigen Herausforderung etwas Fortgeschritteneres ausprobieren (wie das Deklarieren von Variablen und mehrdimensionalen Arrays). Sie müssen nicht die ganzzahligen Literale spielen .

Hier sind einige Beispiele für Ada-Array-Literale und eine pythonähnliche äquivalente Darstellung zur Verdeutlichung:

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

Herausforderung

Das Ziel dieser Herausforderung besteht darin, das Ada-Array-Literal mit der kürzesten Bytezahl für ein bestimmtes Eingabearray auszugeben. Beachten Sie, dass Ada-Arrays von jedem gewünschten Index aus starten können. Sie können also auswählen, wie der Startindex aussehen soll, solange jeder Wert sequentiell ist. In diesem Beispiel beginne ich mit 1, was für Ada idiomatisch ist. Sie können jedoch auch mit einer anderen Ganzzahl beginnen.

Eingang

Ihre Eingabe besteht aus einer Liste von Ganzzahlen, in welcher Form auch immer.

Ausgabe

Ihre Ausgabe ist eine Textzeichenfolge, die das kürzeste gültige Ada-Array-Literal darstellt, das die Liste der Eingabe-Ganzzahlen darstellt. Sie können einen beliebigen Startindex für dieses Array verwenden, aber Ihre Auswahl (was auch immer es ist) muss in Ihrer Antwort angegeben werden (der Startindex kann auch dynamisch sein).

Die ganzen Zahlen sind wie in den Beispielen als vorzeichenbehaftete Dezimalzahlen darzustellen. Diese Herausforderung umfasst nicht das Golfen von ganzzahligen Werten.

Beispiele

Hier sind einige Beispiele:

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)

Mindestanforderungen

• Unterstützt mindestens 100 Nummern und Eingaben mit mindestens 256 Nummern.

• Erstellen Sie für alle diese Eingaben das richtige Ergebnis

  • Beinhaltet das Setzen von "anderen" am Ende
  • Beinhaltet das Setzen eines Index für einzelne Elementarrays

• Beenden Sie (vorzugsweise auf TIO) für jeden der oben genannten Eingänge in weniger als einer Minute.

Die kürzeste Lösung in Bytes gewinnt!

Referenzimplementierung

Probieren Sie es online aus!

Diese Implementierung verwendet die Eingabe als Array, wobei jedes Zeichen eine Zahl ist. Großbuchstaben sind spezielle Konstanten für große Werte. Das Programmargument ist der zu verwendende 'Startindex'.

Der Abschnitt "Code" im TIO-Link ist eine korrekte Lösung für das Problem, während "Kopf-" und "Fußzeile" die Teststruktur implementieren.

JavaScript (ES6),  307  304 Byte

2 Bytes dank @KevinCruijssen gespeichert

Das ist peinlich lang ...

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

Probieren Sie es online aus!

05AB1E , 136 134 132 Bytes

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

EDIT: Jetzt für alle Testfälle behoben.

Probieren Sie es online aus oder überprüfen Sie alle Testfälle (mit Ausnahme des "Huge Input", da dieser zu groß ist).

Erläuterung:

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

Sehen Sie diese 05AB1E Spitze Mine (Abschnitt Wie Kompresse Strings nicht Teil des Wörterbuchs? ) Zu verstehen , warum …ˆ†=>ist "others=>".