介绍

这是此挑战的后续活动，在此过程中，您将扮演那个人的邪恶双胞胎角色。邪恶时，您不想最大化自己的份额，而希望尽可能地不公平，并且不会太明显，这就是为什么您提出以下方案的原因：

您将告诉其他人，您希望自己像兄弟姐妹一样公平，因此您将把整数分成相等长度的片段。因此，对于每个整数，您都会想出合适的人数，以使最大和最小的部分之间的差异最大。

例如，如果给定整数6567，则可以将其保留为原样，将其分为两部分65,67或四部分6,5,6,7。这为您带来以下最大差异：

6567    -> max() = 0
65,67   -> max(|65-67|) = 2
6,5,6,7 -> max(|6-5|,|6-5|,|6-6|,|6-7|,|5-6|,|5-7|,|6-7|) = 2

由于您只想做恶人，所以您不喜欢67它7，因此您将输出2或4。

另一个（不太特殊的情况）；给定整数，121131您可以像这样拆分它：

121131      -> max() = 0
121,131     -> max(|121-131|) = 10
12,11,31    -> max(|12-11|,|12-31|,|11-31|) = 20
1,2,1,1,3,1 -> max(…) = 2

这次只有一个解决方案-即3-由于三个人的差异最大。

挑战

给定一个整数，确定最大程度地邪恶的任何可能方式，并报告实现此目标所需的人数。

规则

• 输入将始终≥1
• 输入可以是整数，数字列表或字符串
• 您不必处理无效的输入

测试用例

您只需要报告所需的结果人数，可能的分区仅用于说明：

In -> splits (difference) -> Out
1 -> [1] (0) -> 1
10 -> [1,0] (1) -> 2
11 -> [11] or [1,1] (0) -> 1 or 2
12 -> [1,2] (1) -> 2
42 -> [4,2] (2) -> 2
101 -> [1,0,1] (1) -> 3
2222 -> [2222] or [22,22] or [2,2,2,2] (0) -> 1 or 2 or 4
6567 -> [65,67] or [6,5,6,7] (2) -> 2 or 4
123000 -> [123,000] (123) -> 2
123001 -> [123,001] (122) -> 2
121131 -> [12,11,31] (20) -> 3
294884 -> [294,884] (590) -> 2
192884729 -> [192,884,729] (692) -> 3
123456189012 -> [123456,189012] (65556) -> 2
123457117346 -> [1234,5711,7346] (6112) -> 3

果冻， 16  14 字节

Ṁ_Ṃ
sLÆD$ḌÇÞṪL

一个单子链接，它获取整数列表（数字）并返回一个整数。

在线尝试！或见一个测试套件

怎么样？

Ṁ_Ṃ - Link 1, maximal difference: list of numbers
Ṁ   - maximum
  Ṃ - minimum
 _  - subtract

sLÆD$ḌÇÞṪL - Main link: list of numbers, theDigits  e.g. [1,2,3,0,0,1]
    $      - last two links as a monad:
 L         -   length                                    6
  ÆD       -   divisors                                  [1,2,3,6]
s          - split into chunks (vectorises)              [[[1],[2],[3],[0],[0],[1]],[[1,2],[3,0],[0,1]],[[1,2,3],[0,0,1]],[[1,2,3,0,0,1]]]
     Ḍ     - from decimal (vectorises)                   [[1,2,3,0,0,1],[12,30,1],[123,1],[123001]]
       Þ   - sort by:
      Ç    -   call last link (1) as a monad              3             29        122     0
           -                                         ... [[123001],[1,2,3,0,0,1],[12,30,1],[123,1]]
        Ṫ  - tail                                        [123,1]
         L - length                                      2

Pyth，20个字节

leoeSaM^N2vcRQ*M{yPl

在这里尝试！

我不再使用分区，因为事实证明它会更长！！！我最终分成了长度等于长度除数的子列表。

05AB1E，12个字节

gDÑΣôDδαà}θ÷

在线尝试！

05AB1E，12个字节

gDÑΣôàsß-}θ÷

在线尝试！

怎么运行的

gDÑΣôDδαà}θ÷| 完整程序。

g | 长度（位数）。
 D | 复制（将长度的两个副本推入堆栈）。
  Ñ| 获取（堆栈顶部的）除数。
   Σ} | 按键功能排序。
-------------------------------------------------- ------------
    ôDδαà| 按键功能＃1。
    ô| 将（输入）拆分为该大小的块。
     D | 重复。
      δα| 绝对差的外积。
        à| 获得最大。
    ôàsß-| 按键功能2（替代）。
    ô| 将（输入）拆分为该大小的块。
     à| 最大值。
      s | 交换前两个元素。
       ß| 最低要求
        -| 减去。
-------------------------------------------------- ------------
          θ÷| 使用自定义排序将长度除以最大元素。

05AB1E对于这一挑战简直令人难以置信。

的JavaScript（ES6），118个 115字节

@ edc65节省了3个字节

将输入作为字符串。

f=(s,k=l=s.length,m)=>k?f(s,k-1,l%k||(d=Math.max(...a=s.match(eval(`/.{${l/k}}/g`)))-Math.min(...a))<m?m:(r=k,d)):r

测试用例

f=(s,k=l=s.length,m)=>k?f(s,k-1,l%k||(d=Math.max(...a=s.match(eval(`/.{${l/k}}/g`)))-Math.min(...a))<m?m:(r=k,d)):r

console.log(f('1')) // [1] (0) -> 1
console.log(f('10')) // [1,0] (1) -> 2
console.log(f('11')) // [11] or [1,1] (0) -> 1 or 2
console.log(f('12')) // [1,2] (1) -> 2
console.log(f('42')) // [4,2] (2) -> 2
console.log(f('101')) // [1,0,1] (1) -> 3
console.log(f('2222')) // [2222] or [22,22] or [2,2,2,2] (0) -> 1 or 2 or 4
console.log(f('6567')) // [65,67] or [6,5,6,7] (2) -> 2 or 4
console.log(f('123000')) // [123,0] (123) -> 2
console.log(f('123001')) // [123,1] (122) -> 2
console.log(f('121131')) // [12,11,31] (20) -> 3
console.log(f('294884')) // [294,884] (590) -> 2
console.log(f('192884729')) // [192,884,729] (692) -> 3
console.log(f('123456189012')) // [123456,189012] (65556) -> 2
console.log(f('123457117346')) // [1234,5711,7346] (6112) -> 3

Python 2中，138个 132字节

n=input()
l=len(n)
print len(max([[int(n[l/i*j:][:l/i])for j in range(i)]for i in range(1,l+1)if l%i<1],key=lambda a:max(a)-min(a)))

在线尝试！

哈斯克尔，114个字节

f n|l<-length n=snd$maximum[(a-b,div l i)|i<-[1..l],mod l i<1,a<-i%n,b<-i%n]
i%[]=[]
i%n=read(take i n):i%drop i n

在线尝试！

Perl 5，70个字节

s%.%/A/g;/$/,map$;[$-=$`-$_]=@1,@1for@1=(/.{@{+}}/gc)x!/./g%eg;$_=pop@

在线尝试！

果冻，20字节

ŒṖL€E$ÐfḌạþ`ẎṀ$$ÐṀḢL

在线尝试！