Lấy cảm hứng từ câu hỏi này :

Tạo một hàm (hoặc một chương trình đầy đủ) nhận danh sách các số và xuất ra danh sách được sắp xếp lại, sao cho các số có chỉ số chẵn xuất hiện trước và các số được lập chỉ mục lẻ theo sau. Giá trị của các số không ảnh hưởng đến thứ tự - chỉ các chỉ số của chúng mới làm. Tất cả các chỉ số đều dựa trên không.

Ví dụ:

Đầu vào: [0, 1, 2, 3, 4]

Đầu ra: [0, 2, 4, 1, 3]

Một vi dụ khac:

Đầu vào: [110, 22, 3330, 4444, 55555, 6]

Đầu ra: [110, 3330, 55555, 22, 4444, 6]

Sử dụng đại diện tự nhiên nhất cho các danh sách mà ngôn ngữ của bạn có. Không có giới hạn về độ phức tạp (ví dụ: phân bổ danh sách tạm thời là OK - không cần thực hiện tại chỗ).

PS Nó sẽ hoạt động cho danh sách trống (đầu vào trống => đầu ra trống).

Japt , 1 byte

ó

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

Python, 23 byte

lambda x:x[::2]+x[1::2]

Dùng thử trực tuyến

Bình thường, 5

o~!ZQ

Dùng thử trực tuyến hoặc chạy Test Suite

Giải trình

o~!ZQ    ## implicit: Z = 0; Q = eval(input)
o   Q    ## sort Q using a supplied function
 ~!Z     ## Use the old value of Z, then set Z to be not Z
         ## This assigns a weight to each number in the list, for example given [0,1,2,3,4]
         ## This will give (value, weight) = [(0,0), (1,1), (2,0), (3,1), (4,0)]
         ## The values are sorted by weight and then by index
         ## This happens because Pyth is written in Python, which performs stable sorts

CJam, 7 byte

{2/ze_}

Đẩy một khối (thứ gần nhất với hàm không tên) để biến đổi phần tử ngăn xếp trên cùng theo yêu cầu.

Kiểm tra nó ở đây.

Giải trình

Giải thích giả định rằng đỉnh của ngăn xếp là mảng [0 1 2 3 4]. Các giá trị thực tế không ảnh hưởng đến tính toán.

2/  e# Split the array into chunks of two: [[0 1] [2 3] [4]]
z   e# Zip/transpose, which works on ragged arrays: [[0 2 4] [1 3]]
e_  e# Flatten the result: [0 2 4 1 3]

Mê cung , 28 25 24 23 22 byte

" >
?!?:|}\{@
@\?"":)!

Đây là niềm vui điên rồ! :) Đó là chương trình Labyrinth nén dày đặc nhất mà tôi đã viết cho đến nay. Tôi đã có rất nhiều phiên bản ở mức 20 và 21 byte gần như hoạt động mà tôi vẫn nghi ngờ điều này là tối ưu ...

Này có đầu vào như một danh sách tích cực số nguyên (với một dấu phân cách tùy ý), và in kết quả để STDOUT là số nguyên linefeed được phân định.

Cuộc săn tìm 20/21 byte: Tôi đã kiểm tra tất cả các chương trình có dạng

" XX
?!?X}\{@
@\?XX)!

Ở đâu X là bất kỳ ký tự hợp lý bởi brute force, nhưng không tìm thấy bất kỳ giải pháp hợp lệ. Tất nhiên điều đó không có nghĩa là một giải pháp ngắn hơn không tồn tại, nhưng không thể buộc các chương trình 20 byte mà không có một số giả định kha khá về cấu trúc của nó.

Giải trình

(Lời giải thích hơi lỗi thời, nhưng tôi vẫn không tin rằng giải pháp là tối ưu, vì vậy tôi sẽ chờ đợi để cập nhật điều này.)

Vì vậy, thông thường các chương trình Labyrinth được cho là trông giống như mê cung. Trong khi con trỏ lệnh nằm trong một hành lang, nó sẽ đi theo hành lang đó. Khi IP chạm vào bất kỳ loại đường giao nhau nào, hướng được xác định dựa trên giá trị cao nhất của ngăn xếp chính của Labyrinth (Labyrinth có hai ngăn xếp, với số lượng vô hạn ở dưới cùng). Điều đó thường có nghĩa là bất kỳ vòng lặp không tầm thường nào cũng sẽ khá tốn kém, bởi vì nếu bạn có các ô không tường ở khắp mọi nơi thì mọi thứ đều là một điểm nối và trong hầu hết các trường hợp, đỉnh của ngăn xếp sẽ không có giá trị phù hợp cho IP để đi theo con đường bạn muốn nó đi. Vì vậy, những gì bạn làm là bạn phóng to các vòng lặp sao cho chúng có một tổng thể ở trung tâm chỉ với một điểm vào và thoát được xác định rõ ràng.

Nhưng lần này tôi thực sự may mắn và mọi thứ rất phù hợp với nhau, đến nỗi tôi có thể nghiền nát tất cả thành một khối lớn. :)

Kiểm soát luồng bắt đầu tại _ Nam đi. Việc _đẩy số 0 lên ngăn xếp chính. Điều đó có vẻ như không có, nhưng điều này làm tăng độ sâu ngăn xếp (không ngầm) 1mà chúng ta sẽ cần sau này.

?đọc một số nguyên từ STDIN. Nếu không có số nguyên nào được đọc, điều này sẽ đẩy số không. Trong trường hợp đó, IP tiếp tục di chuyển về phía Nam và @chấm dứt chương trình ngay lập tức (vì danh sách đầu vào trống). Nếu không, IP quay về hướng Đông.

Bây giờ chúng ta đang bước vào một vòng lặp rất chặt chẽ với hai điểm thoát:

 !?;
 \?
  ;

!in số nguyên trở lại STDOUT, chỉ để lại số 0 trên ngăn xếp. IP tiếp tục di chuyển về phía Đông và? đọc số nguyên tiếp theo. Nếu đó là con số không, chúng ta có quyền và di chuyển về phía Nam. ?đọc một số khác (chỉ số chẵn tiếp theo). Một lần nữa, nếu đó là khác không, chúng ta có quyền và di chuyển về phía Tây.

Sau đó \in một nguồn cấp dữ liệu mà không thay đổi ngăn xếp, vì vậy chúng tôi có quyền khác, di chuyển về phía Bắc.!in số nguyên chẵn tiếp theo đó. Vì hiện tại có ít nhất một số nguyên chỉ số lẻ (dương) trên ngăn xếp, chúng tôi tiếp tục rẽ phải và vòng lặp lặp lại.

Khi một trong hai thứ đó ?chạm đến cuối danh sách, chúng sẽ đẩy số 0 và di chuyển thẳng lên phần tương ứng; , loại bỏ số 0 đó.

Trong trường hợp chỉ có một yếu tố duy nhất trong danh sách, chúng tôi đã hoàn thành (vì chúng tôi đã in ngay lập tức), vì vậy IP sẽ tiếp tục di chuyển về phía Đông đến @ , chấm dứt chương trình (in dấu vết linefeed trên đường).

Mặt khác, chúng ta cũng cần in các số nguyên chỉ số lẻ. Trong trường hợp đó, hai đường dẫn (từ hai điểm thoát của vòng lặp thứ nhất) hợp nhất ở giữa ", quay về hướng Đông trong cả hai trường hợp.

_đẩy số 0 để tránh rẽ trái vào @và ;loại bỏ số 0 đó. Bây giờ chúng ta nhập một vòng lặp mới:

     "}
     ""

IP nhập cái này vào ô dưới cùng bên trái, di chuyển về phía Bắc, đi vòng vòng theo chiều kim đồng hồ. Sự }dịch chuyển đỉnh của ngăn xếp chính sang ngăn phụ. Mặc dù vẫn còn một phần tử trên ngăn xếp, IP vẫn tiếp tục làm việc của nó. Khi mọi thứ đã được chuyển sang ngăn xếp phụ trợ (và đảo ngược trong quy trình), IP sẽ tiếp tục di chuyển về phía Đông, đi vào vòng lặp cuối cùng:

       \{@
       #!

\in lại một nguồn cấp dữ liệu một lần nữa, {di chuyển một mục từ ngăn xếp phụ trở lại chính. Nếu đó vẫn là một mục trong danh sách, nó sẽ là số dương và IP sẽ quay về hướng Nam, nơi mục được in !. Sau đó #đẩy độ sâu ngăn xếp (và bây giờ đây là nơi ban đầu _rất quan trọng, bởi vì điều này #đảm bảo độ sâu ngăn xếp dương), do đó IP vẫn quay đúng, qua \và {lại.

Sau khi chúng tôi in mọi thứ, {kéo số 0 từ dưới cùng của ngăn xếp phụ trợ, IP tiếp tục về phía Đông và @chấm dứt chương trình.

MATLAB, 24

@(x)x([1:2:end 2:2:end])

tương tự như con trăn.

Cảm ơn @LuisMendo vì đã lưu 2 byte!

Haskell , 37 byte

concat.foldr(\x[l,r]->[x:r,l])[[],[]]

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

Các foldrđệ quy được xây dựng lên danh sách và thậm chí danh sách lẻ. Chuẩn bị một phần tử vào danh sách được cập nhật bằng cách thêm nó vào danh sách lẻ và gọi nó là danh sách chẵn mới và gọi danh sách chẵn trước đó là danh sách lẻ mới. Sau đó, cặp [l,r]được nối với nhau l++r.

Cảm ơn Ørjan Johansen vì đã lưu 5 byte bằng cách sử dụng danh sách hai phần tử thay cho bộ dữ liệu.

42 byte:

f l=[x|p<-[even,odd],(i,x)<-zip[0..]l,p i]

Thêm các chỉ mục vào danh sách lvà lọc các số chẵn hoặc lẻ.

g(a:_:l)=a:(g l)
g l=l
f l=g l++(g$drop 1 l)

Một định dạng khác, cho 44. Hàm glấy mọi phần tử được lập chỉ mục chẵn. Các chỉ số lẻ được nhận bằng cách bỏ phần tử đầu tiên, sau đó áp dụng g. Nếu lđược đảm bảo không trống, chúng tôi có thể làm một cách an toàn tailcho 41

g(a:_:l)=a:(g l)
g l=l
f l=g l++g(tail l)

PowerShell v3 +, 75 67 49 47 byte

$l=,@()*2
$args|%{$l[($f=!$f)]+=$_}
$l[0]
$l[1]

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

Yêu cầu đầu vào thông qua ghép hình, như được hiển thị trên liên kết TIO.

Tạo một ma trận $ldưới dạng một mảng các mảng, sau đó chuyển đầu $argsvào thành một vòng lặp |%{}. Mỗi lần qua vòng lặp, chúng ta thêm một phần tử vào một trong hai mảng con $lbằng cách lật $fbiến bằng cách sử dụng logic Boolean. Lần đầu tiên thông qua, $flà $null, !trong đó $true, hoặc 1khi lập chỉ mục vào một mảng. Điều này có nghĩa là phần tử đầu tiên được đưa vào mảng thứ hai $l, vì vậy đó là lý do tại sao $l[1]có đầu ra đầu tiên.

Đạo cụ cho TessellatingHeckler cho hỗ trợ chơi gôn và biến thể này.
-2 byte nhờ mazzy.

Hãy cẩn thận

Theo đúng như câu hỏi được viết, điều này không hợp lệ về mặt kỹ thuật, vì PowerShell không có khái niệm "danh sách" là các đối tượng giả bất biến, chỉ có mảng hoặc bảng băm (còn gọi là từ điển). Vì vậy, tôi đang xử lý dòng câu hỏi " Sử dụng đại diện tự nhiên nhất cho các danh sách mà ngôn ngữ của bạn có " như hỏi về mảng, vì đó là PowerShell gần nhất có. Ngoài ra, đầu ra là một thành phần trên mỗi dòng, vì đó là cách PowerShell mặc định để viết ra một mảng. Điều này có nghĩa là một đầu vào của (0,1,2,3,4)đầu ra sẽ 0\r\n2\r\n4\r\n1\r\n3\r\n.

F #, 79 77 56

fun x->List.foldBack(fun x (l,r)->x::r,l)x ([],[])||>(@)

Dựa trên một trong những câu trả lời của Haskell

fun x->x|>List.indexed|>List.partition(fst>>(&&&)1>>(=)0)||>(@)|>List.map snd

Đầu tiên chúng ta lập chỉ mục danh sách, sau đó phân vùng nó với các tiêu chí: mục đầu tiên (chỉ mục) và với 1 bằng 0.
Điều đó cho chúng ta một cặp danh sách các cặp; danh sách đầu tiên sẽ chứa tất cả các evens được lập chỉ mục và các tỷ lệ cược được lập chỉ mục khác.
Từ đó chúng tôi tập hợp lại hai danh sách với toán tử chắp thêm và cuối cùng loại bỏ chỉ mục.

Chỉnh sửa: đã bỏ lỡ một điều hiển nhiên, không cần đặt tên cho arg "xs" (thói quen) để có thể giảm thành tên 1 chữ cái

Tôi cũng có một byte 76 tiềm năng về cơ bản là một byte nhưng được định nghĩa là thành phần hàm. Vấn đề là nó không được biên dịch thành một giá trị nhưng sẽ hoạt động hiệu quả với bất kỳ đối số danh sách nào được đưa ra nên không chắc chắn liệu nó có ổn hay không:

List.indexed>>List.partition(fst>>(&&&)1>>(=)0)>>fun(e,o)->e@o|>List.map snd

Lưu ý: List.indexed chỉ khả dụng từ F # 4.0 mặc dù chưa được ghi lại trong MSDN

JavaScript (ES6), 52 byte

Nó cũng làm điều đó trong một lần

x=>x.map((v,i)=>x[(i*=2)>=(z=x.length)?i-z+--z%2:i])

F=x=>x.map((v,i)=>x[(i*=2)>=(z=x.length)?i-z+--z%2:i])

input.oninput = setValue;

function setValue() {
  var arr = input.value.match(/\d+/g) || [];
  unsorted.innerHTML = arr.join(', ');
  sorted.innerHTML = F(arr).join(', ');
}

setValue();

* {
  font-family: monospace
}

th {
  text-align: right;
  padding-right: 0.5em;
}

<input id="input" type="text" value="0 1 2 3 4 5 6"/>
<hr/>
<table>
  <tr>
    <th>Unsorted:</th>
    <td id="unsorted"></td>
  </tr>
  <tr>
    <th>Sorted:</th>
    <td id="sorted"></td>
  </tr>
</table>

Julia, 23 byte

i->i[[1:2:end;2:2:end]]

J, 8 byte

/:0 1$~#

Đây là một động từ đơn (một đối số), được sử dụng như sau:

  (/:0 1$~#) 110 22 3330 4444 55555 6
110 3330 55555 22 4444 6

Giải trình

/:        Sort the input array according to
  0 1     the array 0 1
     $~   repeated enough times to be of length
       #  length of input

Thạch , 4 byte

s2ZF

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

Dựa trên câu trả lời của Martin's CJam

s2ZF - Main link. Argument: L (a list) e.g.  [110, 22, 3330, 4444, 55555, 6]
s2   - Split into chunks of length 2         [[110, 22], [3330, 4444], [55555, 6]]
  Z  - Columns                               [[110, 3330, 55555], [22, 4444, 6]]
   F - Flatten                               [110, 3330, 55555, 22, 4444, 6]

Toán học, 40 byte

#[[;;;;2]]~Join~If[#=={},#,#[[2;;;;2]]]&

{}[[2;;;;2]] sẽ ném một lỗi.

Burlesque, 12 byte

J2ENj[-2EN_+

Cách sử dụng như trong:

blsq ) {0 1 2 3 4}J2ENj[-2EN_+
{0 2 4 1 3}
blsq ) {110 22 3330 4444 55555 6}J2ENj[-2EN_+
{110 3330 55555 22 4444 6}

Giải trình:

J     -- duplicate
2EN   -- every 2nd element
j     -- swap
[-    -- tail
2EN   -- every 2nd element
_+    -- concatenate parts

Mặc dù một khi bản cập nhật mới được phát hành, bạn có thể thực hiện việc này với Unmerge tích hợp mới (đối diện với tích hợp **sẵn):

blsq ) {110 22 3330 4444 55555 6}J2ENj[-2EN**
{110 22 3330 4444 55555 6}

Perl, 35 33 byte

perl -ape 'push@{$|--},$_ for@F;$_="@0 @1"'

31 byte + 2 byte cho -ap. Đọc một chuỗi được phân tách bằng dấu cách từ STDIN:

$ echo 0 1 2 3 4 | perl -ape 'push@{$|--},$_ for@F;$_="@0 @1"'
0 2 4 1 3

$ echo 110 22 3330 4444 55555 6 | perl -ape 'push@{$|--},$_ for@F;$_="@0 @1"'
110 3330 55555 22 4444 6

Khi đầu vào trống, in một khoảng trắng, mà tôi sẽ xem xét tương đương với một danh sách trống. Nếu không, có thể được sửa với chi phí 4 byte bằng:

perl -anE 'push@{$|--},$_ for@F;$,=$";say@0,@1'

(yêu cầu Perl 5.10+, in một dòng mới)

hoặc với chi phí 5 byte với:

perl -ape 'push@{$|--},$_ for@F;$_=join$",@0,@1'

(không có khoảng trắng ở cuối)

Làm thế nào nó hoạt động

Giải pháp này sử dụng -acờ, phân tách đầu vào trên khoảng trắng và đặt kết quả vào@F mảng.

Phép thuật thực sự xảy ra trong push:

push@{$|--},$_

Các $|biến thường được sử dụng để buộc đầu ra đỏ bừng, nhưng nó có một tài sản hấp dẫn: khi giảm đi nhiều lần, giá trị của nó Toggles giữa 0 và 1.

perl -E 'say $|-- for 0..4'
0
1
0
1
0

Lợi dụng thực tế là không có hạn chế nào đối với các định danh được chỉ định thông qua hội nghị biểu tượng , chúng tôi luân phiên đẩy các phần tử mảng lên @0và @1mảng, do đó @0kết thúc với tất cả các phần tử được lập chỉ mục chẵn và @1với tỷ lệ cược. Sau đó, chúng tôi chỉ cần nối các mảng được xâu chuỗi để có đầu ra của chúng tôi.

C, 70

Không có gì đặc biệt, chỉ là một chức năng ánh xạ chỉ mục.

a=0;main(int c,int** v){for(c--;a<c;)puts(v[1+a*2%c+!(a++<c/2|c%2)]);}

Ít chơi gôn

a=0;
main(int c, int** v) {
  for(c--; a<c;)
    puts(v[1 + a*2%c + !(a++ < c/2 | c%2) ]);
}

Bình thường, 8 byte

+%2Q%2tQ

Tương đối đơn giản

Vitsy, 22 byte

Vitsy thực sự đã không được thực hiện để làm điều này ...

r '' Vl2 / \ [N {VO] l \ [NVO]
r Đảo ngược ngăn xếp đầu vào số ẩn.
 '' V Lưu ký tự "khoảng trắng" làm biến cuối cùng toàn cầu.
     l2 / \ [....] Lặp lại nội dung trong ngoặc theo chiều dài của đầu vào
                        ngăn chia cho 2.
          N {VO Xuất ra mục trên cùng của ngăn xếp dưới dạng số, sau đó thay đổi
                        ngăn xếp một lần sang trái, đẩy một khoảng trắng, xuất nó.
               l \ [...] Trong phần còn lại của ngăn xếp, lặp lại nhiều lần ...
                  NVO Xuất mục trên cùng của ngăn xếp thành một số được phân tách 
                        bởi một không gian.

Perl 6 , 25 byte

Đây là lambda ngắn nhất tôi có thể đến với.

{|.[0,2...*],|.[1,3...*]} # 25 byte "Texas" version
{|.[0,2…*],|.[1,3…*]}     # 25 byte "French" version

say {|.[0,2…*],|.[1,3…*]}( ^5 ); # (0 2 4 1 3)␤

say ((0..4),('m'..'q'),(5..9)).map: {|.[0,2…*],|.[1,3…*]}
# ((0 2 4 1 3) (m o q n p) (5 7 9 6 8))␤


# bind it as a lexical sub
my &foo = {|.[0,2…*],|.[1,3…*]}

say foo [110, 22, 3330, 4444, 55555, 6]; # (110 3330 55555 22 4444 6)␤

say [~] foo 'a'..'z' # acegikmoqsuwybdfhjlnprtvxz␤

Chồn 0,12 , 15 byte

$nI2:[i1+g]r$N.

Hãy thử nó ở đây.

Giải trình

$n                 Read in all of input as numbers
  I2:              The length of the stack divided by 2 (n)
     [             Open for loop that repeats n times
      i1+          Loop counter + 1
         g         Gets the (i+1)th item from the stack and puts it on top
          ]        Close for loop
           r       Reverse the stack (for outputting)
            $N.    Output the whole stack as numbers and stop.

R, 49 byte

q<-function(x)c(x[seq(x)%%2==1],x[seq(x)%%2==0])

Gọi nó là q (blah). Hoặc, nếu x đã chứa danh sách được sắp xếp lại, thì

c(x[seq(x)%%2==1],x[seq(x)%%2==0])

chỉ là 35 byte.

F #, 64

fun x->List.mapi(fun i l->l,i%2)x|>List.sortBy snd|>List.map fst

Lấy cảm hứng từ câu trả lời của Sehnsucht (nhưng không đủ đại diện để bình luận).

Ánh xạ mỗi giá trị thành một tuple trong đó mục nhập thứ hai là modulo của chỉ mục danh sách, sắp xếp theo modulo, sau đó ánh xạ trở lại giá trị ban đầu.

Prolog, 103 byte

r([E,O|T],[E|A],[O|B]):-r(T,A,B).
r([],[],[]).
r([E],[E],[]).
p(L):-r(L,A,B),append(A,B,X),write(X).

Thí dụ

>p([1,2,3,4,5]).
[1,3,5,2,4]

bash và GNU coreutils, 68 byte

Chúng tôi giả định rằng danh sách này được phân tách bằng dòng mới và được chuyển vào đầu vào tiêu chuẩn.

(paste - <(seq 0 5 9999)|tee x|grep 0$;grep 5$<x)|cut -f1|grep -v ^$

Thật không may, điều này sẽ bỏ qua bất kỳ đầu vào nào ngoài chỉ số 1999, vì vậy nó không hoàn toàn đáp ứng thông số kỹ thuật.

Nó cũng ghi đè một tệp tạm thời được mã hóa cứng ('x'), có thể có vấn đề nếu chạy song song và sau đó không xóa tệp. Xin lỗi vì điều đó!

PHP, 78 69 byte

PHP có thể chunk và cắt, nhưng không xen kẽ các mảng; Điều này làm cho điều này hơi cồng kềnh:

function(&$a){while($i++<count($a)>>1)$a[]=array_splice($a,$i,1)[0];}

Gọi bằng cách tham khảo hoặc thử trực tuyến .

Cách tiếp cận đầu tiên (chương trình cho 78 byte):

for(;++$i<$argc;)echo",",$argv[$i++];for($i=1;++$i<$argc;)echo",",$argv[$i++];

in một dấu phẩy hàng đầu; chèn [!$i]trước cái đầu tiên$argv để loại bỏ nó.

Hai giải pháp 78 byte khác (in dấu phẩy hàng đầu và dấu phẩy):

for($n=$argc-2|1;++$i<$argc*2;)$i&1?print",".$argv[$i]:$argv[$n+=2]=$argv[$i];
for($n=$argc-2;++$i<$argc*2;)$i&1?print",".$argv[$i]:$argv[1|$n+=2]=$argv[$i];

Chạy với php -nr '<code>' <arguments>hoặc thử chúng trực tuyến

Japt , 3 byte

ñÏu

Thử nó

ñÏu     :Implicit input of array
ñ       :Sort by
 Ï      :Passing the 0-based index of each through a function
  u     :  Modulo 2 of index

ó c

Thử nó

ó c     :Implicit input of array
ó       :Split into 2 arrays of every 2nd item
  c     :Flatten
        :Implicit output

Clojure / ClojureScript, 52 byte

(defn f[l](flatten(map #(take-nth 2 %)[l(rest l)])))

Được viết bằng ClojureScript REPL, cũng phải là Clojure hợp lệ.

K, 10 byte

{x@<2!!#x}

Dựa trên câu trả lời Pyth 5 byte.

Kali , 191 byte

Cái này khá dài :(
Nó đọc mảng từ args, vì vậy hãy chạy cái này vớihassium file.has 0 1 2 3 4

func main(){a=args;e,o=[]for(c=0;c<a.length;c++)if(c%2==0)e.add(a[c])else o.add(a[c])print("["+(e+o).toString().replace("{", "").replace("}", "").replace("Array", "").replace("  ", "")+"]");}

Chạy và xem mở rộng với trường hợp thử nghiệm ở đây