Introducción

En este desafío debes dividir un número entero en dos partes. Como a nadie le gusta obtener el pastel más pequeño, su objetivo es ser lo más justo posible. Por ejemplo, si desea dividir el entero 7129en dos partes, hay 3 formas posibles de hacerlo.

7,129, 71,29y 712,9son todas las posibilidades, pero 71,29es la forma más justa de dividirlo en dos partes porque minimiza la diferencia entre las dos:

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

Reto

Dado un número entero, determine la mejor forma posible de particionarlo como se describió anteriormente e informe la diferencia resultante.

Reglas

• Dividir solo tiene sentido para enteros de longitud de al menos dos, la entrada siempre será ≥ 10
• La entrada puede ser un número entero, una lista de dígitos o una cadena
• No tiene que manejar entradas no válidas

Casos de prueba

Solo necesita informar la diferencia resultante, la partición solo está aquí para ilustración:

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

Mi primera respuesta de Brachylog

Tomar entrada como una cadena

{~cĊịᵐ-ȧ}ᶠ⌋

Pruébalo en línea!

Explicación:

ᶠse f ind todas las salidas posibles para el predicado en {…}y almacenarlos en una lista. ~cdice que la salida es una lista que, cuando c oncatenated, es igual a la entrada. Luego Ċafirma que la salida de ~ctiene longitud 2.

ịᵐconvierte ambos elementos de la salida en enteros (esto elimina los 0s principales ), -ȧtoma la diferencia absoluta de los dos elementos.

Una vez que tenemos nuestra lista de todas las salidas posibles, obtenemos el elemento mínimo con ⌋

Haskell , 48 bytes

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

[1..n] hace que esto sea demasiado lento para los casos de prueba más grandes.

Pruébalo en línea!

05AB1E , 9 bytes

Código:

ā¤âε£ÆÄ}W

Utiliza la codificación 05AB1E . Pruébalo en línea!

Explicación

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

Pruébalo en línea!

Perl 6 , 40 bytes

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

Pruébalo

Expandido:

{  # 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;}

Pruébalo en línea!

Python 2 , 51 bytes

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

Pruébalo en línea!

Prólogo (SWI) , 195 189 154 117 112 bytes

35 bytes guardados gracias a Eminga

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

Pruébalo en línea!

Este es mi primer intento en el prolog de golf, por lo que puede ser un poco horrible. Así es como funciona.

Al más alto nivel tenemos * . *toma Ay H, y determina si Hes la forma más pequeña de dividir A.

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

La primera línea aquí usa una técnica de esta publicación SO , para realizar esencialmente un mapa del predicado r(A)sobre los enteros de 0a A. Como rconfirma los valores de cada partición, esto nos dará los valores de todas las particiones posibles, además de una carga completa de basura adicional. Todas estas particiones se almacenarán Lsin ningún orden en particular. Una vez hecho esto, ordenamos la lista para encontrar el elemento más pequeño. Luego usamos un corte para evitar el retroceso.

A continuación tenemos la definición de r . Primero rcalcula los dos resultados de la división nombrándolos Xy Y.

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

Luego afirmamos que C es la diferencia de ellos y es positivo.

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

Pruébalo en línea!

Explicación

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
 ]

Carbón , 14 bytes

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

Pruébalo en línea! El enlace es a la versión detallada del código. Convenientemente puedo usar la variante de 2 arg de Slice. Explicación:

   θ            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

Jalea , 9 8 bytes

ḌÐƤḊạḌƤṂ

Pruébalo en línea!

-1 byte gracias a Dennis. La entrada es una lista de dígitos.

Explicación

ḌÐƤḊạḌƤṂ
ḌÐƤ          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}

En realidad, ajustar la especificación es más corto, parece.

Pruébalo en línea!

Retina , 36 bytes

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

Om`^.*
\G1

Pruébalo en línea!

Explicación

\B
,$'¶$`

Esto genera todas las particiones posibles en líneas separadas, así como una línea final con la entrada original.

\d+
$*

Convierta cada número en cada partición a unario.

(1*),\1

Elimine una cantidad máxima e igual de 1s de ambas partes de cada partición (es decir, elimine el mínimo y reste del máximo, lo que da la diferencia absoluta).

Om`^.*

Ordenar las líneas.

\G1

Cuente la 1s en la primera línea, lo que da la mínima diferencia absoluta.

J , 32, 27 23 bytes

-5 bytes gracias a FrownyFrog! -4 bytes si la entrada es una cadena.

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

Pruébalo en línea!

Original: toma un número como entrada

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

Cómo funciona:

                             @": - 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

Pruébalo en línea!

JavaScript (ES6), 64 bytes

Toma la entrada como una cadena.

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

Casos de prueba

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

Comentado

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)

No recursivo (ES7), 65 bytes

Toma la entrada como una cadena.

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

Casos de prueba

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

Comentado

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

Nota : En ambas versiones, lse coacciona a una cadena en la primera iteración. Normalmente, debemos tener cuidado con los ceros iniciales en un literal numérico: 0123 - 10 === 73porque 0123se analiza como un valor octal (ahora está en desuso, pero aún es válido en modo no estricto). Pero'0123' - '10' === 113 , el cero inicial es esta vez ignorado. Entonces, es bueno hacerlo.

De la especificación de la operación abstracta ToNumberaplicada a una cadena:

Un StringNumericLiteral que es decimal puede tener cualquier número de 0 dígitos iniciales

APL (Dyalog) , 27 bytes

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

Pruébalo en línea!

¿Cómo?

¯1+≢⍵- longitud de nmenos 1

∘.=⍨⍳ - matriz de identidad

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

1,- anteponer 1para cada fila

↓ - dividido por filas

⊂∘⍵¨ - para cada uno, particione la cadena por ella

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

↑ - aplanar

-/ - reducir cada par con resta

| - tomar valores absolutos

⌊/ - mínimo

APL (Dyalog) , 35 bytes

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

Pruébalo en línea!

Jalea , 11 bytes

ŒṖṖLÐṂḌạ/€Ṃ

Pruébalo en línea!

-3 bytes gracias a dylnan

Cómo funciona

ŒṖṖ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`)))

Pruébalo en línea!

Pyth , 15 bytes

hSmaFvMdfqlT2./

Pruébalo en línea!

MATL , 15 bytes

"GX@:&)UwU-|vX<

La entrada es una cadena que representa el entero.

Pruébalo en línea! O verificar todos los casos de prueba .

Explicación

"         % 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}]]&

Toma una lista de dígitos.

Pruébalo en línea!

Limpio , 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]])

Define la función @ , tomando una cadena.

Principalmente evidente, el único bit complicado es f=toInt o(%)n: Esto toma la toIntclase de funciones y la compone ( o) con la clase de operador de corte al curry ( %) ya suministrada con el primer argumento ( n). Dado que solo hay un tipo ( Stringequivalente a {#Char}) que tiene sobrecargas para ambos %ytoInt la línea realmente se compila, mientras que normalmente es difícil componer funciones cuando se juega al golf debido a la falta de información contextual dada al compilador.

Pruébalo en línea!

Jalea , 12 bytes

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

Un enlace monádico que toma una lista de dígitos y devuelve el entero.

Pruébalo en línea!

¿Cómo?

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

Banco de pruebas

Toma la entrada como una cadena.

Esto utiliza una de las características más recientes de Pyth, que es que la aplicación de una función a una lista por defecto asigna la función a la lista, si no se define otro comportamiento. Esto significa que vaplicado a una lista de lista de cadenas evalúa todas las cadenas.

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

Tenga en cuenta que la lista de divisiones permite la división en 1 pieza, pero el valor de esta siempre será mayor que el mínimo, por lo que se ignora con seguridad.

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

Pruébalo en línea!

Explicación

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

Funciona mediante el uso de un truco regex que permite un caso final degenerado que siempre calculará una diferencia mayor que la mínima. Para "12345" los valores son:

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}

Pruébalo en línea!

APL + WIN, 31 bytes

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

Solicita la entrada en pantalla del entero como una cadena.

Explicación:

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}{

Pruébalo en línea!

inspirado en el comentario de @ Nahuel-Fouilleul

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

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

Pruébalo en línea!

El recuento incluye los 18 bytes en using System.Linq;. Toma entrada como a string.

• 5 bytes guardados por Caius Jard!

Lisp común, 131 bytes

La primera vez que participé en código golf y decidí usar Lisp, ya que me gusta.

Aquí está mi solución:

(defun f (s) (loop for i from 1 below (length s) minimizing (abs (- (parse-integer (subseq s 0 i)) (parse-integer (subseq s i))))))

La entrada debe ser una cadena, no un entero o una lista.