Arka fon

Ada , tezahürü ile tam olarak bilinmeyen bir programlama dilidir.

Bununla birlikte, dizi değişmez sözdizimi teoride oldukça kısa dizi özelliklerine izin verebilir. Dizi değişmez sözdiziminin basit bir EBNF açıklaması ( bottlecaps.de'ye geçirilebilir) :

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'

Basitlik için kendimizi 1 boyutlu tamsayı dizileriyle sınırlayacağız. Bu, ifade değerleri için yalnızca tamsayılar kullanacağımız anlamına gelir. Belki gelecekteki bir meydan okumada daha gelişmiş bir şey deneyebiliriz (değişkenleri ve çok boyutlu dizileri bildirmek gibi). Tam sayı değişmez golf oynamak zorunda değilsiniz .

Ada dizisi değişmezlerinin bazı örnekleri ve netlik için bir python-esque eşdeğer gösterimi:

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

Meydan okuma

Bu zorluğun amacı, belirli bir girdi dizisi için en kısa bayt-sayısı Ada dizisi değişmezinin çıktısını vermektir. Ada dizilerinin istenen herhangi bir dizinden başlayabileceğini unutmayın, böylece her bir değer sıralı olduğu sürece başlangıç ​​dizininin ne olmasını istediğinizi seçebilirsiniz. Bu örnekte Ada için deyimsel olan 1'den başlamayı seçiyorum, ancak başka bir tamsayıdan başlamayı da seçebilirsiniz.

Giriş

Girişiniz, hangi formda olursa olsun bir tamsayılar listesinden oluşacaktır.

Çıktı

Çıktınız, girdi tam sayılarının listesini temsil eden en kısa geçerli Ada dizisi değişmezini temsil eden bir metin dizesi olacaktır. Bu dizide istediğiniz herhangi bir başlangıç ​​dizinini kullanabilirsiniz, ancak seçiminiz (her ne olursa olsun) cevabınızda belirtilmelidir (başlangıç ​​dizini de dinamik olabilir).

Tamsayılar örneklerde olduğu gibi işaretli ondalık sayılar olarak gösterilmelidir. Bu zorluk tam sayı değerlerinin golf oynamasını kapsamaz.

Örnekler

İşte bazı örnekler:

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)

Minimum Gereksinimler

• En az 100 rakam ve en az 256 rakam uzunluğundaki girişleri destekleyin.

• Tüm bu girdiler için doğru sonucu üretin

  • 'Diğerlerini' sonuna koymayı içerir
  • Tek öğe dizileri için bir dizin eklemeyi içerir

• Yukarıdaki girişlerin her biri için bir dakikadan kısa sürede (tercihen TIO'da) sonlandırın.

Baytlarda en kısa çözüm kazanır!

Referans uygulaması

Çevrimiçi deneyin!

Bu uygulama girdiyi dizi olarak kullanır ve her karakter bir sayıdır. Büyük harfler büyük değerler için özel sabitlerdir. Program argümanı kullanılacak 'başlangıç ​​endeksidir'.

"Üstbilgi" ve "altbilgi" test yapısını uygularken, TIO bağlantısındaki "kod" bölümü soruna doğru bir çözümdür.

JavaScript (ES6),  307  304 bayt

@KevinCruijssen sayesinde 2 bayt kaydedildi

Utanç verici derecede uzun ...

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

Çevrimiçi deneyin!

05AB1E , 136 134 132 bayt

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

EDIT: Şimdi tüm test senaryoları için düzeltildi.

Çevrimiçi deneyin veya tüm test senaryolarını doğrulayın (çok büyük olduğu için 'Büyük Giriş' hariç).

Açıklama:

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

Bu 05AB1E madenin ucu bakın (bölüm kompres dizeleri sözlükte parçası olmayan nasıl? ) Anlamak için …ˆ†=>olduğunu "others=>".