我们有严格增加的非负整数序列，例如：

12 11 10

等待！这个顺序不是严格增加的，是吗？好吧，数字写在不同的基础上。最小的底数是2，最大的底数是10。

任务是猜测每个数字的写法基础，以便：

• 顺序严格增加，
• 基数之和最大。

例如，样本的解决方案将是：

6 8 10

因为在这些基数下该序列变为8 9 10十进制-严格增加的序列，并且我们无法找到该序列仍严格增加且其总和大于的基数6+8+10。

由于第二个限制，解决方案3 5 7并不令人满意：尽管该序列5 6 7位于这些碱基的下面-我们需要最大化碱基和3+5+7 < 6+8+10。

如果毫无根据2<=b<=10，该系列可能会严格增加，例如：

102 10000 10

单

0

应该输出。

输入序列可以以最适合您的解决方案的方式传递（标准输入/命令行参数/函数参数...）。

Pyth，31 30 29字节

e+0f.x!sgM.:iVczdT2ZosN^STlcz

1个字节，感谢@Jakube。

示范。 测试线束。

输入在STDIN上给出，以空格分隔。如果允许使用换行符分隔的输入，我可以将程序缩短2个字节。

说明：

e+0f.x!sgM.:iVczdT2ZosN^STlcz
                                  Implicit: z = input(), T = 10, Z = 0, d = ' '
                        ST        [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
                          lcz     len(z.split())
                       ^          All combinations w/replacement of that length.
                    osN           Order by increasing sum.
   f                              Filter on
              czd                 z.split(' ')
            iV   T                Vectorize the "Convert to base" operation over 
                                  the integers as strings and the base sequence.
          .:      2               Take length 2 subsequences.
        gM                        Map the >= operation over them.
      !s                          Sum and logically negate.
    .x             Z              If that throws an error, returns 0 (e.g. reject)
 +0                               Prepend a 0, in case no sequences are found.
e                                 Take the end of the list.

包括1在可能的基础列表中是安全的，因为i使用Python的int内置函数的不允许1作为基础，因此总是抛出错误，并被捕获并过滤掉。

CJam，43个字节

0B,2>ea,m*{:+~}${ea::~_2$.b__Q|$=*@.b=}=p];

读取命令行参数并打印一个数组。

在CJam解释器中在线尝试。

例子

$ cjam rise.cjam 12 11 10
[6 8 10]
$ cjam rise.cjam 19 18 17
0

怎么运行的

0       e# Push a 0 (default return value).
B,2>    e# Push [0 ... 10] and remove the first two elements.
ea,     e# Push the number of command-line arguments (n).
m*      e# Cartesian power. Pushes all vectors of {2 ... 10}^n.
{:+~}$  e# Sort by the negated sums.
{       e# Find; for each vector V in {2 ... 10}^n:
  ea::~ e#   Evaluate each character of each command-line argument.
  _2$   e#   Copy the results and V.
  .b    e#   Vectorized base conversion (list to integer).
  __    e#   Push two copies.
  Q|$   e#   Deduplicate and sort the last copy.
  =     e#   Compare it to the first. Pushes 1/0 if equal/unequal.
  *     e#   Repeat the original result of .b that many times.
  @.b   e#   Vectorized base conversion (integer to list).
  =     e#   Compare the result to the modified command-line arguments.
        e#   Equality makes sure that the base was greater than all digits.
}=      e# If pushed 1, push V and break.
p       e# Print. Either prints the last V or 0 if none matched.
];      e# Clear the stack to avoid implicitly printing the 0 (if still present).

利亚，176 156 145 118 109 99 97个字节

A->try p=NaN;flipud(map(i->(k=11;t=p;while t<=(p=parseint("$i",k-=1))end;k),flipud(A)))catch;0end

取消高尔夫：

function anonfunc(i)
  # Start with k=11 so that it evaluates to 10 on first while iteration
  k=11
  # set t to the previous value of p
  # Note: p here gets held over between iterations within the map
  t=p
  # Iterate through, dropping k by 1 and evaluating the integer in
  # base k and stopping if the value drops below t
  # Note: "p=" expression inside conditional to ensure k-=1 is evaluated
  # at least once (to make NaN work as desired)
  while t<=(p=parseint("$i",k-=1))
  end
  # if it dropped below t, return the base, k to be the corresponding
  # element in the map
  return k
end

function f(A)
  # Using try/catch to return 0 if no acceptable base found
  try
    # This is a trick to make sure the comparison in the while loop
    # evaluates to false on the first use of it (last value in A)
    p=NaN
    # Apply anonfunc to each element of A, starting with the last element
    # and store the result in S
    S=map(anonfunc,flipud(A))
    # S is backwards, so flip it and return it
    return flipud(S)
  catch
    # Will throw to here if parseint fails with the base due to having
    # a digit not acceptable in the base
    return 0
  end
end

与一维数组输入一起使用。如果将函数分配给c，则您将调用c([12,11,10])并输出[6,8,10]。

注意：我曾经dec(i)在parseint命令中使用过，但是因为它i是一个单字符变量名，并且我不需要访问组件，所以我曾经"$i"获得相同的结果。

朱莉娅259个 204 183字节

在Glen O的帮助下保存了一堆。

A->(M(x)=maxabs(digits(x))+1:10;S=[];X={};for i=M(A[1]),j=M(A[2]),k=M(A[3]) s=map(parseint,map(dec,A),[i,j,k]);all(diff(s).>0)&&(S=[S,sum(s)];X=[X,{[i,j,k]}])end;X==[]?0:X[indmax(S)])

取消+说明：

function f(A)
    # Define a function to obtain the smallest possible base range
    M(x) = (maxabs(digits(x)) + 1):10

    # Define container arrays for the sums and bases
    S = []
    X = {}

    # Loop over all possible bases for each of the elements
    for i = M(A[1]), j = M(A[2]), k = M(A[3])
        # Parse each element of the input as a string
        # in the given base
        s = map(parseint, map(dec, A), [i,j,k])

        # Push the sum and bases if s is rising
        if all(diff(s) .> 0)
            S = [S, sum(s)]
            X = [X, {[i,j,k]}]
        end
    end

    # If X is empty, return 0, otherwise return the bases
    isempty(X) ? 0 : X[indmax(S)]
end

CJam（39个字节）

{Afb:X,9,2f+m*{X\.b__$_&=*},{:+}$0\+W=}

这是一个匿名函数，它将输入作为堆栈上的十进制整数数组，将输出保留为数组或0堆栈上的整数。在线演示。

Python 2（147字节）

def x(s):
 q=int;c=10;o=q(s[-1])+1;l=[]
 for i in map(str,s)[::-1]:
    n=q(i,c)
    while o<=n:
        c-=1;n=q(i,c)
        if 3>c:return 0
    l=[c]+l;o=n
 return l

调用x带有整数列表的函数。

例：

print x([12,11,10])

版画

[6, 8, 10]