Introducción

Este es un seguimiento de este desafío en el que estás tomando el papel del gemelo malvado de esa persona. Siendo malvado, no desea maximizar su participación, sino que sea lo más injusto posible y no lo hará demasiado obvio, por eso se le ocurrió el siguiente esquema:

Les dirás a los demás que quieres ser lo más justo posible como tu hermano y, por lo tanto, dividirás el número entero en partes de igual longitud. Entonces, para cada número entero, obtendrá la cantidad correcta de personas, de modo que la diferencia entre la pieza más grande y la más pequeña sea máxima.

Por ejemplo, si le dan el número entero 6567, puede dejarlo como está, dividirlo en dos 65,67o cuatro partes 6,5,6,7. Esto le brinda las siguientes diferencias máximas:

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

Dado que sólo quiere ser el mal que no prefieren 67más 7y por lo tanto se dará salida a cualquiera 2o 4.

Otro (caso menos especial); dado el número entero 121131, podría dividirlo así:

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

Esta vez solo hay una solución, a saber 3, ya que con tres personas la diferencia es máxima.

Desafío

Dado un número entero, determine cualquier forma posible de ser el máximo malvado e informe la cantidad de personas necesarias para lograrlo.

Reglas

• La entrada siempre será ≥ 1
• La entrada puede ser un número entero, una lista de dígitos o una cadena
• No tiene que manejar entradas inválidas

Casos de prueba

Solo necesita informar el número resultante de personas necesarias, las particiones posibles son solo para ilustración:

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

Jalea ,  16  14 bytes

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

Un enlace monádico que toma una lista de enteros (los dígitos) y devuelve un entero.

Pruébalo en línea! o ver un conjunto de pruebas

¿Cómo?

Ṁ_Ṃ - 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 bytes

leoeSaM^N2vcRQ*M{yPl

Pruébalo aquí!

¡Ya no uso particiones, porque resulta ser más largo! Terminé dividiéndome en sublistas de longitud igual a los divisores de la longitud.

05AB1E , 12 bytes

gDÑΣôDδαà}θ÷

Pruébalo en línea!

05AB1E , 12 bytes

gDÑΣôàsß-}θ÷

Pruébalo en línea!

Cómo funciona

gDÑΣôDδαà} θ ÷ | Programa completo

g | Longitud (recuento de dígitos).
 D | Duplicar (empujar dos copias de la longitud a la pila).
  Ñ ​​| Obtenga los divisores (de la parte superior de la pila).
   Σ} | Ordenar por una función clave.
-------------------------------------------------- ------------
    ôDδαà | Función de tecla # 1.
    ô | Dividir (la entrada) en trozos de ese tamaño.
     D | Duplicar.
      δα | Producto externo de la diferencia absoluta.
        à | Obtén el máximo.
    ôàsß- | Función clave # 2 (alternativa).
    ô | Dividir (la entrada) en trozos de ese tamaño.
     à | Máximo.
      s | Intercambia los dos elementos superiores.
       ß | Mínimo.
        - | Sustraer.
-------------------------------------------------- ------------
          θ ÷ | Divida la longitud por el elemento máximo utilizando la clasificación personalizada.

05AB1E es increíblemente conciso para este desafío.

JavaScript (ES6), 118115 bytes

Guardado 3 bytes gracias a @ edc65

Toma la entrada como una cadena.

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

Casos de prueba

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 bytes

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)))

Pruébalo en línea!

Haskell , 114 bytes

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

Pruébalo en línea!

Perl 5 , 70 bytes

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

Pruébalo en línea!

Jalea , 20 bytes

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

Pruébalo en línea!