Cho tôi biết làm thế nào để flop


29

Là nhà khoa học máy tính, có lẽ bạn đều quen thuộc với các hoạt động danh sách cơ bản của popđẩy . Đây là những thao tác đơn giản sửa đổi danh sách các yếu tố. Tuy nhiên, bạn đã bao giờ nghe nói về hoạt động flop ? (như trong flip- flop )? Nó khá đơn giản. Cho một số n , đảo ngược n phần tử đầu tiên của danh sách. Đây là một ví dụ:

>>> a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> a.flop(4)
[4, 3, 2, 1, 5, 6, 7, 8, 9, 10]

Điều thú vị về hoạt động flop, là bạn có thể sử dụng nó để thực hiện một số điều thú vị cho một danh sách, chẳng hạn như sắp xếp nó . Chúng ta sẽ làm một cái gì đó tương tự với flops:

Đưa ra một danh sách các số nguyên, "Hàng xóm nó". Nói cách khác, sắp xếp nó sao cho mọi phần tử trùng lặp xuất hiện liên tiếp.

Điều này có thể được thực hiện với flops! Ví dụ: lấy danh sách sau:

>>> a = [3, 2, 1, 4, 3, 3, 2]
>>> a.flop(4)
[4, 1, 2, 3, 3, 3, 2]
>>> a.flop(3)
[2, 1, 4, 3, 3, 3, 2]
>>> a.flop(6)
[3, 3, 3, 4, 1, 2, 2]

Điều này dẫn chúng ta đến định nghĩa về thách thức ngày nay:

Đưa ra một danh sách các số nguyên, xuất ra bất kỳ tập hợp flops nào sẽ dẫn đến danh sách được lân cận.

Sử dụng danh sách cuối cùng làm ví dụ, bạn nên xuất ra:

4
3
6

bởi vì việc lật danh sách lên 4, rồi 3, rồi 6 sẽ dẫn đến một danh sách lân cận. Hãy nhớ rằng bạn không cần phải in danh sách ngắn nhất có thể trong danh sách mà hàng xóm liệt kê. Nếu bạn đã in:

4
4
4
3
1
1
6
2
2

thay vào đó, đây vẫn sẽ là một đầu ra hợp lệ. Tuy nhiên, bạn không bao giờ có thể xuất ra một số lớn hơn độ dài của danh sách. Điều này là bởi vì đối với một danh sách a = [1, 2, 3], gọi a.flop(4)là vô nghĩa.

Dưới đây là một số ví dụ:

#Input:
[2, 6, 0, 3, 1, 5, 5, 0, 5, 1]

#Output
[3, 7, 8, 6, 9]


#Input
[1, 2]

#Output
<any list of integers under 3, including an empty list>


#Input
[2, 6, 0, 2, 1, 4, 5, 1, 3, 2, 1, 5, 6, 4, 4, 1, 4, 6, 6, 0]

#Output
[3, 19, 17, 7, 2, 4, 11, 15, 2, 7, 13, 4, 14, 2]


#Input
[1, 1, 1, 1, 2, 2, 2, -1, 4]

#Output
[]


#Input
[4, 4, 8, 8, 15, 16, 16, 23, 23, 42, 42, 15]

#Output
[12, 7]

Hãy nhớ rằng trong mỗi ví dụ này, đầu ra đưa ra chỉ là một đầu ra hợp lệ tiềm năng. Như tôi đã nói trước đây, bất kỳ bộ flops nào lân cận danh sách đã cho là một đầu ra hợp lệ . Bạn có thể sử dụng tập lệnh python này để xác minh xem một danh sách flops đã cho có chính xác trong danh sách không.

Bạn có thể lấy đầu vào và đầu ra ở bất kỳ định dạng hợp lý. Ví dụ: đối số hàm / giá trị trả về, STDIN / STDOUT, đọc / ghi tệp, v.v ... đều hợp lệ. Như thường lệ, đây là , vì vậy hãy tạo ra chương trình ngắn nhất bạn có thể, và vui chơi! :)


3
Tôi nghe nó là fl (điểm oating) op (cương cứng).
Weijun Zhou

3
@ WeijunZhou Đó là thước đo tốc độ tính toán, để đếm các hoạt động được thực hiện với một phần cứng. vi.wikipedia.org/wiki/FLOPS
iPhoenix

3
Các bài nộp phải có tính xác định hay tôi có thể giả ngẫu nhiên cho đến khi mảng được nhóm lại không?
Dennis

3
Là flop zero được phép xuất hiện trong đầu ra?
Laikoni

4
Liên quan . NB bất kỳ câu trả lời nào cho câu hỏi đó sẽ là câu trả lời cho câu hỏi này, nhưng vì được sắp xếp là một điều kiện mạnh hơn so với "hàng xóm" nên có thể chơi golf ngoài trời để điều này có thể không phải là một bản sao (mặc dù thực tế là chỉ Trả lời cho đến nay các loại không đáng khích lệ).
Peter Taylor

Câu trả lời:


7

Haskell , 98 71 byte

h.r
h(x:s)|(a,b)<-span(/=x)s=l b:l s:h(b++r a)
h e=e
r=reverse
l=length

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

Giải trình

Đối với một danh sách độ dài nphương pháp này tạo ra 2*nflops. Nó hoạt động bằng cách nhìn vào phần tử cuối cùng của danh sách, tìm kiếm phần tử tương tự trong danh sách trước đó và lật nó sang vị trí thứ hai đến vị trí cuối cùng. Sau đó, danh sách với phần tử cuối cùng bị xóa được đệ quy "neighboured".

Đối với danh sách [1,2,3,1,2], thuật toán hoạt động như thế này:

[1,2,3,1,2]  flip longest prefix that ends in 2: flop 2
[2,1,3,1,2]  bring first element to second to last position: flop n-1 = flop 4
[1,3,1,2,2]  recursively work on n-1 list
[1,3,1,2]    there is no other 2: flop 0
[1,3,1,2]    flop n-1 = flop 3
[1,3,1,2]    recurse
[1,3,1]      flop 1
[1,3,1]      flop 2
[3,1,1]      recurse
[3,1]        flop 0
[3,1]        flop 1
 ...

Tất cả cùng nhau mang lại flops [2,4,0,3,1,2,0,1,0,0]và danh sách hàng xóm [3,1,1,2,2].


6

Ngôn ngữ Wolfram (Mathicala) , 71 byte

If[(n=Tr[1^#])<1,{},{i=Last@Ordering@#,n,n-1,i-1}~Join~#0[#~Drop~{i}]]&

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

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

Đưa ra một mảng có độ dài n, xuất ra một chuỗi các 4nflop sắp xếp mảng theo thứ tự tăng dần: đặc biệt, đặt các phần tử trùng lặp cạnh nhau.

Ý tưởng là để sắp xếp một mảng, chúng ta di chuyển phần tử lớn nhất của nó đến cuối, và sau đó sắp xếp các n-1phần tử đầu tiên của mảng. Để tránh thực hiện thao tác flop, chúng tôi di chuyển phần tử lớn nhất đến điểm cuối theo cách không làm phiền các phần tử khác:

{3, 2, 1, 5, 3, 3, 2}    starting array, with largest element in position 4
{5, 1, 2, 3, 3, 3, 2}    flop 4 to put the largest element at the beginning
{2, 3, 3, 3, 2, 1, 5}    flop 7 to put the largest element at the end
{1, 2, 3, 3, 3, 2, 5}    flop 6 (7-1) to reverse the effect of flop 7 on other elements
{3, 2, 1, 3, 3, 2, 5}    flop 3 (4-1) to reverse the effect of flop 4 on other elements

Nói chung, nếu phần tử lớn nhất ở vị trí i, chuỗi flop di chuyển nó đến cuối là i, n, n-1, i-1.


Bạn có thể di chuyển phần tử lớn nhất đến cuối chỉ bằng i, n. Tại sao sau đó làm gì n-1, i-1? Không cần một loại ổn định .
Peter Taylor

@PeterTaylor Tôi không nghĩ câu trả lời thực sự thực hiện flops, thay vào đó, nó loại bỏ phần tử lớn nhất mỗi lần và đưa ra kết quả tương đương với thao tác đó về mặt flops.
Neil


3

Thạch , 19 17 byte

ỤỤạ‘Ḣ
ỤÇÐƤĖµUż’ṚF

Sắp xếp danh sách.

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


Tôi nghĩ rằng ỤŒ¿’Æ!‘ṚĖµUż’ṚFloại ngược lại Œ¿là modulo L!.
Jonathan Allan

Vì bất kỳ lý do gì, điều đó không hoạt động cho trường hợp thử nghiệm cuối cùng, điều đó có thể có nghĩa là mã của tôi cũng sẽ thất bại đối với một số trường hợp cạnh tối nghĩa ...
Dennis

Và nó thực sự thất bại cho đầu vào [4, 3, 2, 1, 3]. Bummer.
Dennis

Ôi, ôi; thật là xấu hổ.
Jonathan Allan

Ụ>Ṫ$ƤSạỤĖµUż’ṚFtiết kiệm 2 byte bằng cách thay thế liên kết của trình trợ giúp.
dặm

2

Sạch , 88 byte

Tôi nghĩ rằng có một người có thể ngắn hơn với lính canh, nhưng tôi chưa tìm thấy nó.

import StdEnv
$[h:t]#(a,b)=span((<>)h)t
=map length[b,t]++ $(b++r a)
$e=e
r=reverse

$o r

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

Là một chức năng theo nghĩa đen. Hoạt động theo cách tương tự như câu trả lời Haskell của Laikoni , nhưng chơi golf hơi khác, và tất nhiên cũng bằng một ngôn ngữ khác.


1

JavaScript, 150 byte

(a,f=n=>(a=[...a.slice(0, n).reverse(),...a.slice(n)],n),l=a.length,i=0)=>a.reduce(c=>[...c,f(a.indexOf(Math.max(...a.slice(0, l-i)))+1),f(l-i++)],[])

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

JavaScript, 151 byte

a=>{f=n=>(a=[...a.slice(0,n).reverse(),...a.slice(n)],n),r=[];for(i=a.length+1;--i>0;)r.push(f(a.indexOf(Math.max(...a.slice(0, i)))+1),f(i));return r}

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

Cả hai về cơ bản sắp xếp mảng bằng cách lật số tối đa về đầu và sau đó lật nó về phía sau, lặp lại điều này với mảng còn lại. Cái đầu tiên sử dụng giảm, cái thứ hai sử dụng vòng lặp for.

Ung dung:

array => {
  let flop = n => {
    array = [...array.slice(0, n).reverse(), ...array.slice(n)]; 
    return n;
  }
  let flops = [];
  for (let i = array.length + 1; --i > 0;) 
  {
    let maxIndex = array.indexOf(Math.max(...array.slice(0, i)));
    flops.push(flop(maxIndex + 1), flop(i));
  }
  return flops;
}

0

Perl 5.10 (hoặc cao hơn), 66 byte

Bao gồm +3cho -n Việc use 5.10.0đưa ngôn ngữ lên cấp độ perl 5.10 được coi là miễn phí

#!/usr/bin/perl -n
use 5.10.0;
$'>=$&or$.=s/(\S+) \G(\S+)/$2 $1/*say"$. 2 $."while$.++,/\S+ /g

Chạy với đầu vào là một dòng trên STDIN:

flop.pl <<< "1 8 3 -5 6"

Sắp xếp danh sách bằng cách liên tục tìm thấy bất kỳ sự đảo ngược nào, lật nó ra phía trước sau đó lật ngược lại và lật ngược mọi thứ về vị trí cũ.

Thật khó để có được trong cùng một sân bóng như con trăn trên cái này :-)


Khi sử dụng trang web của chúng tôi, bạn xác nhận rằng bạn đã đọc và hiểu Chính sách cookieChính sách bảo mật của chúng tôi.
Licensed under cc by-sa 3.0 with attribution required.