Giới thiệu

Hãy quan sát mảng sau:

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

Một nhóm bao gồm các chữ số giống nhau cạnh nhau. Trong mảng trên, có 5 nhóm khác nhau:

[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

Nhóm nhỏ nhất trong số này là [2, 2], vì vậy chúng tôi đầu ra [2, 2].

Hãy lấy một ví dụ khác:

[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

Bạn có thể thấy rằng có nhiều nhóm có cùng độ dài. Các nhóm nhỏ nhất là:

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

Vì vậy, chúng tôi chỉ đầu ra [3, 3], [4, 4], [4, 4], [5, 5] trong bất kỳ định dạng hợp lý. Bạn có thể xuất chúng theo thứ tự bất kỳ.

Nhiệm vụ

Cho một mảng chỉ bao gồm các số nguyên dương, xuất (các) nhóm nhỏ nhất từ ​​mảng. Bạn có thể giả sử rằng mảng sẽ chứa ít nhất 1 số nguyên.

Các trường hợp thử nghiệm

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]

Đây là môn đánh gôn , vì vậy bài nộp có số byte ít nhất sẽ thắng!

Bình thường 14 12 11

mM_MmhbrQ8

Phòng thử nghiệm

2 byte nhờ Jakube! Và 1 byte nhờ isaacg!

Thật không may, giải mã độ dài chạy không hoàn toàn làm những gì chúng ta muốn nó làm, nhưng nó sẽ hoạt động với một cách giải quyết nhỏ, nhưng điều đó làm cho nó dài hơn một chút so với thực hiện thủ công:

mr]d9.mhbrQ8

Tín dụng cho Jakube để tìm ra điều này.

Toán học, 24 byte

MinimalBy[Length]@*Split

Đây là một thành phần của hai chức năng có thể được áp dụng cho một danh sách. Splitlấy tất cả các nhóm số liên tiếp và MinimalBy[Length]chọn những nhóm có độ dài tối thiểu.

Haskell, 38 byte

import Data.Lists
argmins length.group

Ví dụ sử dụng: 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]].

Xây dựng các nhóm yếu tố bằng nhau và tìm những nhóm có chiều dài tối thiểu.

Python 2, 120 byte

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

Đưa đầu vào dưới dạng một chuỗi các số nguyên được phân tách bằng dấu cách với một khoảng trắng ở cuối và xuất ra một danh sách các danh sách các chuỗi. Chiến lược là tìm các nhóm sử dụng regex(\d+ )\1* (khớp với một hoặc nhiều số nguyên được phân tách bằng dấu cách, có dấu cách), sau đó chia chúng trên các khoảng trắng thành danh sách các số nguyên và in các nhóm có độ dài bằng với độ dài nhóm tối thiểu.

Dùng thử trực tuyến

C #, 204 byte

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);}}

Tôi không biết nếu sử dụng một chuỗi có công bằng không khi xem xét tất cả các esolang chơi gôn có được đầu vào của họ theo cùng một cách nhưng anh ta đã yêu cầu đầu vào mảng.

vô dụng:

    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);
        }


    }

Tôi cần một cách để có được các kết quả khớp nhỏ nhất cho mảng khớp, hầu hết các byte của tôi bị lãng phí ở đó, giúp đánh giá cao. Tôi đang cố gắng vào công cụ LINQ và lambda.

Python 2.x, 303 byte

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)

Xấu nhất Mã. Không bao giờ.

Đầu vào: Một mảng ở định dạng r'\[(\d,)*(\d,?)?\]'
Nói cách khác, một mảng số python

Đầu ra: Một mảng các mảng (các nhóm nhỏ nhất), theo thứ tự chúng xuất hiện trong mảng đầu vào

Các tính năng trùng hợp bổ sung (Các tính năng mà tôi không có ý định thực hiện):

• Đầu vào có thể là một mảng trống; đầu ra sẽ là một mảng trống.
• Bằng cách thay đổi minthànhmax , nó sẽ trả về một mảng các nhóm lớn nhất.
• Nếu bạn chỉ làm print r, nó sẽ in tất cả các nhóm theo thứ tự.

MATL, 15 byte

Y'tX<tb=bw)wTX"

Dùng thử trực tuyến

Đầu vào là một vectơ, như [1 2 3 4]và đầu ra là một ma trận trong đó mỗi cột là một trong những nhóm nhỏ nhất, ví dụ:

1 100
1 100

cho trường hợp thử nghiệm thứ ba.

Giải trình:

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

Thạch, 22 17 16 byte

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

Hãy thử trực tuyến!

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

Kiểm tra

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 byte

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

Võng mạc, 91 85 80 79 77 76 75 74 byte

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

Hãy thử trực tuyến!

Giải trình

Đầu vào là 1,1,10,10,10,100,100 .

Dòng đầu tiên khớp với các nhóm có cùng điều khoản:

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

Đầu vào trở thành:

1,1
10,10,10
100,100

Hai dòng sau bổ sung số dấu phẩy cho dòng:

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

Đầu vào trở thành:

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

Sau đó, chúng được sắp xếp theo dòng này, tìm số đầu tiên dưới dạng chỉ mục:

O#`.+

Đầu vào trở thành:

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

Sau đó, hai dòng này tìm vị trí có độ dài khác nhau và xóa mọi thứ trở đi:

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

Đầu vào trở thành:

1:1,1
1:100,100

Sau đó, các số được loại bỏ bởi hai dòng này:

.+:
<empty-line>

Trường hợp đầu vào trở thành:

1,1
100,100

APL, 25 ký tự

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

Bằng tiếng Anh:

• đặt trong z phần tách đối số trong đó một số khác với số trước;
• tính chiều dài của mỗi phân đoạn
• so sánh mức tối thiểu với mỗi độ dài tạo ra một boolean ...
• ... được sử dụng để giảm z

J , 31 byte

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

Đầu vào là một mảng các giá trị. Đầu ra là một mảng các mảng được đóng hộp.

Sử dụng

   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│
└───┴───┴───┴───┘

Giải trình

[:(#~[:(=<./)#@>)]<;.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 byte

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

Sử dụng +như identityhàm (+ 5)5 :) Phần còn lại phải rõ ràng, Glà một bản đồ băm được sử dụng như một hàm và được cung cấp một khóa nó trả về giá trị tương ứng.

Brachylog , 6 byte

ḅlᵒlᵍh

Hãy thử trực tuyến!

Đầu vào thông qua biến đầu vào và đầu ra thông qua biến đầu ra.

ḅ         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.

Mặc dù, không giống như ḅ, ᵍnhóm yếu tố bình đẳng không liên tiếp, những lᵒvẫn còn cần thiết để tìm ra nhóm với độ dài ngắn nhất, và nó hoạt động vì thứ tự của nhóm trong đầu ra từ ᵍđược xác định bởi vị trí của phần tử đầu tiên của mỗi nhóm, vì vậy rằng ᵍhᵐcó thể có chức năng như sắp xếp của một deduplicate bởi pseudo-metapredicate.

Perl 5 -MList::Util=pairkeys,min -a , 69 byte

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

Hãy thử trực tuyến!