Sorun Açıklaması

Hepimiz bir Twix'i seviyoruz (çünkü en iyi şeker olduğu için), ama bu çocukların ilk Cadılar Bayramı --- onlar için her şeker türünden en az birini almalıyız. Her Halloween, Numberline caddesinin tüm sakinlerine bu yıl ne tür şeker vereceklerini belirten bir e-posta gönderir.

Ah! Ve 1B dünyasında yaşıyoruz.

Bazı açılardan son derece tembel ve diğerlerinde değil, cadde boyunca konumlarını veren evlerin haritasını çıkardık. Ayrıca şeker çeşitlerini de kaydettik. İşte bu yıl için yaptığımız harita:

 [(-2, {"Kisses", "KitKats"}),
 (1, {"KitKats", "Peanut Butter Cups"}),
 (6, {"Kisses", "Twix"}),
 (9, {"Skittles"}),
 (10, {"Twix"})]

Çocukların küçük bacakları uğruna , her şeker türünden en az birini toplamak için mahalledeki herhangi bir evde başlayan en kısa yürüyüşü bulmamız gerekir .

Örnekler

Birkaç kullanıcının (Shaggy dahil) isteği üzerine, işe yarayan bazı örneklere atıyorum. Umarım bu şeyleri temizler. :) Giriş:

 [(-2, {"Kisses", "KitKats"}),
 (1, {"KitKats", "Peanut Butter Cups"}),
 (6, {"Kisses", "Twix"}),
 (9, {"Skittles"}),
 (10, {"Twix"})]

Çıktı:

[1, 2, 3]

Başka bir harita ve çözüm ...

Giriş:

[(-3, {"KitKats", "Twix"}),
(-1, {"Hundred Grands"}),
(3, {"Kisses"}),
(12, {"Hundred Grands", "Twix", "KitKats"})]

Çıktı :

[0, 1, 2]

Koordinat 9'da ev 6 ve 1'de şeker toplamaya başlayabiliriz. Bu, şeker kotasını 8 birim yürerek doldurur, ancak en kısa çözüm bu mudur?

kurallar

Girişler , örneğe benzer şekilde yapılandırılmış tek bir argüman almalı ve evlerin endekslerini en kısa çözümde ziyaret etmelidir .

Tipik kod golf kuralları geçerlidir: baytlarda en kısa doğru çözüm kazanır!

Not: Bu bana dünyanın en büyük teknoloji şirketlerinden biri tarafından verilen röportaj sorusuydu. Golften hoşlanmıyorsanız, k şeker tipi sayısı ve n ev sayısı olan O (k * n) zaman çözümünü bulmaya çalışın.

Düzenle

Jonathon Allan'ın işaret ettiği gibi, bu durumda "endekslerin" ne anlama geldiği konusunda bazı karışıklıklar var. Şerit üzerindeki koordinatlarını değil , evlerin argüman listesindeki konumlarını çıkarmak istiyoruz .

Jöle , 16 bayt

ŒPṪ€ẎQLƲÐṀẎISƊÞḢ

ṢEn düşük numaralı evden başlayıp Caddeye giderken en kısa yolu veren, en düşük Numberline Avenue evlerinden sıralanan bir listede açıklandığı gibi girişi kabul eden bir monadik Bağlantı (herhangi bir siparişi kabul etmemiz gerekiyorsa a .

Çevrimiçi deneyin!

Tüm bu tür kısa yollar arka bayt yerine bulmak için, ÞḢile ÐṂ; bu da 16 bayttır.

Nasıl?

ŒPṪ€ẎQLƲÐṀẎISƊÞḢ - Link: list of [index, candies]
ŒP               - power-set
        ÐṀ       - keep those for which this is maximal:
       Ʋ         -   last four links as a monad:
  Ṫ€             -     tail €ach -- this removes the candies lists from the current list
                 -                  and yields them for use now
    Ẏ            -     tighten (to a flat list of candies offered by these hoses)
     Q           -     de-duplicate (get the distinct candies offered)
      L          -     length (how many distinct candies are on offer)
              Þ  - sort (now just the indexes of remaining sets due to Ṫ) by:
             Ɗ   -   last three links as a monad:
          Ẏ      -     tighten (to a flat list of indexes since Ṫ leaves a list behind)
           I     -     incremental differences (distances between houses)
            S    -     sum
               Ḣ - head (get the first)

Python 2 , 133 130 127 bayt

def f(l):r=range(len(l));v,c=zip(*l);print min((v[j]-v[i],r[i:j+1])for i in r for j in r if s(*c)==s(*c[i:j+1]))[1]
s={0}.union

Çevrimiçi deneyin!

05AB1E , 22 bayt

æʒ€θ˜I€θ˜åP}€€нD€¥OWQÏ

Giriş listesindeki sayıların en düşükten en yükseğe doğru sıralandığını varsayar.
Birden fazla çözüm bulunursa, bunların hepsini verir.

Çevrimiçi deneyin.

Açıklama:

æ            # Get the powerset (all possible combinations) of the (implicit) input-list
 ʒ           # Filter this list of combinations by:
  €θ         #  Get the last items of each (the list of strings)
    ˜        #  Flatten the list
  I          #  Get the input-list again
   €θ˜       #  Get the last items of each (the list of strings) flattened as well
      å      #  Check for each if it is in the list of strings of this combination
       P     #  Check if all are present
 }           # Close the filter (we now have all combinations, containing all unique strings)
  €€н        # Only leave the first items of each item in the combination (the integers)
     D       # Duplicate this list
      €¥     # Get the deltas (forward differences) of each
        O    # Sum these deltas
         W   # Get the lowest sum (without popping the list)
          Q  # Check for each if it's equal to this minimum
           Ï # And only leave the list of integers at the truthy indices
             # (which are output implicitly as result)

Perl 6 , 70 bayt

{grep({.[@^i;1]⊇.[*;1]},combinations ^$_).min:{[-] .[@^i[*-1,0];0]}}

Çevrimiçi deneyin!

Haskell , 343 372 bayt

@ Yalnızca iyileştirmeler için ASCII sayesinde , yorumlarda önerdiği 271 baytlık bir varyant da var :)

import Data.List
import Data.Function
f s=subsequences(map(\a@(x,y)->(x,y,[(a`elemIndices`s)!!0]))s)
g f s=if f*s<=0 then f+abs f+abs s else f+abs(f-s)
h=foldl(\(a,b,c)(d,e,f)->(g a d,nub(b++e),c++f))(0,[],[])
i s=map h(filter(not.null)s)
l m=filter(\(_,x,_)->length x==(maximum$map(\(_,x,_)->length x)m))m
m=minimumBy(compare`on`(\(p,_,_)->p))
n s=(\(_,_,l)->l)$m$l$i$f s

Çevrimiçi deneyin!

Ungolfed

import Data.List
import Data.Function

allPaths :: [(Integer, [String])] -> [[(Integer, [String], [Int])]]
allPaths xs = subsequences(map (\a@(x,y) -> (x,y,[(a`elemIndices`s) !! 0])) s)

pathLength :: Integer -> Integer -> Integer
pathLength f s = if f*s <= 0 then f + abs f + abs s else f + abs(f - s)

traversePath :: [(Integer, [String], [Int])] -> (Integer, [String], [Int])
traversePath = foldl (\(n1, a1, c1) (n2, a2, c2) -> (pathLength n1 n2, nub (a1 ++ a2), c1 ++ c2)) (0, [], [])

allTraversedPaths :: [[(Integer, [String], [Int])]] -> [(Integer, [String], [Int])]
allTraversedPaths xs = map traversePath (filter (not . null) xs)

getCompletePaths :: [(Integer, [String], [Int])] -> [(Integer, [String], [Int])]
getCompletePaths m = filter (\(_,x,_) -> length x == ( maximum $ map (\(_,x,_) -> length x) m)) m

getFastestPath :: [(Integer, [String], [Int])] -> (Integer, [String], [Int])
getFastestPath = minimumBy (compare `on` (\(p, _, _) -> p))

getPath :: [(Integer, [String])] -> (Integer, [String], [Int])
getPath xs = (\(_,_,l) -> l) getFastestPath $ getCompletePaths $ allTraversedPaths $ allPaths xs

İlk girişim

O (k * n) zaman çözeltisi, O (k * n) boşluklu

$x_i$$i$$0 \le i < n$$x_i$$c_i$$i$

$i_1$$j_1$$i_0 < i_1$$i_0$$j_0$$i_0 \le j_0$

Böylece, algoritmamız:

// A[k] is the number of each candy we get from the first k houses
A := array of n bags
A[0] := {}
for k := 0 to n - 1
  A[k] := A[k - 1] + c[k - 1]
end
best_distance := ∞
best_i := -1
best_j := -1
// Find the range [i, j] such that we get all candy types
j := n
for i := n - 1 to 0
  while j > i and (A[j - 1] - A[i]) has all candy types
    j := j - 1
  end
  if (A[j] - A[i]) does not have all candy types then continue end
  distance = x[j - 1] - x[i]
  if distance < best_distance then
    best_distance = distance
    best_i = i
    best_j = j
  end
end
return best_i ..^ best_j

$A$$O(k)$$O(nk)$$n$$n$$n$$O(n)$$O(nk)$$O(k)$$O(nk)$