क्या यह समय-समय पर दोलन करता है?

19

चुनौती

किसी सूची को देखते हुए, यह निर्धारित करें कि सूची को बढ़ते और घटते तत्वों के समूह में विभाजित करने के परिणामस्वरूप समान आकार की सूची बन जाएगी।

दूसरे शब्दों में, सूची के "मोड़" समान रूप से बाहर रखे गए हैं।

उदाहरण

यहाँ एक उदाहरण है: 0, 3, 7, 5, 2, 3, 6

0, 3, 7बढ़ जाती है, 7, 5, 2घट जाती है, और 2, 3, 6बढ़ जाती है। इसलिए यह सत्य है।

एक और उदाहरण: 1, 4, 6, 8, 5, 3, 5, 7, 9

1, 4, 6, 8बढ़ जाती है, 8, 5, 3घट जाती है, और 3, 5, 7, 9बढ़ जाती है। इसलिए यह मिथ्या है।

नियम और विनिर्देश

  • कोई भी आसन्न तत्व बराबर नहीं होगा
  • सभी संख्याओं को आपकी भाषा की उचित संख्या सीमा के भीतर माना जा सकता है
  • आप मान सकते हैं कि सभी संख्या पूर्णांक हैं, अगर यह आपके जमा करने में मदद करता है
  • यह कोड-गोल्फ है , इसलिए सबसे छोटा उत्तर जीतता है
  • किसी भी उचित प्रतिनिधित्व और आउटपुट में एक सूची के रूप में इनपुट किसी भी सत्य / मिथ्या मूल्य के रूप में। दो मूल्यों के अनुरूप होना चाहिए।

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

Input -> Output
1, 3, 5, 8, 6, 4, 2, 3, 5, 7, 6, 4, 2, 5, 7, 9, 6, 4, 2 -> True
1, 3, 5, 7, 6, 4, 5, 7, 9, 8, 6, 4, 2, 3, 5 -> False
2, 3, 6, 4, 2, 3, 7, 5, 3, 4, 6 -> True
3, 6, 4, 8, 5, 7, 3, 5, 2 -> True
8 -> True
1, 3, 5, 7 -> True
4, 5, 7, 6, 8, 9 -> False
6, 4, 2, 3, 5, 4, 2 -> True
8, 5, 3, 2, 4, 6, 5, 3, 2, 5, 7 -> False

नोट : आप यह नहीं मान सकते हैं कि सभी संख्याएँ एकल अंक हैं (जब तक कि आपकी सभी भाषा संभालने में सक्षम न हो); परीक्षण के मामले दर्शाते हैं कि सिर्फ इसलिए कि मेरे लिए इस प्रकार के मामलों को टाइप करना आसान है: P यहां कुछ परीक्षण मामले हैं जो उस श्रेणी के बाहर की संख्याओं के साथ हैं:

1, 5, 10, 19, 15, 13, 8, 13, 18, 23, 19, 18, 14 -> True
15, 14, 17, 16, 19, 18 -> True
12, 16, 19, 15, 18, 19 -> False
code-golf  array-manipulation  decision-problem 
— HyperNeutrino
स्रोत
क्या पहला रन हमेशा बढ़ता रहेगा, या इनपुट कम होने के साथ शुरू हो सकता है?
— जॉर्डन
@ जोर्डन की शुरुआत कम हो सकती है। मैं इसके लिए एक परीक्षण मामला जोड़ूंगा।
— हाइपरन्यूट्रीनो
क्या समूह हमेशा पूर्ण होते हैं? उदाहरण के लिए 1, 2, 3, 2वैध इनपुट होगा, और यदि ऐसा सच या गलत माना जाता है? उस उदाहरण में अगला मान 1 होने से यह सच हो जाएगा, लेकिन एक 3 इसे गलत बना देगा।
— टॉम कारपेंटर
1
@TomCarpenter यह गलत माना जाता है। वे सभी समान लंबाई (और इस प्रकार सभी पूर्ण) होनी चाहिए।
— हाइपरन्यूट्रिनो

जवाबों:

9

MATL , 10 9 बाइट्स

dZS&Y'da~

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

लुइस मेंडू के लिए एक बाइट धन्यवाद!

स्पष्टीकरण:

इनपुट मानें [0, 3, 7, 5, 2, 3, 6]:

            % Implicit input:                                [0, 3, 7, 5, 2, 3, 6]
d           % Difference between adjacent elements:          [3, 4, -2, -3,  1,  3]
 ZS         % Sign of the differences:                       [1, 1, -1, -1, 1, 1]
   &Y'      % Length of runs of consecutive elements:        [2, 2, 2]
     d      % Difference between the lengths:                [0, 0]
      a     % Any non-zero elements:                         False
       ~    % Negate, to get a truthy value if all are zero: True
— स्टीवी ग्रिफिन
स्रोत
8

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

IṠŒgAE

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

अदनान को 1 बाइट दिया धन्यवाद !

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

I programgAE - पूर्ण कार्यक्रम।

मैं - वृद्धि (डेल्टास)।
 Each - प्रत्येक का संकेत। -1 यदि ऋणात्मक, 0 यदि अशक्त, 1 यदि सकारात्मक।
  Œg - आसन्न तत्वों के समूह रन।
    ए - पूर्ण मूल्य। Vectorizes। यह मान -1 और 1 को एक ही मान देता है।
     ई - सभी समान हैं?

गोल्फ करते समय, मैंने कुछ शांत है, अब विकल्प की खोज की: IṠŒgL€E, IṠŒrṪ€E(का उपयोग करता है रन-लंबाई एन्कोड बजाय)।

— श्री Xcoder
स्रोत
मुझे लगता है कि IṠŒgḂE
— अदनान
@ अदनान A(निरपेक्ष मूल्य) स्थानापन्न हो सकता है Ḃया क्या कोई चाल है जिसके बारे में मुझे जानकारी नहीं है Ḃ?
— मिस्टर एक्सकोडर
कोई भी फ़ंक्शन जो 1 और -1 को एक ही संख्या में एकीकृत करता है, उसे पर्याप्त होना चाहिए
— अदनान
7

ऑक्टेव , 54 50 बाइट्स

@(x)nnz(unique(diff(find([diff(diff(x)>0) 1]))))<2

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

व्याख्या

@(x)nnz(unique(diff(find([diff(diff(x)>0) 1]))))<2

@(x)                                                % Define anonymous function    
                               diff(x)              % Deltas (consecutive differences)
                                      >0            % Positive? Gives signs
                          diff(         )           % Deltas between signs
                         [                1]        % Append 1 to "close" last group
                    find(                   )       % Indices of nonzeros
               diff(                         )      % Deltas. Gives group lengths
        unique(                               )     % Remove duplicates
    nnz(                                       )    % Number of nonzeros. Gives length
                                                <2  % If 1 or 0: input is periodic
— लुइस मेंडो
स्रोत
6

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

Equal@@(1^Differences@#~SplitBy~Sign)&

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

व्याख्या

Equal@@(1^Differences@#~SplitBy~Sign)&  (* Input:                {3, 6, 4, 8, 5, 7, 3, 5, 2} *)

          Differences@#                 (* Take differences:     {3, -2, 4, -3, 2, -4, 2, -3} *)
                       ~SplitBy~Sign    (* Split by sign:        {{3}, {-2}, {4}, {-3}, {2}, {-4}, {2}, {-3}} *)
        1^                              (* Raise to power of 1:  {{1}, {1}, {1}, {1}, {1}, {1}, {1}, {1}} *)
Equal@@                                 (* Check equal:          True *)
— जंगवान मिन
स्रोत
Equal@@(1^Split@Sign@Differences@#)&2 बाइट्स छोटा है, और Equal@@Im@Split@Sign@Differences@#&उससे 1 बाइट छोटा है।
— मिशा लावरोव
और अब जब मैं किसी अन्य बाइट Argको Signबचाने के बजाय जटिल संख्याओं के बारे में सोच रहा हूं ।
— मिशा लावरोव
5

05AB1E , 8 7 बाइट्स

¥0.SγaË

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

-1 अदनान को धन्यवाद।

— जादू ऑक्टोपस Urn
स्रोत
¥0.SγaËएक बाइट बचाना चाहिए
— अदनान
क्या है aमैं इसे डॉक्स में नहीं ढूंढ सकता। is_letter(a)???
— मैजिक ऑक्टोपस Urn
हां, यह सही है
— अदनान
@ अदनान आह ... अजीब विचार, अच्छा विचार।
— मैजिक ऑक्टोपस Urn
4

सी (जीसीसी) , 143 140 138 136 135 132 बाइट्स

  • तीन बाइट्स बचाए; rफ़ंक्शन का उपयोग करके समाप्त करने के बजाय फ़ंक्शन के रिटर्न बूलियन को संग्रहीत करने के लिए एक चर का उपयोग करना return।
  • दो बाइट्स बचाए; गोल्फ int A[]के लिए int*A(एक सूचक एक सरणी का उपयोग कर के बजाय)।
  • Steadybox के लिए धन्यवाद दो बाइट्स सहेजे गए ; गोल्फ f(int*A,int a)के लिए f(A,a)int*A;।
  • एक बाइट को बचाया; गोल्फ if(d!=...के लिए if(d-...।
  • तीन बाइट्स बचाए; गोल्फ ;j++...j+1के लिए ;...++j।
j,d,e,l,m,r;f(A,a)int*A;{for(d=A[0]>A[1],r=1,j=m=l=0;j-~-a;){l++;if(d-(e=A[j]>A[++j]))d=e,j--,r*=l>=(m=!m?l:m),l=0;}r*=-~l==m||m<1;}

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

एक फ़ंक्शन को परिभाषित करता है fजो सूची में प्रत्येक तत्व को देखता है लेकिन अंतिम और इस तत्व के सूची में अगले तत्व के संबंध को निर्धारित करता है। लगातार बराबर तुलनाओं की संख्या को पहली बार संबंध फ़्लिप किया जाता है, प्रारंभिक रन के बाद कोई भी रन जो लंबाई में संग्रहीत लंबाई के परिणाम में भिन्न होता है एक झूठा आउटपुट। अंत में, अंतिम तत्व के दूसरे-से-अंतिम तत्व के संबंध को देखा जाता है ताकि यह बाकी सूची से मेल खाता हो।

— जोनाथन फ्रेच
स्रोत
आप उपयोग कर सकते हैं f(A,a)int*A;के बजाय f(int*A,int a)।
— स्टेडीबॉक्स
3

पायथन 2 , 107 105 103 97 96 94 91 बाइट्स

lambda l:len({sum(g)**2for k,g in groupby(map(cmp,l[:-1],l[1:]))})<2
from itertools import*

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

पायथन 3 , 102 100 97 बाइट्स

lambda l:len({len([*g])for k,g in groupby(x>y for x,y in zip(l,l[1:]))})<2
from itertools import*

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

— TFeld
स्रोत
आप उपयोग कर सकते हैं {...}बजाय set(...)3 बाइट्स को बचाने के लिए
— रॉड
3

भूसी , 7 बाइट्स

EmLġ±Ẋ-

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

यह कैसे काम करता है

EmL Em ġ Ẋ- ~ पूर्ण कार्यक्रम।

     । ~ आसन्न तत्वों के जोड़े पर नक्शा।
      - ~ घटाव के साथ (यह डेल्टास की गणना करता है)
   edic ~ समानता का उपयोग करने वाला समूह विधेय।
    ± ~ संकेत।
 mL ~ लंबाई प्राप्त करें।
ई ~ सभी समान हैं?

कुछ प्यारे विकल्प:

εġLġ±Ẋ-
εüLġ±Ẋ-
— श्री Xcoder
स्रोत
2

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

यह बहुत लंबा लगता है। मैं शायद यहाँ कुछ याद कर रहा हूँ ... trueया तो लौटता है या undefined।

f=(a,p=1)=>a.every((n,i)=>!i|!(1/(y=a[i+1]))|!(i%p)^y>n^a[i-1]>n)||a[p]&&f(a,p+1)

एक अवधि 0 <p <a.length के लिए लगता है कि सभी दिशा परिवर्तन हर पी तत्वों में होते हैं।

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

कोड स्निपेट दिखाएं

— Arnauld
स्रोत
2

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

import re
def f(x):exec"x=map(cmp,x[1:],x[:-1]);"*2;re.match('.([^1]*)(-?1, \\1)*9',`x+[9]`)<0<_

इसे ऑनलाइन आज़माएं! निकास कोड के माध्यम से आउटपुट: क्रैश (1) गलत है, साफ निकास (0) सत्य है।

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

def f(x):d=map(cmp,x[1:],x[:-1]);l=len(d);s=(d+[0])[0];k=(d+[-s]).index(-s);print((k*[s]+k*[-s])*l)[:l]==d

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

— लिन
स्रोत
मैं निश्चित नहीं हूं, हालांकि (...)[:l]<dइसका उलटा हो सकता है (...)[:l]==d।
— जोनाथन फ्रीच
2

हास्केल , 79 78 77 बाइट्स

import Data.List
g s|h:t<-(1<$)<$>group(zipWith(<)s$tail s)=all(==h)t
g _=1<3

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

एक सूची को देखते हुए s, zipWith(<)s$tail sप्रत्येक तत्व के लिए परीक्षण किया जाता है कि क्या वह अपने उत्तराधिकारी से छोटा है, जैसे कि s=[2,3,6,4,2,3,7,5,3]पैदावार [True,True,False,False,True,True,False,False]। फिर groupएक ही तत्वों के साथ चलता है [[True,True],[False,False],[True,True],[False,False]]:। जांच करने के लिए उन सभी सूचियों में एक ही लंबाई है या नहीं, के साथ अपने तत्वों की जगह 1( इस युक्ति देखें ) उपज [[1,1],[1,1],[1,1],[1,1]]और देखें कि क्या पूंछ में सभी तत्वों को tइस सूची के सिर के बराबरh : all(==h)t।

यह दृष्टिकोण सिंगलटन सूचियों के लिए काम नहीं करता है, लेकिन क्योंकि वे हमेशा सच होते हैं, हम उन्हें अपने मामले में संभाल सकते हैं g[_]=1<3:।

— Laikoni
स्रोत
1

जाप , 15 बाइट्स

ä- mg ò¦ mÊä¥ e

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

व्याख्या

ä- mg ò¦ mÊä¥ e                                                  [0,3,7,5,2,3,6]
ä-                // Difference between neighboring elements     [-3,-4,2,3,-1,-3]
   mg             // Get the sign of each element                [-1,-1,1,1,-1,-1]
      ò¦          // Partition between different elements        [[-1,-1],[1,1],[-1,-1]]
         mÊ       // Get the length of each element              [2,2,2]
           ä¥     // Check for uniqueness                        [true,true]
              e   // Return true if all elements are truthy      true
— ओलिवर
स्रोत
1

आर, 36 बाइट्स

function(n)!sd(rle(sign(diff(n)))$l)

diffक्रमिक अंतरों की गणना करता है, फिर signउन लोगों को the 1 तक घटा देता है। rleफिर रन-लेंथ उन्हें एनकोड करता है। इस के सभी तत्व rleसमान होने चाहिए, अर्थात वेक्टर में मानक विचलन शून्य है। !तब सही लॉजिकल आउटपुट तैयार करता है।

— JDL
स्रोत
1

हास्केल (लैंबडॉट), 59 बाइट्स

g(map(1<$).group.ap(zipWith(<))tail->h:t)=all(==h)t;g _=1<3

@ लाकोनी के उत्तर पर आधारित

— BlackCap
स्रोत
अच्छा, मुझे पता नहीं था कि लैम्डाबोट में ViewPatterns सक्षम था। इसमें एक स्थान गायब है g_=1<3।
— लकोनी
@ लाईकोनी मी न तो, लेकिन मैं वास्तव में # फेसेल गया और इसका परीक्षण किया
— ब्लैकऑक
0

क्लोजर, 70 बाइट्स

#({0 1 1 1}(count(set(map count(partition-by pos?(map -(rest %)%))))))

रिटर्न 1truthy और के रूप में nil(उर्फ नल) falsy के रूप में।

— NikoNyrh
स्रोत
0

जावा (ओपनजेडके 8) , 135 बाइट्स

a->{Integer i=0,c,d=0,p=0,r=0;for(;++i<a.length;)d+=(i<2|(c=i.signum(a[i-1]-a[i]))<0?d<0:d>0)?c:p==0|p==-d?c-(p=d):1-(r=1);return r<1;}

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

स्पष्टीकरण

a->{                    // int array
 Integer i=0,c,d=0,p=0,r=0;
                        // variable definitions, use Integer to abuse static calls
 for(;++i<a.length;)    // Loop from 1 till length - 1
  d+=                   // Change d
   (i<2                 // First iteration?
     |(c=i.signum(a[i-1]-a[i]))<0?d<0:d>0
   )                    // Or do c and d have the same sign?
    ?c                  // then increase the magnitude of d.
    :p==0|p==-d         // else we're in a u-turn. Is it the first? Or is the magnitude the same as previously?
     ?c-(p=d)           // assign the new magnitude with sign to p and reset d to -1 (if was positive) or 1 (if was negative)
     :1-(r=1);          // else just do r=1 (technically: "add 1-1=0 to d" as well)
 return r<1;            // return whether there were wrong amplitudes.
}
— ओलिवियर ग्रेजायर
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.