Kızım matematik ödevi için aşağıdaki ödeve sahipti. E, F, G, H, J ve K adında bir çizgi üzerinde yaşayan altı arkadaş düşünün. Hattaki pozisyonları aşağıda belirtildiği gibidir (ölçekli değil):

Böylece F, E'den beş birim ve G'den iki birim yaşar.

Ödeviniz: her bir arkadaşı tam olarak bir kez ziyaret eden ve toplam n birim uzunluğundaki bir yolu tanımlayan , arkadaşların ve n'in konumlarını girdi olarak alan bir program hazırlayın. Bulursa yolu rapor etmelidir (örneğin, uzunluk 17 için "E, F, G, H, J, K" rapor edebilir ve herhangi bir çözüm yoksa zarif bir şekilde çıkmalıdır. Değeri için tamamladım 271 baytta Mathematica'da çözülmemiş bir çözüm ... Bundan daha kısaca mümkün olabileceğinden şüpheleniyorum.

J, 54 bayt

Bir doğru yol verir. Eğer rota yoksa hiçbir şey çıkarmaz.

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

   62 f 0 5 7 13 16 17
GJEKFH

Tüm güzergahları veren 52 bayt kod (her satıra bir tane):

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

Harfler yerine konumlar veren 38 baytlık kod:

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

Mathematica, 55 veya 90 bayt

Mathematica dedin mi? ;)

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

Bu, önce arkadaşlarının pozisyonlarını (herhangi bir sırada) ve daha sonra hedef uzunluğu alan anonim bir işlevdir. Missing[NotFound]Böyle bir yol yoksa geri döner .

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

Tüm geçerli yolları döndürmeye izin verilirse dört bayt kaydedebilirim ( FirstCase-> Cases).

Bir dizi dizeyi döndürmek biraz daha zahmetlidir:

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

Python 2, 154 148 bayt

(veya genel çözüm için 118 bayt)

Bu program stdin'de bir liste ve '[0, 5, 7, 13, 16, 17], n' gibi bir tamsayı olan bir satırı kabul eder ve imkansızsa n uzunluğunun çıktısında bir yol yazdırır.

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

Python'da permütasyon gerektiren küçük programlar yazmak zordur. Bu ithalat ve kullanım çok masraflıdır.

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

Küçültücüden önceki OP gereksiniminin kaynağı:

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

Genel çözüm (küçültülmemiş):

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

Basit algoritma ve çok sayıda kombinasyon nedeniyle, 20'den fazla başlangıç ​​pozisyonu için yürütme çok yavaş olacaktır.

J (48 veya 65)

Bunun çok daha fazla cehennem olabileceğini varsayıyorum. Bunu daha fazla golf oynamak için bir atlama noktası olarak kullanmaktan çekinmeyin

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

Veya harflerle:

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

Bu ne yapar:

   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

(Umarım bu G / Ç formatı uygundur ...)

Nasıl yapar:

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

Girdinin tüm permütasyonlarını üretir

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

Mesafeyi hesaplar

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

Hangi sonuçların girişle aynı olduğunu görür ve bu permütasyonları yeniden oluşturur (bazı karakterlerin burada tıraş edilebileceğinden şüpheleniyorum)

Harflerle:

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

İlk n harfinin bir listesini oluşturun; burada n, giriş listesinin uzunluğudur

indices A. [: letters ]

yukarıdaki ile aynı şeyi yapar

Oktav, 73

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

Gerçekten golf oynamak yok, bu yüzden açıklamaya çalışalım ... içeriden dışarıya, tüm mesafelere izin veriyoruz, o zaman her permütasyon için evler arasındaki farkları alıyoruz, mutlak değeri bir mesafe olarak alıyoruz, onları ekliyoruz yukarı, ilk permütasyonun indeksini istenen mesafe ile bulun ve harflere izin verin ve bu harflerin belirli permütasyonunu bulun.

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

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 = 

(imkansız girişler için boş)

Matlab (86)

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

Bir çözümün var olduğu örnek:

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

Bir çözümün bulunmadığı örnek:

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

Eğer çıkış biçimi rahat olabilir harfler yerine duruşlara ve hiçbir çözüm yoksa boş matrisi üretmek için:

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

Bir çözümün var olduğu örnek:

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

Bir çözümün bulunmadığı örnek:

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

Programın tüm geçerli yolları sağlaması kabul edilebilirse :

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

Bir çözümün var olduğu örnek:

>> 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 bayt

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

Kullanım örneği: 17 # [0, 5, 7, 13, 16, 17]geçerli tüm yolları çıktılayan, yani ["EFGHIJ","JIHGFE"]. Geçerli bir yol yoksa, boş liste []döndürülür.

Harflerin listesi şunları içerir I(umarım bu iyidir).

Nasıl çalışır: bir (name, position)çift listesi yapın , yol uzunluğuna eşit olanlara izin verin ve bunları alın nve konum parçasını kaldırın.