23

हाल ही में मैंने मैथ्स टेस्ट दिया और देखा कि टेस्ट में एक निश्चित नंबर एक दिलचस्प पैटर्न से मेल खाता था। संख्या ( 28384) एक सामान्य अंक अनुक्रम से मेल खाती है जो इस तरह दिखता है

(n)(x)(n+1)(x)(n+2)(x)(n+3) etc...

जहाँ nऔर xएकल अंक पूर्णांक हैं। अनुक्रम किसी के साथ शुरू कर सकते हैं xया nऔर साथ अंत या तो xया n+y।

आपका कार्य एक बहु अंकों का सकारात्मक पूर्णांक दिया गया है, यह एक सत्य या गलत मूल्य का उत्पादन करता है, जो इस बात पर निर्भर करता है कि इनपुट पैटर्न से मेल खाता है या नहीं। इनपुट 4 से 18 अंकों के बीच होगा। आप पूर्णांक के स्ट्रिंग प्रतिनिधित्व के रूप में इनपुट ले सकते हैं। इनपुट 0 से शुरू नहीं होगा, लेकिन इसमें 0 के साथ समाप्‍त या सम्‍मिलित हो सकता है।

n+y हमेशा एकल अंक संख्या होगी (इसलिए लंबाई सीमा 18 क्यों है)।

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

ये एक सत्य मूल्य का उत्पादन करना चाहिए

182838485868788898
4344
85868
12223242526

और ये गलत होना चाहिए

12345
6724013635
36842478324836
1222232425
5859510511

सभी कोड गोल्फ के साथ, सबसे छोटा कोड जीतता है! सौभाग्य और बाधाओं, कभी भी आपके पक्ष में हो सकता है!

code-golf number sequence

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

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

— कृति लिथोस

@KritiiLithos "आप पूर्णांक के स्ट्रिंग प्रतिनिधित्व के रूप में इनपुट ले सकते हैं।"

— श्री Xcoder

क्या नियम के अनुकूल संख्या के लिए दोनों xऔर nगैर-शून्य हैं?

— श्री एक्सकोडर

@ Mr.Xcoder संख्या 0 से शुरू नहीं हो सकती है लेकिन इसमें 0s के साथ समाप्‍त या समाप्‍त हो सकता है

— caird coinheringaahing

8

पायथन 2 , 84 81 80 79 बाइट्स

-1 बाइट ओवस के लिए धन्यवाद

lambda x:g(x,1)|g(x,0)
g=lambda x,a:len(set(x[a::2]))==(x[a<1::2]in"123456789")

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

पायथन 3 , 82 79 78 77 बाइट्स

lambda x:g(x,1)|g(x,0)
g=lambda x,a:len({*x[a::2]})==(x[a<1::2]in"123456789")

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

पायथन 3 में थोड़ा छोटा है, लेकिन मुझे नहीं लगता कि यह अपना जवाब देने लायक था।

व्याख्या

हम एक फ़ंक्शन सेट करते हैं gजो स्ट्रिंग और एक इंडेक्स (या तो 1 या 0) लेता है। gफिर वापस आता है या नहीं len(set(x[a::2])), वह हर दूसरी स्थिति में अनूठे अंकों की संख्या है, समान (x[a==0::2]in"123456789")अंकों के क्रम में है या नहीं। यदि अंक बढ़ते क्रम में हैं, तो यह सभी रिटर्न एक समान है या नहीं, यदि नहीं तो यह पूछेंगे कि क्या सेट खाली है, जो कि यह नहीं हो सकता है, इस प्रकार हमेशा गलत वापस आ रहा है।

— गेहूं का जादूगर
स्रोत

हमेशा की तरह, मैं आउट हो गया हूं। <

— श्री एक्सकोडर

x[a<1::2]in"123456789"हो सकता है "0"<x[a<1::2]<":"(वर्णों की तुलना वर्णों की तुलना करता है)

— कैलक्यूलेटरफ्लीन

@CalculatorFeline मुझे नहीं लगता कि यह सच है। यह सिर्फ जाँच करता है कि स्ट्रिंग एक संख्या से शुरू होती है।

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

ओह सही, हालांकि यह एकल पात्रों के लिए काम करता है।

— कैलक्यूलेटरफ्लीन

लेकिन क्या आपको वास्तव में जरूरत है a<1? ऐसा लगता है कि बस हो सकता है a।

— कैलक्यूलेटरफ्लीन

4

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

Ds2ZI’M¦Ẏ¬Ạ

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

स्पष्टीकरण:

Ds2ZI’M¦Ẏ¬Ạ Accepts an integer
D           Get individual digits
  2         2
 s          Split into chunks of specific length
   Z        Zip
    I       Take deltas
     ’      Decrement
      M     Take maximal indices
       ¦    Apply at specific indices
        Ẏ   Reduce dimensionality
         ¬  Vectorized NOT
          Ạ Check if all are truthy

— आउटगोल्फर को एरिक करें
स्रोत

2

05AB1E , 15 बाइट्स

TG9LNýN.øŒ})˜Iå

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

व्याख्या

TG9LNýN.øŒ})˜Iå
TG        }     # For 1 to 9...
  9L             # Push [1 .. 9]
    Ný           # Join with current value 
      N.ø        # surround with current value
         Œ       # Push substrings
           )    # Wrap stack to array
            ˜   # Deep flatten the array
             I  # Push input
              å # Is the input in the array?
                # Implicit print

यह काम करना चाहिए (मामलों का परीक्षण किया गया) लेकिन अगर आपको कोई खामी मिलती है तो कृपया मुझे बताएं।

14 बाइट्स अगर कोई भी उत्पादन गलत नहीं है:

TG9LNýN.øŒIåi1

— Datboi
स्रोत

2

डी, 117 बाइट्स

int f(string n){int o=n[0]!=n[2],x=n[o];foreach(i,c;n){if(i%2!=o&&i>1&&c!=n[i-2]+1||i%2==o&&c!=x)return 0;}return 1;}

निश्चित रूप से सबप्टिमल, लेकिन यह ठीक काम करता है

यह ऑनलाइन की कोशिश करो!

— TuxCrafting
स्रोत

2

हास्केल, 108 113 97 95 बाइट्स

d(x:_:r)=x:d r
d r=r
c(x:n:r)=and$all(==x)(d r):zipWith(==)(d$n:r)[n..]
f s@(_:n:_)=c s||c(n:s)

नमूना कॉल: f "182838485868788898"पैदावारTrue

स्पष्टीकरण के साथ Ungolfed संस्करण:

-- Take every other element from the string, starting with the first
d (x:_:r) = x : d r
d r       = r
c (x:n:r) = and $ all (== x) (d r)              -- Every other char is equal to the first
                : zipWith (==) (d $ n:r) [n..]  -- The remaining chars are a prefix of n(n+1)(n+2)...
f s@(_:n:_) = c s      -- The case where s already starts with x
           || c (n:s)  -- If not, prepend a dummy x and try again

— सिराकुसा
स्रोत

2

विशेष रूप से PPCG और हास्केल गोल्फ में आपका स्वागत है! isPrefixOfPrelude में नहीं है, इसलिए आपको import Data.Listअपने कोड में शामिल करना होगा या विकल्प का उपयोग करना होगा, जैसे and(zipWith(==)(n:r)[n..])।

— लकोनी

@ लिकोनी: संकेत के लिए धन्यवाद! मैंने फंक्शन को उसी के अनुसार बदल दिया।

— सिराकुसा

1

मुझे लगता है कि x/=yबस हो सकता है 1>0क्योंकि अगर नहीं x/=yतो x==yऔर पहले मामले में यह कैच।

— कैलक्यूलेटरफैनलाइन

तुम भी जरूरत नहीं है where, परिभाषित करने cऔर dबाहर सहायक कार्यों के रूप fमें ठीक है। fफिर छोटा किया जा सकता है f s@(_:n:_)=c s||c(n:s)।

— लकोनी

1

फिर आप हास्केल में गोल्फिंग नियमों के मार्गदर्शक में रुचि ले सकते हैं । भले ही यह एक नियम नहीं है, आप इसके बजाय newlines का उपयोग कर सकते हैं ;। यह एक ही बाइट काउंट है लेकिन कोड की पठनीयता में सुधार करता है।

— लैकोनी

1

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

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

s=>[...s].every((d,i)=>d-s[j^(k=i+j&1)]==k*i>>1,j=s[2]-s[0])

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

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

let f =

s=>[...s].every((d,i)=>d-s[j^(k=i+j&1)]==k*i>>1,j=s[2]-s[0])

console.log('[Truthy]');
console.log(f("182838485868788898"))
console.log(f("4344"))
console.log(f("85868"))
console.log(f("12223242526"))

console.log('[Falsy]');
console.log(f("12345"))
console.log(f("6724013635"))
console.log(f("36842478324836"))
console.log(f("1222232425"))

स्निपेट का विस्तार करें

— Arnauld
स्रोत

1

सी (जीसीसी), 123 बाइट्स

#define X*s&&*s++-++n&&(r=0)
t,n,x,r;f(char*s){t=*s==s[2];for(r=1,n=s[t],x=s[!t],s+=2;*s;)t||X,*s&&*s++-x&&(r=0),t&&X;n=r;}

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

— Steadybox
स्रोत

1

पायथन 3 , 99 96 89 बाइट्स

सहेजे गए 3 बाइट्स: all()फ़ंक्शन का उपयोग
@WheatWizard ने 7 बाइट्स बचाए: शॉर्टहैंडिंग & |और अतिरिक्त चर को बदलकरk<1

lambda x,g=lambda x,k:(x[k<1::2]in'123456789')&all(j==x[k]for j in x[k::2]):g(x,0)|g(x,1)

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

स्पष्टीकरण:

पहले स्ट्रिंग को दो सूचियों में विभाजित करें: एक विषम-अनुक्रमित और अन्य समान-अनुक्रमित तत्वों के साथ। A और B दो सूचियाँ ऐसी होनी चाहिए जो या तो:

A में समान संख्या और B में आरोही क्रम में लगातार संख्याएँ हैं।

या इसके ठीक विपरीत है

बी में एक ही नंबर होता है और ए में आरोही क्रम में लगातार नंबर होते हैं।

लगातार स्थिति की जाँच की जाती है: a in '123456789'

एक ही नंबर की स्थिति की जाँच की जाती है: all(i=a[x] for i in a)

— officialaimm
स्रोत

1

आप के उदाहरण की जगह ले सकता iके साथ k<1और ड्रॉप iसब एक साथ तर्क।

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

1

आप पार्सन्स में पहले विधेय को घेर सकते हैं और &इसके बजाय उपयोग कर सकते हैं and। आपके orसाथ भी बदला जा सकता है |।

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

1

मैं इसे अंतत: आपके उत्तर की ओर धर्मान्तरित होता हुआ देख रहा हूँ:: D

— आधिकारिक 13

1

पीएचपी , 68 बाइट्स

for(;$v<10;)$s.=strstr(+$v.join(+$v,range(1,9)).+$v++,$argn);echo$s;

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

खोज स्ट्रिंग का आउटपुट भाग जिसमें सत्य स्ट्रिंग के रूप में खोज स्ट्रिंग के अंत तक इनपुट की पहली घटना शामिल है और मिथ्या के लिए कुछ भी नहीं है

2 बाइट्स के लिए और अधिक आप की जगह ले सकता echo$s;के साथ !!echo$s;पाने के लिए 1truthy मूल्य के रूप में

सरणी में निम्नलिखित स्ट्रिंग्स में से एक में इनपुट की घटना का पता लगाएं

Array
(
    [0] => 0102030405060708090
    [1] => 1112131415161718191
    [2] => 2122232425262728292
    [3] => 3132333435363738393
    [4] => 4142434445464748494
    [5] => 5152535455565758595
    [6] => 6162636465666768696
    [7] => 7172737475767778797
    [8] => 8182838485868788898
    [9] => 9192939495969798999
)

— जार्ग हुल्सरमैन
स्रोत

1

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

f=
s=>[...s].every((e,i)=>i<2|e-s[i-2]==(s[2]!=s[0])^i%2)

<input oninput=o.textContent=this.value[3]?f(this.value):``><pre id=o>

स्निपेट का विस्तार करें

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

— नील
स्रोत

1

MATL , 15 बाइट्स

2L&),duw]hSFTX=

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

चैट में @LuisMendo की कुछ मदद के साथ। ध्यान दें कि, यदि खाली आउटपुट + त्रुटि को 'मिथ्या' भी माना जाता है, तो Xइसे छोड़ दिया जा सकता है, स्कोर को 14 बाइट्स तक लाया जा सकता है ।

2L&)     % Split the input into odd and even-indexed elements
    ,   ] % Do twice (new feature since MATL v20.0), i.e., on both halves of the input
     d     % Pairwise differences of the array. Results in [0,0,...] for the 'constant' part,
            %  and [1,1,...] for the 'increasing' part.
      u      % Get unique elements. Results in [0] for the constant part, [1] for the increasing part.
       w      % Swap the stack to do the same for the other half of the input.
         hS    % Horizontal concatenation followed by sort. Results in [0,1] for the desired string.
           FTX= % Check if the result is indeed [0,1]. Implicit display.

— Sanchises
स्रोत

0

गणितज्ञ, 121 बाइट्स

(m[x_]:=Take[s=IntegerDigits@#,{x,Length@s,2}];w[b_,n_]:=Union@Differences@m@b=={1}&&Length@Union@m@n==1;w[1,2]||w[2,1])&

— J42161217
स्रोत

0

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

ASm.+sMd.Tcz2&-GZ-H1

आउटपुट []जब संख्या अंक पैटर्न से मेल खाती है, तो कुछ और अन्यथा।

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

स्पष्टीकरण (इनपुट के साथ उदाहरण 85868)

ASm.+sMd.Tcz2&-GZ-H1

          cz2           # Chop the input in pairs: ['85', '86', '8']
        .T              # Transpose, ignore absences: ['888', '56']
     sM                 # Convert to integers: [[8, 8, 8], [5, 6]]
  m.+  d                # Compute deltas: [[0, 0], [1]]
 S                      # Sort: [[0, 0], [1]]
A                       # Assign first list to G and second list to H
              -GZ       # Filter 0 on G (on absence): [0, 0] -> []
                 -H1    # Filter 1 on H (on absence): [1] -> []
             &          # Check both lists are empty (logical and): [] & [] -> []

— जिम
स्रोत

0

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

qU2Ssm{.+d.TcjQT2

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

मेरे जेली जवाब के रूप में एक ही एल्गोरिदम।

स्पष्टीकरण:

qU2Ssm{.+d.TcjQT2 Accepts an integer
             jQT  Take digits of input
            c   2 Split in pairs
          .T      Transpose
     m            Map the following on each of the two resulting lists:
       .+d          Take deltas
      {             Deduplicate
    s             The list is now in [[a, b, ...], [A, B, ...]] format, convert it to [a, b, ..., A, B, ...]
   S              Sort
qU2               Check if equal to [0, 1]

— आउटगोल्फर को एरिक करें
स्रोत

0

पायथन 3 , 167 161 157 131 106 बाइट्स

-55 बाइट्स @ WheatWizard के सुझावों के लिए धन्यवाद

def g(t):k,c,f,j=t[::2],t[1::2],'123456789',''.join;return(len({*k})and j(c)in f)or(len({*c})and j(k)in f)

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

— मिस्टर एक्सकोडर
स्रोत

आगे गोल्फ हो सकता है। मैं पहले से ही संपादित करता हूं।

— श्री एक्सकोडर

आपने मेरे जवाब में यह तरकीब देखी होगी लेकिन set(c)जैसी है वैसी ही है {*c}। (कम से कम अजगर 3 में)

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

@HeatWizard धन्यवाद संपादन

— मिस्टर एक्सकोडर

3

[t[z]for z in range(0,len(t),2)]यह भी सिर्फ एक सूची ब्याह है। आप इसे बस के साथ कर सकते हैं t[::2]। यदि आप इस वाक्य रचना से परिचित नहीं हैं, तो मेरा सुझाव है कि डॉक्स पर एक नज़र डालें, क्योंकि यह बहुत उपयोगी है।

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

@WheatWizard वाह, यह वास्तव में उपयोगी है। अफसोस की बात है कि मैं अभी उत्तर को संपादित नहीं कर सकता। मैं जितनी जल्दी हो सकेगा, मैं करूंगा। सलाह के लिए बहुत

— धन्यवाद

0

जावा (ओपनजेडके 8) , 128 119 118 108 107 104 बाइट्स

s->{int i=3,a=s[2]-s[0],b=s[3]-s[1];for(;++i<s.length;)a+=b-(b=s[i]-s[i-2]==a?a:2);return(a|b)==1&a!=b;}

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

स्पष्टीकरण:

s->{                             // lambda
  int i=3,                       //  iterating index
      a=s[2]-s[0],               //  diff of even-indexed characters
      b=s[3]-s[1];               //  diff of odd-indexed characters
  for(;++i<s.length;)            //  iterate
    a+=b-(b=                     //   swap a and b
        s[i]-s[i-2]==a?a:2       //    or set b to 2 if the diffs don't match
      ));                        //
  return (a|b)==1                //  return true if both a and b are in (0,1)
        &a!=b;                   //         but different
}

— ओलिवियर ग्रेजायर
स्रोत

0

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

.
$*11;
(1+)(?<=\1;1+;\1)

^1+;1+

^;?(;1;)+;?$

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

आउटपुट 1 यदि यह पैटर्न से मेल खाता है, तो यदि यह नहीं है

व्याख्या

.
$*11;

प्रत्येक अंक n को n + 1 में परिवर्तित करें, जिसे अर्धविराम द्वारा अलग किया गया है

(1+)(?<=\1;1+;\1)

(अनुगामी न्यूलाइन) प्रत्येक अंक को स्वयं के बीच के अंतर और उससे पहले के 2 स्थानों में परिवर्तित करता है

^1+;1+

(अनुगामी न्यूलाइन) पहले 2 अंक निकालता है

^;?(;1;)+;?$

इस पैटर्न के मैचों की संख्या की गणना करता है, जो 0 और 1s को वैकल्पिक करने के लिए जांच करता है

— PunPun1000
स्रोत

क्या यह अंक पैटर्न से मेल खाता है?

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

पायथन 2 , 84 81 80 79 बाइट्स

पायथन 3 , 82 79 78 77 बाइट्स

व्याख्या

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

05AB1E , 15 बाइट्स

व्याख्या

डी, 117 बाइट्स

हास्केल, 108 113 97 95 बाइट्स

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

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

सी (जीसीसी), 123 बाइट्स

पायथन 3 , 99 96 89 बाइट्स

पीएचपी , 68 बाइट्स

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

MATL , 15 बाइट्स

गणितज्ञ, 121 बाइट्स

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

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

पायथन 3 , 167 161 157 131 106 बाइट्स

जावा (ओपनजेडके 8) , 128 119 118 108 107 104 बाइट्स

स्पष्टीकरण:

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

व्याख्या