Введение

В этом задании вы должны разбить целое число на две части. Поскольку никто не любит получать кусочек пирога меньшего размера, ваша цель - быть максимально справедливым. Например, если вы хотите разбить целое число 7129на две части, есть 3 возможных способа сделать это.

7,129, 71,29и 712,9все возможности, но 71,29это самый справедливый способ разделить его на две части, потому что это минимизирует разницу между ними:

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

Вызов

По целому числу определите наилучший из возможных способов его разбиения, как описано выше, и сообщите полученную разницу.

правила

• Разделение имеет смысл только для целых чисел длиной не менее двух, входные данные всегда будут ≥ 10
• Ввод может быть целым числом, списком цифр или строкой
• Вам не нужно обрабатывать неверный ввод

Testcases

Вам нужно только сообщить о результирующей разнице, разделение здесь только для иллюстрации:

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

Брахилог , 12 11 байт

Мой первый ответ на брахилог

Принять ввод как строку

{~cĊịᵐ-ȧ}ᶠ⌋

Попробуйте онлайн!

Объяснение:

ᶠбудет е IND все возможные выходы для предиката в {…}и хранить их в списке. ~cговорит , что выход список , который, когда с oncatenated, равно вход. Далее Ċутверждает, что выход ~cимеет длину 2.

ịᵐпреобразует оба элемента вывода в целые числа (это избавляет от ведущих 0s), -ȧпринимает абсолютную разницу двух элементов.

Как только у нас будет список всех возможных выходных данных, мы получим минимальный элемент с ⌋

Haskell , 48 байтов

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

[1..n] делает это слишком медленным для больших тестовых случаев.

Попробуйте онлайн!

05AB1E , 9 байтов

Код:

ā¤âε£ÆÄ}W

Использует кодировку 05AB1E . Попробуйте онлайн!

объяснение

ā            # 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 байта

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

Попробуйте онлайн!

Perl 6 , 40 байт

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

Попробуй это

Expanded:

{  # 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 байта

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

Попробуйте онлайн!

Python 2 , 51 байт

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

Попробуйте онлайн!

Пролог (SWI) , 195 189 154 117 112 байт

35 байтов сэкономлено благодаря 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).

Попробуйте онлайн!

Это моя первая попытка игры в пролог, поэтому она может быть немного ужасной. Вот как это работает.

На высшем уровне мы имеем *. *принимает Aи H, и определяет, Hявляется ли наименьший способ разделения A.

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

Первая строка здесь использует технику из этого поста SO , чтобы по существу выполнить карту предиката r(A)над целыми числами от 0до A. Так как rподтверждает значения каждого раздела, это даст нам значения всех возможных разделов, плюс целую загрузку дополнительного мусора. Все эти разделы будут храниться в произвольном Lпорядке. Как только это будет сделано, мы сортируем список, чтобы найти самый маленький элемент. Затем мы используем сокращение, чтобы предотвратить возврат.

Далее у нас есть определение r. Сначала rвычисляет два результата разделения, называя их Xи Y.

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

Тогда мы утверждаем, что Cэто их различие и является положительным.

  C is abs(X-Y).

Haskell , 68 65 байт

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

Попробуйте онлайн!

объяснение

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
 ]

Древесный уголь , 14 байтов

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

Попробуйте онлайн! Ссылка на подробную версию кода. Мне удобно использовать 2-арковый вариант Slice. Объяснение:

   θ            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

Желе , 9 8 байт

ḌÐƤḊạḌƤṂ

Попробуйте онлайн!

-1 байт благодаря Денису. Ввод представляет собой список цифр.

объяснение

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

Фанки , 159 134 99 байт

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

На самом деле подгонка спецификации короче кажется.

Попробуйте онлайн!

Сетчатка , 36 байт

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

Om`^.*
\G1

Попробуйте онлайн!

объяснение

\B
,$'¶$`

Это создает все возможные разделы на отдельных строках, а также завершающую строку с исходным вводом.

\d+
$*

Конвертировать каждое число в каждом разделе в одинарное.

(1*),\1

Удалите максимальное и равное количество 1s из обеих частей каждого раздела (т.е. удалите минимум и вычтите его из максимума, что дает абсолютную разницу).

Om`^.*

Сортировка строк.

\G1

Посчитайте 1s в первой строке, что дает минимальную абсолютную разницу.

J , 32, 27 23 байта

-5 байт благодаря FrownyFrog! -4 байта, если вход является строкой.

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

Попробуйте онлайн!

Оригинал: принимает число в качестве ввода

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

Как это работает:

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

Попробуйте онлайн!

JavaScript (ES6), 64 байта

Принимает ввод в виде строки.

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

Контрольные примеры

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

комментарии

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)

Нерекурсивный (ES7), 65 байт

Принимает ввод в виде строки.

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

Контрольные примеры

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

комментарии

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

Примечание : в обеих версиях lприводится к строке на первой итерации. Как правило, мы должны быть осторожны с ведущими нулями в числовом литерале: 0123 - 10 === 73потому что 0123анализируется как восьмеричное значение (теперь это устарело, но все еще допустимо в нестрогом режиме). Но '0123' - '10' === 113ведущий ноль в этот раз игнорируется. Так что это правильно.

Из спецификации абстрактной операции, ToNumberпримененной к строке:

Десятичное число StringNumericLiteral может содержать любое количество первых 0 цифр

APL (Dyalog) , 27 байтов

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

Попробуйте онлайн!

Как?

¯1+≢⍵- длина nминус 1

∘.=⍨⍳ - единичная матрица

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

1,- готовить 1для каждого ряда

↓ - разделить на строки

⊂∘⍵¨ - для каждого разделить строку на него

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

↑ - расплющить

-/ - уменьшить каждую пару с вычитанием

| - принять абсолютные значения

⌊/ - минимум

APL (Dyalog) , 35 байт

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

Попробуйте онлайн!

Желе , 11 байт

ŒṖṖLÐṂḌạ/€Ṃ

Попробуйте онлайн!

-3 байта благодаря Дилнану

Как это работает

ŒṖṖ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 байт

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

Попробуйте онлайн!

Pyth , 15 байт

hSmaFvMdfqlT2./

Попробуйте онлайн!

MATL , 15 байт

"GX@:&)UwU-|vX<

Ввод - это строка, представляющая целое число.

Попробуйте онлайн! Или проверьте все тестовые случаи .

объяснение

"         % 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 байт

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

Принимает список цифр.

Попробуйте онлайн!

Чистый , 106 83 байта

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

Определяет функцию @, беря строку.

Наиболее очевидный, единственный хитрый момент f=toInt o(%)n: он берет toIntкласс функций и компонует его ( o) с классом оператора карризованного слайса ( %), уже предоставленным с первым аргументом ( n). Поскольку существует только один тип ( Stringэквивалентный {#Char}), который имеет перегрузки для обоих типов , %и toIntстрока фактически компилируется, тогда как обычно сложно составлять функции при игре в гольф из-за отсутствия контекстной информации, передаваемой компилятору.

Попробуйте онлайн!

Желе , 12 байт

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

Монадическая ссылка, содержащая список цифр и возвращающая целое число.

Попробуйте онлайн!

Как?

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 байт

hSaMv<./Ql

Тестирование

Принимает ввод в виде строки.

При этом используется одна из последних функций Pyth, которая заключается в том, что при применении функции к списку по умолчанию используется отображение функции по списку, если не определено другое поведение. Это означает, что vприменительно к списку строк список оценивает все строки.

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

Обратите внимание, что список разделений позволяет разделить на 1 часть, но значение этого всегда будет больше, чем минимум, поэтому он безопасно игнорируется.

Tcl , 116 байт

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

Попробуйте онлайн!

объяснение

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

Он работает с использованием трюка с регулярными выражениями, позволяющего вырожденному конечному случаю, который всегда будет вычисляться с превышением минимальной разницы. Для «12345» значения:

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

Рубин , 44 байта

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

Попробуйте онлайн!

APL + WIN, 31 байт

⌊/|(⍎¨m↓¨⊂n)-⍎¨(m←⍳¯1+⍴n)↑¨⊂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 байта

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

Попробуйте онлайн!

вдохновленный комментарием @ Nahuel-Fouilleul

C # (.NET Core) , 112 107 + 18 = 125 байт

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

Попробуйте онлайн!

Количество включает 18 байтов в using System.Linq;. Принимает вход как string.

• 5 байтов сохранены Caius Jard!

Common Lisp, 131 байт

Я впервые участвовал в Code Golf, и я решил использовать Lisp, так как мне это нравится.

Вот мое решение:

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

Входные данные должны быть строкой, а не целым числом или списком.