บทนำ

ในการท้าทายนี้คุณควรแบ่งจำนวนเต็มเป็นสองส่วน เนื่องจากไม่มีใครชอบที่จะได้ชิ้นเค้กเล็ก ๆ เป้าหมายของคุณคือยุติธรรมเท่าที่จะทำได้ ตัวอย่างเช่นถ้าคุณต้องการที่จะแยกจำนวนเต็ม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

Brachylog , 12 11 ไบต์

คำตอบ Brachylog แรกของฉัน

รับอินพุตเป็นสตริง

{~cĊịᵐ-ȧ}ᶠ⌋

ลองออนไลน์!

คำอธิบาย:

ᶠจะฉ IND ผลที่เป็นไปได้ทั้งหมดสำหรับการวินิจฉัยใน{…}และเก็บไว้ในรายการ ~cบอกว่าเอาต์พุตเป็นรายการที่เมื่อ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/^(.+)(.+)$/}

ทดสอบมัน

ขยาย:

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

ลองออนไลน์!

Prolog (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และกำหนดว่าเป็นวิธีที่มีขนาดเล็กที่สุดที่จะแยกHA

    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คำนวณสองผลของการแยกตั้งชื่อพวกเขาและXY

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)

Non-recursive (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 ไบต์ขอบคุณ dylnan

มันทำงานอย่างไร

ŒṖṖ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 (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) กับคลาสโอเปอเรเตอร์ slice curated ( %) ที่ให้มาพร้อมกับอาร์กิวเมนต์แรก ( n) เนื่องจากมีเพียงประเภทเดียว ( Stringเทียบเท่า{#Char}) ซึ่งมีทั้งสองเกินพิกัด%และtoIntเส้นนั้นคอมไพล์จริง ๆ ในขณะที่ปกติมันยากที่จะเขียนฟังก์ชั่นเมื่อเล่นกอล์ฟเนื่องจากขาดข้อมูลเชิงบริบทที่ให้กับคอมไพเลอร์

ลองออนไลน์!

เยลลี่ 12 ไบต์

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

ลิงก์ monadic ที่ใช้รายการตัวเลขและส่งคืนจำนวนเต็ม

ลองออนไลน์!

อย่างไร?

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

มันทำงานโดยใช้เคล็ดลับ regex ช่วยให้กรณีสุดท้ายเลวลงที่จะคำนวณให้มากขึ้นกว่าความแตกต่างขั้นต่ำ สำหรับ“ 12345” ค่าคือ:

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

Ruby , 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!

เสียงกระเพื่อมสามัญ 131 ไบต์

ครั้งแรกที่ฉันเข้าร่วมในการตีกอล์ฟฉันตัดสินใจใช้ 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))))))

อินพุตต้องเป็นสตริงไม่ใช่จำนวนเต็มหรือรายการ