Einführung

In dieser Challenge solltest du eine ganze Zahl in zwei Teile teilen. Da niemand das kleinere Stück Kuchen mag, ist es Ihr Ziel, so fair wie möglich zu sein. Wenn Sie beispielsweise die Ganzzahl 7129in zwei Teile teilen möchten , gibt es drei Möglichkeiten.

7,129, 71,29und es 712,9gibt alle Möglichkeiten, aber es 71,29ist die fairste Art, es in zwei Teile aufzuteilen, weil es den Unterschied zwischen den beiden minimiert:

7 129 -> |7-129| = 122
71 29 -> |71-29| = 42
712 9 -> |712-9| = 703

Herausforderung

Bestimmen Sie anhand einer Ganzzahl die bestmögliche Partitionierungsmethode wie oben beschrieben und geben Sie die resultierende Differenz an.

Regeln

• Das Teilen ist nur für ganze Zahlen mit einer Länge von mindestens zwei sinnvoll. Die Eingabe ist immer ≥ 10
• 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 den resultierenden Unterschied melden, die Partitionierung dient nur zur Veranschaulichung:

10 -> 1,0 -> 1
11 -> 1,1 -> 0
12 -> 1,2 -> 1
13 -> 1,3 -> 2
101 -> 1,01 -> 0
128 -> 12,8 -> 4
313 -> 3,13 -> 10
1003 -> 1,003 -> 2
7129 -> 71,29 -> 42
81128 -> 81,128 -> 47
999999 -> 999,999 -> 0
9999999 -> 999,9999 or 9999,999 -> 9000

Brachylog , 12 11 Bytes

Meine erste Brachylog-Antwort

Eingabe als String übernehmen

{~cĊịᵐ-ȧ}ᶠ⌋

Probieren Sie es online!

Erläuterung:

ᶠFINDET ALLE MÖGLICHEN AUSGABEN FÜR DAS PREDIKAT IN UND SPEICHERT SIE IN EINER LISTE {…}. ~csagt , daß die Ausgabe eine Liste ist , das, wenn c , mit dem Eingang gleich ist oncatenated. Next setzt Ċvoraus, dass die Ausgabe von ~cdie Länge 2 hat.

ịᵐWandelt beide Elemente der Ausgabe in Ganzzahlen um (dies beseitigt führende 0s) und -ȧberechnet die absolute Differenz der beiden Elemente.

Sobald wir unsere Liste aller möglichen Ausgaben haben, erhalten wir das minimale Element mit ⌋

Haskell , 48 Bytes

f n=minimum[abs$n`div`10^k-n`mod`10^k|k<-[1..n]]

[1..n] macht dies zu langsam für die größeren Testfälle.

Probieren Sie es online!

05AB1E , 9 Bytes

Code:

ā¤âε£ÆÄ}W

Verwendet die 05AB1E- Codierung. Probieren Sie es online!

Erläuterung

ā            # Get the array [1, 2, .., len(input)]
 ¤â          # Cartesian product with the last element, (e.g. for input 12345:
               [[1, 5], [2, 5], [3, 5], [4, 5], [5, 5]])
   ε   }     # For each element:
    £        #   Get the substrings (12345 [3, 5] £ --> [123, 45])
     Æ       #   Reduce by subtraction
      Ä      #   Get the absolute value
        W    # Take the minimum of all results

Python 2 , 64 Bytes

lambda n:min(abs(int(n[i:])-int(n[:i]))for i in range(1,len(n)))

Probieren Sie es online!

Perl 6 , 40 Bytes

{min map {abs [-] @$_},m:ex/^(.+)(.+)$/}

Probier es aus

Erweitert:

{  # bare block lambda with implicit parameter ｢$_｣

  min
    map
      {
        abs
          [-]    # reduce with &infix:«-»
            @$_  # the input of this inner block as a Positional
      },

      # split ｢$_｣ into 2 in every possible way
      m
      :exhaustive
      /^ (.+) (.+) $/
}

C 94 Bytes

c,r,d,a;f(n){for(c=1,r=0,d=n<11?1:n;n;r+=n%10*c,c*=10,n/=10)a=abs(r-n),d=r&&a<d?a:d;return d;}

Probieren Sie es online!

Python 2 , 51 Bytes

f=lambda n,k=1:min(abs(n/k-n%k),k/n*n or f(n,10*k))

Probieren Sie es online!

Prolog (SWI) , 195 189 154 117 112 Bytes

Dank Eminga 35 Bytes gespart

A*H:-findall(X,(between(0,A,I),r(A,I,X)),L),sort(L,[H|_]),!.
r(A,B,C):-Z is 10**B,divmod(A,Z,X,Y),C is abs(X-Y).

Probieren Sie es online!

Dies ist mein erster Versuch im Prologgolf, es kann also ein bisschen schrecklich sein. So funktioniert es.

Auf höchstem Niveau haben wir *. *Nimmt Aund Hund bestimmt, ob Hder kleinste Weg zum Teilen ist A.

    A*H:-
      findall(X,(between(0,A,I),call(r,A,I,X)),L),
      sort(L,[H|_]),
      !.

In der ersten Zeile wird eine Technik aus diesem SO-Post verwendet , um im Wesentlichen eine Zuordnung des Prädikats r(A)über die ganzen Zahlen von 0bis durchzuführen A. Da rdie Werte der einzelnen Partitionen bestätigt werden, erhalten wir die Werte aller möglichen Partitionen plus eine ganze Ladung zusätzlichen Mülls. Alle diese Partitionen werden Lin keiner bestimmten Reihenfolge gespeichert . Sobald dies erledigt ist, sortieren wir die Liste, um das kleinste Element zu finden. Wir verwenden dann einen Schnitt, um ein Zurückverfolgen zu verhindern.

Als nächstes haben wir die Definition von r. Zuerst rberechnet die beiden Ergebnisse der geteilten Namen sie Xund Y.

r(A,B,C):-
  Z is 10**B,
  divmod(A,Z,X,Y),
  C is abs(X-Y).

Dann behaupten wir, dass Cdas der Unterschied von ihnen ist und positiv ist.

  C is abs(X-Y).

Haskell , 68 65 Bytes

f x=minimum[abs$read(take i x)-read(drop i x)|i<-[1..length x-1]]

Probieren Sie es online!

Erläuterung

minimum              -- Minimum of ...
 [abs$               -- The absolute value of ...
  read(take i x)     -- The first i characters of x
  -                  -- Minus ...
   read(drop i x)    -- The last i characters of x
 |i<-[1..length x-1] -- From i=1 to i=length x - 1
 ]

Holzkohle , 14 Bytes

Ｉ⌊Ｅθ↔⁻Ｉ…θκＩ✂θκ

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Praktischerweise bekomme ich die 2-arg-Variante von Slice. Erläuterung:

   θ            Input string
  Ｅ             Map over characters
        θ   θ   Input string
         κ   κ  Current map index
       …        Mold to length (i.e. head)
           ✂    Slice (i.e. tail)
      Ｉ   Ｉ     Cast to integer
     ⁻          Subtract
    ↔           Absolute value
 ⌊              Minimum
Ｉ               Cast to string
                Implicitly print

Gelee , 9 8 Bytes

ḌÐƤḊạḌƤṂ

Probieren Sie es online!

-1 Byte dank Dennis. Die Eingabe ist eine Liste von Ziffern.

Erläuterung

ḌÐƤḊạḌƤṂ
ḌÐƤ          Convert to integer from decimal for all Ƥostfixes. [1,2,3]->[123,23,3]
   Ḋ         Remove the first element ->[23,3]
     ḌƤ      Convert to integer from decimal for all Ƥrefixes [1,2,3]->[1,12,123]
    ạ        Absolute difference. [23,3]ạ[1,12,123]->[22,9,123]
       Ṃ     Minimum

Funky , 159 134 99 Bytes

s=>{S={}fori=1i<#s i++{S[#S]=(((v=s::sublist)(0,i)::[email protected](i)::reduce@..)^2)^.5};math.min...S}

Eigentlich passt die Spezifikation kürzer, wie es scheint.

Probieren Sie es online!

Netzhaut , 36 Bytes

\B
,$'¶$`
\d+
$*
(1*),\1

Om`^.*
\G1

Probieren Sie es online!

Erläuterung

\B
,$'¶$`

Dadurch werden alle möglichen Partitionen in separaten Zeilen sowie eine nachfolgende Zeile mit der ursprünglichen Eingabe generiert.

\d+
$*

Wandle jede Zahl in jeder Partition in eine unäre um.

(1*),\1

Entferne eine maximale und gleiche Menge von 1s von beiden Teilen jeder Partition (dh entferne das Minimum und subtrahiere es vom Maximum, was die absolute Differenz ergibt).

Om`^.*

Sortieren Sie die Zeilen.

\G1

Zähle das 1s in der ersten Zeile, was den minimalen absoluten Unterschied ergibt.

J , 32, 27, 23 Bytes

-5 Bytes dank FrownyFrog! -4 Byte, wenn die Eingabe eine Zeichenfolge ist.

[:<./}:@(".\)|@-1}.".\.

Probieren Sie es online!

Original: Nimmt eine Zahl als Eingabe

(".\(}:@[([:<./|@-)}.@])".\.)@":

Wie es funktioniert:

                             @": - convert the number to list of chars and
(".\                    ".\.)    - form all prefixes/suffixes and convert them to numbers
    (}:@[          }.@])         - drop the last prefix / first suffix
         (     |@-)              - find the absolute differences
          [:<./                  - find the minimum

Probieren Sie es online!

JavaScript (ES6), 64 Byte

Übernimmt die Eingabe als Zeichenfolge.

f=([c,...s],l=0)=>c?Math.min(Math.abs((l+=c)-s.join``),f(s,l)):l

Testfälle

f=([c,...s],l=0)=>c?Math.min(Math.abs((l+=c)-s.join``),f(s,l)):l

console.log(f("10"     )) // -> 1
console.log(f("11"     )) // -> 0
console.log(f("12"     )) // -> 1
console.log(f("13"     )) // -> 2
console.log(f("101"    )) // -> 0
console.log(f("128"    )) // -> 4
console.log(f("313"    )) // -> 10
console.log(f("1003"   )) // -> 2
console.log(f("7129"   )) // -> 42
console.log(f("81128"  )) // -> 47
console.log(f("999999" )) // -> 0
console.log(f("9999999")) // -> 9000

Kommentiert

f = ([c, ...s],           // c = current character, s = array of remaining characters
                l = 0) => // l = left part of the integer, initialized to 0 (see footnote)
  c ?                     // if c is defined:
    Math.min(             //   return the minimum of:
      Math.abs(           //     1) the absolute value of:
        (l += c) -        //       the updated left part
        s.join``          //       minus the right part
      ),                  //     end of Math.abs()
      f(s, l)             //     2) the result of a recursive call
    )                     //   end of Math.min()
  :                       // else:
    l                     //   stop the recursion by returning l (now equal to the input)

Nicht rekursiv (ES7), 65 Byte

Übernimmt die Eingabe als Zeichenfolge.

s=>Math.min(...[...s].map(c=>((l+=c)-s.slice(++i))**2,i=l=0))**.5

Testfälle

let f =

s=>Math.min(...[...s].map(c=>((l+=c)-s.slice(++i))**2,i=l=0))**.5

console.log(f("10"     )) // -> 1
console.log(f("11"     )) // -> 0
console.log(f("12"     )) // -> 1
console.log(f("13"     )) // -> 2
console.log(f("101"    )) // -> 0
console.log(f("128"    )) // -> 4
console.log(f("313"    )) // -> 10
console.log(f("1003"   )) // -> 2
console.log(f("7129"   )) // -> 42
console.log(f("81128"  )) // -> 47
console.log(f("999999" )) // -> 0
console.log(f("9999999")) // -> 9000

Kommentiert

s =>                            // given s
  Math.min(...                  // get the minimum value in the result of this map():
    [...s].map(c =>             //   for each character c in s:
      ((l += c)                 //     append c to l (the left part)
                - s.slice(++i)) //     and subtract the right part from it
      ** 2,                     //     square the result
      i =                       //     start with i = 0 (split position)
      l = 0                     //     and l = 0 (left part, see footnote)
    )                           //   end of map()
  )                             // end of Math.min()
  ** .5                         // return the square root of the smallest square

Hinweis : lWird in beiden Versionen bei der ersten Iteration zu einer Zeichenfolge gezwungen. Normalerweise sollten wir vorsichtig mit führenden Nullen in einem numerischen Literal sein: 0123 - 10 === 73weil 0123es als Oktalwert analysiert wird (dies ist jetzt veraltet, aber im nicht strengen Modus immer noch gültig). Aber '0123' - '10' === 113, die führende Null wird diesmal ignoriert. Es ist also vernünftig, dies zu tun.

Aus der Spezifikation der abstrakten Operation, ToNumberdie auf eine Zeichenfolge angewendet wird:

Ein StringNumericLiteral, das dezimal ist, kann eine beliebige Anzahl führender 0-Stellen haben

APL (Dyalog) , 27 Bytes

{⌊/|-/⍎¨↑⊂∘⍵¨↓1,∘.=⍨⍳¯1+≢⍵}

Probieren Sie es online!

Wie?

¯1+≢⍵- Länge von nminus 1

∘.=⍨⍳ - Identitätsmatrix

      1,∘.=⍨⍳3
1 1 0 0
1 0 1 0
1 0 0 1

1,- Voranstellen 1für jede Zeile

↓ - durch Reihen geteilt

⊂∘⍵¨ - Partitionieren Sie für jede Zeichenfolge die Zeichenfolge

      1 0 1 0 ⊂ '7129'
┌──┬──┐
│71│29│
└──┴──┘

↑ - ebnen

-/ - Reduziere jedes Paar durch Subtraktion

| - Absolutwerte nehmen

⌊/ - Minimum

APL (Dyalog) , 35 Bytes

{⌊/|-/⍎¨(⊂∘⍵⍤1)1,∘.=⍨⍳¯1+≢⍵}

Probieren Sie es online!

Jelly , 11 Bytes

ŒṖṖLÐṂḌạ/€Ṃ

Probieren Sie es online!

-3 Bytes dank Dylnan

Wie es funktioniert

ŒṖṖLÐṂḌạ/€Ṃ - Main link. Argument: n (integer)    e.g    7129
ŒṖ          - Partitions of n's digits;                  [[7, 1, 2, 9], [7, 1, [2, 9]], [7, [1, 2], 9], [7, [1, 2, 9]], [[7, 1], 2, 9], [[7, 1], [2, 9]], [[7, 1, 2], 9], [7, 1, 2, 9]]
  Ṗ         - Remove the final element                   [[7, 1, 2, 9], [7, 1, [2, 9]], [7, [1, 2], 9], [7, [1, 2, 9]], [[7, 1], 2, 9], [[7, 1], [2, 9]], [[7, 1, 2], 9]]
    ÐṂ      - Keep the lists with the minimum...         [[7, [1, 2, 9]], [[7, 1], [2, 9]], [[7, 1, 2], 9]]
   L        -   length
      Ḍ     - From digits                                [[7, 129], [71, 29], [712, 9]]
        /   - Reduce...
         €  - ...each...
       ạ    - ...by absolute difference                  [122, 42, 703]
          Ṃ - Take the minimum                           42

Python 2 , 58 Bytes

lambda n:min(abs(n%10**i-n/10**i)for i in range(len(`n`)))

Probieren Sie es online!

Pyth , 15 Bytes

hSmaFvMdfqlT2./

Probieren Sie es online!

MATL , 15 Bytes

"GX@:&)UwU-|vX<

Die Eingabe ist eine Zeichenfolge, die die Ganzzahl darstellt.

Probieren Sie es online! Oder überprüfen Sie alle Testfälle .

Erläuterung

"         % Implicit input. Do the following as many times as input length
  G       %   Push input
  X@      %   Push iteration index (1-based), k
  :       %   Range: gives [1 2 ... k]
  &)      %   Two-ouput reference indexing: gives a substring with the first
          %   k characters in the input and then a substring with the rest
  U       %   Convert to number
  wU      %   Swap, convert to number
  -|      %   Absolute difference
  v       %   Vertically concatenate stack. This concatenates the obtained
          %   absolute difference with the minimum so far; does nothing in 
          %   the first iteration
  X<      %   Minimum of array
          % Implicit end. Implicit display

Wolfram Language (Mathematica) , 66 Bytes

Min@Abs[#-#2&@@FromDigits/@#&/@ReplaceList[#,{a__,b__}:>{a}|{b}]]&

Nimmt eine Liste von Ziffern.

Probieren Sie es online!

Sauber , 106 83 Bytes

import StdEnv
@n#f=toInt o(%)n
=hd(sort[abs(f(0,i)-f(i+1,size n))\\i<-[0..size n]])

Definiert die Funktion @, wobei eine Zeichenfolge verwendet wird.

Meistens ist es selbstverständlich, dass das einzige schwierige Bit ist f=toInt o(%)n: Es nimmt die toIntKlasse der Funktionen und setzt sie ( o) mit der Klasse des Curry-Slice-Operators ( %) zusammen, die bereits mit dem ersten Argument ( n) geliefert wurde . Da es nur einen ( Stringäquivalenten {#Char}) Typ gibt , der für beide überladen ist, %und toIntdie Zeile tatsächlich kompiliert, ist es normalerweise schwierig, Funktionen beim Golfen zu kompilieren, da dem Compiler keine kontextbezogenen Informationen zur Verfügung stehen.

Probieren Sie es online!

Gelee , 12 Bytes

JṬ€œṗ€⁸Ḍạ/€Ṃ

Ein monadischer Link, der eine Liste von Ziffern erstellt und die Ganzzahl zurückgibt.

Probieren Sie es online!

Wie?

JṬ€œṗ€⁸Ḍạ/€Ṃ - Link: list of digits     e.g. [7,1,2,9]
J            - range of length               [1,2,3,4]
 Ṭ€          - untruth €ach                  [[1],[0,1],[0,0,1],[0,0,0,1]]
      ⁸      - chain's left argument         [7,1,2,9]
   œṗ€       - partition at truthy for €ach  [[[],[7,1,2,9]],[7,[1,2,9]],[[7,1],[2,9]],[[7,1,2],9]]
       Ḍ     - undecimal (vectorises)        [[0,7129],[7,129],[71,29],[712,9]]
         /€  - reduce €ach by:
        ạ    - absolute difference           [7129,122,42,703]
           Ṃ - minimum                       42

Pyth, 10 Bytes

hSaMv<./Ql

Testsuite

Übernimmt die Eingabe als Zeichenfolge.

Hierbei wird eine der neueren Funktionen von Pyth verwendet, nämlich, dass beim Anwenden einer Funktion auf eine Liste standardmäßig die Funktion auf die Liste abgebildet wird, sofern kein anderes Verhalten definiert ist. Dies bedeutet, dass vauf eine Liste von Zeichenfolgen angewendet alle Zeichenfolgen ausgewertet werden.

hSaMv<./Ql
hSaMv<./QlQ    Implicit variable
      ./Q      Form all partitions of the input string.
               Split it in all possible ways, maintaining the order.
               Partitions are ordered from shortest to longest.
     <   lQ    Take the prefix as long as the input string.
               This keeps just the splits into one and two pieces.
    v          Evaluate. All strings are converted to numbers.
  aM           Map the absolute difference function.
hS             Minimum

Beachten Sie, dass die Aufteilungsliste die Aufteilung in 1 Teil zulässt. Der Wert dieser Aufteilung ist jedoch immer größer als das Minimum, sodass sie sicher ignoriert wird.

Tcl , 116 Bytes

foreach d [split [set b [set R $argv]] {}] {append L $d
regexp .(.+) $R - R
set b [expr min($b,abs($L-$R))]}
puts $b

Probieren Sie es online!

Erläuterung

b ← R ← input number
for each digit (d) in the input number:
  L += d
  strip first digit off of R using a regular expression
  b ← min( b, distance between L and R )
print b

Es funktioniert mit einem Regex-Trick, der einen entarteten Endfall ermöglicht, der immer größer als die minimale Differenz ist. Für "12345" sind die Werte:

1 2345 → 2344
12 345 → 333
123 45 → 78
1234 5 → 1229
12345 5 → 12340 (degenerate case)

Ruby , 44 Bytes

->a{((w=1)..a).map{((a%w*=10)-a/w).abs}.min}

Probieren Sie es online!

Java 8, 88 82 Bytes

n->{int r=-1,t,p=1;for(;n>=p;p*=10)if(r<0|(t=Math.abs(n/p-n%p))<r)r‌​=t;return r;}

• Port von @Dennis 'Python 2 Antwort
• Und dann von 6 Bytes von @NahuelFouilleul golfen .

Probieren Sie es online aus.

APL + WIN, 31 Bytes

⌊/|(⍎¨m↓¨⊂n)-⍎¨(m←⍳¯1+⍴n)↑¨⊂n←⎕

Fordert zur Eingabe einer Ganzzahl als Zeichenfolge auf.

Erläuterung:

m←⍳¯1+⍴n Create a list of numbers from 1 to length of string - 1

↑¨⊂n←⎕ Using m create a nested vector taking successively characters from the front of the string defined by m

⍎¨ Convert from character to integer

(⍎¨m↓¨⊂n) Using m create a nested vector dropping successively characters from the front of the string defined by m 

⌊/| take the minimum absolute value after subtracting the two vectors of integers

Perl 5 , 51 41 + 1 ( -p) = 42 Bytes

$\=$_;$\=$\>($"=abs$'-$`)?$":$\while//g}{

Probieren Sie es online!

inspiriert von @ Nahuel-Fouilleuls Kommentar

C # (.NET Core) , 112 107 + 18 = 125 Byte

n=>Enumerable.Range(1,n.Length-1).Min(i=>System.Math.Abs(int.Parse(n.Remove(i))-int.Parse(n.Substring(i))))

Probieren Sie es online!

Die Zählung umfasst die 18 Bytes in using System.Linq;. Nimmt Eingaben als string.

• 5 Bytes von Caius Jard gespeichert!