जितना संभव हो उतना निष्पक्ष रहें

Question

परिचय

इस चुनौती में आपको एक पूर्णांक को दो टुकड़ों में विभाजित करना चाहिए। चूंकि किसी को भी केक का छोटा टुकड़ा मिलना पसंद नहीं है, इसलिए आपका लक्ष्य जितना संभव हो उतना उचित होना चाहिए। उदाहरण के लिए यदि आप पूर्णांक 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

चुनौती

एक पूर्णांक को देखते हुए विभाजन के सर्वोत्तम संभव तरीके को निर्धारित किया गया है जैसा कि ऊपर वर्णित है और परिणामी अंतर की रिपोर्ट करें।

नियम

• विभाजित करना कम से कम दो के पूर्णांक के लिए समझ में आता है, इनपुट हमेशा for 10 होगा
• इनपुट या तो पूर्णांक, अंकों की सूची या एक स्ट्रिंग हो सकता है
• आपको अमान्य इनपुट को संभालने की आवश्यकता नहीं है

परीक्षण के मामलों

आपको केवल परिणामी अंतर की रिपोर्ट करने की आवश्यकता है, विभाजन केवल चित्रण के लिए यहां है:

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

Answer 1

ब्रेकीलॉग , 12 11 बाइट्स

मेरा पहला Brachylog उत्तर

इनपुट को एक स्ट्रिंग के रूप में लें

{~cĊịᵐ-ȧ}ᶠ⌋

इसे ऑनलाइन आज़माएं!

स्पष्टीकरण:

ᶠहोगा च इंडस्ट्रीज़ में विधेय के लिए सभी संभव outputs {…}और उन्हें एक सूची में संग्रहीत करते हैं। ~cकहते हैं कि आउटपुट एक सूची है, जब c oncatenated, इनपुट के बराबर है। अगला Ċदावा करता है कि आउटपुट की ~cलंबाई 2 है।

ịᵐआउटपुट के दोनों तत्वों को पूर्णांक में परिवर्तित करता है (इससे अग्रणी 0s से छुटकारा मिलता है ), -ȧदो तत्वों का पूर्ण अंतर लेता है।

एक बार जब हमारे पास सभी संभावित आउटपुट की हमारी सूची होगी, तो हमें न्यूनतम तत्व प्राप्त होगा ⌋

Answer 2

हास्केल , 48 बाइट्स

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

[1..n] यह बड़े परीक्षण मामलों के लिए बहुत धीमी गति से बनाता है।

इसे ऑनलाइन आज़माएं!

Comments

अच्छी नौकरी! मैं स्ट्रिंग्स का उपयोग करके इतना अंधा हो गया कि मैं भूल गया कि मैं अंकगणित का उपयोग कर सकता हूं।

— गेहूं जादूगर

Answer 3

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

Comments

यदि आप की जगह आप के £साथ की °‰जरूरत नहीं होगी ¤â।

— एमिग्ना

Answer 4

पायथन 2 , 64 बाइट्स

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

इसे ऑनलाइन आज़माएं!

Answer 5

पर्ल 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
      /^ (.+) (.+) $/
}

Answer 6

सी, 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;}

इसे ऑनलाइन आज़माएं!

Answer 7

पायथन 2 , 51 बाइट्स

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

इसे ऑनलाइन आज़माएं!

Answer 8

प्रोलोग (एसडब्ल्यूआई) , 195 189 154 117 112 बाइट्स

35 बाइट्स ने एमिंगा को धन्यवाद दिया

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|_]),
      !.

यहां पहली पंक्ति इस एसओ पद की एक तकनीक का उपयोग करती है , जो अनिवार्य रूप 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).

Comments

ऐसा लगता है कि यहाँ एक मिथ्या है जो X is div(A,10**B),Y is div(A,10**B)हमेशा देगा C=0(अर्थ)H हमेशा 0 के रूप में अच्छी तरह से होगा)। क्या Y is mod(A,10**B)मुझे मान लेना चाहिए ?

— एमिग्ना

दूसरी पंक्ति r(A,B,C):-Z is 10**B,divmod(A,Z,X,Y),C is abs(X-Y).32 बाइट्स भी बचा सकती है (यदि आप कम से कम एसडब्ल्यूआई प्रोलॉग का उपयोग कर रहे हैं, तो अन्य संस्करणों के बारे में सुनिश्चित नहीं हैं)।

— एमिग्ना

पहली पंक्ति उदाहरण के A*Hबजाय उदाहरण के साथ शुरू हो सकती हैl(A,H) दूसरे बचाने के 3. और यदि आप SWI का उपयोग कर रहे हैं, तो आप TIO लिंक

— Emigna

इसके अलावा, मुझे नहीं लगता कि आपको इसकी आवश्यकता है ,!? उस बिंदु पर कोई भी पीछे नहीं हटना चाहिए।

— एमिग्ना

@Emigna सुझावों के लिए धन्यवाद, मैं उन्हें शीघ्र ही लागू करूंगा। मैंने यह भी सोचा ,!कि यह आवश्यक नहीं होगा, लेकिन जब मैं कार्यक्रम का परीक्षण करता हूं तो यह बैकट्रेस करता है। यह हर संभव आदेश देने की कोशिश करता है Lऔर फिर उन सभी को क्रमबद्ध करता है। मतलब यह एक ही उत्तर A!समय देगा।

— गेहूं जादूगर

Answer 9

हास्केल , 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
 ]

Answer 10

चारकोल , 14 बाइट्स

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

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। आसानी से मुझे 2-arg वेरिएंट का उपयोग करने के लिए मिलता है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

Answer 11

जेली , ९ by बाइट्स

ḌÐƤḊạḌƤṂ

इसे ऑनलाइन आज़माएं!

-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

Comments

हम्म, आपकी व्याख्या यह नहीं दर्शाती है कि आपका कोड वास्तव में क्या करता है।

— आउटगॉल्फर

@EriktheOutgolfer क्या यह "अंतिम तत्व को हटाने" वाला हिस्सा है जब उसे यह कहना चाहिए कि "पहले तत्व को हटा दें"? मैं इसे ठीक करूँगा, इसे इंगित करने के लिए धन्यवाद

— dylnan

Answer 12

फंकी , 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}

वास्तव में फिटिंग फिटिंग छोटा लगता है।

इसे ऑनलाइन आज़माएं!

Answer 13

रेटिना , 36 बाइट्स

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

Om`^.*
\G1

इसे ऑनलाइन आज़माएं!

व्याख्या

\B
,$'¶$`

यह अलग-अलग लाइनों पर सभी संभावित विभाजन उत्पन्न करता है, साथ ही मूल इनपुट के साथ एक अनुगामी रेखा भी।

\d+
$*

प्रत्येक विभाजन में प्रत्येक संख्या को एकात्मक में बदलें।

(1*),\1

1प्रत्येक विभाजन के दोनों हिस्सों से अधिकतम और समान मात्रा निकालें (यानी न्यूनतम निकालें, और इसे अधिकतम से घटाएं, जो पूर्ण अंतर देता है)।

Om`^.*

लाइनों को छाँटें।

\G1

1पहली पंक्ति पर एस की गणना करें , जो न्यूनतम पूर्ण अंतर देता है।

Answer 14

जे , 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

इसे ऑनलाइन आज़माएं!

Comments

@FrownyFrog - धन्यवाद!

— गैलेन इवानोव

Answer 15

जावास्क्रिप्ट (ईएस 6), 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)

---

गैर-पुनरावर्ती (ईएस 7), 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 अंकों की अग्रणी संख्या हो सकती है

Answer 16

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+≢⍵}

इसे ऑनलाइन आज़माएं!

Answer 17

जेली , 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

Comments

आप बदल सकते हैं L=2$$Ðfकरने के लिए ṖLÐṂइस मामले में

— dylnan

Answer 18

पायथन 2 , 58 बाइट्स

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

इसे ऑनलाइन आज़माएं!

Answer 19

Pyth , 15 बाइट्स

hSmaFvMdfqlT2./

इसे ऑनलाइन आज़माएं!

Answer 20

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

Answer 21

वोल्फ्राम भाषा (गणितज्ञ) , 66 बाइट्स

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

अंकों की एक सूची लेता है।

इसे ऑनलाइन आज़माएं!

Answer 22

क्लीन , 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 लाइन वास्तव में संकलित होती है, जबकि आम तौर पर कंपाइलर को दी गई संदर्भ संबंधी जानकारी की कमी के कारण गोल्फिंग करते समय कार्यों की रचना करना कठिन होता है।

इसे ऑनलाइन आज़माएं!

Answer 23

जेली , 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

Answer 24

अजगर, 10 बाइट्स

hSaMv<./Ql

परीक्षण सूट

एक स्ट्रिंग के रूप में इनपुट लेता है।

यह पायथ की हाल की विशेषताओं में से एक का उपयोग करता है, जो यह है कि सूची में किसी फ़ंक्शन को लागू करने के लिए कोई अन्य व्यवहार निर्धारित नहीं होने पर, सूची से फ़ंक्शन को मैप करने के लिए चूक करता है। इसका मतलब यह है कि 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 टुकड़े में विभाजित करने की अनुमति देती है, लेकिन इसका मूल्य हमेशा न्यूनतम से बड़ा होगा, इसलिए इसे सुरक्षित रूप से संग्रहीत किया जाता है।

Answer 25

टीईसी , 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)

Comments

आप lmapइसके बजाय बाइट्स शेव कर सकते हैं foreach: tio.run/##LYuxCsMgFEV3v@IOb1DaZO8/ZHItDlolBEx4qC2FkG9/…

— सेरोलिओल

Answer 26

रूबी , 44 बाइट्स

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

इसे ऑनलाइन आज़माएं!

Answer 27

एपीएल + विन, 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

Comments

मैं एपीएल को नहीं जानता, क्या इसका परीक्षण करने का कोई तरीका है?

— ।

दुर्भाग्य से APL + जीत TIO में नहीं है। यदि आप APL के साथ खेलना चाहते हैं तो आप Dyalog वेबसाइट से APLX की एक प्रति मुफ्त में डाउनलोड कर सकते हैं और मेरा कोड इसके साथ काम करता है। यह Dyalog की कोशिश APL ऑन-लाइन में काम नहीं करता है। dyalog.com/aplx.htm

— ग्राहम

Answer 28

पर्ल 5 , 51 41 + 1 ( -p) = 42 बाइट्स

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

इसे ऑनलाइन आज़माएं!

@ नहुएल-फोइयूल की टिप्पणी से प्रेरित

Comments

46 बाइट्स$\--;$d=abs$``-$',$\=$\<0|$d<$\?$d:$\while//g}{

— नहुएल फौलीउल

Answer 29

C # (.NET कोर) , 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 बाइट्स!

Comments

string.Removeआपको कुछ बाइट्स बचा सकता है

— कायुस जार्ड

Answer 30

कॉमन लिस्प, 131 बाइट्स

मेरा पहली बार कोड गोल्फ में भाग लेने और मैंने लिस्प का उपयोग करने का फैसला किया, क्योंकि मुझे यह पसंद है।

यहाँ मेरा समाधान है:

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

इनपुट के लिए एक स्ट्रिंग होना चाहिए, न कि पूर्णांक या सूची।

Comments

PPCG में आपका स्वागत है! दुर्भाग्य से मैं लिस्प को नहीं जानता, लेकिन मैंने देखा कि आप इसे 11 बाइट्स से छोटा कर सकते हैं यदि आप इसे एक अनाम फ़ंक्शन बनाते हैं और कुछ व्हाट्सएप को हटाते हैं , तो यहां देखें । आप नहीं देखा है, तो यह , हो सकता है आप कुछ सुझाव मिल जाएगा।

— ბიმო