संकट:

आपका कार्य यह तय करना है कि संख्याओं के अनुक्रम में, प्रत्येक संख्या में उस संख्या के कम से कम एक अंक होते हैं जो इससे पहले थे।

उदाहरण के लिए, निम्नलिखित को सत्य लौटना चाहिए:

[1, 12, 203, 0, 30]
             ^   ^ Contains a 0
        ^ Contains a 2
    ^ Contains a 1

निम्नलिखित को गलत होना चाहिए:

[1, 32, 23, 34]
    ^ Doesn't contain a 1, therefore false

आपका सबमिशन एक फंक्शन या फुल प्रोग्राम हो सकता है।

इनपुट:

इनपुट किसी भी उचित प्रकार का अनुक्रम हो सकता है। संख्याओं की एक श्रृंखला, तार की एक सरणी, संख्याओं का एक सीमांकित स्ट्रिंग, आदि।

हालांकि, आदेश मायने रखता है, इसलिए जो भी संरचना आप इनपुट के रूप में स्वीकार करना चाहते हैं, जाहिर है उसका निश्चित क्रम होना चाहिए।

इनपुट को स्टड के माध्यम से या एक तर्क के रूप में लिया जा सकता है।

आप मान सकते हैं:

सभी नंबर गैर-नकारात्मक पूर्णांक होंगे
इनपुट में हमेशा कम से कम 2 नंबर होंगे
इनपुट नंबर 0 से शुरू नहीं होंगे

आउटपुट:

आउटपुट एक सत्य या गलत मूल्य होगा (जैसा कि आपकी भाषा द्वारा परिभाषित किया गया है), यह दर्शाता है कि उपरोक्त विनिर्देश पूरा हुआ है या नहीं।

सत्य / असत्य मूल्यों को परीक्षणों के बीच सुसंगत होने की आवश्यकता नहीं है।

यह या तो स्टडआउट के लिए आउटपुट हो सकता है या वापस आ सकता है।

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

True cases:
[1, 1, 1, 11, 111, 11, 1]
[12, 23, 34, 45, 56]
[65, 54, 43, 32, 21]
[123, 29, 9, 59, 55, 52, 2017, 2]
[1234567890, 19, 95, 5012, 23]

False cases:
[1, 2, 3, 4, 5, 1, 11] (2 doesn't contain a 1)
[12, 23, 33, 45] (45 doesn't contain a 3)
[98, 87, 76, 11, 12, 23] (11 doesn't contain a 7 or 6)

यह कोड-गोल्फ है, इसलिए कम से कम बाइट्स जीतता है।

code-golf

— Carcigenicate
स्रोत

7

जेली , 5 4 बाइट्स

f2\Ạ

इनपुट स्ट्रिंग्स की एक सरणी है।

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

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

f2\Ạ  Main link. Argument: A (array of strings)

 2\   Pairwise reduce by:
f       Filter, yielding all chars in the left string that appear in the right one.
   Ạ  All; yield 1 if all strings are non-empty, 0 if not.

— डेनिस
स्रोत

13

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

lambda x:reduce(lambda a,b:set(a)&set(b)and b,x)

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

के लिए एक खाली सेट Falseऔर अंतिम तत्व प्रिंट करेंTrue

— छड़ी
स्रोत

12

रेटिना , 25 20 बाइट्स

(.).*¶(?=.*\1)

^.+$

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

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

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

11

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

{⊇ᵐ=∧?t}ˡ

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

ध्यान दें कि यह न केवल पूर्णांक की सूची के साथ काम करता है, बल्कि तार की सूची या सूचियों की सूची के साथ भी काम करता है।

व्याख्या

{      }ˡ       Left fold on the input:
 ⊇ᵐ=              It is possible to find a number which is a subset of both input numbers
    ∧             (and)
     ?t           The output is the second number (to continue the fold)

— Fatalize
स्रोत

2

यह अच्छा है। लगता है ... घोषणात्मक? आपको लगता है कि आप भाषा को विनिर्देशन बता रहे हैं।

— कैरिजिनेट

3

@Carcigenicate Brachylog वास्तव में कथात्मक, यह कथात्मक तर्क प्रोग्रामिंग भाषा पर आधारित है Prolog ।

— घातक

2

जब मैं असीमित खाली समय प्राप्त करता हूं, तो सीखने के लिए वास्तव में मेरी (तेजी से) भाषाओं की लंबी सूची पर प्रस्ताव। बहुत सारी शांत भाषाएं हैं!

— कारजेनिकेट

8

जावास्क्रिप्ट (ईएस 6), 47 44 ^_* 43 बाइट्स

@Neil को एक बाइट धन्यवाद दिया

x=>x.every(y=>y.match(`[${p}]`,p=y),p=1/19)

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

टेस्ट स्निपेट

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

let f =
x=>x.every(y=>y.match(`[${p}]`,p=y),p=1/19)

let g = x => console.log("f([%s]): %s", x.join(", "), f(x.map(String)))

g([1, 1, 1, 11, 111, 11, 1])
g([12, 23, 34, 45, 56])
g([65, 54, 43, 32, 21])
g([123, 29, 9, 59, 55, 52, 2017, 2])
g([123456789, 19, 95, 5012, 23])

g([1, 2, 3, 4, 5, 1, 11])
g([12, 23, 33, 45])
g([98, 87, 76, 11, 12, 23])

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

* _{( 44 को पार करना अभी भी नियमित 44 है )}

— ETHproductions
स्रोत

करता है `[${p}]`काम नहीं?

— नील

@ हर सरणी के पहले आइटम के लिए नहीं।

— ETHproductions

आह, मुझे लगता है कि आपको एक वर्कअराउंड मिला। मुझे अब तक मिला था a=>a.reduce((l,r)=>`${l}`.match(`[${r}]`)&&r)(जो संख्यात्मक इनपुट के लिए भी काम करता है)।

— नील

p&&यदि आप सेट करते हैं तो शायद आप इसे हटा सकते हैं p=1/19?

— नील

@ नील मैं, उह ... अच्छी तरह से ... यह प्रतिभाशाली है, धन्यवाद :-)

— ETHproductions

6

05AB1E , 10 बाइट्स

ü‚vy`Så1åP

इसे ऑनलाइन आज़माएं! या टेस्ट सूट के रूप में

व्याख्या

ü‚          # map pairing over each pair in input
  v         # for each pair
   y`       # push as 2 separate elements on stack
     Så     # check each digit in 2nd number for membership in first
       1å   # check if any 1 exists in the resulting list
         P  # product of stack

— Emigna
स्रोत

€Sü.å- काश यह काम ऐसा होता जैसा मैंने सोचा था कि यह होगा।

— मैजिक ऑक्टोपस Urn

@carusocomputing: हाँ, यह बहुत अच्छा होता। या बस ü.åया €Süå।

— एमिग्ना

डॉट वाइज फिर से कमांड के साथ काम क्यों नहीं करता है?

— मैजिक ऑक्टोपस यूरन

1

@ कोरसोकोम्पुटिंग: यह केवल अगले बाइट को कमांड के रूप में लागू करने के लिए लागू किया गया है। यह डॉट को ध्यान में नहीं रखता है।

— एमिग्ना

6

CJam , 18 15 14 बाइट्स

मार्टिन एंडर के लिए धन्यवाद 4 बाइट्स बचाए

l~Afb_1>.&:,:*

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

व्याख्या

l~              e# Read and eval the input
  Afb           e# Convert each number to a list of digits
     _          e# Duplicate the array
      1>        e# Slice it after the first element
        .&      e# Vectorized set intersection; take the set intersection of corresponding 
                e#  elements of the two arrays
          :,    e# Get the length of each intersection
            :*  e# Take the product of the whole array. 
                e#  Will be 0 if any intersection was empty.

— बिजनेस कैट
स्रोत

6

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

-3 बाइट्स @NickHansen को धन्यवाद! मुझे वास्तव में उन मोनाड ऑपरेटरों के साथ बेहतर होने की आवश्यकता है

-4 और -9 बाइट्स @Laikoni और @nimi के लिए क्रमशः धन्यवाद!

and.(zipWith(any.flip elem)=<<tail)

यह संस्करण इनपुट को स्ट्रिंग्स की एक सरणी के रूप में लेता है, आवश्यकता को समाप्त करता है show, लेकिन जहां तक मैं देख सकता हूं यह पुराने संस्करण के समान ही काम करता है:

all(\(x,y)->any(`elem`x)y).(zip=<<tail).map show

(मुझे पूरा यकीन है कि मुझे इस तरह एक अनाम फ़ंक्शन सबमिट करने की अनुमति है, लेकिन यदि आवश्यक हो तो मैं इसे ठीक कर दूंगा)

पहले संख्याओं को स्ट्रिंग्स में परिवर्तित किया जाता है। फिर मोनाड जादू zip=<<tailएक फ़ंक्शन बनाता है जो सूची को अपने आप से जोड़ देता है जो प्रत्येक प्रविष्टि को अपने पड़ोसी (ओं) के साथ जोड़ देता है। फिर allप्रत्येक जोड़ी के लिए एक लैम्ब्डा मैप करता है जो यह जांचता है कि क्या एक स्ट्रिंग में दूसरे से कोई चार्ट है और अंत में जांचता है कि वे सभी बाहर निकलते हैं True।

पुराना संस्करण जो मूल रूप से उसी तरह काम करता है:

f a=and$zipWith(\b->any(`elem`show b).show)a$tail a

— user1472751
स्रोत

मैं ज़िप और कुछ (->) मोनड प्रवंचना का उपयोग करके एक बाइट दाढ़ी बनाने में सक्षम था: f (x, y) = कोई ('elem'x) y; g = all f। (Zip = << tail) .map शो। । संपादित करें: एलएम को [उम्मीद है कि स्पष्ट रूप से] बैकटिक्स में होना चाहिए लेकिन यह टिप्पणी फ़ॉर्मेटर के साथ संभव नहीं है।

— निक हैनसेन

44 बाइट्स:and.(zipWith(any.flip elem)=<<tail).map show

— लाकोनी

इसे इनपुट को स्ट्रिंग्स की सूची के रूप में लेने की अनुमति है, उदाहरण के लिए ["1234567890", "19", "95", "5012", "23"], ताकि आप ड्रॉप कर सकें .map show।

— नीम

5

गणितज्ञ 62 47 35 बाइट्स

मार्टिन बाइट की बदौलत 12 बाइट बच गए।

FreeQ[#⋂#2&@@@Partition[#,2,1],{}]&

FreeQ[#⋂#2&@@@Partition[#,2,1],{}]&[{{1},{1,2},{2,0,3},{0},{3,1}}]

असत्य

FreeQ[#⋂#2&@@@Partition[#,2,1],{}]&[{{1},{1,2},{2,0,3},{0},{3,0}}]

सच

— DavidC
स्रोत

4

रूबी, 49 48 बाइट्स

->x{x.each_cons(2){|z|x&&=z*' '=~/(.).* .*\1/};x}

आउटपुट nilझूठे और सच्चे के लिए एक "यादृच्छिक" पूर्णांक है।

— जीबी
स्रोत

4

जावा 8, 94 90 87 बाइट्स

इनपुट संख्याओं का प्रतिनिधित्व करने वाले तारों का एक सरणी है। दूसरी स्ट्रिंग के साथ शुरू, यह प्रत्येक पिछले स्ट्रिंग के खिलाफ एक नियमित अभिव्यक्ति तुलना करता है देखने के लिए अगर यह अपनी वर्णों के किसी भी शामिल हैं: .*[previous string].*।

golfed:

a->{int r=1,i=0;while(++i<a.length)r*=a[i].matches(".*["+a[i-1]+"].*")?1:0;return r>0;}

Ungolfed:

public class NumberChainingPredicate {

  public static void main(String[] args) {
    System.out.println("Expect true:");
    for (String[] input : new String[][] { { "1", "1", "1", "11", "111", "11", "1" }, { "12", "23", "34", "45", "56" },
        { "65", "54", "43", "32", "21" }, { "123", "29", "9", "59", "55", "52", "2017", "2" },
        { "1234567890", "19", "95", "5012", "23" } }) {
      System.out.println(java.util.Arrays.toString(input) + " = " + exec(f(), input));
    }

    System.out.println();
    System.out.println("Expect false:");
    for (String[] input : new String[][] { { "1", "2", "3", "4", "5", "1", "11" }, { "12", "23", "33", "45" },
        { "98", "87", "76", "11", "12", "23" } }) {
      System.out.println(java.util.Arrays.toString(input) + " = " + exec(f(), input));
    }
  }

  private static java.util.function.Function<String[], Boolean> f() {
    return a -> {
      int r = 1, i = 0;
      while (++i < a.length) {
        r *= a[i].matches(".*[" + a[i - 1] + "].*") ? 1 : 0;
      }
      return r > 0;
    };
  }

  private static boolean exec(java.util.function.Function<String[], Boolean> function, String[] input) {
    return function.apply(input);
  }

}

अच्छा! मेरी तुलना में बहुत छोटा था .. वैसे भी, आप कुछ और गोल्फ कर सकते हैं: a->{for(int i=1;i<a.length;)if(!a[i].matches(".*["+a[i++-1]+"].*"))return 0>1;return 1>0;}( 90 बाइट्स )

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

मैंने इसे ९ ० तक गोल्फ भी दिया, लेकिन एक अलग तरीके से:a->{int r=1;for(int i=0;++i<a.length;)r*=a[i].matches(".*["+a[i-1]+"].*")?1:0;return r>0;}

— बिजनेस कैट

1

नेवरमाइंड, 87:a->{int r=1,i=0;for(;++i<a.length;)r*=a[i].matches(".*["+a[i-1]+"].*")?1:0;return r>0;}

— बिजनेस कैट

आप दोनों को धन्यवाद। मुझे लगता है कि एक सार्थक राशि से इसे सुधारने का एकमात्र तरीका अब रेगेक्स को देखना है।

4

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

Dµf"ḊẠ

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

व्याख्या

Dµf"ḊẠ
Dµ        Treat the first (i.e. only) input as a list of decimal digits
   "      For each pair of corresponding elements in {the input digits} and
    Ḋ     {the input digits} with the first element removed
  f       take all elements common to both sides
     Ạ    then return true if the result has no empty lists, false otherwise

2/यहां उपयोग करने का प्रयास करना सबसे स्पष्ट है, लेकिन यह आकार के सभी स्लाइस पर एक अपरिपक्व कार्य करता है। 2. आसन्न तत्वों के सभी जोड़े पर "Ḋप्रभावी ढंग से एक बाइनरी फ़ंक्शन चलाता है , जिसका अर्थ है कि हम fसीधे उपयोग कर सकते हैं (बजाय इसे एक यूरीरी में बदलने के लिए। समारोह के रूप में f/)। यह अंत में इनपुट के अंतिम तत्व को छोड़ देता है, लेकिन सौभाग्य से 0 का इनपुट भी नहीं बनता है जब दशमलव में परिवर्तित किया जाता है, तो इसका कोई प्रभाव नहीं पड़ता है Ạ।

4

पायथन 3 , 48 बाइट्स

f=lambda x:x==x[:1]or{*x[0]}&{*x[1]}and f(x[1:])

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

— डेनिस
स्रोत

3

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

Dœ&L¥2\Ạ

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

कैसे?

Dœ&L¥2\Ạ - Main link: the list of integers            e.g. [3, 13, 351, 73, 82]
D        - convert all the integers to decimal lists       [[3],[1,3],[3,5,1],[7,3],[8,2]]
     2\  - 2-slice cumulative reduce with:
    ¥    -     last two links as a dyad:
 œ&      -         multiset intersection                   [[3],[1,3],[3],[]]
         -         length                                  [1,2,1,0]
       Ạ - all truthy?                                     0

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

3

05AB1E , 5 बाइट्स

कोड:

üÃõå_

CP-1252 एन्कोडिंग का उपयोग करता है । इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें! ।

स्पष्टीकरण:

üÃ         # Intersection on each pair
  õå       # Check if the empty string exists
    _      # Boolean negate

— अदनान
स्रोत

अरे यार यह काम करता है! RüÃõå_मैं अपने दम पर आया था। मैं आपका सबसे अच्छा जवाब देने के लिए सम्मानित हो गया हूँ, मेरा डिलीट करना। Rहालांकि आपको इसकी आवश्यकता क्यों नहीं है ?

— मैजिक ऑक्टोपस Urn

1

@carusocomputing हम्म, Rतब के लिए क्या है ? : पी

— अदनान

2

पॉवरशेल , 87 बाइट्स

param($n)(1..($a=$n.length-1)|?{[char[]]$n[($i=$_)-1]|?{$n[$i]-like"*$_*"}}).count-eq$a

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

किसी भी उपाय से कम से कम नहीं, लेकिन दूसरों की तुलना में थोड़ा अलग दृष्टिकोण का उपयोग कर रहे हैं, और निफ्टी |?{}कार्यक्षमता को दर्शाता है ।

यह इनपुट को स्ट्रिंग्स की एक सरणी के रूप में लेता है $n, फिर 1ऊपर से छोरों तक length-1। हम का उपयोग करें Where-Object( |?{...}) उन सूचकांकों कि एक विशेष स्थिति के लिए truthy हैं बाहर निकलने के लिए। आप इसे forएक ifक्लॉज के साथ संयोजन लूप की तरह सोच सकते हैं ।

यहां क्लॉज है [char[]]$n[($i=$_)-1]|?{$n[$i]-like"*$_*"}। यही है, हम वर्तमान इंडेक्स को ले जा रहे हैं $_, इसे सेटिंग में $iऔर घटाकर 1, और इंडेक्स में $n(यानी, इसलिए हम अपने इनपुट ऐरे में पिछले तत्व प्राप्त करते हैं) का उपयोग कर रहे हैं। उसके बाद एक- charऐरे के रूप में डाला जाता है और दूसरी Where-Objectप्रक्रिया के माध्यम से भेजा जाता है।

भीतरी खंड $n[$i]-like"*$_*"निर्दिष्ट करता है कि मौजूदा सूचकांक में स्ट्रिंग $iहै -likeवर्तमान चरित्र $_पिछले सूचकांक से। इसलिए यह किसी भी वर्ण का उत्पादन करेगा जो दो सरणी तत्वों के बीच आम है। इस प्रकार, बाहरी खंड केवल सत्य होगा यदि कोई पात्र सामान्य है (चूंकि एक खाली सरणी पॉवरशेल में गलत है), और इसलिए सूचकांक केवल तभी चुना जाएगा जब आम में वर्ण हों।

फिर, हम ऊपर सूचकांकों की कि सभी मानदंडों के अनुरूप इकट्ठा होते हैं, और सत्यापित करें कि .countक्या है -eqइनपुट सरणी की लंबाई के UAL। उस बूलियन परिणाम को पाइपलाइन पर छोड़ दिया गया है, और आउटपुट निहित है।

— AdmBorkBork
स्रोत

2

पर्ल 5 , 31 बाइट्स

मार्टिन एंडर के खूबसूरत जवाब का एक बंदरगाह ।

कोड + -pध्वज के 30 बाइट्स ।

s/(\S)\S* (?=\S*\1)//g;$_=!/ /

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

— बापू
स्रोत

2

एपीएल (डायलॉग एपीएल) , 9 बाइट्स

∧/×≢¨2∩/⎕

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

∧/ की सूची में सभी हैं

× चिन्ह

≢ की टैली की

¨ की प्रत्येक

2∩/ की जोड़ी-वार चौराहों

⎕ इनपुट?

— एडम
स्रोत

मुझे यकीन नहीं है कि "संकेत" का क्या मतलब है, लेकिन आप मान सकते हैं कि सभी संख्याएं सकारात्मक होंगी।

— कार्सिनेट

@ करिश्माई शून्य वे भी हो सकते हैं।

— आदम

हाँ क्षमा करें। "गैर नकारात्मक"।

— कारिन्जनेट

2

PHP, 65 68

for(;null!==$a=$argv[++$i+1];)$r+=$a==strtr($a,$argv[$i],_);echo!$r;

सभी नंबरों पर पुनरावृत्ति करें और पिछले में दिखाई देने वाले सभी अंकों को हटा दें। गणना करें कि यह कितनी बार स्वयं संख्या को हटाता है (कोई अंक नहीं हटाया गया)। यदि कम से कम एक की बराबरी की है तो हमारा एक जोड़े में मेल नहीं है।

एक गलती का उपयोग फिक्स्ड trimके insted strtr। @ JörgHülsermann को धन्यवाद

— क्रिस्टोफ
स्रोत

एक बड़ा खेद है। दिए गए testcases के लिए आपके समाधान काम करता है। ["filename",1,11,414]काम नहीं करता है।

— जॉर्ग हल्सरमैन

@ JörgHülsermann यकीन है कि trimकेवल प्रमुख और अनुगामी आकर्षण के लिए काम करता है। ठीक कर दिया।

— क्रिस्टोफ़

PHP <7.1 के लिए, आप (-5 बाइट्स) के a&बजाय उपयोग कर सकते हैं null!==।

— टाइटस

... लेकिन यह केवल पहले अंक के लिए ही काम करेगा $argv[$i], क्योंकि "यदि अलग-अलग लंबाई के हैं और दोनों के अतिरिक्त वर्णों को नजरअंदाज किया जाता है।" (मैनुअल से)

— टाइटस

2

PHP, 75 बाइट्स

for($b=3**39;--$argc;)preg_replace("#[$b]#","",$b=$argv[$argc])<$b?:die(1);

कमांड लाइन तर्कों से संख्या लेता है; 1सत्य के लिए, झूठे के साथ बाहर निकलता है 0। इसे ऑनलाइन
चलाएं -rया परीक्षण करें ।

के साथ शुरू $b= सभी अंक युक्त एक नंबर
तर्कों के माध्यम से नीचे
- $bतर्क से सभी अंकों को हटा दें
- प्रति को प्रतिवाद $b
- यदि कोई अंक नहीं निकाला गया था, तो बाहर निकलें 1
निहित: साथ बाहर निकलें 0

— टाइटस
स्रोत

1

PHP, 77 बाइट्स

for($i=$t=1;++$i<$argc;)$t*=preg_match("#[{$argv[$i-1]}]#",$argv[$i]);echo$t;

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

1

वैकल्पिक: foreach($argv as$k=>$v)$t=$k--?$t*preg_match("#[{$argv[$k]}]#",$v)):1;echo$t;77 बाइट्स (अप्रयुक्त)।

— इस्माइल मिगुएल

1

@IsmaelMiguel भारी विकल्प पहले आपको बदलना $k--होगा --$kऔर एक को छोड़ना होगा) उसके बाद आपका दृष्टिकोण काम करना चाहिए और आपको चेतावनी के लिए एक @ जोड़ना होगा

— Jörg Hülsermann

ओह, हाँ, बेकार कोष्ठकों पर ध्यान नहीं दिया जो वाक्यविन्यास त्रुटियों का कारण बनता है। और मैं इसके बारे में असहमत हूं $k--। मैंने विशेष रूप से इसका उपयोग किया ताकि $ k अभी भी पहले रन पर 0 है। और चेतावनी आग्नेय है। इसका मतलब है कि कोड अब 76 बाइट्स है, लेकिन अभी भी अप्रयुक्त है।

— इस्माइल मिगुएल

संपादन के बाद, मैं पुष्टि कर सकता हूं कि foreach($argv as$k=>$v)$t=$k--?$t*preg_match("#[{$argv[$k]}]#",$v):1;echo$t;यह काम कर रहा है जैसा कि इसे करना चाहिए। साथ परीक्षण $argv = array(1, 12, 123, 3, 34, 45, 5, 5);प्रदर्शित करता है 1और साथ परीक्षण $argv = array(1, 12, 123, 3, 34, 45, 5, 6);प्रदर्शित करता है 0, के रूप में उम्मीद।

— इस्माइल मिगुएल

@IsmaelMiguel आप भूल जाते हैं कि फ़ाइलनाम में पहला पैरामीटर है।

— जॉर्ग हल्सरमैन

1

MATL , 14 बाइट्स

1&)"V@VX&nv@]x

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

धन्यवाद @LuisMendo एक बाइट बचाने के लिए। स्पष्टीकरण:

1&)            % 'Pop' the first item from the input and push it on the stack.
   "       ]   % Main 'for' loop, to loop over the rest of the input.
    V            % Stringify previous (or first) iten from the input.
     @V          % Push current number, convert to string
       X&        % Intersect with stringified number already on the stack.
         nv      % Count the size of the intersection, and add it to the existing list of sizes.
           @     % Push the current number again for the intersection in the next loop. 
             x % Remove the number pushed by the last loop.
               % Else the program would end with the result on the second instead of the first position in the stack

— Sanchises
स्रोत

आप एक बाइट की जगह बचा सकते हैं 1)VGद्वारा 1&)(और इस से बचा जाता है पहले नंबर दोहरा)

— लुइस Mendo

@LuisMendo बेशक! मुझे जोर से याद आया कि MATL में यह कार्यक्षमता थी, लेकिन कल्पना में "पॉप" (जैसे कतार या स्टैक में) की खोज करने से कोई परिणाम नहीं मिला, इसलिए मुझे लगा कि मुझसे गलती हुई है।

— Sanchises

हां, वास्तव में यह संदर्भ अनुक्रमण का एक विशेष मामला है। दो आउटपुट के साथ, एक संदर्भ अनुक्रमण ऑपरेशन जैसा )कि चयनित मानों को पहले आउटपुट के रूप में देता है, और फिर दूसरे आउटपुट के रूप में शेष मान

— लुइस मेंडो

@LuisMendo चतुर। उन्हें MATLAB को बेहतर बनाने के लिए आपको MATL दोस्तों को रखना चाहिए ...

— Sanchises

Haha। मैं कभी

— लुइस मेंडो

1

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

(fn[n](every?(fn[[q w]](some q w))(partition 2 1(map #(set(str %))n))))

एक अनाम फ़ंक्शन जो संख्याओं के अनुक्रम को स्वीकार करता है। रिटर्न true/ false।

मुझे पसंद है कि यह कैसे पढ़ता है। यहाँ निश्चित रूप से कुछ क्षेत्रों में सुधार किया जा सकता है। मेरे फ़ंक्शन को mapआसानी से नहीं बदला जा सकता है ताकि इसे फ़ंक्शन मैक्रो की आवश्यकता न हो, जिसका अर्थ है कि संपूर्ण फ़ंक्शन मैक्रो का उपयोग नहीं कर सकता है, जो संभवतः कुछ बाइट्स जोड़ते हैं। यह अच्छा होगा अगर मैं every?विधेय में मूल्यों को अनपैक करने का एक बेहतर तरीका समझ सकता हूं ।

(defn number-chain? [nums]
  (let [; Turn each number into a set of characters
        set-nums (map #(set (str %)) nums)

        ; Partition the sets into lists of neighbors
        ; [1 2 3 4] -> [[1 2] [2 3] [3 4]]
        partitioned (partition 2 1 set-nums)]

    ; Does every second neighbor contain some element of the first?
    (every?
      (fn [[l1 l2]]
        (some l1 l2))
      partitioned)))

— Carcigenicate
स्रोत

1

SimpleTemplate, 124 बाइट्स

वाह, यह एक कसरत थी!

{@eachargv asA keyK}{@ifK}{@setR"/[",O,"]/"}{@calljoin intoR"",R}{@ifA is notmatchesR}{@return}{@/}{@/}{@setO A}{@/}{@echo1}

यह "बस" एक पुराने तत्व का उपयोग करके एक रेगीक्स बनाता है, जो 1एक सत्य मूल्य के रूप में दिखा रहा है , या अन्यथा कुछ भी नहीं।

Ungolfed:

{@each argv as number key K}
    {@if K}
        {@set regex "/[", old, "]/"}
        {@call join into regex "", regex}
        {@if number is not matches regex}
            {@return false}
        {@/}
    {@/}
    {@set old number}
{@/}
{@echo 1}

— इस्माइल मिगुएल
स्रोत

1

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

s=>/^(.*(.).*\n(?=.*\2))+.+$/.test(s)

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

— नील
स्रोत

1

पिप , 12 10 बाइट्स

$&B@X^_MPg

कमांड-लाइन तर्कों की एक श्रृंखला के रूप में इनपुट लेता है। आउटपुट सत्य के लिए एक गैर-रिक्त सूची है और झूठी के लिए एक खाली सूची है। इसे ऑनलाइन आज़माएं या सभी परीक्षण मामलों को सत्यापित करें ।

व्याख्या

         g  List of all cmdline args
       MP   Map this function to consecutive pairs of items from that list:
     ^_      Split 1st item of pair into list of characters
    X        Convert to regex that matches any of those characters
  B@         Find all matches in 2nd item of pair
$&          Fold on logical AND--truthy if all items are truthy, falsey if one is falsey
            Print (implicit)

— DLosc
स्रोत

1

रोड़ा , 45 35 बाइट्स

{[_=~`(\S*(\S)\S* (?=\S*\2))+\S+`]}

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

यह पर्ल 5 समाधान के समान है, जो मार्टिन एंडर द्वारा रेटिना समाधान का एक बंदरगाह है। -10 बाइट्स @ @ नील को धन्यवाद।

यहाँ एक अलग समाधान है ( 73 72 बाइट्स):

{[_/""]|{|x|{x|[0]()unless[not(_ in y)]else[1]}if tryPeek y}_|sum|[_=0]}

यह एक अनाम फ़ंक्शन है जो स्ट्रीम से स्ट्रिंग्स खींचता है और जांचता है कि लगातार स्ट्रिंग्स में समान वर्ण होते हैं। स्पष्टीकरण:

{
    [_/""]|    /* split strings -> creates arrays of characters */
    {|x|       /* begin for loop over character arrays */
        {      /* begin if tryPeek(y) -> peeks the second item from the stream */
               /* x and y are now two consecutive character arrays */
            x| /* push characters in x to the stream */
            [0]()unless[not(_ in y)]else[1] /* pushes 0 to the stream */
                                            /* if y contains the character */
                                            /* in the stream, otherwise 1 */
        }if tryPeek y
    }_|        /* end for loop */
    sum|       /* sum all numbers in the stream */
    [_=0]      /* return true if the sum is zero */
}

यह संभवतः अधिक गोल्फ हो सकता है ...

— fergusq
स्रोत

यह एक एकल regexp है कि एक ही बार में पूरे परीक्षण करता है मदद मिलेगी? कुछ इस तरह ^(\S*(\S)\S* (?=\S*\2))+\S+$।

— नील

@ नील जो काम करने लगता है। धन्यवाद!

— फर्ग्यूसक

1

बैश + यूनिक्स उपयोगिताओं, 71 69 बाइट्स

sed "s/\(.*\)/<<<\1 \&\&grepx[\1]/;1s/.*g/g/;\$s/ .*//"|tr 'x
' \ |sh

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

इनपुट स्टड पर है, प्रति पंक्ति एक नंबर।

आउटपुट बाहर निकलने के कोड में है: 0 सत्य के लिए, 1 झूठी के लिए।

यह शायद अधिक गोल्फ हो सकता है।

काम करने के लिए ऊपर दिए गए कोड के लिए, वर्तमान निर्देशिका में कोई फ़ाइल नहीं हो सकती है जिसका नाम एकल अंक है। यदि यह स्वीकार्य नहीं है, तो 2 अतिरिक्त बाइट की लागत के [\1]साथ कार्यक्रम में बदलें '[\1]'।

सैंपल रन (चुनौती में प्रदान किया गया अंतिम परीक्षण मामला):

$ echo '98
> 87
> 76
> 11
> 12
> 23' | ./digittest > /dev/null; echo $?
1

(यहां 1 गलत है।)

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

मैं ऊपर चलाए गए नमूने पर प्रदर्शित करूंगा।

Sed कमांड इनपुट को इनपुट में परिवर्तित करता है:

grepx[98]
<<<87 &&grepx[87]
<<<76 &&grepx[76]
<<<11 &&grepx[11]
<<<12 &&grepx[12]
<<<23

Tr कमांड तब इसे स्ट्रिंग में कनवर्ट करता है:

grep [98] <<<87 &&grep [87] <<<76 &&grep [76] <<<11 &&grep [11] <<<12 &&grep [12] <<<23

यह स्ट्रिंग वांछित ऑपरेशन करने के लिए एक शेल कमांड है, इसलिए मैं इसे sh में पाइप करता हूं और मुझे किया जाता है।

— मिशेल स्पेक्टर
स्रोत

फ़ाइल प्रतिबंध ठीक है, हालांकि यह निश्चित रूप से एक अजीब सीमा है।

— कार्विनेट

1

क्यू, 57 बाइट्स

{r::();({r,::any(last x)in y;x,enlist y}\)($)0,x;all 1_r}

वैश्विक आर।
स्ट्रिंग के सरणी में इनपुट को परिवर्तित करता है।
स्कैन ऐरे से जाँच करता है कि अंतिम स्ट्रिंग में कुछ वर्ण वर्तमान स्ट्रिंग में है।
प्रत्येक परिणाम को r पर जोड़ता है।
1 रिटर्न अगर सभी तार चरण 3 को संतुष्ट करते हैं तो रिटर्न 0 है।

नोट: 0 फ़ंक्शन के भीतर इनपुट सरणी की शुरुआत करने के लिए संलग्न है। ऐसा इसलिए किया गया था ताकि पहले तत्व की तुलना की जा सके। अन्यथा, पहले तत्व का अंतिम चरित्र तुलना के लिए पकड़ा जाता है। एक प्रकार की जाँच कर सकता है, जो वर्तमान गिनती में 7 बाइट जोड़ता है।

— डैनियल प्लेनव्यू
स्रोत

यह मेरे क्लोजर जवाब के लिए एक समान दृष्टिकोण की तरह दिखता है। नीट लुकिंग लैंग्वेज।

— Carcigenicate

नंबर चेनिंग प्रेडिकेट

संकट:

इनपुट:

आउटपुट:

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

जेली , 5 4 बाइट्स

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

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

रेटिना , 25 20 बाइट्स

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

व्याख्या

जावास्क्रिप्ट (ईएस 6), 47 44 * 43 बाइट्स

टेस्ट स्निपेट

05AB1E , 10 बाइट्स

CJam , 18 15 14 बाइट्स

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

गणितज्ञ 62 47 35 बाइट्स

रूबी, 49 48 बाइट्स

जावा 8, 94 90 87 बाइट्स

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

व्याख्या

पायथन 3 , 48 बाइट्स

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

कैसे?

05AB1E , 5 बाइट्स

पॉवरशेल , 87 बाइट्स

पर्ल 5 , 31 बाइट्स

एपीएल (डायलॉग एपीएल) , 9 बाइट्स

PHP, 65 68

PHP, 75 बाइट्स

PHP, 77 बाइट्स

MATL , 14 बाइट्स

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

SimpleTemplate, 124 बाइट्स

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

पिप , 12 10 बाइट्स

व्याख्या

रोड़ा , 45 35 बाइट्स

बैश + यूनिक्स उपयोगिताओं, 71 69 बाइट्स

क्यू, 57 बाइट्स

जावास्क्रिप्ट (ईएस 6), 47 44 ^_* 43 बाइट्स