Börekim Bisected Oldu mu?


43

Olumsuz tamsayılar listesinde boşuna olmayan bir program veya işlev yazın. Bunun "1 2 3 4"ya da gibi makul bir uygun biçimde girildiğini varsayabilirsiniz [1, 2, 3, 4].

Giriş listesindeki sayılar, her dilim boyutunun karşılık gelen numara ile orantılı olduğu ve tüm dilimler, verilen sırayla çizelge etrafında düzenlenmiş olan bir tam pasta grafiğinin dilimlerini temsil eder .

Örneğin, pasta 1 2 3 4:

1 2 3 4 örnek

Kodunuzun yanıtlaması gereken soru şudur: Pasta grafiği hiç ikiye bölünmüş mü? Yani, dairenin bir tarafından diğer tarafına, onu simetrik olarak ikiye bölen mükemmel bir düz çizgi var mı?

Sen gerek çıkışı bir truthy en az bir açıortay ve çıkış bir varsa değerini falsy hiçbiri yoksa değer .

Örnekte 1 2 3 4arasında 4 1ve arasında bir 2 3sapma vardır ve bu yüzden çıktı truthy olur.

Ancak girdi için 1 2 3 4 5bisector yoktur, bu yüzden çıktı yanlış olur:

1 2 3 4 5 örnek

Ek örnekler

Sayıların farklı düzenlenmesi, bisektörleri kaldırabilir.
örneğin 2 1 3 4→ sahte:

2 1 3 4 örnek

Giriş listesinde yalnızca bir sayı varsa, pasta ikiye ayrılmaz.
örneğin 10→ sahte:

10 örnek

Birden fazla bisküvi olabilir. Sıfırdan daha fazla olduğu sürece, çıkış truthy'dir.
örneğin 6 6 12 12 12 11 1 12→ truthy: (burada 3 tane bisküvi var)

6 6 12 12 12 11 1 12 örnek

Bisküvi, görsel olarak belirgin olmasalar bile olabilir.
örneğin 1000000 1000001→ sahte:

1000000 1000001 örneği

örneğin 1000000 1000001 1→ truthy:

1000000 1000001 1 örnek

( Pasta grafikleri oluşturmak için nces.ed.gov'a teşekkürler .)

Test Kılıfları

Truthy
1 2 3 4
6 6 12 12 12 11 1 12
1000000 1000001 1
1 2 3
1 1
42 42
1 17 9 13 2 7 3
3 1 2
10 20 10

Falsy
1 2 3 4 5
2 1 3 4
10
1000000 1000001
1
1 2
3 1 1
1 2 1 2 1 2
10 20 10 1

puanlama

Bayt cinsinden en kısa kod kazanır. Tiebreaker daha erken bir cevaptı.


30
Sanırım turta sekti demek istiyorsun ?
Alex A.

@HelkaHomba, sektörleri çalışmasını sağlayacak şekilde yeniden düzenleyebilir misiniz ve "sayıları farklı şekilde düzenleyerek bisektörleri kaldırabilir" derken bunu mu kastediyorsunuz?
Solomon Ucko

@SolomonUcko Sektörleri yeniden düzenleyemezsiniz.
Calvin'in Hobileri,

1
Yanlış davaların sadece [2 1 3 4] gerçekten değerlendirilmesi gerekir. Diğer yanlış davalar kolayca reddedilir, çünkü toplamları tuhaf (veya uzunlukları <2).
Benny Jobigan

Yanıtlar:


12

J, 18 bayt

Dennis sayesinde 5 bayt.

+/e.[:,/2*+/\-/+/\

@HelkaHomba : Hayır.

kullanım

>> f =: +/e.[:,/2*+/\-/+/\
>> f 6 6 12 12 12 11 1 12
<< 4
>> f 10 20 10 1
<< 0

Ungolfed

black_magic  =: +/\-/+/\
doubled_bm   =: 2 * black_magic
flatten      =: ,/
sum          =: +/
is_member_of =: e.
f =: sum is_member_of monadic flatten doubled_bm

Önceki 23 bayt sürümü:

[:+/[:+/+/=+:@-/~@(+/\)

kullanım

>> f =: [:+/[:+/+/=+:@-/~@(+/\)
>> f 6 6 12 12 12 11 1 12
<< 4
>> f 10 20 10 1
<< 0

Ungolfed

black_magic =: -/~@(+/\)
double      =: +:
equals      =: =
sum         =: +/
monadic     =: [:
of          =: @
f =: monadic sum monadic sum (sum equals double of black_magic)

açıklama

Tüm alt dizelerin toplamı black_magic tarafından hesaplanır. +/\Kısmi toplam hesaplar.

Örneğin, a b c dolur a a+b a+b+c a+b+c+d.

-/~O zaman, girdi göre bir çıkarma tablo oluşturur x y zolur:

x-x x-y x-z
y-x y-y y-z
z-x z-y z-z

Uygulandığında a a+b a+b+c a+b+c+dsonuç şöyle olur:

    0  -b -b-c -b-c-d
    b   0   -c   -c-d
  b+c   c    0     -d
b+c+d c+d    d      0

Bu, içermeyen tüm alt dizelerin toplamını hesapladı a.

Bu, yeterli olmasını garanti eder, çünkü eğer bir biseksiyon varsa a, diğer biseksiyon içermez ave ayrıca sarılmaz .


3
Bazı yeniden yapılandırmalarla, 13 bayta kadar:+/e.&,2*+/\\.
Zgarb

10

Jöle , 9 8 bayt

Ḥ+\©_Sf®

Boş olmayan bir liste (truthy) veya boş bir liste (sahte) döndürün. Çevrimiçi deneyin! veya tüm test durumlarını doğrulayın .

Nasıl çalışır

Ḥ+\©_Sf®  Main link. Argument: A (list)

Ḥ         Double all integers in A.
 +\       Take the cumulative sum of 2A.
   ©      Copy; store the result in the register.
    _S    Subtract the sum of A from each partial sum of 2A.
      f®  Filter; intersect this list with the list in the register.

7

Julia, 34 30 29 bayt

!x=sum(x)∈cumsum!(x,2x).-x'

1 byte kapalı golf için @GlenO teşekkürler!

Çevrimiçi deneyin!

Nasıl çalışır

Kümülatif toplamına depolama sonra 2x içinde X , biz satır vektörü çıkarma x' sütun vektördür gelen x tüm olası farklar matrisi, sonuçta. Esas olarak, tüm bu bitişik altdizilimlerden toplamı hesaplar x ilk değer, bunların negatif içermeyen ve 0 'diyagonal olarak s.

Son olarak, x orijinal dizisinin toplamının oluşturulan matrise ait olup olmadığını test ederiz . Bu durumda, bitişik alt listelerden en az birinin toplamı, tüm listenin toplamının yarısına eşittir, bu da en az bir tane bisektör olduğu anlamına gelir.


15
Başkası bir cevap vermeden önce Dennis 5 cevap verirken izleyelim.
Calvin'in Hobileri

6

Python 2,64 bayt

f=lambda l,s=0:l>[]and(sum(l)==s)|f(l[1:],s+l[0])|f(l,s+l.pop())

Ardından kalanları toplamı önden veya sondan kaldırmaya çalışır, kalanın toplamı silinmiş olanın toplamına eşittir s. Liste uzunluğunda üstel zaman alır.

Dennis 3 bayt kurtardı pop.


Listeleri veren garip bir alternatif:f=lambda l,s=0:l and(sum(l)==s)*l+f(l[1:],s+l[0])+f(l,s+l.pop())
xnor 8

5

Haskell, 41 bayt

f l=elem(sum l/2)$scanr(:)[]l>>=scanl(+)0

Buradaki fikir ltoplamı eşit olan bir alt liste olup olmadığını kontrol etmektir sum l/2. Bu alt listelerin toplamını olarak oluştururuz scanr(:)[]l>>=scanl(+)0. Bunun nasıl çalıştığına bakalıml=[1,2,3]

>> scanr(:)[]l
[[1,2,3],[2,3],[3],[]] 
-- the suffixes of l

>> scanl(+)0 [2,3,4]
[0,2,5,9]
-- the cumulative sums of the input

>> scanr(:)[]l>>=scanl(+)0
[0,1,3,6,0,2,5,0,3,0]
-- the cumulative sums of the suffixes of l, flattened to a single list

Eski 43 bayt:

f l|c<-scanl1(+)l=elem(sum l/2)$(-)<$>c<*>c

cBirikimli toplamların listesini oluşturur . Daha sonra, bu toplamların herhangi birinin farklılık sum l/2listesinin bir elemanı olup olmadığını kontrol ederek farklılık gösterip göstermediğini kontrol eder (-)<$>c<*>c.


4

Pyth, 10 9 bayt

}sQmysd.:

Pyth Compiler'da test edin .

Nasıl çalışır

       .:  Generate the list of all adjacent sublists.
   m       Map over the result:
     sd       Add the integers of the sublist.
    y         Double the sum.
 sQ        Compute the sum of the input.
}          Check if it belongs to the list of doubled sublist sums.

4

Aslında, 21 bayt

;Σ@2*;lR@τ╗`╜V♂Σi`Míu

Çevrimiçi deneyin!

Bu program 0, yanlış durumlar için ve gerçek durumlar için pozitif bir tamsayı olarak yazdırır .

Açıklama:

;Σ@2*;lR@τ╗`╜V♂Σi`Míu
;Σ                     sum of copy of input
  @2*                  double values in other copy
     ;lR               copy, range(1, len(input)+1)
        @τ             append other copy to itself
          ╗            save in reg0
           `╜V♂Σi`M    map: generate cyclic cumulative sums
                   íu  1-based index of sum of input (0 if not found)

Rekabet etmeyen sürüm, 10 bayt

;Σ@2*σ;)-∩

Çevrimiçi deneyin!

Bu program yanlış durumlar için boş bir liste, aksi takdirde boş olmayan bir liste çıkarır. Aslında Dennis'in Jelly cevabının limanı . Rekabetçi değil, çünkü kümülatif toplam ve vectorized fark işlevselliği mücadeleden sonraki.

Açıklama:

;Σ@2*σ;)-∩
;Σ          sum of copy of input
  @2*       multiply values in other copy by 2
     σ;     two copies of cumulative sum
       )-   subtract sum of input from each element in one copy
         ∩  set intersection with other copy

4

Python 2, 76 74 70 66 bayt

def f(x):n=sum(x);print n in[2*sum(x[k/n:k%n])for k in range(n*n)]

4 8 baytlık golf oynamak için @xnor'a teşekkürler !

İdeone üzerinde test et . (daha büyük test vakaları hariç)


Ben Yapabileceğiniz fark n=sum(x)yapmak n in ...; için daha büyük bir değer kullanmak zarar vermez n.
xnor,

Ooh, bu akıllıca. Teşekkür ederim!
Dennis,

3

MATL , 10 bayt

EYst!-Gs=z

Çıktı, bisektörlerin sayısıdır.

Çevrimiçi deneyin!

açıklama

Dennis'in Julia'nın cevabıyla aynı yaklaşım .

E       % Implicit input. Multiply by 2 element-wise 
Ys      % Cumulative sum 
t!-     % Compute all pairwise differences. Gives a 2D array 
Gs      % Sum of input 
=       % Test for equality, element-wise 
z       % Number of nonzero elements. Implicit display 

3

Yakut, 60 53 bayt

->a{a.any?{r=eval a*?+;a.rotate!.any?{|i|0==r-=2*i}}}

Giriş dizinin her dönüşü yaparak ve uzunluğu 1 her dilim alarak olası tüm bölümleri oluşturur .. n, burada ngiriş dizisinin boyutudur. Sonra giriş dizisinin toplam toplamının yarısı toplamı olan bir bölüm olup olmadığını kontrol eder.


2

JavaScript (ES6), 83 bayt

a=>a.map(_=>a.slice(--n).map(m=>s.push(t+=m),t=0),s=[],n=a.length)&&s.includes(t/2)

Tüm olası toplamları oluşturur, ardından son toplamın yarısının (tüm listenin toplamı) listede görünüp görünmediğini kontrol eder. (Tutarları biraz tuhaf bir sıraya göre düzenlemek için en son ihtiyacım olan tutarı 4 bayt kurtarır.)


2

Dyalog APL, 12 bayt

+/∊2×+\∘.-+\

TryAPL ile test edin .

Nasıl çalışır

+/∊2×+\∘.-+\  Monadic function train. Right argument: y (vector)

     +\   +\  Yield the cumulative sum of y.
       ∘.-    Compute all differences of all partial sums.
              This computes the sums of all adjacent subvectors of y that do not
              contain the first value, their negatives, and 0's in the diagonal.
   2×         Multiply all differences by 2.
+/            Yield the sum of y.
  ∊           Test for membership.

2

Python 2 , 47 bayt

k=t=1
for x in input():t<<=x;k|=t*t
print k&k/t

Çevrimiçi deneyin!

2.75 yıl sonra eski çözümümü % 25'in üzerinde yenisini kullanarak yenmek için geri döndüm .

Bu 1 bayt uzun versiyon biraz daha net.

k=t=0
for x in input():t+=x;k|=4**t
print k&k>>t

Çevrimiçi deneyin!

Buradaki düşünce, birikimli toplamlar kümesini tbit olarak depolamak ve bunun bir toplam toplam olduğunu belirtmek için biti kayarlamaktır . Daha sonra, herhangi iki kümülatif toplamın, bu kadar bit kaydırıp liste toplamının (final ) yarıya kadar farklılık gösterip göstermediğini ve sonucun sıfır olmadığını görmek için orijinalle bit yönünde yapıp yapmadığını kontrol ederiz.2*tttk&


1

APL, 25 karakter

Listenin verildiğini varsayarsak X ← 1 2 3 4.

(+/X)∊∘.{2×+/⍺↑⍵↓X,X}⍨⍳⍴X←⎕

Açıklama:

APL'nin formu sağdan sola değerlendirdiği ilk not. Sonra:

  • X←⎕ kullanıcı girdisini alır ve içine kaydeder. X

  • ⍴X uzunluğu verir X

  • ⍳⍴X 1'den 1'e kadar olan sayılar ⍴X

  • Ve de {2×+/⍺↑⍵↓X,X}biz parantez içine tanımlıyorsanız bir diyadik işleve sol ve sağ argüman vardır.

    • Şimdi için ⍺↑⍵↓X,Xkısmen: X,Xsadece kendisiyle X birleştirir; ve al ve bırak.
    • +/+sağ taraftaki listeyi azaltır / katlar

    Yani 2 {2×+/⍺↑⍵↓X,X} 1= 2×+/2↑1↓X,X= 2×+/2↑1↓1 2 3 4 1 2 3 4=

    = 2×+/2↑2 3 4 1 2 3 4= 2×+/2 3= 2×5= 10.

  • ∘.brace⍨idxsadece idx ∘.brace idx. ( diyagonal harita; ∘.dış üründür)

    Bu bizi bir verir Yani ⍴Xtarafından ⍴Xmatrisin bağlı tüm sublists iki kez toplamları içeren.

     4  6  8  2
    10 14 10  6
    18 16 14 12
    20 20 20 20
    

    Yapmamız gereken son şey, toplamının Xbu matrisin içinde bir yerde olup olmadığını kontrol etmektir.

  • Hangi ile yapıyoruz (+/X)∊matrix?

1

Brachylog , 6 bayt

sj+~+?

Çevrimiçi deneyin!

Başarı veya başarısızlık, yazdırma true.veya false.program olarak çalıştırıldığında çıktı verir.

s         A contiguous sublist of the input
 j        with all of its items duplicated
  +       sums to
   ~+     the sum of the elements of
     ?    the input.

1

C, 161 145 129 bayt

  • @LeakyNun sayesinde birkaç byte kurtarıldı
  • @ceilingcat sayesinde birkaç byte kurtarıldı
i;j;k;t;r;s;f(x,n)int*x;{for(t=i=k=r=0;i<n;)t+=x[i++];for(;++k<n;i=n)for(;i--;r|=2*s==t)for(s=0,j=i;j<i+k;)s+=x[j++%n];return r;}

Ungolfed çevrimiçi deneyin

int f(int*x,int n)
{
    int t=0;

    for(int i=0;i<n;i++)
    {
        t += x[i];
    }

    for(int k=1;k<n;k++) // subset-size
    {
        for(int i=0,s;i<n;i++) // where to start
        {
            s=0;

            for(int j=i;j<i+k;j++) // sum the subset
            {
                s+=x[j%n];
            }

            if(2*s==t) return 1; // TRUE
        }
    }

    return 0; // FALSE
}

Belki de önce seviyeye değişkenlerin beyanlarını taşıyarak ve değiştirerek bazı bayt kaydedebilirsiniz i<n;i++için i++<nbazı uzaklıklar ile uğraşmak gerekebilir olsa (.
Çatlak Nun'ı

0

Haskell, 68 bayt

f l|x<-[0..length l]=any(sum l==)[2*(sum$take a$drop b l)|a<-x,b<-x]

İşlev fönce, verilen listenin olası tüm dilimlerinin toplamlarının bir listesini oluşturur. Sonra liste elemanlarının toplamı ile karşılaştırır. Toplamın bir yarısına kadar gelirsek, o zaman bir iksirimiz olduğunu biliyoruz. Ayrıca siz takeya dropda listedekilerden daha fazla eleman varsa, Haskell'in hata atmadığı gerçeğini kullanıyorum .


0

Mathematica, 48 bayt

!FreeQ[Outer[Plus,#,-#],Last@#/2]&@Accumulate@#&

Anonim işlev, sayısız diğer cevaplara benzer şekilde hareket eder.

Outer[Plus, #, -#], Accumulate@#(sırayla giriş listesinde yer alan sırayla toplamların bir listesini vermek) , oyunculuk yaparken , Leaky Nun'in cevabının altındaki aynı tabloyu oluşturur.

!FreeQ[..., Last@#/2]Sonuçta ortaya çıkan tabloda (Last@#)/2yer almıyorsaLast@# ve ardışık toplamların sonuncusu mu yani giriş listesindeki tüm öğelerin toplamı olup olmadığını kontrol eder .

Bu cevap biraz ilginçse, yeni bir algoritma yüzünden değil, Mathematica'ya özgü püf noktaları hakkında; örneğin !FreeQ, MemberQtablonun düzleşmesini gerektirmediği için kontrol ettiği ve bir bayt tasarrufu sağladığı için güzel.


Bence !FreeQ[2Tr/@Subsequences@#,Tr@#]&çalışması gerekir, ama ben önümüzdeki 10 gün ya da öylesine için bunu test etmek için 10.4 müsait olmayacaktır.
Martin Ender,

@MartinEnder Kesinlikle işe yarayacak gibi görünüyor, ama ben
10.2'deyim

0

APL (NARS), karakter 95, bayt 190

{1≥k←≢w←⍵:0⋄s←+/⍵⋄∨/{s=2×s-+/⍵}¨↑¨{⍵⊂w}¨{(k⍴2)⊤⍵}¨{1≥≢⍵:⍵⋄⍵,∇{(1+2×(↑⍵))×2*0..¯2+≢⍵}⍵}2*0..k-1}

4 elementin bir giriş dizisini göz önünde bulundurun: 1 2 3 4. Setin bu alıştırma bölümü için faydalı olanı nasıl seçebiliriz? Bazıları, kullanabileceğimiz bu 4 elementin bölümünün soldaki ikili sayıya düştüğünü düşünüyor:

0001,0010,0100,1000 2^(0..4) 1 2 4  8 
0011,0110,1100,                3 6 12
0111,1110,                       7 14
1111                               15

(1001 veya 1011 ecc bu sette olabilirdi ama zaten 0110 ve 0100 ecc'ye sahibiz), bu nedenle sadece bir fonksiyon için, girdi dizisinin eleman sayısından bu ikili sayıları inşa eden tek bir fonksiyon yazmak ...:

c←{1≥≢⍵:⍵⋄⍵,∇{(1+2×(↑⍵))×2*0..¯2+≢⍵}⍵}

bu girişlerden 1 2 4 8 [2 ^ 0..lenBytesArgument-1] 3 6 12, 7 14, 15; bu yüzden bu sayılardan ikilik bul ve bunları kullanarak giriş dizisinin doğru bölümlerini bul ... Sadece o giriş 4 elemanı için c fonksiyonunu test ettim, fakat diğer elemanlar için uygun görünüyor.

Ölçek:

  f←{1≥k←≢w←⍵:0⋄s←+/⍵⋄∨/{s=2×s-+/⍵}¨↑¨{⍵⊂w}¨{(k⍴2)⊤⍵}¨{1≥≢⍵:⍵⋄⍵,∇{(1+2×(↑⍵))×2*0..¯2+≢⍵}⍵}2*0..k-1}
  f¨(1 2 3 4)(6 6 12 12 12 11 1 12)(1000000 1000001 1)(1 2 3)(1 1)(42 42)
1 1 1 1 1 1 
  f¨(1 2 3 4 5)(2 1 3 4)(,10)(1000000 1000001)(,1)(1 2)(3 1 1)
0 0 0 0 0 0 0 
Sitemizi kullandığınızda şunları okuyup anladığınızı kabul etmiş olursunuz: Çerez Politikası ve Gizlilik Politikası.
Licensed under cc by-sa 3.0 with attribution required.