Con gái tôi đã có bài tập sau đây cho bài tập về nhà toán học của mình. Hãy tưởng tượng sáu người bạn sống trên một dòng, được đặt tên là E, F, G, H, J và K. Vị trí của họ trên dòng được chỉ định (không theo tỷ lệ) bên dưới:

Do đó, F sống năm đơn vị từ E và hai đơn vị từ G, v.v.

Nhiệm vụ của bạn: tạo một chương trình xác định đường dẫn truy cập chính xác từng người bạn một lần với tổng độ dài n đơn vị, lấy vị trí của bạn bè và n làm đầu vào. Nó sẽ báo cáo đường dẫn nếu nó tìm thấy nó (ví dụ: trong chiều dài 17, nó có thể báo cáo "E, F, G, H, J, K" và nó sẽ thoát ra một cách duyên dáng nếu không có giải pháp nào tồn tại. một giải pháp vô căn cứ trong Mathicala với 271 byte. Tôi nghi ngờ nó có thể chính xác hơn thế nhiều.

J, 54 byte

Đầu ra một tuyến chính xác. Nếu không có tuyến đường tồn tại, nó không có kết quả.

   f=.4 :'{.(x=+/|:2|@-/\"#.s A.y)#(s=.i.!6)A.''EFGHJK'''

   62 f 0 5 7 13 16 17
GJEKFH

Mã 52 byte xuất ra tất cả các tuyến (một trên mỗi dòng):

f=.4 :'(x=+/|:2|@-/\"#.s A.y)#(s=.i.!6)A.''EFGHJK'''

Mã 38 byte xuất ra các vị trí thay vì các chữ cái:

f=.4 :'p#~x=+/|:2|@-/\"#.p=.(i.!6)A.y'

Toán học, 55 hoặc 90 byte

Toán học bạn nói gì? ;)

FirstCase[Permutations@#,p_/;Tr@Abs@Differences@p==#2]&

Đây là một chức năng ẩn danh trước tiên nhận vị trí của bạn bè (theo bất kỳ thứ tự nào) và sau đó là độ dài mục tiêu. Nó trở lại Missing[NotFound], nếu không có con đường như vậy tồn tại.

FirstCase[Permutations@#,p_/;Tr@Abs@Differences@p==#2]&[{0, 5, 7, 13, 16, 17}, 62]
(* {7, 16, 0, 17, 5, 13} *)

Tôi có thể lưu bốn byte nếu trả lại tất cả các đường dẫn hợp lệ ( FirstCase-> Cases).

Trả về một chuỗi các chuỗi phức tạp hơn một chút:

FromCharacterCode[68+#]&/@Ordering@FirstCase[Permutations@#,p_/;Tr@Abs@Differences@p==#2]&

Python 2, 154 148 byte

(hoặc 118 byte cho giải pháp chung)

Chương trình này chấp nhận một dòng có danh sách và số nguyên như '[0, 5, 7, 13, 16, 17], n' trên stdin và in một đường dẫn trên đầu ra có độ dài n hoặc không có gì nếu không thể.

# echo "[0, 5, 7, 13, 16, 17], 62" | python soln.py 
['G', 'J', 'E', 'K', 'F', 'H']

Thật khó để viết các chương trình nhỏ bằng Python yêu cầu hoán vị. Mà nhập khẩu và sử dụng là rất tốn kém.

from itertools import*
a,c=input()
for b in permutations(a):
 if sum(abs(p-q)for p,q in zip(b[1:],b))==c:print['EFGHJK'[a.index(n)]for n in b];break

Nguồn cho yêu cầu OP trước khi khai thác:

from itertools import*

puzzle, goal = input()
for option in permutations(puzzle):
    if sum(abs(p-q) for p,q in zip(option[1:], option)) == goal :
        print ['EFGHJK'[puzzle.index(n)] for n in option];
        break

Giải pháp chung (không rút gọn):

from itertools import*

puzzle, goal = input()
for option in permutations(puzzle):
    if sum(abs(p-q) for p,q in zip(option[1:], option)) == goal :
        print option;
        break

Do thuật toán đơn giản và số lượng kết hợp lớn, việc thực hiện cho hơn 20 vị trí ban đầu sẽ rất chậm.

J (48 hoặc 65)

Tôi đưa ra giả thuyết rằng điều này có thể bị đánh golf nhiều hơn. Hãy sử dụng nó như một điểm khởi đầu để chơi gôn hơn nữa

]A.~[:I.(=([:([:+/}:([:|-)}.)"1(A.~([:i.[:!#))))

Hoặc với các chữ cái:

([:I.(=([:([:+/}:([:|-)}.)"1(A.~([:i.[:!#)))))A.[:(a.{~65+[:i.#)]

Những gì nó làm:

   62 (]A.~[:I.(=([:([:+/}:([:|-)}.)"1(A.~([:i.[:!#))))) 0 5 7 13 16 17
 7 16  0 17  5 13
 7 16  5 17  0 13
 7 17  0 16  5 13
 7 17  5 16  0 13
13  0 16  5 17  7
13  0 17  5 16  7
13  5 16  0 17  7
13  5 17  0 16  7

(Tôi hy vọng định dạng I / O này ổn ...)

Làm thế nào nó làm điều đó:

(A.~([:i.[:!#))

Tạo ra tất cả các hoán vị của đầu vào

([:+/}:([:|-)}.)"1

Tính khoảng cách

(]A.~[: I. (= ([:distance perms)))

Nhìn thấy kết quả giống như đầu vào và tạo lại các hoán vị đó (tôi nghi ngờ một số ký tự có thể bị xóa ở đây)

Với các chữ cái:

((a.{~65+[:i.#))

Tạo danh sách n chữ cái đầu tiên, trong đó n là độ dài của danh sách đầu vào

indices A. [: letters ]

làm như trên

Tháng Mười, 73

function r=t(l,d,s)r=perms(l)(find(sum(abs(diff(perms(d)')))==s,1),:);end

Thực sự không có việc đánh gôn này, vì vậy hãy để tôi giải thích ... từ trong ra ngoài, chúng tôi hoán vị tất cả các khoảng cách, sau đó cho mỗi lần hoán vị, chúng tôi lấy sự khác biệt giữa các ngôi nhà, lấy giá trị tuyệt đối làm khoảng cách, thêm chúng vào lên, tìm chỉ số của hoán vị đầu tiên với khoảng cách mong muốn, và hoán vị các chữ cái và tìm hoán vị cụ thể của các chữ cái.

octave:15> t(["E" "F" "G" "H" "J" "K"],[0 5 7 13 16 17],62)
ans = HEJFKG

đó là 13-0-16-5-17-7 => 13 + 16 + 11 + 12 + 10 = 62.

octave:16> t(["E" "F" "G" "H" "J" "K"],[0 5 7 13 16 17],2)
ans = 

(trống cho đầu vào không thể)

Matlab (86)

x=input('');X=perms(1:6);disp(char(X(find(sum(abs(diff(x(X).')))==input(''),1),:)+64))

Ví dụ trong đó một giải pháp tồn tại:

>> x=input('');X=perms(1:6);disp(char(X(find(sum(abs(diff(x(X).')))==input(''),1),:)+64))
[0, 5, 7, 13, 16, 17]
62
DBFAEC
>>

Ví dụ trong đó một giải pháp không tồn tại:

>> x=input('');X=perms(1:6);disp(char(X(find(sum(abs(diff(x(X).')))==input(''),1),:)+64))
[0, 5, 7, 13, 16, 17]
100
>> 

Matlab (62)

Nếu định dạng đầu ra có thể được nới lỏng bằng cách tạo các vị trí thay vì các chữ cái và tạo ra một ma trận trống nếu không có giải pháp nào tồn tại:

X=perms(input(''));X(find(sum(abs(diff(X.')))==input(''),1),:)

Ví dụ trong đó một giải pháp tồn tại:

>> X=perms(input(''));X(find(sum(abs(diff(X.')))==input(''),1),:)
[0, 5, 7, 13, 16, 17]
62
ans =
    13     5    17     0    16     7

Ví dụ trong đó một giải pháp không tồn tại:

>> X=perms(input(''));X(find(sum(abs(diff(X.')))==input(''),1),:)
[0, 5, 7, 13, 16, 17]
62
ans =
   Empty matrix: 0-by-6

Matlab (54)

Nếu chương trình chấp nhận để cung cấp tất cả các đường dẫn hợp lệ :

X=perms(input(''));X(sum(abs(diff(X.')))==input(''),:)

Ví dụ trong đó một giải pháp tồn tại:

>> X=perms(input(''));X(sum(abs(diff(X.')))==input(''),:)
[0, 5, 7, 13, 16, 17]
62
ans =
    13     5    17     0    16     7
    13     5    16     0    17     7
    13     0    17     5    16     7
    13     0    16     5    17     7
     7    16     5    17     0    13
     7    16     0    17     5    13
     7    17     5    16     0    13
     7    17     0    16     5    13

Haskell, 109 byte

import Data.List
a%b=abs$snd a-snd b
n#l=[map(fst)p|p<-permutations(zip['E'..]l),n==sum(zipWith(%)p(tail p))]

Ví dụ sử dụng: 17 # [0, 5, 7, 13, 16, 17]đầu ra tất cả các đường dẫn hợp lệ, nghĩa là ["EFGHIJ","JIHGFE"]. Nếu không có đường dẫn hợp lệ, danh sách trống []sẽ được trả về.

Danh sách các chữ cái bao gồm I(hy vọng điều đó tốt).

Cách thức hoạt động: lập danh sách các (name, position)cặp, hoán vị và lấy những nơi có độ dài đường dẫn bằng nvà loại bỏ phần vị trí.