Chuyển đổi một số thành tổng các chữ số

Không phải bất kỳ tổng nào: chúng tôi cần tổng ngắn nhất
Không phải bất kỳ chữ số nào: bạn chỉ có thể sử dụng các chữ số của số

Ví dụ
Bạn sẽ được cung cấp dưới dạng đầu vào một số nguyênn>0

Hãy nói n=27. Bạn phải thể hiện 27dưới dạng tổng , chỉ sử dụng các chữ số[2,7] , theo cách ngắn nhất có thể. Bạn không phải sử dụng tất cả các chữ số của số đã cho!

Vì vậy 27=2+2+2+7+7+7. Sau đó chúng tôi lấy các chữ số đó và đếm chúng : [2,2,2,7,7,7].
Câu trả lời cuối cùng cho n=27là6

Thêm một ví dụ nữa n=195để có được số tiền ngắn nhất, chúng ta phải sử dụng các chữ số sau:
[5,5,5,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9]và câu trả lời là23

Các thách thức

Cho một số nguyên n>0, xuất ra số chữ số tối thiểu (có trong số) tổng hợp với số này

Các trường hợp thử nghiệm

Input->Output

1->1  
2->1  
10->10  
58->8  
874->110  
1259->142  
12347->1765  
123456->20576  
3456789->384088  

Đây là code-golf. Câu trả lời ngắn gọn nhất trong byte thắng!

Husk , 12 byte

Lḟo=⁰ΣṁΠḣ∞d⁰

Xử lý các số có hai chữ số khá nhanh. Hãy thử trực tuyến!

Giải trình

Lḟo=⁰ΣṁΠḣ∞d⁰  Input is n, say n = 13.
          d⁰  Digits of n: [1,3]
         ∞    Repeat infinitely: [[1,3],[1,3],[1,3],[1,3]...
        ḣ     Prefixes: [[],[[1,3]],[[1,3],[1,3]],[[1,3],[1,3],[1,3]],...
      ṁ       Map and concatenate
       Π      Cartesian product: [[],[1],[3],[1,1],[3,1],[1,3],[3,3],[1,1,1],[3,1,1],...
 ḟo           Find the first element
     Σ        whose sum
   =⁰         equals n: [3,3,3,3,1]
L             Return its length: 5

Bình thường , 12 byte

lef!-TsM`Q./

Hãy thử trực tuyến!

Thật không may, nó bộ nhớ lỗi trên đầu vào lớn như 58.

Giải trình

lef!-TsM`Q./
          ./    All lists of integers that sum to [the input]
  f             Filter for:
    -TsM`Q           Remove all occurrences of the digits in the input
   !                 Check if falsey (i.e. an empty list)
le              Length of the last occurrence, which is the shortest because all the
                filtered partitions share the same digit pool

Toán học, 78 byte

(t=1;While[(s=IntegerPartitions[x=#,t,IntegerDigits@x])=={},t++];Tr[1^#&@@s])&  

tìm thấy trường hợp thử nghiệm cuối cùng trong 5 giây

R , 78 byte

function(n){while(all(F-n)){F=outer(F,n%/%10^(0:nchar(n))%%10,"+")
T=T+1}
T-1}

Hãy thử trực tuyến! (phiên bản đánh gôn)

Thuật toán thuần túy, vì vậy nó không thực sự giải quyết được tất cả các trường hợp thử nghiệm và tôi nghĩ rằng nó đã cố gắng phân bổ 40.000 GB cho trường hợp thử nghiệm cuối cùng ...

Ttrong R mặc định để 1chúng tôi gặp lỗi do lỗi mà chúng tôi đã sửa ở bước quay lại, nhưng chúng tôi cũng nhận đượcF mặc định 0nào sẽ trả hết.

giải thích vô căn cứ:

function(n){
 d <- n%/%10^(0:nchar(n))%%10   # digit list with a 0 appended at end
 d <- unique(d[d>0])            # filter zeros (not technically necessary)
                                # and get unique digits
 x <- 0                         # storage for sums
 i <- 0                         # counter for number of sums done
 while(!any(x==n)){             # until we find a combination
  x <- outer(x,d,"+")           # take all sums of x and d, store as x
  i <- i + 1}                   # increment counter
i}                              # return counter

Hãy thử trực tuyến! (phiên bản ít golf hơn)

Python 2, 168 155 144 byte

Nó không phải là ngắn nhất có thể, nhưng nó là tốt nhất - đầu tiên và không thực sự xấu, thời gian chạy khôn ngoan.

n=input()
g=sorted(set(n)-{0})[::-1]
def h(k):
 if k<0:return
 if`k`in g:return 1
 for d in g:
  f=h(k-int(d))
  if f:return 1+f
print h(int(n)) 

Đây filter(None...là loại bỏ 0 dưới dạng một chữ số, điều mà tôi đã học được khi làm điều này.

Vấn đề lớn nhất là các khung stack python, thực tế không cho phép tôi chạy cái này trên các đầu vào lớn nhất. Vì vậy, nó không phải là một giải pháp hợp lệ, thực sự, tôi đã chơi xung quanh với việc tăng giới hạn đệ quy dẫn đến lỗi seg. Điều này phải được thực hiện với một vòng lặp và một ngăn xếp hoặc với sự thông minh hơn rất nhiều để làm việc trong python.

chỉnh sửa: Cảm ơn caird và Chas Brown cho 13 byte!

Chồng , 13 byte

Khá kém hiệu quả

VVo=⁰ΣMṖNṘ⁰d⁰

Hãy thử trực tuyến!

JavaScript (ES6), 82 byte

f=(n,l=0,a=n,[c,...b]=a)=>n?1/c?Math.min(!+c|+c>n?1/0:f(n-c,l+1,a),f(n,l,b)):1/0:l

<input type=number oninput=o.textContent=f(this.value)><pre id=o>

Đưa đầu vào dưới dạng một chuỗi.

Ruby , 70 byte

->n{w,s=n.digits,0;s+=1while !w.product(*[w]*s).find{|x|x.sum==n};s+1}

Rất chậm, hãy thử tất cả các kết hợp có thể tăng kích thước cho đến khi chúng tôi có được một giải pháp.

Cảm ơn Dennis cho Ruby 2.4 trên TIO.

Hãy thử trực tuyến!

Thạch , 23 byte

D;0ṗµḟ€0
ÇS€=µT
Çị1ĿL€Ṃ

Hãy thử trực tuyến!

Điều này rất không hiệu quả, nó không chạy cho các trường hợp thử nghiệm sau trường hợp thứ ba trên TIO do giới hạn thời gian> _ <

Bất kỳ lời khuyên chơi golf đều được chào đón!

Python 2 , 183 176 172 166 161 byte

def f(n,D=0,p=0,b=0):
	D=D or set(map(int,`n`))-{0}
	d=min(D);c=0;D=D-{d}
	q=[p+n/d,b][n%d>0]
	while c<min(D or{0}):q=b=f(n-c*d,D,p+c,b);c+=1
	return[q,b][q>b>0]

Hãy thử trực tuyến!

Dài hơn câu trả lời Python khác, nhưng thực hiện tất cả các trường hợp thử nghiệm cộng với 987654321 dưới một giây trên TIO.

Lợi dụng thực tế là nếu d1<d2là các chữ số, thì cần có nhiều nhất d2-1 d1là tổng (vì các d2trường hợp d1có thể được thay thế bằng các d1trường hợp d2cho một tổng ngắn hơn). Do đó, sắp xếp các chữ số theo thứ tự tăng dần, có "chỉ" nhiều nhất 9! = 362880có thể xem xét; và độ sâu đệ quy tối đa của 9(không phụ thuộc vào giá trị của n).

Haskell , 91 byte

f n=[read[c]|c<-show n,c>'0']#n!!0
s#n|n>0,x:m<-(s#).(n-)=<<s=[1+minimum(x:m)]|1<3=[0|n==0]

Hãy thử trực tuyến! Ví dụ sử dụng: f 58sản lượng 8. Nhanh chóng cho các số có hai chữ số, chậm khủng khiếp cho các đầu vào lớn hơn.

Hàm fchuyển đổi số đầu nvào thành một danh sách các chữ số trong khi lọc các số không. Sau đó, danh sách này và nchính nó được trao cho (#)hàm, trả về một danh sách đơn. !!0trả về phần tử của danh sách singleton này.

(#)sử dụng danh sách đơn và trống làm loại tùy chọn. Đưa ra một đầu vào n=58và s=[5,8], ý tưởng là trừ tất cả các chữ số stừ nđó, sau đó áp dụng đệ quy (#)và kiểm tra chữ số nào dẫn đến số bước tối thiểu và trả về một cộng với mức tối thiểu này. Phần đầu tiên được tính bởi (s#).(n-)=<<s, giống nhưconcat(map(s#)(map(n-)s)) . Vì vậy, trong ví dụ của chúng tôi đầu tiên [58-5,58-8]được tính toán, tiếp theo là [[5,8]#53,[5,8]#50]kết quả trong [[7],[7]]hoặc [7,7]sau đó concat. Kết quả được khớp trên mẫux:m để đảm bảo danh sách có ít nhất một phần tử ( minimumkhông thành công), sau đó danh sách đơn 1 cộng với mức tối thiểu của kết quả được trả về. Nếunlà số 0 nhỏ hơn hoặc cuộc gọi đệ quy trả về một danh sách trống, chúng tôi đang ở trong một nhánh thất bại của tìm kiếm và một danh sách trống được trả về. Nếu n==0chi nhánh đã thành công và [0]được trả lại.

Haskell , 101 byte

f n=[d|d<-[9,8..1],show d!!0`elem`show n]#n!!0
s@(d:r)#n|n>=d,[x]<-s#(n-d)=[x+1]|1<3=r#n
s#n=[0|n==0]

Hãy thử trực tuyến! Một cách tiếp cận hiệu quả hơn, kiểm tra tất cả các trường hợp thử nghiệm dưới một giây.

Lần này, danh sách các chữ số của đầu vào được tính theo thứ tự giảm dần, cho phép (#)cố gắng sử dụng chữ số lớn nhất thường xuyên nhất có thể, sau đó lớn nhất thứ hai, và cho đến khi tìm thấy giải pháp. Giải pháp đầu tiên được tìm thấy theo cách này cũng được đảm bảo là nhỏ nhất.