บทนำ

ลองสังเกตอาร์เรย์ต่อไปนี้:

[1, 1, 1, 2, 2, 1, 1, 1, 1, 2, 2, 2, 1, 1, 1]

กลุ่มประกอบด้วยตัวเลขเดียวกันติดกัน ในอาร์เรย์ด้านบนมี 5 กลุ่มที่แตกต่างกัน:

[1, 1, 1, 2, 2, 1, 1, 1, 1, 2, 2, 2, 1, 1, 1]

 1, 1, 1 
          2, 2
                1, 1, 1, 1
                            2, 2, 2
                                     1, 1, 1

กลุ่มที่เล็กที่สุดของเหล่านี้เราจึงเอาท์พุท[2, 2][2, 2]

ลองทำตัวอย่างอื่น:

[3, 3, 3, 4, 4, 4, 4, 5, 5, 4, 4, 3, 3, 4, 4]

 3, 3, 3
          4, 4, 4, 4
                      5, 5
                            4, 4
                                  3, 3
                                        4, 4

คุณจะเห็นว่ามีหลายกลุ่มที่มีความยาวเท่ากัน กลุ่มที่เล็กที่สุดคือ:

[3, 3], [4, 4], [4, 4] and [5, 5].

ดังนั้นเราจึงแสดงผล[3, 3], [4, 4], [4, 4], [5, 5]ในรูปแบบที่สมเหตุสมผล คุณสามารถส่งออกสิ่งเหล่านี้ในลำดับใดก็ได้

งาน

กำหนดอาร์เรย์ที่ประกอบด้วยจำนวนเต็มบวกเท่านั้นเอาท์พุทกลุ่มที่เล็กที่สุดจากอาร์เรย์ คุณสามารถสันนิษฐานได้ว่าอาร์เรย์จะมีจำนวนเต็มอย่างน้อย 1 ตัว

กรณีทดสอบ

Input: [1, 1, 2, 2, 3, 3, 4]
Output: [4]

Input: [1]
Output: [1]

Input: [1, 1, 10, 10, 10, 100, 100]
Output: [1, 1], [100, 100]

นี่คือโค้ดกอล์ฟดังนั้นการส่งที่มีจำนวนไบต์น้อยที่สุดจะชนะ!

Pyth, 14 12 11

mM_MmhbrQ8

ชุดทดสอบ

2 ไบต์ขอบคุณ Jakube! และ 1 ไบต์ต้องขอบคุณ isaacg!

น่าเสียดายที่การถอดรหัสความยาวรันไม่ได้ทำในสิ่งที่เราต้องการ แต่มันจะทำงานกับวิธีแก้ปัญหาเล็กน้อย

mr]d9.mhbrQ8

ขอมอบเครดิตให้แก่ Jakube เพื่อค้นหาสิ่งนี้

Mathematica ขนาด 24 ไบต์

MinimalBy[Length]@*Split

นี่คือองค์ประกอบของทั้งสองฟังก์ชั่นที่สามารถนำไปใช้กับรายการ Splitใช้ตัวเลขทุกกลุ่มติดต่อกันและMinimalBy[Length]เลือกกลุ่มที่มีความยาวน้อยที่สุด

Haskell, 38 ไบต์

import Data.Lists
argmins length.group

ตัวอย่างการใช้งาน: ->argmins length.group $ [3,3,3,4,4,4,4,5,5,4,4,3,3,4,4][[4,4],[3,3],[4,4],[5,5]]

สร้างกลุ่มขององค์ประกอบที่เท่ากันและค้นหากลุ่มที่มีความยาวน้อยที่สุด

Python 2, 120 ไบต์

import re
r=[x.group().split()for x in re.finditer(r'(\d+ )\1*',input())]
print[x for x in r if len(x)==min(map(len,r))]

รับอินพุตเป็นสตริงของจำนวนเต็มที่คั่นด้วยช่องว่างด้วยช่องว่างต่อท้ายและแสดงรายการของรายการสตริง กลยุทธ์คือการค้นหากลุ่มโดยใช้ regex (\d+ )\1*(ซึ่งตรงกับหนึ่งหรือมากกว่าจำนวนเต็มคั่นด้วยช่องว่างกับพื้นที่ต่อท้าย) จากนั้นแยกพวกเขาในช่องว่างเป็นรายการของจำนวนเต็มและพิมพ์กลุ่มเหล่านั้นที่มีความยาวเท่ากับความยาวกลุ่มขั้นต่ำ

ลองออนไลน์

C #, 204 ไบต์

void f(string o){var r=Regex.Matches(o,@"([0-9])\1{0,}").Cast<Match>().OrderBy(x=>x.Groups[0].Value.Length);foreach(var s in r){foreach(var z in r)if(s.Length>z.Length)return;Console.WriteLine(s.Value);}}

ฉันไม่ทราบว่าการใช้สตริงนั้นยุติธรรมหรือไม่ถ้าพิจารณาจาก esolangs กอล์ฟทั้งหมดจะได้รับอินพุตในลักษณะเดียวกัน แต่เขาขออินพุตอาร์เรย์

ungolfed:

    public static void f(string inp)
    {

        var r = Regex.Matches(inp, @"([0-9])\1{0,}").Cast<Match>().OrderBy(x => x.Groups[0].Value.Length);

        foreach (Match s in r)
        {
            foreach (Match z in r)
                if (s.Length > z.Length)
                    return;

        Console.WriteLine(s.Value);
        }


    }

ฉันต้องการวิธีที่จะได้รับการจับคู่ที่เล็กที่สุดสำหรับอาร์เรย์การจับคู่ไบต์ส่วนใหญ่ของฉันเสียไปที่นั่นช่วยชื่นชม ฉันพยายามเข้าไปใน LINQ และแลมบ์ดา

Python 2.x, 303 ไบต์

x=input()
r=[q[2]for q in filter(lambda l:(len(l[2])>0)&((l[0]<1)or(x[l[0]-1]!=x[l[0]]))&((l[1]>len(x)-1)or(x[l[1]]!=x[l[1]-1]))&(len(filter(lambda k:k==l[2][0],l[2]))==len(l[2])),[(a,b,x[a:b])for a in range(0,len(x))for b in range(0,len(x)+1)])]
print filter(lambda k:len(k)==min([len(s)for s in r]),r)

น่าเกลียด รหัส. เคย

อินพุต: อาร์เรย์ในรูปแบบหรือr'\[(\d,)*(\d,?)?\]'
อีกนัยหนึ่งคืออาร์เรย์ของตัวเลข

เอาท์พุท: อาร์เรย์ของอาร์เรย์ (กลุ่มที่เล็กที่สุด) ตามลำดับที่ปรากฏในอาร์เรย์อินพุต

คุณสมบัติบังเอิญเพิ่มเติม (คุณสมบัติที่ฉันไม่ได้ตั้งใจจะทำ):

• อินพุตสามารถเป็นอาร์เรย์ว่างได้ ผลลัพธ์จะเป็นอาร์เรย์ที่ว่างเปล่า
• โดยการเปลี่ยนminเป็นmaxมันจะส่งกลับอาร์เรย์ของกลุ่มที่ใหญ่ที่สุด
• ถ้าคุณทำprint rมันจะพิมพ์กลุ่มทั้งหมดตามลำดับ

MATL, 15 ไบต์

Y'tX<tb=bw)wTX"

ลองออนไลน์

อินพุตเป็นเวกเตอร์เช่น[1 2 3 4]และเอาต์พุตเป็นเมทริกซ์ที่แต่ละคอลัมน์เป็นหนึ่งในกลุ่มที่เล็กที่สุดเช่น:

1 100
1 100

สำหรับกรณีทดสอบครั้งที่สาม

คำอธิบาย:

Y'    %// Run length encoding, gives 2 vectors of group-lengths and values
t     %// Duplicate group lengths
X<    %// Minimum group length
tb    %// Duplicate and get vector of group lengths to the top
=     %// Find which group lengths are equal to the minimum
bw)   %// And get the values of those groups
wTX"  %// Repeats the matrix of minimum-length-group values by the minimum group length

เยลลี่, 22 17 16 ไบต์

I0;œṗ¹L=¥ÐfL€Ṃ$$

ลองออนไลน์!

I0;œṗ¹L=¥ÐfL€Ṃ$$     Main link. List: z = [a,b,c,...]

I                    Compute [b-a, c-b, d-c, ...]
 0;                  Concatenate 0 in front: [0, b-a, c-b, d-c, ...]
   œṗ                Split z where the corresponding item in the above array is not zero.
      L=¥Ðf          Filter sublists whose length equal:
           L€Ṃ$      the minimum length throughout the list.

     ¹         $     (grammar stuffs)

JavaScript (ES6), 106

a=>(a.map((v,i)=>v==a[i-1]?g.push(v):h.push(g=[v]),h=[]),h.filter(x=>!x[Math.min(...h.map(x=>x.length))]))

ทดสอบ

f=a=>(a.map((v,i)=>v==a[i-1]?g.push(v):h.push(g=[v]),h=[]),h.filter(x=>!x[Math.min(...h.map(x=>x.length))]))

console.log=x=>O.textContent+=x+'\n'

;[[1, 1, 1, 2, 2, 1, 1, 1, 1, 2, 2, 2, 1, 1, 1]
, [3, 3, 3, 4, 4, 4, 4, 5, 5, 4, 4, 3, 3, 4, 4]
, [1, 1, 2, 2, 3, 3, 4]
, [1]
, [1, 1, 10, 10, 10, 100, 100]]
.forEach(t=>console.log(t+' -> '+f(t).join` `))

<pre id=O></pre>

JavaScript (ES6), 113 ไบต์

a=>a.map(n=>n==c[0]?c.push(n):b.push(c=[n]),c=b=[])&&b.sort((a,b)=>a[l]-b[l],l='length').filter(e=>e[l]==b[0][l])

เรติน่า, 91 85 80 79 77 76 75 74 ไบต์

M!`\b(\d+)(,\1\b)*
(,()|.)+
$#2:$&
O#`.+
s`^(.*\b(.+:).*)¶(?!\2).+
$1
.+:
<empty-line>

ลองออนไลน์!

คำอธิบาย

1,1,10,10,10,100,100การป้อนข้อมูลที่เป็น

บรรทัดแรกจับคู่กลุ่มที่มีคำเหมือนกัน:

M!`\b(\d+)(,\1\b)*

อินพุตจะกลายเป็น:

1,1
10,10,10
100,100

สองบรรทัดต่อไปนี้จะเพิ่มจำนวนคอมมาของบรรทัด:

(,()|.)+
$#2:$&

อินพุตจะกลายเป็น:

1:1,1
2:10,10,10
1:100,100

จากนั้นจะถูกจัดเรียงตามบรรทัดนี้ซึ่งค้นหาหมายเลขแรกเป็นดัชนี:

O#`.+

อินพุตจะกลายเป็น:

1:1,1
1:100,100
2:10,10,10

จากนั้นทั้งสองบรรทัดจะค้นหาสถานที่ที่ความยาวแตกต่างกันและนำทุกอย่างออกไป:

s`^(.*\b(.+:).*)¶(?!\2).+
$1

อินพุตจะกลายเป็น:

1:1,1
1:100,100

จากนั้นตัวเลขจะถูกลบออกโดยสองบรรทัดเหล่านี้:

.+:
<empty-line>

ที่อินพุตจะกลายเป็น:

1,1
100,100

APL, 25 ตัวอักษร

{z/⍨(⊢=⌊/)≢¨z←(1,2≠/⍵)⊂⍵}

เป็นภาษาอังกฤษ:

• ใส่อาร์กิวเมนต์แยกที่จำนวนจะแตกต่างจากก่อนหน้า;
• คำนวณความยาวของแต่ละ subarray
• เปรียบเทียบค่าต่ำสุดกับแต่ละความยาวที่สร้างบูลีน ...
• ... ที่ใช้เพื่อลด z

J , 31 ไบต์

[:(#~[:(=<./)#@>)]<;.1~1,2~:/\]

อินพุตเป็นอาร์เรย์ของค่า เอาท์พุทเป็นอาร์เรย์ของอาร์เรย์ชนิดบรรจุกล่อง

การใช้

   f =: [:(#~[:(=<./)#@>)]<;.1~1,2~:/\]
   f 1 1 2 2 3 3 4
┌─┐
│4│
└─┘
   f 3 3 3 4 4 4 4 5 5 4 4 3 3 4 4
┌───┬───┬───┬───┐
│5 5│4 4│3 3│4 4│
└───┴───┴───┴───┘

คำอธิบาย

[:(#~[:(=<./)#@>)]<;.1~1,2~:/\]  Input: s
                              ]  Identity function, get s
                         2       The constant 2
                             \   Operate on each overlapping sublist of size 2
                          ~:/      Check if each pair is unequal, 1 if true else 0
                       1,        Prepend a 1 to that list
                 ]               Identity function, get s
                  <;.1~          Using the list above, chop s at each true index
[:(             )                Operate on the sublists
             #@>                 Get the length of each sublist
     [:(    )                    Operate on the length of each sublist
         <./                     Get the minimum length
        =                        Mark each index as 1 if equal to the min length else 0
   #~                            Copy only the sublists with min length and return

Clojure 65 ไบต์

#(let[G(group-by count(partition-by + %))](G(apply min(keys G))))

ใช้+เป็นidentityฟังก์ชั่นตามที่(+ 5)เป็น 5 :) ส่วนที่เหลือควรชัดเจนGเป็น hash-map ที่ใช้เป็นฟังก์ชั่นและกำหนดให้มันส่งคืนค่าที่สอดคล้องกัน

Brachylogขนาด 6 ไบต์

ḅlᵒlᵍh

ลองออนไลน์!

อินพุตผ่านตัวแปรอินพุตและเอาต์พุตผ่านตัวแปรเอาต์พุต

ḅ         The list of runs of consecutive equal elements of
          the input
 lᵒ       sorted by length
   lᵍ     and grouped by length
          has the output variable
     h    as its first element.

แม้ว่าจะแตกต่างḅ, ᵍกลุ่มองค์ประกอบเท่ากับไม่ต่อเนื่องกันที่lᵒยังคงจำเป็นที่จะหากลุ่มที่มีความยาวสั้นที่สุดและการทำงานเพราะคำสั่งของกลุ่มในการส่งออกจากที่ᵍถูกกำหนดโดยตำแหน่งขององค์ประกอบแรกของแต่ละกลุ่มเพื่อ ที่ᵍhᵐสามารถทำหน้าที่เหมือนdeduplicate โดยหลอก metapredicate

Perl 5 -MList::Util=pairkeys,min -a , 69 ไบต์

map$r{y/ //}.="[ $_]",pairkeys"@F "=~/((\d+ )\2*)/g;say$r{min keys%r}

ลองออนไลน์!