45

स्ट्रिंग के एक टुकड़े पर विचार करें ("रस्सी" के रूप में, "वर्णों का एक गुच्छा" के रूप में नहीं), जो वास्तविक रेखा पर आगे और पीछे मुड़ा हुआ है। हम स्ट्रिंग के आकार का वर्णन उन बिंदुओं की एक सूची के साथ कर सकते हैं जो इसे (क्रम में) से गुजरता है। सरलता के लिए, हम मान लेंगे कि वे सभी बिंदु पूर्णांक हैं।

एक उदाहरण के रूप में लें [-1, 3, 1, -2, 5, 2, 3, 4](ध्यान दें कि प्रत्येक प्रविष्टि एक गुना का अर्थ नहीं है):

यहाँ छवि विवरण दर्ज करें

^{ऊर्ध्वाधर दिशा के साथ फैली स्ट्रिंग केवल विज़ुअलाइज़ेशन उद्देश्यों के लिए है। वास्तविक लाइन पर चपटा हुआ स्ट्रिंग की कल्पना करें।}

अब यहां सवाल है: सबसे बड़ी संख्या क्या है इस तार को एक कट के साथ काटा जा सकता है (जो उपरोक्त चित्र में ऊर्ध्वाधर होना होगा)। इस मामले में, जवाब है 6 के बीच एक कट कहीं भी साथ 2और 3:

यहाँ छवि विवरण दर्ज करें

अस्पष्टताओं से बचने के लिए, कटौती को गैर-पूर्णांक स्थिति में किया जाना चाहिए।

चुनौती

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

आप एक पूर्ण कार्यक्रम या एक समारोह लिख सकते हैं। आप STDIN, कमांड-लाइन तर्क, प्रॉम्प्ट या फ़ंक्शन पैरामीटर के माध्यम से इनपुट ले सकते हैं। आप STDOUT को आउटपुट लिख सकते हैं, इसे एक संवाद बॉक्स में प्रदर्शित कर सकते हैं या इसे फ़ंक्शन से वापस कर सकते हैं।

आप मान सकते हैं कि सूची किसी भी सुविधाजनक सूची या स्ट्रिंग प्रारूप में है।

सूची में कम से कम 2 और 100 से अधिक प्रविष्टियाँ नहीं होंगी । प्रविष्टियाँ पूर्णांक होंगी, प्रत्येक की सीमा -2 ³¹ < p _i <2 ^{31 में होगी} । आप मान सकते हैं कि कोई भी लगातार दो प्रविष्टियाँ समान नहीं हैं।

आपके कोड को उचित डेस्कटॉप पीसी पर 10 सेकंड से कम समय में इस तरह के किसी भी इनपुट (नीचे दिए गए परीक्षण मामलों सहित) को संसाधित करना होगा।

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

सभी परीक्षण मामलों में केवल आउटपुट के बाद इनपुट होते हैं।

[0, 1]
2

[2147483647, -2147483648]
2

[0, 1, -1]
3

[1, 0, -1]
2

[-1, 3, 1, -2, 5, 2, 3, 4]
6

[-1122432493, -1297520062, 1893305528, 1165360246, -1888929223, 385040723, -80352673, 1372936505, 2115121074, -1856246962, 1501350808, -183583125, 2134014610, 720827868,  -1915801069, -829434432, 444418495, -207928085, -764106377, -180766255, 429579526,  -1887092002, -1139248992, -1967220622, -541417291, -1617463896, 517511661, -1781260846,  -804604982, 834431625, 1800360467, 603678316, 557395424, -763031007, -1336769888,  -1871888929, 1594598244, 1789292665, 962604079, -1185224024, 199953143, -1078097556, 1286821852, -1441858782, -1050367058, 956106641, -1792710927, -417329507, 1298074488,  -2081642949, -1142130252, 2069006433, -889029611, 2083629927, 1621142867, -1340561463,  676558478, 78265900, -1317128172, 1763225513, 1783160195, 483383997, -1548533202,  2122113423, -1197641704, 319428736, -116274800, -888049925, -798148170, 1768740405,  473572890, -1931167061, -298056529, 1602950715, -412370479, -2044658831, -1165885212,  -865307089, -969908936, 203868919, 278855174, -729662598, -1950547957, 679003141,  1423171080, 1870799802, 1978532600, 107162612, -1482878754, -1512232885, 1595639326,  1848766908, -321446009, -1491438272, 1619109855, 351277170, 1034981600, 421097157,  1072577364, -538901064]
53

[-2142140080, -2066313811, -2015945568, -2013211927, -1988504811, -1884073403, -1860777718,  -1852780618, -1829202121, -1754543670, -1589422902, -1557970039, -1507704627, -1410033893,  -1313864752, -1191655050, -1183729403, -1155076106, -1150685547, -1148162179, -1143013543,  -1012615847, -914543424, -898063429, -831941836, -808337369, -807593292, -775755312, -682786953, -679343381, -657346098, -616936747, -545017823, -522339238, -501194053,  -473081322, -376141541, -350526016, -344380659, -341195356, -303406389, -285611307, -282860017, -156809093, -127312384, -24161190, -420036, 50190256, 74000721, 84358785,  102958758, 124538981, 131053395, 280688418, 281444103, 303002802, 309255004, 360083648,  400920491, 429956579, 478710051, 500159683, 518335017, 559645553, 560041153, 638459051,  640161676, 643850364, 671996492, 733068514, 743285502, 1027514169, 1142193844, 1145750868,  1187862077, 1219366484, 1347996225, 1357239296, 1384342636, 1387532909, 1408330157,  1490584236, 1496234950, 1515355210, 1567464831, 1790076258, 1829519996, 1889752281,  1903484827, 1904323014, 1912488777, 1939200260, 2061174784, 2074677533, 2080731335, 2111876929, 2115658011, 2118089950, 2127342676, 2145430585]
2

— मार्टिन एंडर
स्रोत

क्या हम यह मान सकते हैं कि कटौती उस स्थान पर होनी चाहिए जो अधिकतम टुकड़ों की गारंटी देता है?

— डेविड जेएन

2

मैं शायद कहूंगा, "कितने टुकड़े" निर्धारित करने के बजाय "सबसे बड़ी संख्या में टुकड़े निर्धारित करें"।

— डेविड

1

a reasonable desktop PCबल्कि अस्पष्ट नहीं है?

— ग्लोबबी

3

@globby यह काफी सामान्य वाक्यांश है जिसका उपयोग हम तब करते हैं जब रनटाइम जीतने की कसौटी का हिस्सा नहीं होता है (लेकिन इसका उपयोग केवल यह सुनिश्चित करने के लिए किया जाता है कि समाधान ब्रूट बल का उपयोग नहीं कर रहे हैं)। इसका ज्यादातर मतलब यह है कि सीमा 100% सख्त नहीं है। यदि आपकी मशीन पर 15 सेकंड लगते हैं (और आप एक सुपर कंप्यूटर का उपयोग नहीं कर रहे हैं), तो संभावना है कि, किसी के इर्द-गिर्द एक डेस्कटॉप पीसी हो जहां वह 10 सेकंड में पूरा हो। लेकिन अगर आपकी मशीन पर एक मिनट भी कम लगता है, तो आपको एक अलग दृष्टिकोण के बारे में सोचना होगा। इसके अलावा, सीमा को ऐसे चुना जाता है कि एक कुशल एल्गोरिदम आसानी से 10 सेकंड के भीतर अच्छी तरह से पूरा हो जाएगा।

— मार्टिन एंडर

2

@ZainR नं ।

— मार्टिन एंडर

16

एपीएल, 16 14 बाइट्स

1+⌈/+/2≠/∘.≤⍨⎕

2 बाइट बचाने के लिए @ngn को धन्यवाद।

⎕वास्तव में एक बॉक्स चरित्र, नहीं एक लापता-फ़ॉन्ट त्रुटि है। आप tryapl.org पर कार्यक्रम की कोशिश कर सकते हैं , लेकिन चूंकि ⎕पूरी तरह से वहाँ समर्थित नहीं है, इसलिए आपको इसे इनपुट मूल्य से बदलना होगा:

    1+⌈/+/2≠/∘.≤⍨ ¯1 3 1 ¯2 5 2 3 4
6

व्याख्या

कार्यक्रम को उदाहरण इनपुट के साथ सबसे अच्छा समझाया गया है s = ¯1 3 1 ¯2 5 2 3 4, जिसे STDIN द्वारा लिया गया है ⎕। सबसे पहले, हम का उपयोग करके स्वयं ≤के sसाथ- रूटर उत्पाद की गणना करते हैं ∘.≤⍨। यह एक बूलियन मैट्रिक्स में परिणाम करता है जिसकी iवें पंक्ति बताती है कि कौन से तत्व निम्न sसे कम या इसके बराबर हैं s[i]:

1 1 1 0 1 1 1 1
0 1 0 0 1 0 1 1
0 1 1 0 1 1 1 1
1 1 1 1 1 1 1 1
0 0 0 0 1 0 0 0
0 1 0 0 1 1 1 1
0 1 0 0 1 0 1 1
0 0 0 0 1 0 0 1

की घटनाओं 0 1और 1 0पंक्ति पर iनिशान स्थानों पर जहां स्ट्रिंग बिंदु के ऊपर से गुजरता s[i] + 0.5। हम हर पंक्ति में इनका उपयोग करते हुए मिलान करते हैं 2≠/, "2-सब्लिस्ट्स को कम करें ≠":

0 0 1 1 0 0 0
1 1 0 1 1 1 0
1 0 1 1 0 0 0
0 0 0 0 0 0 0
0 0 0 1 1 0 0
1 1 0 1 0 0 0
1 1 0 1 1 1 0
0 0 0 1 1 0 1

क्या रहता है पंक्तियों के साथ ले जाने के लिए +/

2 5 3 0 2 3 5 3

और इनमें से अधिकतम एक 1+⌈/:

अधिकांश APL कार्यान्वयन में STDOUT में परिणाम स्वचालित रूप से मुद्रित होता है।

— Zgarb
स्रोत

@ n @h --a̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳ मेरा बुरा - अपेक्षित परिणाम टुकड़ों की संख्या है, न कि इसका उत्पादन करने का स्थान।

— जे ...

तकनीकी रूप से यह 16 अक्षर, 28 बाइट्स है। यूनिकोड आपके साथ ऐसा करेगा = P

— KChaloux

1

@KChaloux केवल अगर आप utf8 बाइट्स में गिनते हैं, जो कि आप एपीएल के लिए नहीं करेंगे। एक एकल-बाइट कोड पृष्ठ है जिसमें एपीएल द्वारा उपयोग किया जाने वाला संपूर्ण वर्ण सेट है, इसलिए गिनती के लिए इसका उपयोग करना उचित है।

— मार्टिन एंडर

@ मार्टिनबटनर एक विश्वसनीय स्रोत लिंक बहुत अच्छा होगा। अन्यथा, कोई भी बाइट काउंट कम करने के लिए किसी भी भाषा के लिए इस्तेमाल किए जाने वाले पात्रों के सेट के साथ खुद का एक मनमाना वेब पेज बना सकता है।

— बजे

1

@GuillaumeLethuillier एपीएल वास्तव में सीखना आसान है, कम से कम उस बिंदु पर जहां आप इस तरह के सरल गोल्फिंग उत्तर लिख सकते हैं। ×गुणन के लिए आसान-से-याद नामों जैसे कुछ दर्जन फ़ंक्शन हैं , और बहुत ही सरल वाक्यविन्यास नियम हैं। Google एक अच्छे मार्गदर्शक के लिए "Dyalog APL" में महारत हासिल कर रहा है।

— जर्बर्ब

16

पायथन, 88 75 73 बाइट्स

lambda x:max(sum((a+.5-m)*(a+.5-n)<0for m,n in zip(x,x[1:]))for a in x)+1

बस एक सीधा सादा मेमना

बस एक और दृष्टिकोण दिखाने के लिए:

पायथ, 28 27 बाइट्स

heSmsmq@S+k(d)1dC,QtQm+b.5Q

यह लगभग बराबर है

lambda x:max(sum(a+.5==sorted(n+(a+.5,))[1]for n in zip(x,x[1:]))for a in x)+1

एसटीडीआईएन से इनपुट सूची पर लागू। इसे ऑनलाइन दुभाषिया पर आज़माएँ ।

— Sp3000
स्रोत

आप फ़ंक्शन को समान मात्रा में वर्णों में भी संग्रहीत कर सकते हैं:def f(x):max(sum((a+.5-m)*(a+.5-n)<0for m,n in zip(x,x[1:]))for a in x)+1

— ईसाई सोना

4

@ChristianSonne आपका फ़ंक्शन कुछ भी वापस नहीं करता है।

— जक्यूब

गोली मारो, तुम सही हो @Jakube

— क्रिश्चियन Sonne

मुझे पूरी तरह यकीन नहीं है कि यह कैसे काम करता है, लेकिन मुझे लगता है कि आप +.5कुछ पात्रों को बचाने के लिए एस हटा सकते हैं । मुझे एहसास हुआ कि वे मेरे लिए व्यर्थ थे।

— केएसएफटी

@KSFT यह स्ट्रिंग को अंतराल में तोड़ता है, हर पर पुनरावृत्त करता है a = point + .5और अंतराल की संख्या को कड़ाई से युक्त करता है a। बिना .5आप तरह के मामलों के साथ समस्याओं होगा [1, 0, -1]उदाहरण।

— Sp3000

16

पायथ : 31 30 29 28 24 23 वर्ण (अजगर 68 वर्ण)

heSmsm&<hSkdgeSkdC,tQQQ

इसे यहाँ आज़माएँ: पायथ कंपाइलर / एक्ज़ीक्यूटर

यह इनपुट के रूप में पूर्णांक की एक सूची की उम्मीद करता है [-1, 3, 1, -2, 5, 2, 3, 4]

यह मेरे पायथन कार्यक्रम का सीधा अनुवाद है:

lambda s:1+max(sum(min(a)<i<=max(a)for a in zip(s,s[1:]))for i in s)

पुराना हल: पायथ 28 चार

सिर्फ संग्रह करने के कारणों के लिए।

heSmsm<*-dhk-dek0C,tQQm+b.5Q

एक समान पायथन कोड होगा:

f=lambda x:1+max(sum((i-a)*(i-b)<0for a,b in zip(x,x[1:]))for i in [j+.5 for j in x])

— Jakube
स्रोत

बहुत यकीन है कि आप ,QtQइसके बजाय का उपयोग कर सकते हैं[QtQ)

— FryAmTheEggman

iचौराहा लाइन नहीं है, i - 0.5है। और इसलिए 1 (वास्तव में 1 - 0.5 = 0.5) अंदर है (-1, 1)। min(a)<i<=max(a)के बराबर है min(a) < i - 0.5 < max(a), जो पाइथ min(a) < i < max(a)+1(नोटिस ) के साथ पाइथ में हल किया गया hहै heSk।

— जकुबे

मुझे लगता है कि आप यहीं हैं। या कम से कम मुझे कोई भी मामला नहीं मिल रहा है जहां यह तर्क विफल हो ...

— ऑप्टिमाइज़र

आप का उपयोग करके एक चरित्र को बचा सकता है g, जो >=, अगर आप को बदलने के <dheSkसाथ geSkd।

— isaacg

2

शुक्रिया @isaacg लेकिन आप हमेशा साथ क्यों आते हैं और मेरे समाधान को नष्ट करते हैं, जब मैं वास्तव में खुश और इसके बारे में आश्वस्त हूं? ;-)

— जकूबे

10

CJam, 36 34 33 30 बाइट्स

q~[__(+]zW<f{f{1$+$#1=}1b}$W=)

मेरा मानना है कि वहाँ जंगली में एक बेहतर एल्गोरिथ्म है। फिर भी, यह सभी परीक्षण मामलों के लिए आवश्यक सीमा के तहत काम करता है (ऑनलाइन कंपाइलर पर भी)

इनपुट की तरह है

[-2142140080 -2066313811 -2015945568 -2013211927 -1988504811 -1884073403 -1860777718  -1852780618 -1829202121 -1754543670 -1589422902 -1557970039 -1507704627 -1410033893  -1313864752 -1191655050 -1183729403 -1155076106 -1150685547 -1148162179 -1143013543  -1012615847 -914543424 -898063429 -831941836 -808337369 -807593292 -775755312 -682786953 -679343381 -657346098 -616936747 -545017823 -522339238 -501194053  -473081322 -376141541 -350526016 -344380659 -341195356 -303406389 -285611307 -282860017 -156809093 -127312384 -24161190 -420036 50190256 74000721 84358785  102958758 124538981 131053395 280688418 281444103 303002802 309255004 360083648  400920491 429956579 478710051 500159683 518335017 559645553 560041153 638459051  640161676 643850364 671996492 733068514 743285502 1027514169 1142193844 1145750868  1187862077 1219366484 1347996225 1357239296 1384342636 1387532909 1408330157  1490584236 1496234950 1515355210 1567464831 1790076258 1829519996 1889752281  1903484827 1904323014 1912488777 1939200260 2061174784 2074677533 2080731335 2111876929 2115658011 2118089950 2127342676 2145430585]

आउटपुट (उपरोक्त मामले के लिए) है

यह काम किस प्रकार करता है

q~[__(+]zW<f{f{1$+$#1=}1b}$W=)
q~                                "Evaluate input string as array";
  [__                             "Put two copies of it in an array";
     (+]                          "Shift first element of second copy to its end";
        z                         "Zip together the two arrays. This creates";
                                  "pair of adjacent elements of the input.";
         W<                       "Remove the last pair";
           f{            }        "For each element of input array, take the zipped";
                                  "array and run the code block";
             f{       }           "For each element of the zipped array along with";
                                  "the current element from input array, run this block";
               1$+                "Copy the current number and add it to the pair";
                  $#              "Sort the pair and find index of current number";;
                    1=            "check if index == 1 for a < I <= b check";
                       1b         "Get how many pairs have this number inside of them";
                          $W=)    "Get the maximum parts the rope can be cut into";

अब मान लें कि इनपुट ऐरे है [-1 3 1 -2 5 2 3 4], ज़िपिंग स्टेप्स जैसे दिखते हैं:

[-1 3 1 -2 5 2 3 4] [[-1 3 1 -2 5 2 3 4] [-1 3 1 -2 5 2 3 4]
[-1 3 1 -2 5 2 3 4] [[-1 3 1 -2 5 2 3 4] [3 1 -2 5 2 3 4 -1]
[-1 3 1 -2 5 2 3 4] [[-1 3] [3 1] [1 -2] [-2 5] [5 2] [2 3] [3 4]]]

अंतिम पंक्ति पर दूसरा सरणी स्ट्रिंग के सिलवटों है।

अब हम [-1 3 1 -2 5 2 3 4]इसे सेट करते हैं और उनमें से प्रत्येक की संख्या की गणना करते हैं। उस संख्या में से अधिकतम प्राप्त करें, इसे बढ़ाएं और हमारे पास हमारा उत्तर है।

इसे यहाँ ऑनलाइन आज़माएँ

— अनुकूलक
स्रोत

10

मतलाब (123) (97) (85)

अंत में, XNOR = के लिए एक उपयोग =) मुझे यकीन है कि इसे और अधिक नीचे गोल्फ किया जा सकता है।

लेकिन ईमानदारी से कहूं तो मैं थोड़ा शर्मिंदा हूं कि मतलाब वह भाषा बन रही है जिसे मैं सबसे अच्छी तरह से जानता हूं = /

अनुमानित रनटाइम है O(n^2)।

EDIT2:

a=input();v=2:nnz(a);disp(max(arrayfun(@(e)sum(~xor(a(v-1)<e,e<a(v))),sort(a)-.5))+1)

संपादित करें: नए और अधिक गोल्फ संस्करण (@DennisJaheruddin से संकेत सहित, धन्यवाद!)

a=input();c=sort(a)-.5;n=0;v=2:nnz(c);for e=c;n=[n,sum(~xor(a(v-1)<e,e<a(v)))];end;disp(max(n)+1)

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

a=input();
c=conv(sort(a),[.5,.5],'valid');' %find all cutting positions by taking the mean of two successive points
k=numel(c);
for e=1:k %iterate over all 'cuts'
    n(e)=sum(~xor(a(1:k)<c(e),c(e)<a(2:k+1)));%find the number of threads the cut cuts
end
disp(max(n)+1) %output the max

@ मार्टिनबटनर: मैं वास्तव में आपके छोटे-से-पहले-मैं-से-बिस्तर की चुनौतियों का आनंद लेता हूं!

— flawr
स्रोत

10

मेरी पत्नी

— gnibbler

9

@Xnor के लिए नोट्स लेने का समय =)

— त्रुटी

मुझे लगता है कि आप कटिंग पॉइंट को खोजने में कुछ बचत कर सकते हैं क्योंकि तह हमेशा पूर्णांक होते हैं: c=sort(a)-.5निश्चित रूप से पहला बिंदु तब सीमा से बाहर है, लेकिन निश्चित रूप से इससे निपटने में आसान है। सबसे खराब स्थिति में आप कर सकते हैं c(1)=[];। - इसके अलावा आप डिसाइड कमांड को स्ट्रिप कर सकते हैं, बस किसी चीज की गणना करने पर वह उसे लिख देगा ।-- अंत में इस केस numelसे बदला जा सकता हैnnz

— डेनिस जहरुद्दीन

लेकिन मुझे अपने convदृष्टिकोण पर बहुत गर्व था ... = डी। मैं हमेशा के बारे में भूल जाता हूं nnz, बहुत-बहुत धन्यवाद!

— १३

मैं इसे इस तरह से भी कम करने के लिए काफी कुछ तरीके खोज सकता था! मैं dispकिसी का उपयोग कर रहा हूँ जब से एक बार critized कि आपके द्वारा प्रस्तावित विधि के साथ, आपको अन्य वर्ण भी मिलते हैं (var का नाम ans) या stdout को लिखा है ...

— त्रुटी

9

गणितज्ञ १३४ १३३ १०४

कोड के आकार के बावजूद हल करने में मज़ा। इसके अलावा गोल्फ अभी भी करने के विचार को बदल कर प्राप्त किया जा सकता IntervalMemberQ[Interval[a,b],n]के साथ a<n<b।

n_~f~i_:=Count[IntervalMemberQ[#,n]&/@i,1>0];
g@l_:=Max[f[#,Interval/@Partition[l,2,1]]&/@(Union@l+.5)]+1

g[{-1, 3, 1, -2, 5, 2, 3, 4}]

6

व्याख्या

list1अंकों की दी गई सूची list2एक छोटी सूची है जो उन संख्याओं को हटाती है जो सिलवटों पर नहीं थीं; वे अप्रासंगिक हैं। यह करने के लिए आवश्यक नहीं है, लेकिन यह एक स्पष्ट और अधिक कुशल समाधान की ओर जाता है।

list1 = {-1, 3, 1, -2, 5, 2, 3, 4};
list2 = {-1, 3, 1, -2, 5,2, 3, 4} //. {beg___, a_, b_, c_, end___} /; (a <= b <= c) 
 \[Or] (a >= b >= c) :> {beg, a, c, end}

नीचे दिए गए भूखंडों में अंतराल list1और list2दिखाए गए हैं:

NumberLinePlot[Interval /@ Partition[list1, 2, 1]]
NumberLinePlot[intervalsArrangedVertically = Interval /@ Partition[list2, 2, 1]]

अंतराल

हमें केवल गुना बिंदुओं द्वारा निर्धारित प्रत्येक अंतराल में एक ही लाइन का परीक्षण करने की आवश्यकता है। परीक्षण रेखाएँ भूखंड में धराशायी खड़ी रेखाएँ हैं।

delimitersLeftToRight = Union[list2]
testLines = delimitersLeftToRight + .5
NumberLinePlot[
 intervalsArrangedVertically = Interval /@ Partition[list2, 2, 1], 
 GridLines -> {testLines, {}}, 
 GridLinesStyle -> Directive[Gray, Dashed]]

परीक्षण लाइनों

fप्रत्येक परीक्षण लाइन के कट या क्रॉसिंग की संख्या का पता लगाता है। X = 2.5 पर रेखा 5 क्रॉसिंग बनाती है। स्ट्रिंग के 5 + 1 टुकड़े छोड़ता है।

f[num_, ints_] := Count[IntervalMemberQ[#, num] & /@ ints, True]
f[#, intervalsArrangedVertically] & /@ testLines
Max[%] + 1

{२, ३, ५, ३, २, ०}
६

— DavidC
स्रोत

8

पायथ, 21 बाइट्स

heSmsmq1xS+dSkdC,tQQQ

इसे यहाँ आज़माएँ।

अजगर-शैली की सूची के रूप में इनपुट दें, जैसे [-1, 3, 1, -2, 5, 2, 3, 4]

बारीकी से @ जकुब के कार्यक्रम पर आधारित है, लेकिन एक बेहतर केंद्रीय एल्गोरिथ्म के साथ। एक >चेक और एक >=चेक करने के बजाय , मैं .index()संयुक्त रूप से तीन नंबरों पर करता हूं और यह सुनिश्चित करता हूं कि इंडेक्स 1 है, इसका मतलब न्यूनतम से अधिक है और अधिकतम से कम या बराबर है।

— isaacg
स्रोत

7

आर, 86 83

के माध्यम से काम कर रहा था और तब मुझे एहसास हुआ कि मैं अनिवार्य रूप से ऑप्टिमाइज़र और अन्य लोगों के लिए एक ही समाधान के साथ आया था, जिन पर मुझे संदेह है।

वैसे भी यहां यह एक फ़ंक्शन के रूप में है जो एक वेक्टर लेता है

f=function(l)max(colSums(mapply(function(n)c(l[-1],NA,l)<=n&c(l,l[-1],NA)>=n,l),T))

— MickyT
स्रोत

ठीक है, इसलिए मैं पक्षपाती हूं और जैसा हूं R। FWIW आप T"TRUE" के लिए उपयोग करके 3 वर्णों को बचा सकते हैं

— कार्ल विटथॉफ्ट

@CarlWitthoft टिप के लिए धन्यवाद

— मिकी

4

गोल्फस्क्रिप्ट (43 बाइट्स)

~[.(;]zip);{$}%:x{0=:y;x{{y>}%2,=},,}%$-1=)

दक्षता के संदर्भ में, यह O (n ^ 2) है जो यह मानता है कि तुलनाओं में O (1) समय लगता है। यह इनपुट को लाइन सेगमेंट में तोड़ता है और प्रत्येक शुरुआती बिंदु के लिए यह आधे-खुले लाइन सेगमेंट को गिनता है जो इसे पार करते हैं।

ऑनलाइन डेमो

— पीटर टेलर
स्रोत

4

अजगर - 161

यह शायद अधिक गोल्फ हो सकता है। gnibbler ने गोल्फ को बहुत मदद की।

l=input()
d={}
for i in zip(l,l[1:]):d[sum(i)/2.]=0
for i,k in zip(l,l[1:]):
 for j in[m for m in d.keys()if min(i,k)<m<max(i,k)]:d[j]+=1
print max(d.values())+1

— KSFT
स्रोत

1

@ MartinBüttner / Jakube मैंने इसे ठीक किया। यह अब सभी परीक्षण मामलों में दस सेकंड से कम समय के लिए काम करता है।

— केएसएफटी

इस पर दो डाउनवोट क्यों हैं?

— केएसएफटी

3

रूबी, ६३

अवधारणा में पायथन समाधान के समान।

->a{a.map{|x|a.each_cons(2).count{|v|v.min<x&&x<=v.max}}.max+1}

f=यदि आप नामांकित फ़ंक्शन चाहते हैं, तो कोड से पहले 2 वर्ण जोड़ें । Thx to MarkReed ।

— vectorized
स्रोत

नंगे खरीद एक चर को निर्दिष्ट किए बिना एक स्वीकार्य जवाब प्रतीत होता है। दो पात्रों को बचाता है।

— मार्क रीड

3

सी #, 73 65 बाइट्स

N=>1+N.Max(i=>N.Zip(N.Skip(1),(f,s)=>f<i+.5==i+.5<s).Count(b=>b))

नियमों को पढ़कर मुझे लगा कि एक C # मेमने को बहुत अच्छा करना चाहिए।

संपादित करें: अभी-अभी Countफ़िल्टरिंग के लिए एक उपयोगी अधिभार मिला है!

आप उपयुक्त delegateप्रकार को परिभाषित करके इसका परीक्षण कर सकते हैं :

delegate int solver(int[] l);

और तब

var l = new int[] { -1, 3, 1, -2, 5, 2, 3, 4 };
solver s = N=>1+N.Max(i=>N.Zip(N.Skip(1),(f,s)=>f<i+.5==i+.5<s).Count(b=>b));

Console.WriteLine(s(l));

— कार्ल वाल्श
स्रोत

3

मतलाब ( 63 43)

इनपुट को फ़ंक्शन में दी गई एक पंक्ति वेक्टर के रूप में दिया जाता है f। इसलिए उदाहरण के लिए f([-1, 3, 1, -2, 5, 2, 3, 4])रिटर्न 6।

f=@(x)max(sum(diff(bsxfun(@le,2*x',x(1:end-1)+x(2:end)))~=0))+1

छोटा संस्करण:

f=@(x)max(sum(diff(bsxfun(@lt,x',x))~=0))+1

ऑक्टेव (31)

ऑक्टेव में bsxfunस्वचालित प्रसारण के लिए धन्यवाद हटाया जा सकता है:

f=@(x)max(sum(diff(x'<x)~=0))+1

— लुइस मेंडो
स्रोत

2

जावास्क्रिप्ट (ईएस 6) 80 82

टिप्पणियां देखें - बाइट काउंट में F को असाइन नहीं किया गया है (यह अभी भी परीक्षण के लिए आवश्यक है)

F=l=>Math.max(...l.map(v=>l.map(t=>(n+=t>u?v<t&v>=u:v>=t&v<u,u=t),n=1,u=l[0])&&n))

फायरफॉक्स / फायरबग कंसोल में टेस्ट

;[
 F([0, 1])
,F([2147483647, -2147483648])
,F([0, 1, -1])
,F([1, 0, -1])
,F([-1, 3, 1, -2, 5, 2, 3, 4])  
,F([-1122432493, -1297520062, 1893305528, 1165360246, -1888929223, 385040723, -80352673, 1372936505, 2115121074, -1856246962, 1501350808, -183583125, 2134014610, 720827868, -1915801069, -829434432, 444418495, -207928085, -764106377, -180766255, 429579526, -1887092002, -1139248992, -1967220622, -541417291, -1617463896, 517511661, -1781260846, -804604982, 834431625, 1800360467, 603678316, 557395424, -763031007, -1336769888, -1871888929, 1594598244, 1789292665, 962604079, -1185224024, 199953143, -1078097556, 1286821852, -1441858782, -1050367058, 956106641, -1792710927, -417329507, 1298074488, -2081642949, -1142130252, 2069006433, -889029611, 2083629927, 1621142867, -1340561463, 676558478, 78265900, -1317128172, 1763225513, 1783160195, 483383997, -1548533202, 2122113423, -1197641704, 319428736, -116274800, -888049925, -798148170, 1768740405,  473572890, -1931167061, -298056529, 1602950715, -412370479, -2044658831, -1165885212, -865307089, -969908936, 203868919, 278855174, -729662598, -1950547957, 679003141,  1423171080, 1870799802, 1978532600, 107162612, -1482878754, -1512232885, 1595639326, 1848766908, -321446009, -1491438272, 1619109855, 351277170, 1034981600, 421097157, 1072577364, -538901064])
,F([-2142140080, -2066313811, -2015945568, -2013211927, -1988504811, -1884073403, -1860777718, -1852780618, -1829202121, -1754543670, -1589422902, -1557970039, -1507704627, -1410033893,  -1313864752, -1191655050, -1183729403, -1155076106, -1150685547, -1148162179, -1143013543,  -1012615847, -914543424, -898063429, -831941836, -808337369, -807593292, -775755312, -682786953, -679343381, -657346098, -616936747, -545017823, -522339238, -501194053,  -473081322, -376141541, -350526016, -344380659, -341195356, -303406389, -285611307, -282860017, -156809093, -127312384, -24161190, -420036, 50190256, 74000721, 84358785,  102958758, 124538981, 131053395, 280688418, 281444103, 303002802, 309255004, 360083648,  400920491, 429956579, 478710051, 500159683, 518335017, 559645553, 560041153, 638459051,  640161676, 643850364, 671996492, 733068514, 743285502, 1027514169, 1142193844, 1145750868,  1187862077, 1219366484, 1347996225, 1357239296, 1384342636, 1387532909, 1408330157,  1490584236, 1496234950, 1515355210, 1567464831, 1790076258, 1829519996, 1889752281,  1903484827, 1904323014, 1912488777, 1939200260, 2061174784, 2074677533, 2080731335, 2111876929, 2115658011, 2118089950, 2127342676, 2145430585])
]

उत्पादन

[२, २, ३, २, ६, ५३, २]

— edc65
स्रोत

2

पायथन lambdaसमाधानों के आधार पर , आपको फ़ंक्शन को वास्तविक चर में निर्दिष्ट करने की आवश्यकता नहीं है, इसलिए आप दो वर्णों को बंद कर सकते हैं।

— मार्क रीड

1

हां। जब तक अन्यथा चुनौती में नहीं कहा गया है, अनाम कार्य पूरी तरह से ठीक हैं।

— मार्टिन एंडर

1

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

>þ`^ƝS$€Ṁ‘

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

यह काम किस प्रकार करता है

>þ`^ƝS$€Ṁ‘ - Main link. 1 argument        e.g.   [1, 0, -1]
>þ`        - Greater than outer product          [[0, 0, 0], [1, 0, 0], [1, 1, 0]]
      $€   - Over each sublist:           e.g.   [1, 1, 0]
    Ɲ      -   Over each overlapping pair e.g.   [1, 0]
   ^       -     Perform XOR                     1
     S     -   Take the sums                     [0, 1, 1]
        Ṁ  - Take the maximum                    1
         ‘ - Increment                           2

— केर्ड सिक्काहिरिंग
स्रोत

1

05AB1E , 6 बाइट्स

ε@Ôg}à

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

स्पष्टीकरण:

ε   }    # for each element of the input
 @       # is each element >= this one? (returns list of booleans)
  Ô      # connected uniquified
   g     # length
     à   # maximum

— ग्रिमी
स्रोत

0

जावास्क्रिप्ट (Node.js) , 71 बाइट्स

a=>Math.max(...a.map(t=>a.map(u=>s+=(a[i++]-t-.5)*(u-t-.5)<0,s=i=1)|s))

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

— l4m2
स्रोत

0

++ , 27 बाइट्स जोड़ें

D,w,@@,VbUG€<ÑBxs
L~,A€wM1+

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

_{उनके एपीएल उत्तर के लिए ज़र्ब को धन्यवाद}

इस चुनौती का प्रमुख हिस्सा बाहरी उत्पाद कमांड को लागू करना है। दुर्भाग्य से, Add ++ में ऐसा करने के लिए एक बेसिन नहीं है, न कि इसमें उन कार्यों को परिभाषित करने का कोई तरीका है जो अन्य कार्यों को तर्क के रूप में लेते हैं। हालांकि, हम अभी भी एक सामान्यीकृत बाहरी उत्पाद कार्य कर सकते हैं। जैसे किसी फ़ंक्शन को किसी अन्य फ़ंक्शन के अंदर एक्सेस करने का एकमात्र तरीका एक मौजूदा फ़ंक्शन, उपयोगकर्ता परिभाषित या बिलिन को संदर्भित करने के माध्यम से होता है, हमें एक 'बिल्डिन' बनाना होगा जो इस तरह के फ़ंक्शन को संदर्भित करता है।

एक सामान्यीकृत "टेबल" फ़ंक्शन कुछ इस तरह दिखाई देगा:

D,func,@@,+

D,iter,@@*, VbUG €{func}
D,table,@@, $ bRbU @ €{iter} B]

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

जहां funcएक डाइएडिक फ़ंक्शन है जिसमें हमारा ऑपरेंड शामिल है। आप w फ़ंक्शन के प्रारंभ में, मूल सबमिशन में इस संरचना की बेहोश समानता देख सकते हैं , लेकिन यहां हम चाहते हैं, मुख्य रूप से, एक मोनडिक बाहरी उत्पाद फ़ंक्शन - एक बाहरी उत्पाद फ़ंक्शन जो दोनों पक्षों पर समान तर्क लेता है।

सामान्य टेबल फ़ंक्शन लाभ उठाता है कि कैसे €जल्दी से डाईडिक कार्यों के लिए पहुंचता है। अगर स्टैक दिखता है

 [a b c d e]

जब €{func}सामना किया जाता है, तो €चबूतरे eको बांधने के लिए बाएं तर्क के रूप में बांधता है, और उस आंशिक कार्य को मैप करता है a, b, c, d। हालाँकि, €सूची के बजाय पूरे स्टैक पर त्वरित मानचित्र। इसलिए हमें तर्कों को पहले तर्क के रूप में समतल करना होगा।

तालिका समारोह इस तरह कुल मिलाकर काम करता है

D,func,@@,+

D,iter,		; Define our helper function iter
		;   This takes an array as its left argument
		;   And a single integer as its right argument
	@@	; Dyadic arguments - take two arguments and push to the stack
	*,	; After execution, return the entire stack, rather then just the top element
		;
		; Example arguments:	[5 6 7 8] 1
		; 
	VbUG	; Unpack the array;	[5 6 7 8 1]
		;
	€{func}	; Map func over the stack
		; As func is dyadic, this pops the right argument
		;   and binds that to a monadic func
		; This then maps the remaining elements, [5 6 7 8]
		;   over the monadic call of func, yielding [6 7 8 9]
		; Now, as the * flag was defined, we return the entire array
		;   rather than just the last element.
		; We'd achieve the same behaviour by removing the flag and appending B]

D,table,	; Define the main table function
		;   This takes two arrays as arguments
		;   Returns a single 2D array representing their outer product with func
	@@,	; Take the two arrays and push to the stack
		; 
		; Example arguments:	[[1 2 3 4] [5 6 7 8]]
		;
	$	; Swap;		STACK = [[5 6 7 8] [1 2 3 4]]
	bR	; Reverse last;	STACK = [[5 6 7 8] [4 3 2 1]]
	bU	; Unpack;	STACK = [[5 6 7 8] 4 3 2 1]
	@	; Reverse;	STACK = [1 2 3 4 [5 6 7 8]]
		; 
		; This allows us to place the stack so that each element of
		;   the first array is iterated over with the second array
		;
	€{iter}	; Map iter;	STACK = [[6 7 8 9] [7 8 9 10] [8 9 10 11] [9 10 11 12]]
		;
	B]	; Return the whole stack;

$table>?>?
O

हालांकि, हम तथ्य यह है कि हम अपने बाहरी तालिका की जरूरत होने के लिए की वजह से काफी एक बहुत द्वारा इस छोटा कर सकते हैं monadic , और केवल तर्क पारित कर दिया करने के लिए लागू करने के लिए की जरूरत है। Aआदेश, व्यक्तिगत रूप से ढेर करने के लिए प्रत्येक तर्क धक्का तो हम किसी भी ढेर हेरफेर के साथ गड़बड़ चारों ओर की जरूरत नहीं है। संक्षेप में, यदि हमारा तर्क सरणी है [a b c d], तो हमें स्टैक बनाने की आवश्यकता है

[a b c d [a b c d]]

शीर्ष मान, निश्चित रूप से, तर्क bUहै। आपने सामान्य उदाहरण से देखा होगा जो अनपैक कमांड है अर्थात यह शीर्ष सरणी को स्टैक में विभाजित करता है। तो उपरोक्त विन्यास बनाने के लिए, हम कोड का उपयोग कर सकते हैं

L,bUA

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

हालांकि, यह एक बाइट द्वारा छोटा किया जा सकता है। एक उपनाम के रूप में L,bU, हम ~ध्वज का उपयोग कर सकते हैं , तर्कों को पहले से ढेर में विभाजित करने के लिए, हमारे विन्यास उदाहरण में

L~,A

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

जो कार्यक्रम में दूसरी पंक्ति की शुरुआत है। अब हमने मोनैडिक बाहरी उत्पाद को लागू किया है, हमें बस बाकी एल्गोरिदम को लागू करने की आवश्यकता है। एक बार (इससे कम) के साथ तालिका का परिणाम प्राप्त करने के बाद <, और प्रत्येक पंक्ति में [0 1]और [1 0]जोड़े की संख्या गिनें। अंत में, हम इन गणनाओं में से अधिकतम लेते हैं, और इसे बढ़ाते हैं।

स्टेप वॉक के लिए पूरा कदम है

D,w,		; Define a function w
		;   This takes an array and an integer as arguments
		;   First, it produces the outer product with less than
		;   Then reduce overlapping pairs by XOR
		;   Finally, sum the rows
	@@,	; Take two arguments
		;
		; Example arguments:		[[0 1 2 3] 0]
		;
	VbUG€<	; Map < over the array;	STACK = [0 1 1 1]
	ÑBx	; Equals [1 0];		STACK = [1 0 0]
	s	; Sum;			STACK = [1]

L		; Define a lambda function
		;   This takes one argument, an array
	~,	;   Splat the array to the stack before doing anything
		;
		; Example argument:		[0 1 2 3]
		;
	A€w	; Map with w;		STACK = [1 1 1 0]
	M	; Maximum;		STACK = [1]
	1+	; Increment;		STACK = [2]

— समुदाय
स्रोत

आप इस तार को कितने टुकड़ों में काट सकते हैं?

चुनौती

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

एपीएल, 16 14 बाइट्स

व्याख्या

पायथन, 88 75 73 बाइट्स

पायथ, 28 27 बाइट्स

पायथ : 31 30 29 28 24 23 वर्ण (अजगर 68 वर्ण)

पुराना हल: पायथ 28 चार

CJam, 36 34 33 30 बाइट्स

मतलाब (123) (97) (85)

गणितज्ञ १३४ १३३ १०४

व्याख्या

पायथ, 21 बाइट्स

आर, 86 83

गोल्फस्क्रिप्ट (43 बाइट्स)

अजगर - 161

रूबी, ६३

सी #, 73 65 बाइट्स

मतलाब ( 63 43)

ऑक्टेव (31)

जावास्क्रिप्ट (ईएस 6) 80 82

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

यह काम किस प्रकार करता है

05AB1E , 6 बाइट्स

जावास्क्रिप्ट (Node.js) , 71 बाइट्स

++ , 27 बाइट्स जोड़ें