พื้นหลัง

Adaเป็นภาษาการเขียนโปรแกรมที่ไม่รู้จักกันอย่างแพร่หลายในเรื่องความตึง

อย่างไรก็ตามอาเรย์ของตัวอักษรอาเรย์สามารถในทางทฤษฎีอนุญาตให้มีข้อกำหนดส นี่คือคำอธิบาย 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'

เราจะ จำกัด ตัวเองให้เป็นอาร์เรย์จำนวนเต็ม 1 มิติเพื่อความง่าย ซึ่งหมายความว่าเราจะใช้เฉพาะจำนวนเต็มสำหรับค่าการแสดงออก บางทีในความท้าทายในอนาคตเราสามารถลองอะไรที่สูงกว่านี้ได้ (เช่นการประกาศตัวแปรและอาร์เรย์หลายมิติ) คุณไม่ต้องกอล์ฟอักษรจำนวนเต็ม

นี่คือตัวอย่างบางส่วนของตัวอักษรอาร์เรย์ 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 สามารถเริ่มต้นจากดัชนีใดก็ได้ที่ต้องการดังนั้นคุณสามารถเลือกสิ่งที่คุณต้องการให้ดัชนีเริ่มต้นตราบเท่าที่แต่ละค่าเรียงตามลำดับ ในตัวอย่างนี้ฉันเลือกที่จะเริ่มต้นที่ 1 ซึ่งเป็นสำนวนสำหรับ Ada แต่คุณสามารถเลือกที่จะเริ่มต้นด้วยจำนวนเต็มอื่น ๆ

อินพุต

ข้อมูลที่คุณป้อนจะประกอบด้วยรายการจำนวนเต็มไม่ว่าจะสะดวกในรูปแบบใด

เอาท์พุต

ผลลัพธ์ของคุณจะเป็นสตริงข้อความที่แสดงถึงตัวอักษรอาร์เรย์ 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¦}н

แก้ไข: แก้ไขสำหรับกรณีทดสอบทั้งหมดตอนนี้

ลองใช้แบบออนไลน์หรือตรวจสอบกรณีทดสอบทั้งหมด (ยกเว้นกรณี 'อินพุตขนาดใหญ่' เนื่องจากมีขนาดใหญ่เกินไป)

คำอธิบาย:

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