introduction

Il s'agit d'un suivi de ce défi où vous incarnez le mauvais jumeau de cette personne. Étant maléfique, vous ne voulez pas maximiser votre part, mais soyez aussi injuste que possible et vous n'allez pas le rendre trop évident, c'est pourquoi vous avez proposé le schéma suivant:

Vous allez dire aux autres que vous voulez être aussi juste que possible comme votre frère et donc vous allez diviser l'entier en morceaux de longueur égale. Ainsi, pour chaque entier, vous obtiendrez le bon nombre de personnes de sorte que la différence entre la plus grande et la plus petite pièce soit maximale.

Par exemple, si l'on vous donne l'entier, 6567vous pouvez le laisser tel quel, le diviser en deux 65,67ou quatre 6,5,6,7. Cela vous donne les différences maximales suivantes:

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

Puisque vous voulez seulement être le mal que vous ne préférez pas 67plus 7et ainsi vous sortie soit 2ou 4.

Un autre (cas moins spécial); étant donné l'entier, 121131vous pouvez le diviser comme ceci:

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

Cette fois, il n'y a qu'une seule solution - à savoir 3- car avec trois personnes, la différence est maximale.

Défi

Étant donné un nombre entier, déterminez tout moyen possible d'être au maximum mauvais et signalez le nombre de personnes nécessaires pour y parvenir.

Règles

• L'entrée sera toujours ≥ 1
• L'entrée peut être soit un entier, une liste de chiffres ou une chaîne
• Vous n'avez pas à gérer les entrées non valides

Cas de test

Il vous suffit de signaler le nombre de personnes nécessaires résultant, les partitions possibles sont uniquement à titre d'illustration:

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

Gelée ,  16  14 octets

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

Un lien monadique prenant une liste d'entiers (les chiffres) et renvoyant un entier.

Essayez-le en ligne! ou voir une suite de tests

Comment?

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

leoeSaM^N2vcRQ*M{yPl

Essayez-le ici!

Je n'utilise plus de partitions, car cela s'avère plus long !!! J'ai fini par me diviser en sous-listes de longueur égales aux diviseurs de la longueur.

05AB1E , 12 octets

gDÑΣôDδαà}θ÷

Essayez-le en ligne!

05AB1E , 12 octets

gDÑΣôàsß-}θ÷

Essayez-le en ligne!

Comment ça fonctionne

gDÑΣôDδαà} θ ÷ | Programme complet.

g | Longueur (nombre de chiffres).
 D | Dupliquer (pousser deux copies de la longueur dans la pile).
  Ñ ​​| Obtenez les diviseurs (du haut de la pile).
   Σ} | Trier par fonction clé.
-------------------------------------------------- ------------
    ôDδαà | Fonction clé n ° 1.
    ô | Divisez (l'entrée) en morceaux de cette taille.
     D | Dupliquer.
      δα | Produit extérieur de différence absolue.
        à | Obtenez le maximum.
    ôàsß- | Fonction clé n ° 2 (alternative).
    ô | Divisez (l'entrée) en morceaux de cette taille.
     à | Maximum.
      s | Échangez les deux éléments supérieurs.
       ß | Le minimum.
        - | Soustraire.
-------------------------------------------------- ------------
          θ ÷ | Divisez la longueur par l'élément maximum à l'aide du tri personnalisé.

05AB1E est juste incroyablement concis pour ce défi.

JavaScript (ES6), 118 115 octets

Enregistré 3 octets grâce à @ edc65

Prend l'entrée sous forme de chaîne.

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

Cas de 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 octets

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

Essayez-le en ligne!

Haskell , 114 octets

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

Essayez-le en ligne!

Perl 5 , 70 octets

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

Essayez-le en ligne!

Gelée , 20 octets

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

Essayez-le en ligne!