Einführung

Dies ist eine Fortsetzung dieser Herausforderung, bei der Sie die Rolle des bösen Zwillings dieser Person übernehmen. Als Übel wollen Sie Ihren Anteil nicht maximieren, sondern sind so unfair wie möglich und Sie werden es nicht zu offensichtlich machen. Deshalb haben Sie folgendes Schema entwickelt:

Sie werden den anderen sagen, dass Sie so fair wie möglich sein möchten, wie Ihr Geschwister, und daher werden Sie die ganze Zahl in gleich lange Stücke aufteilen. Sie werden also für jede ganze Zahl die richtige Anzahl von Personen finden, so dass der Unterschied zwischen dem größten und dem kleinsten Teil maximal ist.

Wenn Sie beispielsweise die Ganzzahl erhalten, können 6567Sie sie unverändert lassen und in zwei 65,67oder vier Teile teilen 6,5,6,7. Dies gibt Ihnen die folgenden maximalen Unterschiede:

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

Da Sie nur böse sein wollen bevorzugen Sie nicht 67über 7und so werden Sie Ausgang entweder 2oder 4.

Ein anderer (weniger spezieller Fall); Wenn 121131Sie die ganze Zahl angeben, können Sie sie wie folgt aufteilen:

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

Diesmal gibt es nur eine Lösung - nämlich 3- da bei drei Personen der Unterschied maximal ist.

Herausforderung

Gegeben eine ganze Zahl bestimmen , jede mögliche Art und Weise des Seins maximal Übel und berichten über die Zahl der Menschen , dies zu erreichen , benötigt.

Regeln

• Die Eingabe ist immer ≥ 1
• Die Eingabe kann entweder eine Ganzzahl, eine Ziffernliste oder eine Zeichenfolge sein
• Sie müssen keine ungültigen Eingaben verarbeiten

Testfälle

Sie müssen nur die resultierende Anzahl der benötigten Personen angeben, die möglichen Partitionen dienen nur zur Veranschaulichung:

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

Jelly ,  16 bis  14 Bytes

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

Ein monadischer Link, der eine Liste von ganzen Zahlen (die Ziffern) aufnimmt und eine ganze Zahl zurückgibt.

Probieren Sie es online! oder sehen Sie sich eine Testsuite an

Wie?

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

Probieren Sie es hier aus!

Ich benutze keine Partitionen mehr, weil es sich als länger herausstellt !!! Am Ende wurde ich in Unterlisten mit einer Länge aufgeteilt, die den Teilern der Länge entspricht.

05AB1E , 12 Bytes

gDÑΣôDδαà}θ÷

Probieren Sie es online!

05AB1E , 12 Bytes

gDÑΣôàsß-}θ÷

Probieren Sie es online!

Wie es funktioniert

gDÑΣôDδαà} θ ÷ | Volles Programm.

g | Länge (Anzahl der Stellen).
 D | Duplizieren (zwei Kopien der Länge auf den Stapel legen).
  Ñ ​​| Holen Sie sich die Divisoren (von der Spitze des Stapels).
   Σ} | Nach einer Tastenfunktion sortieren.
-------------------------------------------------- ------------
    ôDδαà | Tastenfunktion # 1.
    ô | Teilen Sie (die Eingabe) in Blöcke dieser Größe auf.
     D | Duplikat.
      δα | Äußeres Produkt der absoluten Differenz.
        à | Holen Sie sich das Maximum.
    ôàsß- | Tastenfunktion 2 (alternativ).
    ô | Teilen Sie (die Eingabe) in Blöcke dieser Größe auf.
     à | Maximal.
      s | Tauschen Sie die beiden oberen Elemente aus.
       ß | Minimum.
        - | Subtrahieren.
-------------------------------------------------- ------------
          θ ÷ | Teilen Sie die Länge mit der benutzerdefinierten Sortierung durch das maximale Element.

05AB1E ist für diese Herausforderung einfach unglaublich knapp.

JavaScript (ES6), 118 115 Byte

3 Bytes gespart dank @ edc65

Übernimmt die Eingabe als Zeichenfolge.

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

Testfälle

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

Probieren Sie es online!

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

Probieren Sie es online!

Perl 5 , 70 Bytes

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

Probieren Sie es online!

Gelee , 20 Bytes

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

Probieren Sie es online!