Arka fon

3Blue1Brown'un kolye bölme problemi (veya çaldığı kolye problemi olarak adlandırdığı gibi) ve Borsuk-Ulam teoremiyle ilişkisi hakkındaki son videosundan ilham aldım .

Bu problemde, iki hırsız çeşitli mücevher türlerinden oluşan değerli bir kolye çaldı. Her mücevher türünün çift sayısı vardır ve hırsızlar her mücevher türünü ikisi arasında eşit olarak bölmek ister. Yakalama, kolyeyi bir dizi bitişik parçaya bölerek ve segmentleri ikisi arasında dağıtarak yapmaları gerektiğidir.

Burada gösterilen dört mücevher tip bir örnektir S, E, Dve R(sırasıyla safir, yakut, elmas ve yakut, için). Diyelim ki kolye aşağıdaki gibidir:

[S,S,S,E,S,D,E,R,S,R,E,S,S,S,D,R,E,E,R,E,D,E,R,R,D,E,E,E]

Orada 8safir, 10zümrüt, 4elmas ve 6yakut. Kolyeyi aşağıdaki gibi bölebiliriz:

[[S],[S],[S,E,S,D,E,R,S],[R,E,S,S,S,D,R,E,E,R,E,D,E],[R,R,D,E,E,E]]

Sonra bir hırsıza birinci, üçüncü ve beşinci bölümleri ve diğer hırsıza ikinci ve dördüncü bölümleri verirsek, her biri 4safir, 5zümrüt, 2elmas ve 3yakutla sonuçlanır :

[S],    [S,E,S,D,E,R,S],                            [R,R,D,E,E,E]
    [S],                [R,E,S,S,S,D,R,E,E,R,E,D,E],

0-İndexing kullanarak , bu kesimler endekslerde meydana gelir [1,2,9,22].

Hedef

Böyle adil bir bölünmenin , mücevher türlerinin sayısı olan çoğu nkesimde her zaman yapılabileceği ortaya çıkıyor n. Göreviniz, bir kolyeyi giriş olarak alan ve minimal bir bölünme (en az sayıda kesim) sağlayan eksiksiz bir program veya işlev yazmaktır.

Giriş

Giriş herhangi bir uygun biçimde olabilir. Kolye bir dizi mücevher olmalı ve daha fazlası değil; örn. tamsayıların listesi, mücevher türlerini temsil eden anahtarlı sözlük ve indekslerin listesi olan değerler. İsteğe bağlı olarak kolyenin uzunluğunu veya farklı mücevher türlerinin sayısını dahil edebilirsiniz, ancak başka herhangi bir girdi almamalısınız.

Giriş kolyesinin geçerli olduğunu varsayabilirsiniz. Belirli bir türde garip sayıda mücevher bulunan veya kolyenin boş olduğu durumda işlem yapmanıza gerek yoktur.

Çıktı

Yine, çıktı herhangi bir uygun formatta olabilir; örneğin, bir parça listesi, bir kesme pozisyonları listesi, iki hırsızı temsil eden anahtarları ve parça listesi olan değerleri içeren bir sözlük, vs. bunların uzunlukları, vb kullanabilir 0- veya 1- indeksleme. Sıralama biçiminiz için önemli değilse, çıktınız herhangi bir sırada olabilir. Yukarıdaki çıktı birkaç farklı formatta:

list of segments: [[S],[S],[S,E,S,D,E,R,S],[R,E,S,S,S,D,R,E,E,R,E,D,E],[R,R,D,E,E,E]]
list of cuts:     [1,2,9,22]
list of lengths:  [1,1,7,13,6]
dictionary:       {'thief1' : [(R,R,D,E,E,E),(S),(S,E,S,D,E,R,S)], 'thief2' : [(S),(R,E,S,S,S,D,R,E,E,R,E,D,E)]}

Düzenin, segmentler listesinde (hırsızlar arasında değişen segmentler) ve uzunluklar listesinde (segmentleri tanımlamak için) önemli olduğunu, ancak kesim listesinde veya sözlükte önemli olmadığını unutmayın. Edit: Greg Martin bu adil bir bölüm iki kesimde elde edilebilir beri geçerli çıktılar olmayacağına dikkat çekti

Test senaryoları

[1,2,1,2,1,3,1,3,3,2,2,3] -> [[1,2,1],[2,1,3,1],[3,3,2],[2,3]]
[1,1,1,1,2,2,3,3,3,3,3,3] -> [[1,1],[1,1,2],[2,3,3,3],[3,3,3]]
[1,1,1,1,1,1,1,1,1,1,1,1] -> [[1,1,1,1,1,1],[1,1,1,1,1,1]]
[1,1,1,1,2,3,4,2,3,4,2,2] -> [[1,1],[1,1,2,3,4,2],[3,4,2,2]]

notlar

1. Standart boşluklar yasaktır.
2. Bu kod golfü ; en kısa cevap (bayt cinsinden) kazanır.

Brachylog , 13 bayt

~c.ġ₂z₁Ċcᵐoᵛ∧

Çevrimiçi deneyin!

Not: Metaforat ᵛ, bu zorluktan daha yenidir .

açıklama

~c.ġ₂z₁Ċcᵐoᵛ∧  Input is a list, say L = [1,2,2,2,1,2,3,3]
~c.            Output is a partition of the input: [[1,2,2],[2,1,2],[3],[3]]
  .ġ₂          Split the output into chunks of length 2: [[[1,2,2],[2,1,2]],[[3],[3]]]
     z₁        Zip (transpose) the chunks: [[[1,2,2],[3]],[[2,1,2],[3]]]
       Ċ       This is a 2-element list (forbid the trivial partition).
        cᵐ     Concatenate both: [[1,2,2,3],[2,1,2,3]]
          oᵛ   If you sort both lists, they are equal.
            ∧  Don't unify with the output.

Bölümler, blok sayısının artan sırasına göre numaralandırılır, bu nedenle sonuç mümkün olduğunca az sayıda bloğa sahip olur.

Jöle , 18 bayt

s2ZFṢ$€E¬,L
ŒṖṖÇÞḢ

Çevrimiçi deneyin!

Verimli değil - örnekte, bu uygulamanın ilk adımı 2 ^27'nin bir listesini oluşturmak olacağı için büyük kaynaklar olmadan çalışmayacak 28 mücevher var. olası bölümün .

Listelerin bir listesini döndürür - alternatif hırsızlar arasında bunları sıralamak için segmentler. (TIO çıktısını yeniden yazın: bir listede yalnızca tek bir öğe olduğunda örtük baskı parantezle uğraşmaz,[] )

Nasıl?

s2ZFṢ$€E¬,L - Link 1, get (isUnfair, Slices): A possible partition
s2          - split into slices of length 2 (any odd one on it's own at the end)
  Z         - transpose (first item is one thief's slices, second is the others)
     $€     - last two links as a monad for €ach
   F        -     flatten
    Ṣ       -     sort
       E    - equal? (theif1's jewels == theif2's jewels)
        ¬   - not
          L - length (number of slices in the partition)
         ,  - pair

ŒṖṖÇÞḢ - Main link: necklace
ŒṖ     - all partitions
  Ṗ    - pop, we must remove the rightmost one...
              because Link 1 will say it is fair, and it will have length 1!
              (a list of one thing has all entries equal)
    Þ  - sort by
   Ç   -     last link (1) as a monad
     Ḣ - head (get the first one, i.e. minimal isUnfair, then minimal length)

Mathematica, 118 bayt

Neredeyse Jelly yendi ... sadece 1 kapalı;)

SelectFirst[l_±c_:=Append[-#±Most@c,#2]&@@l~TakeDrop~Last@c;l_±{}:={l};i=#;(i±#)&/@Range@#2~Subsets~#3,Tr[Tr/@#]==0&]&

Üç argüman alan saf işlev: kolye, gibi belirteçlerin bir listesi olarak {A, A, A, A, B, C, D, B, C, D, B, B}; kolyenin uzunluğu; ve farklı mücevher zamanlarının sayısı. Formdaki alt listelerin bir listesini döndürür{{A, A}, {-A, -A, -B, -C, -D, -B}, {C, D, B, B}}Negatif işaretsiz belirteçlerin bir hırsıza ve negatif işaretli belirteçlerin diğer hırsıza gittiği . (Bu gereksiz bilgi olsa da, algoritma bu gösterime yol açar ve negatif işaretlerin kaldırılması birkaç bayta mal olur.)

İlk olarak, bir liste ve bir dizi nkesim yeri alan ve n+1bu nkesim yerlerinde giriş listesini keserek elde edilen alt listelerin listesini döndüren bir işlev uygulamalıyız ; ikili infix operatörü ±bu amaçla kullanılır ve yinelemeli olarak tanımlanır l_±c_:=Append[-#±Most@c,#2]&@@l~TakeDrop~Last@c;l_±{}:={l};. Hemen sonraki negatif işaret nedeniyle Append, sonuç, alt listelerin dönüşümlü olarak her tokene eklenmiş ve negatif işaretlere sahip olmamasıdır.

Ardından, uzunluğu en fazla sayıda mücevher türü olan olası tüm kesme yeri setlerini üretiyoruz ve bu kesme yeri setlerinin her birine operatörü (mücevherlerin giriş listesiyle birlikte) uygulamak için kullanıyor Range@#2~Subsets~#3ve kullanıyoruz .i=#;(i±#)&/@±

Son olarak, SelectFirst[...,Tr[Tr/@#]==0&]&ortaya çıkan kolye bölümlerinden ilki adil olanı seçer. Bunu, tüm alt listelerdeki tüm öğeleri tam anlamıyla toplayarak yapar; Mathematica, her tokenin pozitif ve negatif kopyalarını bariz bir şekilde iptal edecek kadar akıllıdır.

Pyth, 16 bayt

hfqFSMsM.TcT2t./

Çevrimiçi deneyin: Gösteri veya Test Paketi

Açıklama:

hfqFSMsM.TcT2t./Q   implicit Q (=input) at the end
              ./Q   create all partitions of the input list 
                    (they are already sorted by number of cuts)
             t      remove the partition with zero splits
 f                  filter for partitions T, which satisfy:
          cT2          chop into pieces of length 2
        .T             transpose to get the pieces of each thieve
    SMsM               combine all pieces for each thieve and sort the results
  qF                   check if they got the same jewels
h                   print the first such partition

05AB1E , 14 bayt

.œ¨ʒ2ôζε˜{}Ë}¤

Çevrimiçi deneyin veya tüm test senaryolarını doğrulayın .

Açıklama:

.œ                # All partitions of the (implicit) input
                  #  i.e. [2,3,2,1,3,1]
                  #   → [[[2],[3],[2],[1],[3],[1]],[[2],[3],[2],[1],[3,1]],
                  #      ...,[[2,3,2,1,3,1]]]
  ¨               # Remove the last one
   ʒ        }     # Filter this list by:
    2ô            # Split it into parts of 2
                  #  i.e. [[2,3],[2],[1],[3,1]] → [[[2,3],[2]],[[1],[3,1]]]
                  #  i.e. [[2,3,2],[1,3],[1]] → [[[2,3,2],[1,3]],[[1]]]
      ζ           # Swap rows and columns (using space as filler if necessary)
                  #  i.e. [[[2,3],[2]],[[1],[3,1]]] → [[[2,3],[1]],[[2],[3,1]]]
                  #  i.e. [[[2,3,2],[1,3]],[[1]]] → [[[2,3,2],[1]],[[1,3]," "]]
       ε  }       # Map each inner list to:
        ˜         # Flatten the list
                  #  i.e. [[2,3],[1]] → [2,3,1]
                  #  i.e. [[1,3]," "] → [1,3," "]
         {        # Sort the list
                  #  i.e. [2,3,1] → [1,2,3]
                  #  i.e. [1,3," "] → [1,3," "]
           Ë      # Check if both sorted lists are equal
                  # (if not, remove them from the partitions)
             ¤    # After filtering, take the last one as result (and output implicitly)
                  #  i.e. [[[2],[3,2],[1,3],[1]],[[2,3],[2],[1],[3,1]]]
                  #   → [[2,3],[2],[1],[3,1]]