27

इस चुनौती को छोटा रखना।

आपको 4 नंबर दिए गए हैं: p1, P2, p3 और p4।

संख्या के जादुई योग को निम्नानुसार परिभाषित किया गया है:

magic_sum = |p1 - p2| + |p2 - p3| + |p3 - p4| + |p4 - p1|

आपको केवल उपरोक्त पूर्णांक मान (p1, P2, p3 या p4) में से एक को बदलने की अनुमति है। आपको मूल्य बदलने की आवश्यकता है जैसे कि मूल्यों का जादू योग इसके न्यूनतम मूल्य को प्राप्त करता है।

उदाहरण के लिए:

p1, P2, p3, p4 = 17, -6, 15, 33. इस मामले में जादू राशि का मूल्य 78 है।

आप यहां -6 को 16 में बदल सकते हैं, और जादू राशि का मूल्य 36 हो जाएगा, जो न्यूनतम प्राप्य मूल्य है।

ध्यान रखें कि संख्या सकारात्मक या नकारात्मक पूर्णांक हो सकती है।

यह कोड-गोल्फ है, कोड जीत में कम से कम बाइट्स। एक मनोरंजक भाषा पर एक व्यावहारिक भाषा का उपयोग करने के लिए ब्राउनी इंगित करता है। काश चौथा आप के साथ रहे।

बार बार कहना:

नमूना 1

इनपुट 1

17 -6 15 33

आउटपुट 1

व्याख्या १

-6 को 16 से बदला जा सकता है और यह हमें न्यूनतम प्राप्य जादू योग देता है।

नमूना २

इनपुट 2

10 10 10 10

आउटपुट 2

0 or 2

या तो स्वीकार्य है

व्याख्या २

न्यूनतम प्राप्य जादू योग 0 है क्योंकि 4 सकारात्मक पूर्णांकों का न्यूनतम योग 0. है। यदि एक संख्या को बदलना है, तो 10 में से एक को 9 में बदला जा सकता है और इस प्रकार आउटपुट 2 को उत्पन्न किया जा सकता है।

नमूना ३

इनपुट 3

1 2 3 4

आउटपुट 3

व्याख्या ३

इनपुट द्वारा ही इसकी जादू योग के रूप में 6 पैदावार होती है। 4 से 1 को बदलने और न्यूनतम जादू योग प्राप्त होता है, जो कि 4 है।

code-golf optimization

— कोइशोर रॉय
स्रोत

10

+1, लेकिन अधिक उदाहरणों के साथ कर सकता है।

— जोनाथन एलन

2

एक पूरी तरह से काम किया उदाहरण और कुछ और परीक्षण के मामले और यह +1मेरे से है।

— झबरा

@ शगुन किया। मेरी +1 कहाँ है : पी

— कोइशोर रॉय

1

@KoishoreRoy बदलाव के बिना केस 3 का परीक्षण 6 नहीं होगा?

— wizzwizz4

@ wizzwizz4 | 1 - 2 | + | २ - ३ | + | ३ - ४ | + | ४ - १ | = 1 + 1 + 1 + 3 = 6। तुम सही हो। संपादन किया।

— किशोर राय

14

जेली , 6 बाइट्स

ṢŒœIṂḤ

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

मेरे पायथन जवाब का एक बंदरगाह ।

     (input)        [17, -6, 15, 33]
Ṣ    sort           [-6, 15, 17, 33]
Œœ   odd-even elts  [[-6, 17], [15, 33]]
I    increments     [23, 18]
M    minimum        18
Ḥ    double         36

— XNOR
स्रोत

20

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

a,b,c,d=sorted(input())
print min(c-a,d-b)*2

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

क्रमित के रूप में इनपुट a,b,c,d,आरोही क्रम में, के छोटे लेता है c-aऔर d-b, और यह दोगुना हो जाता है। यह काम क्यों करता है?

सबसे पहले, ध्यान दें कि जब हम कुल चक्रीय योग को अधिकतम दूरी तक बढ़ाने के लिए एक तत्व को बदलते हैं, तो यह एक पड़ोसी को बराबर करने के लिए इसे बदलने के लिए इष्टतम (या इष्टतम के लिए बंधा हुआ) है 17, -6, 15, 33 -> 17, 17, 15, 33। ऐसा इसलिए है क्योंकि इसके बाएँ और दाएँ चक्रीय पड़ोसियों के लिए इसकी कुल दूरी कम से कम उन पड़ोसियों के बीच की दूरी है, इसलिए इन्हें बराबर बनाना सबसे अच्छा है जो हम कर सकते हैं।

अब, एक संख्या के दो आसन्न प्रतियों को हटाने से समान चक्रीय दूरी प्राप्त होती है। उदाहरण में, यह 17, 15, 33दूरी दे रहा है 2 + 18 + 16। इसलिए चार संख्याओं में से एक को बदलने के बजाय, यह केवल तीन संख्याओं को छोड़ने और अपनी चक्रीय दूरियों के योग का उपयोग करने के बराबर है।

ध्यान दें कि 3 संख्याओं के साथ, सबसे बड़ी दूरी दो छोटे लोगों का योग है। ऐसा इसलिए है क्योंकि यदि हम संख्याओं को क्रमबद्ध करते हैं a ≤ b ≤ c, तो |a - c| = |a - b| + |b - c|। दूसरे शब्दों में, हम दो बार सबसे बड़ी और सबसे छोटी संख्या के बीच यात्रा करते हैं, एक बार एक गड्ढे को रोकने के रूप में मध्यम संख्या का उपयोग करते हैं। तो, तीन दूरी का योग न्यूनतम और अधिकतम के बीच की दूरी से दोगुना है, इसलिए (c-a)*2।

तो, सवाल यह है कि हम न्यूनतम संख्या और अधिकतम तीन संख्याओं के बीच की सबसे छोटी दूरी पाने के लिए कौन सी संख्या हटाते हैं। स्पष्ट रूप से हम या तो सबसे छोटी या सबसे बड़ी संख्या को हटाते हैं। उन्हें a, b, c, dक्रमबद्ध क्रम में कॉल करना , aपत्तियों को हटाना d - bऔर dपत्तियों को हटाना c - a, और अंतिम परिणाम डबल जो भी छोटा हो।

— XNOR
स्रोत

यहाँ एक परीक्षण के मामले के साथ मेरी मदद करो। क्या होगा यदि जादू राशि पहले से ही 0 है, जो सबसे कम प्राप्य संख्या है। उस स्थिति में, उत्तर 0 होना चाहिए? या अगले सबसे कम संभव संख्या। इंक्यूज़ इनपुट है [१०,१०,१०,१०], मैजिक योग ० है। दूसरा सबसे कम संभव २ है। मुझे बताएं कि आप क्या सोचते हैं।

— कोइशोर रॉय

मैं आपको जो कहता हूं, वह सुनता हूं, तो आप दिए गए चार नंबरों के आदेश को अनदेखा कर सकते हैं (आपका पहला कदम उन्हें क्रमबद्ध करना है)। लेकिन अगर हम के लिए कहा था पाँच संख्या p1के माध्यम से p5, और अभी भी केवल अनुमति एक नंबर बदलने? चार-संख्या वाला मामला बहुत आसान लगता है (केवल आपका उत्तर देखने के बाद)।

— जेपी स्टिग नीलसन

@KoishoreRoy मुझे आपके किसी एक को अनुमति देने का समाधान पसंद है।

— xnor

@JeppeStigNielsen हां, यह तथ्य कि ऑर्डर मायने नहीं रखता है 4 नंबर के लिए विशेष है, और ऐसा इसलिए होता है क्योंकि तीन नंबर बनाने के लिए एक को हटाने के बाद, सभी संख्याओं के जोड़ चक्रीय रूप से आसन्न होते हैं। पांच नंबरों के साथ यह काम नहीं करेगा (आप निश्चित रूप से एक उदाहरण पा सकते हैं), और चुनौती बहुत अलग होगी।

— xnor

काश मैं दो बार उत्थान कर पाता। सुंदर अवलोकन, अच्छी तरह से समझाया गया।

— योना

9

आर , 66 33 बाइट्स

function(x)2*min(diff(sort(x),2))

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

Xnor के एल्गोरिथ्म के साथ बहुत कम (उनकी व्याख्या पढ़ें और उनके पोस्ट को बढ़ाएं !)।

पुराना संस्करण:

आर , 66 बाइट्स

function(x,m=matrix(x,3,4))min(colSums(abs(diff(rbind(m,m[1,])))))

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

4 पूर्णांकों के वेक्टर के रूप में इनपुट लेता है।

यह काम करता है क्योंकि न्यूनतम को अपने पड़ोसियों में से एक के बराबर संख्या निर्धारित करके प्राप्त किया जा सकता है (यह न्यूनतम प्राप्त करने का एकमात्र तरीका नहीं है)। यह देखने के लिए कि यह क्यों सच है, एक कॉन्फ़िगरेशन ढूंढें जो न्यूनतम प्राप्त करता है; हम बदल । का कोई भी मूल्य जैसे कि एक ही योग देगा ( स्थिर रहता है), इसलिए हम चुन सकते हैं । $p_2$ $p_2$ $p_1\leq p_2\leq p_3$ $|p_1-p_2|+|p_2-p_3|$ $p_2=p_1$

चुनने के 4 तरीके हैं जो हम बदलते हैं; इनमें से प्रत्येक के लिए, हमें केवल 3 पूर्ण अंतरों के योग की गणना करनी होगी।

कोड मैट्रिक्स में मान सेट करता है , जहां प्रत्येक कॉलम 4 संख्याओं के आकार 3 के सबसेट का प्रतिनिधित्व करता है। पहली पंक्ति को 4 वीं पंक्ति के साथ कॉपी करें और पूर्ण अंतरों की गणना करें, फिर कॉलम की न्यूनतम राशि लें। $3\times4$ rbind

— रॉबिन राइडर
स्रोत

4

जेली , 11 10 बाइट्स

I;SASƲ$-ƤṂ

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

एक मोनडिक लिंक जो एक सूची लेता है यदि इनपुट के रूप में पूर्णांक। मनमाना सूची आकार के लिए काम करना चाहिए। इस आधार पर काम करता है कि सूची से प्रत्येक संख्या को हटाकर, जादू राशि की गणना करके और न्यूनतम लेने के लिए न्यूनतम योग प्राप्त किया जा सकता है।

— निक केनेडी
स्रोत

3

जेली , 8 बाइट्स

ṁ-Ƥ⁸IA§Ṃ

एक मोनडिक लिंक पूर्णांक की एक सूची को स्वीकार करता है * जो एक पूर्णांक देता है

_{* 1 से अधिक होने तक कोई संख्या हो सकती है; एक ही शैली के जादू के फार्मूले का उपयोग करते हुए पड़ोसियों के मतभेदों को समेटे हुए हैं।}

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

कैसे?

ṁ-Ƥ⁸IA§Ṃ - Link: list of integers, X       e.g. [17,-6,15,33]
 -Ƥ      - for overlapping "outfixes" of length length(X)-1:
         -                                      [[-6,15,33],[17,15,33],[17,-6,33],[17,-6,15]]
ṁ  ⁸     -   mould like X                       [[-6,15,33,-6],[17,15,33,17],[17,-6,33,17],[17,-6,15,17]]
    I    - incremental differences              [[21,18,-39],[-2,18,-16],[-23,39,-16],[-23,21,2]]
     A   - absolute (vectorises)                [[21,18,39],[2,18,16],[23,39,16],[23,21,2]]
      §  - sums                                 [78,36,78,46]
       Ṃ - minimum                              36

— जोनाथन एलन
स्रोत

3

जाप `-Q` , 11 बाइट्स

ñÍó ®r- ÑÃn

@ Xnor के एल्गोरिथ्म का उपयोग करता है, जिसने मुझे 4 बाइट्स बचाए।

@ बग्घी के लिए 5 बाइट्स को सहेजा गया

कोशिश करो

— अज्ञान का अवतार
स्रोत

लगता है ठीक काम कर रहा है, लेकिन क्या आप बताएंगे कि यह क्यों काम करता है?

— किशोर राय

@KoishoreRoy ने स्पष्टीकरण दिया

— अज्ञानता का अवतार

29 बाइट्स (मुझे लगता है )

— झबरा

@ जब मैंने अपना उत्तर अपडेट किया, तो मैंने गलती से नक्शे को बदल दिया, जिससे कुछ गोल्फ अमान्य हो गए, लेकिन अन्य अच्छे हैं

— अज्ञानता का प्रतीक

अच्छी तरह से (आगे) गोल्फ वाले :) आप ÃÃएक नई पंक्ति के साथ प्रतिस्थापित करके 1 और बाइट बचा सकते हैं ।

— झबरा

3

जे , ^{24 20 18} 17 बाइट्स

वैकल्पिक संस्करण xnor एल्गोरिथ्म का उपयोग कर:

2*[:<./2 2-/@$\:~

किस तरह

दो बार 2 पंक्ति 2 *के न्यूनतम इनपुट को आकार देने से गठित 2x2 मैट्रिक्स [:<./की पहली पंक्ति से घटाया गया[:-/2 2$\:~

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

मूल उत्तर: J , 24 बाइट्स

[:<./1(1#.2|@-/\],{.)\.]

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

निक कैनेडी के विचार का उपयोग करना।

1(...)\.] लंबाई 1 से सभी उपसर्गों में क्रिया को लागू करें (लंबाई n का एक उपसर्ग n सन्निहित तत्वों के साथ एक सूची है, इसलिए यह 1 एल्म हटाए गए हर संभव सूची का उत्पादन करता है)
(1 #. 2 |@-/\ ] , {.)यह इनपुट के लिए पहले एल्म को जोड़कर ] , {.और |@-/लंबाई 2 के infixes को एब्स अंतर को लागू करके 2 ...\और परिणाम को जोड़कर मैजिक योग की गणना करता है 1 #.।
[:<./ मिनट वापस करता है

— जोनाह
स्रोत

2

05AB1E , 11 7 बाइट्स

पोर्ट ऑफ @xnor जेली उत्तर ।
-4 बाइट्स @Emigna और @Grimy की बदौलत ।

{2ô`αß·

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

7 बाइट्स विकल्प जो केवल 05AB1E की विरासत संस्करण में काम करता है ( नए संस्करण में €पहले की आवश्यकता होगी ¥):

{2ôø¥W·

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

स्पष्टीकरण:

{        # Sort the (implicit) input-list
         #  i.e. [17,-6,15,33] → [-6,15,17,33]
 2ô      # Split this list into parts of size 2
         #  → [[-6,15],[17,33]]
   `     # Push both separated to the stack
    α    # And take their absolute differences
         #  → [23,18]
     ß   # Pop and push the minimum
         #  → 18
      ·  # Double it (and output implicitly as result)
         #  → 36

{        # Sort the (implicit) input-list
         #  i.e. [17,-6,15,33] → [-6,15,17,33]
 2ô      # Split this list into parts of size 2
         #  → [[-6,15],[17,33]]
   ø     # Zip/transpose, swapping rows/columns
         #  → [[-6,17],[15,33]]
    ¥    # Get the deltas/forward differences of the inner lists
         #  → [[23],[18]]
     W   # Get the flattened minimum (without popping)
         #  → 18
      ·  # Double it (and output implicitly as result)
         #  → 36

— केविन क्रूज़सेन
स्रोत

1

विरासत में 7 बाइट्स: {2ôø¥W·या 8 के साथ €फिर से लिखना।

— प्रातः

2

गैर-विरासत में 7 बाइट्स:{2ô`αW·

— ग्रैमी

@ ईमनिगा स्मार्ट, धन्यवाद!

— केविन क्रूज़सेन

@Grimy साथ ही धन्यवाद!

— केविन क्रूज़सेन

1

C ++ (gcc)

पूरा कार्यक्रम: 138 बाइट्स

#include<iostream>
#include<regex>
using namespace std;int main(){int a[4];for(int&b:a)cin>>b;sort(a,a+4);cout<<min(a[2]-*a,a[3]-a[1])*2;}

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

मुख्य कार्य: 84 बाइट्स

#include<regex>
int m(int*a){std::sort(a,a+4);return std::min(a[2]-*a,a[3]-a[1])*2;}

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

इसके अलावा एल्गोरिथ्म xnor का उपयोग करके अपने पायथन 2 पोस्ट में समझाया गया है।

— movatica
स्रोत

0

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

Ｉ⌊ＥＥθΦθ⁻κμΣＥι↔⁻λ§ι⊕μ

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। पता चलता है कि मैं @ NickKennedy के विचार का उपयोग कर रहा हूं। स्पष्टीकरण:

   Ｅθ                   Map over input array
     Φθ                 Filter over input array where
       ⁻κμ              Outer and inner indices differ
  Ｅ                     Map over resulting list of lists
           Ｅι           Map over remaining values in list
                §ι⊕μ    Get the next value in the list
             ↔⁻λ        Compute the absolute difference with the current value
          Σ             Take the sum of absolute differences
 ⌊                      Take the minimum sum
Ｉ                       Cast to string and implicitly print

— नील
स्रोत

0

जावास्क्रिप्ट (ईएस 6), 51 बाइट्स

Xnor की अधिक चतुर विधि का उपयोग करना :

a=>([a,b,c,d]=a.sort((a,b)=>a-b),b+c<a+d?c-a:d-b)*2

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

मूल उत्तर, 96 बाइट्स

4 पूर्णांकों की एक सरणी के रूप में इनपुट लेता है। ~~संभवतः~~ निश्चित रूप से सबसे छोटा तरीका नहीं है।

a=>a.map(m=x=>a.map((y,i)=>a[m=a.map(v=>s+=Math.abs(p-(p=v)),a[i]=x,p=a[3],s=0)|m<s?m:s,i]=y))|m

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

— Arnauld
स्रोत

0

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

@ Xnor के एल्गोरिथ्म का एक बंदरगाह

2{#3-#}~Min~{#4-#2}&@@Sort@#&

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

— J42161217
स्रोत

0

जावा 8 , 235 बाइट्स

@ Xnor के पायथन उत्तर और एल्गोरिथ्म का एक बंदरगाह

import java.util.*;interface M{static void main(String[]A){Scanner I=new Scanner(System.in);int a[]={0,0,0,0};for(int i=0;i<4;a[i++]=I.nextInt());java.util.Arrays.sort(a);System.out.print(2*(a[2]-a[0]>a[3]-a[1]?a[3]-a[1]:a[2]-a[0]));}}

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

जावा 10 , अप्रमाणित, 222 बाइट्स

जावा 10 के साथ, मुझे स्कैनर घोषणा के बाईं ओर प्रतिस्थापित करने में सक्षम होना चाहिए var, हालांकि मैं इसे ऑनलाइन संकलित नहीं कर सकता था और इस प्रकार मैं इसे केवल एक सामान्य ज्ञान के रूप में जोड़ सकता हूं। माफ़ कीजिये।

interface M{static void main(String[]A){var I=new java.util.Scanner(System.in);int a[]={0,0,0,0};for(int i=3;i<4;a[i++]=I.nextInt());java.util.Arrays.sort(a);System.out.print(2*(a[2]-a[0]>a[3]-a[1]?a[3]-a[1]:a[2]-a[0]));}}

— हीरे की धूल
स्रोत

1

AFAIK आप अपने सबमिशन के रूप में एक फ़ंक्शन कर सकते हैं, जैसे कि अन्य उत्तर कैसे किए गए हैं। आसपास के वर्ग, इंटरफ़ेस आदि को शामिल करने की आवश्यकता नहीं है

— ताऊ

मुझे एक न्यूनतम जादू राशि बनाओ

नमूना 1

नमूना २

नमूना ३

जेली , 6 बाइट्स

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

आर , 66 33 बाइट्स

आर , 66 बाइट्स

जेली , 11 10 बाइट्स

जेली , 8 बाइट्स

कैसे?

जाप -Q , 11 बाइट्स

जे , 24 20 18 17 बाइट्स

किस तरह

मूल उत्तर: J , 24 बाइट्स

05AB1E , 11 7 बाइट्स

C ++ (gcc)

पूरा कार्यक्रम: 138 बाइट्स

मुख्य कार्य: 84 बाइट्स

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

जावास्क्रिप्ट (ईएस 6), 51 बाइट्स

मूल उत्तर, 96 बाइट्स

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

जावा 8 , 235 बाइट्स

जावा 10 , अप्रमाणित, 222 बाइट्स

जाप `-Q` , 11 बाइट्स

जे , ^{24 20 18} 17 बाइट्स