Encode Faktör Ağaçlarını kaçırdıysanız , bir Faktör Ağacı tanımı aşağıdadır:

• Boş dize 1'dir.
• Birleştirme, çarpmayı temsil eder.
• Bir dizi N parantez (ya da herhangi bir eşleştirilmiş karakter) içine temsil eder , n 2, birinci asal sayı olmak üzere, asal sayı.
  • Bu yinelemeli yapıldığını Not n inci asal için faktör ağacı n parantez içinde.
• Bir sayının faktörleri en küçükten en büyüğe sıralanmalıdır.

Örneğin, 2 ila 10 arasındaki faktör ağaçları şunlardır:

()
(())
()()
((()))
()(())
(()())
()()()
(())(())
()((()))

Bu meydan okuma benzer bir format kullanır; ancak bu zorluk bu yapıların kodunu çözmektir .

Test Durumları

Utanmazca çalınan son meydan okuma yeniden .

Yukarıdaki 9 ek olarak…

()()((()))((())) => 100
(()(()(()))) => 101
(()())(((())))(()(())) => 1001
(((((((()))))))) => 5381
(()())((((()))))(()()(())(())) => 32767
()()()()()()()()()()()()()()() => 32768

kurallar

• Girişteki eşleştirilmiş karakterler, parantez, köşeli ayraçlar, köşeli ayraçlar veya açılı ayraçlar seçiminizdir. İstenirse diğer biçimlere (ör. XML etiketleri) izin verebilirim.
• 2'den 2 ^15'e veya 32768'den herhangi bir sayı için Faktör Ağaçlarını işleyebilmelisiniz .
• Bu kod golf olduğundan , bayt cinsinden en kısa cevap kazanır.

Wolfram Dili (Mathematica) , 52 45 bayt

ToExpression@*StringReplace[{"["->"Prime[1"}]

Çevrimiçi deneyin!

Giriş parantez kullanır.

Girdiyi, sonucu hesaplayan bir Mathematica ifadesine dönüştürür. Biz sadece değiştirerek bunu [birlikte Prime[1. Bu , bitiştirmenin Mathematica'da çarpma olduğu için çalışır .

Prolog (SWI) , 134 128 127 124 bayt

Bu cevap, ben ve 0 'arasındaki işbirliğinin bir parçası. İkimiz birlikte çalıştık, yayınlamamın tek nedeni Rock, Paper, Scissors kazandığım için.

\Q-->{Q=1};"(",\N,")",\B,{findnsols(N,I,(between(2,inf,I),\+ (between(3,I,U),0=:=I mod(U-1))),L)->append(_,[Y],L),Q is Y*B}.

Çevrimiçi deneyin!

açıklama

Bu cevap, prologda golfü neyin eğlenceli hale getirdiğinin mükemmel bir örneğidir.

Bu cevap, kesin yan tümce dilbilgileri için Prologs güçlü sistemini kullanır. İşte bizim dilbilgisi biraz ungolfed.

head(1)-->[].
head(Q)-->"(",head(N),")",head(B),{prime(N,Y),Q is Y*B}.
isprime(I):- \+ (between(3,I,U),0 =:= I mod(U-1)).
prime(N,Y):-
  findnsols(N,I,(
    between(2,inf,I),
    isprime(I)
  ),L),
  append(_,[Y],L),!.

İlk inşaat kuralı:

head(1)-->[].

Bu, Prolog'a boş dizenin 1'e karşılık geldiğini bildirir.

İkinci inşaat kuralımız biraz daha karmaşık.

head(Q)-->"(",head(N),")",head(B),{prime(N,Y),Q is Y*B}.

Bu, boş olmayan herhangi bir dizenin, aynı kurallara sahip bir cümle etrafında, aynı kurallara sahip bir cümlenin sağında parantez içerdiğini gösterir.

Ayrıca bize bu maddenin ( Q) değerinin kurala uyduğunu söyler :

{prime(N,Y),Q is Y*B}

Bunu kırmak Q, 2 sayının Yve B. Bsola maddenin sadece değeridir ve Ybir Ninci asal Nparantez içinde maddesinin değeridir.

Bu kural, faktör ağacının oluşum kurallarının her ikisini de kapsar

• Birleştirme çoğalır
• Muhafaza en önemli olanı aldı

Şimdi kesin tanımlar için. Golf edilmemiş versiyonda iki tahmin vardır (gerçek kodumda tahminleri uzakta zincirledim). Burada ilgili iki tahmin isprime/1, asal sayı ile eşleşen ve prime/2verilen Nve Yasff Yile eşleşen asal sayıdır N. İlk önce

isprime(I):- \+ (between(3,I,U),0 =:= I mod(U-1)).

Asallık bir oldukça standart tanımının Bu eserler, biz 2 arasında numara yoksa ısrar ve I2 değil de dahil olmak üzere, Iböler o I.

Bir sonraki yüklem de oldukça basit

prime(N,Y):-
  findnsols(N,I,(
    between(2,inf,I),
    isprime(I)
  ),L),
  append(_,[Y],L),!.

Asal findnsolsolan ilk Nsayıları bulmak için kullanırız , sonra sonuncuyu döndürürüz. Buradaki hile findnsols, en küçük N asalları bulması garanti edilmese de, SWI'nin işleyiş şekli nedeniyle betweenher zaman daha küçük asalları bulacaktır. Ancak bu, daha fazla prim bulmasını önlemek için kesmemiz gerektiği anlamına gelir.

Golfler

Kodumuzdaki nedeni iki kez iletebiliriz. Çünkü isprimetanımı sadece içine taşınabiliyorsa prime. Bir sonraki, primedoğrudan DCG'nin içine taşınmaktır , ancak çok fazla prim üretmesini primeönlemek için bir kesim kullandığımızdan findnsols, bir sorunumuz var. Kesim, istediğimiz bit yerine tüm DCG'yi keser. Biraz dokümantasyon kazısından sonra, once/1sadece bu kısmı kesmek için kullanılabilir, ancak tüm DCG'yi değil. Bununla birlikte, daha fazla belge kazma, ->operatörün benzer bir görevi yerine getirmek için de kullanılabileceğini ortaya koymuştur . ->Operatör eşdeğerdir ,!,biz diğer tarafına bizim kesim taşındı bu yüzden append/3ve onu değiştirdi ->.

SWI-Prolog'da tahminler (ve kurallar), operatörlere normalde gereken parantezleri bırakmamızı sağlayan adlar olarak verilebilir. Böylece kuralı çağırarak 6 bayt tasarruf edebiliriz \.

Python 3 , 125110 bayt

lambda s:eval(s.replace("]","1]*").replace("[","p[1*")+"1")
p=2,
k=P=1
while k<1e4:
 if P%k:p+=k,
 P*=k*k;k+=1

Çevrimiçi deneyin!

Asalları oluşturmak için xnor'ın Wilson Teoremi yöntemini uygulamasını kullanır . Yedekler ()ile [].

JavaScript (ES6), 98 bayt

Notjagan'ın Python cevabından ilham aldı . Giriş ifadesini devasa ve çirkin yürütülebilir bir dizeye dönüştürür.

s=>eval(s.split`)(`.join`)*(`.split`(`.join`(g=(n,k)=>(C=d=>n%--d?C(d):k-=d<2)(++n)?g(n,k):n)(1,`)

CVe gişlevlerinin tek bir tanede birleştirilmesi bazı baytlar kaydedebilir, ancak daha fazla özyineleme gerektirir.

Test senaryoları

let f =

s=>eval(s.split`)(`.join`)*(`.split`(`.join`(g=(n,k)=>(C=d=>n%--d?C(d):k-=d<2)(++n)?g(n,k):n)(1,`)

;[
  "()",                             // 2
  "(())",                           // 3
  "()()",                           // 4
  "((()))",                         // 5
  "()(())",                         // 6
  "(()())",                         // 7
  "()()()",                         // 8
  "(())(())",                       // 9
  "()((()))",                       // 10
  "()()((()))((()))",               // 100
  "(()(()(())))",                   // 101
  "(()())(((())))(()(()))",         // 1001
  "(((((((())))))))",               // 5381
  "(()())((((()))))(()()(())(()))", // 32767
  "()()()()()()()()()()()()()()()"  // 32768
]
.forEach(s => console.log(s, '-->', f(s)))