introduzione

Questo è il seguito di questa sfida in cui stai assumendo il ruolo del gemello malvagio di quella persona. Essendo malvagio non vuoi massimizzare la tua parte, ma piuttosto essere il più ingiusto possibile e non lo renderai troppo ovvio, ecco perché hai ideato il seguente schema:

Dirai agli altri che vuoi essere il più equo possibile come il tuo fratello e quindi dividerai l'intero in pezzi di uguale lunghezza. Quindi per ogni numero intero otterrai la giusta quantità di persone in modo tale che la differenza tra il pezzo più grande e quello più piccolo sia massima.

Ad esempio se ti viene dato il numero intero 6567puoi lasciarlo così com'è, dividerlo in due pezzi 65,67o quattro 6,5,6,7. Questo ti dà le seguenti differenze massime:

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

Dal momento che vuoi solo essere cattivo, non preferisci 67oltre 7e quindi uscirai o 2o 4.

Un altro (caso meno speciale); dato il numero intero 121131puoi dividerlo in questo modo:

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

Questa volta c'è solo una soluzione - vale a dire 3- poiché con tre persone la differenza è massima.

Sfida

Dato un numero intero determinare qualsiasi modo possibile di essere al massimo male e riportare il numero di persone necessarie per raggiungere questo obiettivo.

Regole

• L'ingresso sarà sempre ≥ 1
• L'input può essere un numero intero, un elenco di cifre o una stringa
• Non è necessario gestire input non validi

Casi test

Devi solo segnalare il numero risultante di persone necessarie, le possibili partizioni sono solo a scopo illustrativo:

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

Gelatina ,  16  14 byte

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

Un collegamento monadico che prende un elenco di numeri interi (le cifre) e restituisce un numero intero.

Provalo online! o vedere una suite di test

Come?

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

leoeSaM^N2vcRQ*M{yPl

Provalo qui!

Non uso più le partizioni, perché risulta essere più lungo !!! Ho finito per dividere in liste di lunghezza pari ai divisori della lunghezza.

05AB1E , 12 byte

gDÑΣôDδαà}θ÷

Provalo online!

05AB1E , 12 byte

gDÑΣôàsß-}θ÷

Provalo online!

Come funziona

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

g | Lunghezza (conteggio delle cifre).
 D | Duplica (spingi due copie della lunghezza nella pila).
  Ñ ​​| Ottieni i divisori (in cima alla pila).
   Σ} | Ordina per una funzione chiave.
-------------------------------------------------- ------------
    ôDδαà | Tasto funzione # 1.
    ô | Dividi (l'input) in blocchi di quella dimensione.
     D | Duplicare.
      δα | Prodotto esterno di assoluta differenza.
        à | Ottieni il massimo.
    ôàsß- | Tasto funzione # 2 (alternativa).
    ô | Dividi (l'input) in blocchi di quella dimensione.
     à | Massimo.
      s | Scambia i primi due elementi.
       ß | Minimo.
        - | Sottrarre.
-------------------------------------------------- ------------
          θ ÷ | Dividi la lunghezza per l'elemento massimo usando l'ordinamento personalizzato.

05AB1E è incredibilmente conciso per questa sfida.

JavaScript (ES6), 118 115 byte

Salvato 3 byte grazie a @ edc65

Accetta l'input come stringa.

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

Casi test

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 byte

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

Provalo online!

Haskell , 114 byte

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

Provalo online!

Perl 5 , 70 byte

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

Provalo online!

Gelatina , 20 byte

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

Provalo online!