এটা আবার হ্যালোইন!

Question

সমস্যার বিবরণ

আমরা সকলেই একটি টোমিক্স পছন্দ করি (কারণ এটি সেরা ক্যান্ডি), তবে এটি বাচ্চাদের প্রথম হ্যালোইন --- আমরা তাদের জন্য প্রতিটি ধরণের ক্যান্ডির কমপক্ষে একটি নিতে পারি। প্রতিটি হ্যালোইন নাম্বারলাইন অ্যাভিনিউয়ের সমস্ত বাসিন্দারা একটি ইমেল প্রেরণ করে জানিয়েছিল যে তারা এই বছর কী ধরনের মিছরি উপহার দিবে।

উহু! এবং আমরা 1D বিশ্বে বাস করি।

অন্যভাবে নয়, কিছু উপায়ে ব্যতিক্রমী অলস হওয়ার কারণে, আমরা রাস্তায় ঘরগুলি তাদের অবস্থান দেওয়ার জন্য একটি মানচিত্র তৈরি করেছি। আমরা তাদের কাছে থাকা ক্যান্ডির প্রকারগুলিও লক্ষ করেছি। আমরা এই বছরের জন্য তৈরি মানচিত্র এখানে:

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

বাচ্চাদের ছোট্ট পায়ের খাতিরে , প্রতিটি ধরণের ক্যান্ডির কমপক্ষে একটি সংগ্রহ করার জন্য আমাদের আশেপাশের যে কোনও বাড়িতে ছোট ছোট হাঁটাচলা শুরু করতে হবে find

উদাহরণ

দু'জন ব্যবহারকারীর (শেগি সহ) অনুরোধে আমি কয়েকটি কাজের উদাহরণে টস করব। আশা করি এটি পরিষ্কার হয়ে যায়। :) ইনপুট:

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

আউটপুট:

[1, 2, 3]

অন্য মানচিত্র এবং সমাধান ...

ইনপুট:

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

আউটপুট :

[0, 1, 2]

আমরা স্থানাঙ্ক 9 থেকে 6 এবং 1 টি বাড়িতে ক্যান্ডি সংগ্রহ করা বাড়িতে শুরু করতে পারি That এটি 8 ইউনিট হাঁটার মাধ্যমে মিছরি কোটা পূরণ করে, তবে এটি কি সংক্ষিপ্ততম সমাধান?

বিধি

সংক্ষিপ্ততম সমাধানে দেখার জন্য প্রবেশদ্বারগুলি অবশ্যই একই কাঠামোগত একক যুক্তি গ্রহণ করবে এবং বাড়ির সূচকগুলিকে আউটপুট দেবে।

টিপিক্যাল কোড গল্ফের নিয়মগুলি প্রয়োগ হয়: বাইট জিতে সংক্ষিপ্ততম সঠিক সমাধান!

পিএস এটি ছিল একটি আন্তর্জাতিক সাক্ষাত্কারের প্রশ্ন যা বিশ্বের অন্যতম বৃহত্তম প্রযুক্তি সংস্থা আমাকে দিয়েছে। আপনি যদি গল্ফ পছন্দ করেন না, তবে কোনও ও (কে * এন) সময় সমাধান সন্ধান করার চেষ্টা করুন যেখানে কে ক্যান্ডি ধরণের সংখ্যা এবং এন হল ঘরের সংখ্যা।

সম্পাদন করা

জোনাথন অ্যালান যেমন উল্লেখ করেছেন, এই ক্ষেত্রে "সূচকগুলি" কী বোঝায় তা নিয়ে কিছুটা বিভ্রান্তি রয়েছে। আমরা আর্গুমেন্ট তালিকায় ঘরগুলির অবস্থান আউটপুট করতে চাই এবং লেনের স্থানাঙ্কগুলি নয়।

Comments

এটি একটি কাজের উদাহরণ এবং কিছু পরীক্ষার ক্ষেত্রে প্রয়োজন।

— শেগি

আমরা কি দুটি যুক্তি নিতে পারি; বাড়ির নম্বরগুলির তালিকা এবং ক্যান্ডির ধরণের সম্পর্কিত একটি তালিকা?

— অ্যাডম

@ কেভিন ক্রুইজসেন না: সংক্ষিপ্ততম সমাধানে ঘরের সূচকগুলি আউটপুট আউট করুন

— অ্যাডাম

আমি ধরে নিয়েছি "সূচকগুলি" এবং "অবস্থানগুলি" সমার্থক (অর্থাত্ নম্বলাইন অ্যাভিনিউতে ঠিকানাগুলি আমাদের ফিরে আসা উচিত) কী ভুল?

— জনাথন অ্যালান

@ কেভিন ক্রুজসেন দুর্দান্ত প্রশ্ন! নম্বরগুলি ইনপুটটিতে ক্রমযুক্ত হওয়ার নিশ্চয়তা রয়েছে। এবং আমি এই অনুমানটিকে অনুমতি দেব যে সংখ্যার সাথে আমি জানি সমস্ত ক্যান্ডিগুলি তাদের বানান (হ্যান্ড্রেড গ্র্যান্ডস এবং থ্রি মুস্কেটিয়ারস) হিসাবে স্ট্রিংগুলিতে কোনও অঙ্ক নেই। :)

— Qfwfq

Answer 1

জেলি , 16 বাইট

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

নিম্নতম থেকে সর্বোচ্চ নাম্বার অ্যাভিনিউ ঘরগুলিতে বাছাই করা তালিকায় বর্ণিত ইনপুট গ্রহণ করা এক মোনাডিক লিংক (যদি আমাদের কোনও অর্ডার গ্রহণের প্রয়োজন হয় তবে আমরা একটি প্রেন্ডিং করতে পারি Ṣ) যা সর্বনিম্ন সংখ্যাযুক্ত বাড়ি থেকে শুরু করে অ্যাভিনিউতে ভ্রমণ করে সবচেয়ে সংক্ষিপ্ত পথ দেয়।

এটি অনলাইন চেষ্টা করুন!

আমরা সবাই এই ধরনের সবচেয়ে কম পাথ চিহ্ন বাইট প্রতিস্থাপন এটি করতে চান, ÞḢসঙ্গে ÐṂ; এটিও 16 বাইট।

কিভাবে?

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

Comments

খুশী হলাম। আপনার ব্যাখ্যার জন্য, আমি মনে করি আপনি দ্বিতীয় দ্রুতটির জন্য সর্বাধিক মানে।

— নিক কেনেডি

হ্যাঁ যে আমি করেছি।

— জোনাথন অ্যালান

Answer 2

পাইথন 2 , 133 130 127 বাইট

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

এটি অনলাইন চেষ্টা করুন!

Answer 3

05 এ বি 1 ই , 22 বাইট

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

ধরে নিই ইনপুট-তালিকার সংখ্যাগুলি সর্বনিম্ন থেকে সর্বোচ্চে বাছাই করা হয়েছে।
যদি একাধিক সমাধান পাওয়া যায় তবে এটি সমস্তটি আউটপুট দেয়।

এটি অনলাইনে চেষ্টা করুন।

ব্যাখ্যা:

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

Answer 4

পার্ল 6 , 70 বাইট

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

এটি অনলাইন চেষ্টা করুন!

Answer 5

হাস্কেল , 343 372 বাইট

কেবলমাত্র ASCII- এর উন্নতির জন্য ধন্যবাদ , মন্তব্যগুলিতে তিনি প্রস্তাবিত একটি 271 বাইটের বৈকল্পিকও রয়েছে :)

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

এটি অনলাইন চেষ্টা করুন!

---

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

---

প্রথম প্রচেষ্টা

Comments

আপনার কেবলমাত্র এই টিউপলের তৃতীয় উপাদানটি ফিরে আসা উচিত এবং আপনার আমদানির পরে একটি বহিরাগত নিউলাইন রয়েছে

— এএসসিআইআই-

315? (এখনও কেবল তৃতীয় উপাদানটি ফিরতে হবে)

— এএসসিআইআই-

আসলে আসলে ... এটি দ্বিতীয় টেস্টকেসটিতেও কাজ করে না

— ASCII- কেবল

সুতরাং হ্যাঁ আপনি দৈর্ঘ্যটি হার্ডকোড করতে পারবেন না

— ASCII- কেবল

358

— এএসসিআইআই-কেবল

Answer 6

ও (কে * এন) সময় সমাধান, ও (কে * এন) স্পেস সহ

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

সুতরাং, আমাদের অ্যালগরিদম হ'ল:

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