Talimatlar

Bir girdi tamsayı n ( n >= 0) verildiğinde , en küçük pozitif tamsayı m çıktısı veren bir program yazın, burada:

• n = a[1]^b[1] + a[2]^b[2] + a[3]^b[3] + ... + a[k]^b[k]
• ave baynı uzunlukta sonlu dizilerdir
• tüm elemanları adaha azm
• tüm elemanları bdaha azm
• tüm unsurları aolan farklı ve tam sayılara[x] >= 0
• tüm unsurları bolan farklı ve tam sayılarb[x] >= 0
• a[x]ve b[x]her ikisi de 0 değildir (0 ^ 0 belirsiz olduğundan)

Bu kod golf , çok az bayt kazanır.

Örnekler

In 0 -> Out 1
Possible Sum: 

In 1 -> Out 2
Possible Sum: 1^0

In 2 -> Out 3
Possible Sum: 2^1

In 3 -> Out 3
Possible Sum: 2^1 + 1^0

In 6 -> Out 4
Possible Sum: 2^2 + 3^0 + 1^1

In 16 -> Out 5
Possible Sum: 2^4

In 17 -> Out 4
Possible Sum: 3^2 + 2^3

In 23 -> Out 6
Possible Sum: 5^1 + 3^0 + 2^4 + 1^3

In 24 -> Out 5
Possible Sum: 4^2 + 2^3

In 27 -> Out 4
Possible Sum: 3^3

In 330 -> Out 7
Possible Sum: 6^1 + 4^3 + 3^5 + 2^4 + 1^0

GolfScript (59 karakter)

~:T),{),.0{2$0-{2${{4$2$^}2*@3$\?4$+f~}%\;~}%+\;\;}:f~T&}?)

Çevrimiçi demo

Bu, belirli bir değer için ulaşılabilir değerleri sıralamak ve işe yarayan milk değeri aramak için özyineleme kullanır m. Bu, xnor'un cevabından hafifçe ilham aldı, ancak uygulamada oldukça farklı.

teşrih

~:T                  # Evaluate input and store in T (for Target)
),{                  # Search [0 1 ... T] for the first m which matches a predicate
  ),.0               #   Push [0 ... m] to the stack twice and then 0
                     #   Stack holds: possibleAs possibleBs sum
  {                  #   Define the recursive function f
    2$0-{            #     Map over A in possibleAs (except 0)
      2${            #       Map over B in possibleBs (except 0)
        {4$2$^}2*    #         Duplicate respective possibles and remove selected values
        @3$\?4$+     #         Compute sum' = sum + A^B
        f            #         Recursive call gives an array [sums]
        ~            #         Push the sums to the stack individually
        }%           #       End map: this collects the sums into a combined array
      \;             #       Pop A, leaving just the combined [sums] inside the map
      ~              #       Repeat the trick: push to the stack individually
    }%               #     End map, collecting into a combined array
                     #     Stack now holds: possibleAs possibleBs sum [sums]
    +                #     Include the original sum in the array of reachable sums
    \;\;             #     Pop possibleAs and possibleBs
  }:f                #   End function definition
  ~                  #   Evaluate the function
  T&                 #   Test whether the sums contain T
}?                   # End search
)                    # Increment to get m

Python, 120

f=lambda n,A,B:n*all(f(n-a**b,A-{a},B-{b})for a in A for b in B)
g=lambda n,m=1,M={0}:f(n,M-{0},M)and g(n,m+1,M|{m})or m

Fonksiyon folup olmadığını kontrol eder sağlayan bir yardımcı fonksiyonudur nolabilir olmayan farklı bazlarla birlikte bir kuvvetler toplamı olarak ifade edilebilir Agelen ve üstlerin B. Doğal bir özyinelemeli strateji kullanır: nsıfır olmamalıdır ve mümkün olan her türlü taban ve üs seçimini deneriz ve hepsinin başarısız olması gerekir. Bunları izin verilen listelerden kaldırıyoruz nve karşılık gelen miktarda azaltıyoruz .

İşlev gana işlevdir. Çalışan bir mşeyi arar . Men fazla izin verilen değerler kümesidir m-1. 0Durdurulmasına izin verilen üslerden 0**0(Python'un 1 olarak değerlendirdiği) kullanılmasını kaldırıyoruz . Bu hiçbir şeye zarar vermez, çünkü diğerleri için 0**xişe yaramaz .0x

Python 2, 138 bayt

from itertools import*
S=lambda n,m=0,R=[]:m*any(n==sum(map(pow,*C))for k in R for C in product(*tee(permutations(R,k))))or S(n,m+1,R+[m])

(Tüm ipuçları için @ Jakube'a teşekkürler)

itertoolsModül hakkında daha önce hiç bu kadar soru sormamıştım. Son dava yaklaşık bir dakika sürer.

m = 1Bir çözüm bulana kadar arama yaparak ve arttırarak başlarız . Bir çözümü kontrol etmek için tekrarlıyoruz:

• k = 0 to m-1, kçözümdeki terimlerin sayısı nerede
• Tüm olası terimler kombinasyonu (alt kümelerin iki permütasyonunu [0, 1, ... m-1]boyut ile birleştirerek k), sonra toplayıpn

Biz isteriz ki bu Not kkadar m-1- olsa bile teknik olarak mterimler toplamda mümkün, her zaman bir çözüm var m-1gibi terimleri 0^0izin verilmez ve 0^bkazandırdığı hiçbir şey. Bu aslında önemlidir, çünkü 0^0bir sorun gibi görünen Python tarafından 1 olarak kabul edilir, ancak önemli değil!

İşte nedeni.

Hatalı 0^0olarak bulunan bir çözümün 1, ör 3^2 + 1^1 + 0^0 = 11. Yalnızca m-1terimler ürettiğimiz için , jtemel olarak kullanmadığımız bazı şeyler olmalı (burada j = 2). Burada jgeçerli bir çözüm elde etmek için temeli 0 değiştirebiliriz 3^2 + 1^1 + 2^0 = 11.

Hepimizin kadar iterated Had maçısından, o zaman biz gibi yanlış çözümler almış olabilir m = 2için n = 2aracılığıyla 0^0 + 1^1 = 2.

GolfScript ( 90 84 bayt)

[0.,.]](~:T),(+{:x;{:|2,{:c)|=x),^{c[1$x]=:A^x^:-;[|~-+@A-?+@A+@]}%}/+~}%.[]*T&}?)\;

Çevrimiçi demo

teşrih

[0.,.]             # Base case: [sum As Bs] is [0 [] []]
](~:T              # Collect it in an array of cases; fetch parameter, eval, store in T.
),(+               # Create array [1 2 ... T 0]. Putting 0 at the end means that it won't
                   # be reached except when T is 0, and nicely handles that special case.
{                  # Loop over the values from that array...
  :x;              #   ...assigning each in turn to x (and popping it from the stack)
  {                #   Stack holds array of [sum As Bs] cases; map them...

    :|             #     Store [sum As Bs] in |
    2,{:c          #     For c in [0 1]...
      )|=x),^      #       Get [0 1 ... x]^ either As or Bs, depending on c
      {            #       Map these legal new As or Bs respectively...
        c[1$x]=:A  #         Work out which of that value or x is the new A
        ^x^:-;     #         And the other one is the new B
        [          #         Begin gathering in an array
          |~       #           Push sum As Bs to the stack
          -+       #           Add - to Bs to get Bs'
          @A-?+    #           Rotate sum to top and add A^- to get sum'
          @A+      #           Rotate As to top and add A to get As'
          @        #           Final rotation to put elements in the right order
        ]          #         Gather in array [sum' As' Bs']
      }%           #       End map
    }/             #     End for
    +~             #     Push all the elements corresponding to x^B and A^x on to the stack
  }%               #   End map, collecting the untouched [sum As Bs] and all the new
                   #   [sum' As' Bs'] arrays into a new array of reached cases.
  .[]*T&           #   Flatten a copy of that array and filter to values equal to T.
                   #   This gives a truthy value iff we've found a way to make T.
}?                 # Loop until we get a truthy value, and push the corresponding x
)\;                # Increment to get the value of m and discard the array of cases

En zarif hile, özel davanın ele alınmasıdır 0.

Haskell'in 143 130

import Data.List
p n=head$[1..]>>=(\m->[m|let x=permutations[0..m-1]>>=inits,a<-x,b<-x,sum(zipWith(\x y->x^y*signum(x+y))a b)==n])

Kullanım örneği: p 23-> 6.

Bu basit bir kaba kuvvet araştırmasıdır. Her liste [0..0], [0..1], [0..2] ... [0..∞]için permütasyonların tüm başlangıç ​​segmentlerini alın (örn. [0..2]: permütasyonlar:, [012], [102], [210], [120], [201], [021]1. permütasyon için başlangıç ​​segmentleri:, [0], [01], [012]2.: [1], [10], [102]vb.). Bu listelerden 2'sinin her kombinasyonu için güçlerin toplamını hesaplayın. İlki n'ye eşit olduğunda durun.

Python: 166 karakter

from itertools import*;p=permutations
f=lambda n,r=[0]:any(n==sum(map(lambda x,y:(x+y>0)*x**y,a,b))for j in r for a,b in product(p(r,j),p(r,j)))*1or 1+f(n,r+[len(r)])

açıklama

İşlev f, sayıların güçlerinin toplamı olarak ifade edilebilen tüm olası tam sayıları oluşturur r. İle başlarsa r = [0]. Bu tamsayılardan herhangi biri eşitse n, uzunluğunu döndürür r, aksi takdirde genişletilmiş olarak kendini yinelemeli olarak çağırır r.

Toplam olarak ifade edilebilecek tüm tamsayıların hesaplanması iki döngü ile yapılır. İlk döngü, for j in rifadenin uzunluğunu bize bildiren (2 ^ 3 + 1 ^ 2'nin uzunluğu 2'dir). İç döngü r, uzunluk permütasyonlarının tüm kombinasyonları üzerinde tekrar eder j. Her biri için güçlerin toplamını hesaplarım.

JavaScript (ES6) 219 224

Özyinelemeli işlev. M = 1 ile başlayarak, üsler için 1..m ve üsler için 0..m tamsayılarının tüm kombinasyonlarını deniyorum (0 üssü 0 ^ 0 == undefined verildiğinde işe yaramaz).
Hiçbir çözüm bulunamazsa, m'yi artırın ve tekrar deneyin.
Giriş 0 için özel durum (bence bu özelliklerde yine de bir hatadır)

C işlevi, belirli uzunluktaki bir diziden tüm kombinasyonları özyinelemeli olarak üretir, böylece

C(3, [1,2,3]) --> [[3,2,1], [3,1,2], [2,3,1], [2,1,3], [1,3,2], [1,2,3]]

Üçüncü seviye every, üslerin a ve b üslerinin dizisini birbirine sıkıştırmak için kullanılır ( zipJavaScript'te işlev yoktur ). Kullanılması everyerken durdurmak için İki dizide tüm unsurları kullanmayan bir çözüm varken.

F=(n,j=1,k=[],
  C=(l,a,o=[],P=(l,a,i=l)=>{
    for(l||o.push(a);i--;)
      e=[...a],P(l-1,e.concat(e.splice(i,1)))
  })=>P(l,a)||o
)=>n&&C(k.push(j++),k)[E='every'](a=>C(j,[0,...k])[E](b=>a[E](x=>t-=Math.pow(x,b.pop()),t=n)))
?F(n,j,k):j

FireFox / FireBug konsolunda test et

;[0,1,2,3,6,16,17,23,24,27,330].map(x=>[x,F(x)])

Çıktı

[[0, 1], [1, 2], [2, 3], [3, 3], [6, 4], [16, 5], [17, 4], [23, 6], [ 24, 5], [27, 4], [330, 7]]