अब सब एक साथ

24

9 के माध्यम से अंक 1 की सूची को देखते हुए, आउटपुट प्रत्येक अंक को एक एकल सन्निहित ब्लॉक के रूप में एक साथ समूहीकृत किया जाता है। दूसरे शब्दों में, एक ही अंक के दो अलग-अलग अंकों से अलग नहीं होते हैं। यदि कोई अंक बिल्कुल दिखाई नहीं देता है तो यह ठीक है। सबसे कम बाइट्स जीतता है।

इनपुट: अंकों की गैर-रिक्त सूची 1 के माध्यम से 9. यह दशमलव संख्या, स्ट्रिंग, सूची या इसी तरह के अनुक्रम के रूप में हो सकता है।

आउटपुट: एक सुसंगत सत्य मान यदि सभी अंकों को सन्निहित ब्लॉकों में वर्गीकृत किया जाता है, और यदि वे नहीं हैं, तो एक सुसंगत फ़ासी मूल्य।

सही मामले:

3
51
44999911
123456789
222222222222222222222

झूठे मामले:

818
8884443334
4545
554553
1234567891

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

code-golf  sequence 
— XNOR
स्रोत
2
क्या सिंगलटन स्ट्रिंग्स की सूची स्वीकार्य इनपुट प्रारूप होगी?
— डेनिस
हां, सिंगलटन ठीक हैं।
— xnor
क्या कोई मुझे बता सकता है कि इस समस्या के लिए सबसे कुशल एल्गोरिदम क्या होगा? या वहाँ एक और अधिक सामान्य समस्या है कि यह नीचे गिर जाता है कि मैं देख सकता हूँ?
@ amt528 आप प्रत्येक अंक पर पुनरावृत्ति करके यह जाँच कर सकते हैं कि पहले से कोई रन नहीं है।
— xnor
क्या आप इसका उदाहरण दे सकते हैं कि यह कैसे लागू किया जाता है?

जवाबों:

18

पायथन 3, 38 34 33 बाइट्स

lambda s:s==sorted(s,key=s.index)

यह तर्क के रूप में अंकों या एकल तार की सूची की अपेक्षा करता है। Ideone पर इसका परीक्षण करें ।

4 बाइट बंद करने के लिए @xsot को धन्यवाद!

1 बाइट को बंद करने के लिए @immibis को धन्यवाद!

— डेनिस
स्रोत
यदि आपको इसके बजाय स्ट्रिंग्स की एक सूची को स्वीकार करने की अनुमति है, तो आप इसे छोटा कर सकते हैंlambda s:s==sorted(s,key=`s`.find)
— xsot
आह, मैंने एक सूची लेने की कोशिश की, लेकिन मैंने बैकटिक्स का उपयोग करने के बारे में नहीं सोचा था ... मैं ओपी से पूछूंगा।
— डेनिस
क्या मुझे कुछ याद आ रहा है - आप सिर्फ इस्तेमाल क्यों नहीं कर सकते s.find?
— user253751
@immibis sको सिंगलटन स्ट्रिंग्स की एक सूची बनानी होगी (या मुझे sतुलना करने के लिए सूची में डालना होगा), और list.findपरिभाषित नहीं किया गया है ...
— डेनिस
@ डेनिस s.indexतब? लगता है मेरे लिए काम करता है।
— user253751
14

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

s=>!/(.)(?!\1).*\1/.test(s)

दो गैर-सन्निहित अंकों की तलाश के लिए नकारात्मक लुकहेड का उपयोग करता है। यदि कम से कम दो ऐसे अंक मौजूद हैं, तो उन्हें चुना जा सकता है ताकि पहले अंक में एक अलग अंक हो।

— नील
स्रोत
1
या, बस एक regex XD का उपयोग करें। वह भी काम करता है।
— कॉनर ओ'ब्रायन
1
अहम रेटिना अहम
— जॉन ड्वोरक
13

05AB1E , 4 बाइट्स

कोड:

Ô¹ÙQ

स्पष्टीकरण:

Ô     # Push connected uniquified input. E.g. 111223345565 would give 1234565.
 ¹    # Push input again.
  Ù   # Uniquify the input. E.g. 111223345565 would give 123456.
   Q  # Check if equal, which yields 1 or 0.

CP-1252 एन्कोडिंग का उपयोग करता है ।

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

— अदनान
स्रोत
2
आप ... बस जेली को हरा दो ... मैंने कभी नहीं सोचा था कि यह संभव था ...
— बेलेंट
11

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

ĠIFPỊ

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

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

ĠIFPỊ  Main link. Input: n (list of digits or integer)

Ġ      Group the indices of n by their corresponding values, in ascending order.
       For 8884443334, this yields [[7, 8, 9], [4, 5, 6, 10], [1, 2, 3]].
 I     Increments; compute the all differences of consecutive numbers.
       For 8884443334, this yields [[1, 1], [1, 1, 4], [1, 1]].
  F    Flatten the resulting 2D list of increments.
   P   Product; multiply all increments.
    Ị  Insignificant; check if the product's absolute value is 1 or smaller.
— डेनिस
स्रोत
पाँच बाइट्स आप कहते हैं? किस तरह की एन्कोडिंग है?
— जॉन ड्वोरक
4
जेली का अपना कोड पेज है , जो एक-एक बाइट को समझने वाले 256 अक्षरों में से प्रत्येक को एन्कोड करता है।
— डेनिस
9

अजगर, 6 5 बाइट्स

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

SIxLQ

यहाँ अजगर समाधान से प्रेरित है ।

परीक्षण सूट

स्पष्टीकरण:

SIxLQ
  xLQ   Map each element in the input to its index in the input. Input is implicit.
SI      Check whether this list is sorted.
— isaacg
स्रोत
3
SIxLQकाम करने लगता है।
— FryAmTheEggman
यह जीनियस है।
— माल्टसेन
1
दूसरा Qठीक से पार्स नहीं लगता है, यह तर्क आदेश या कुछ 0और आप सभी को मिलता है स्वैप करता है और यह हमेशा सच होता है। यहाँ एक परीक्षण सूट है।
— FryAmTheEggman
8

आर, 66 48 46 43 38 बाइट्स

function(s)!any(duplicated(rle(s)$v))

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

सबसे छोटा नहीं, लेकिन मुझे लगा कि यह एक मजेदार तरीका है। हम लंबाई चलाते हैं इनपुट को एन्कोड करते हैं और मान निकालते हैं। यदि मूल्यों की सूची में डुप्लिकेट शामिल हैं FALSE, तो वापस लौटें , अन्यथा वापस लौटें TRUE।

सभी परीक्षण मामलों को ऑनलाइन सत्यापित करें

मिकीट के लिए 20 बाइट्स बचाए गए, 3 अल्बर्ट मैस्कल्स को धन्यवाद, और 5 धन्यवाद मेल करने के लिए!

— एलेक्स ए।
स्रोत
7

Matl , 8 बाइट्स

t!=tXSP=

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

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

व्याख्या

इनपुट पर विचार करें 22331, जो स्थिति को संतुष्ट करता है। परीक्षण यदि प्रत्येक वर्ण एक दूसरे के बराबर होता है, तो 2 डी सरणी देता है

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

अंतिम परिणाम सत्य होना चाहिए अगर उस सरणी की पंक्तियों (परमाणु के रूप में माना जाता है) में (लेक्सिकोग्राफिक) घटते क्रम में हैं । तुलना के लिए, इनपुट 22321सरणी देता है

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

जिसमें पंक्तियों को क्रमबद्ध नहीं किया गया है।

t!   % Take string input. Duplicate and tranpose
=    % Test for equality, element-wise with broadcast: gives a 2D array that
     % contains 0 or 1, for all pairs of characters in the input
t    % Duplicate
XS   % Sort rows (as atomic) in increasing order
P    % Flip vertically to obtain decreasing order
=    % Test for equality, element-wise
— लुइस मेंडो
स्रोत
5

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

M`(.)(?!\1).+\1
0

इसे ऑनलाइन आज़माएं! (सभी परीक्षण मामलों को एक साथ चलाने के लिए थोड़ा संशोधित किया गया है।)

पहला रेगेक्स उन अंकों से मेल खाता है जो अन्य अंकों से अलग होते हैं , इसलिए हमें 0वैध इनपुट्स के लिए और कहीं भी 1और 9अवैध इनपुट्स के लिए मिलता है (के लालच के कारण .+, हम n-1मैचों के लिए अधिक से अधिक नहीं प्राप्त कर सकते हैंn विभिन्न अंकों के )।

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

— मार्टिन एंडर
स्रोत
मैंने एक छोटा बना दिया, लेकिन यह आपके लिए काफी करीब है कि इसके बजाय एक टिप्पणी होनी चाहिए। मैच के बजाय एंटीग्रेप का उपयोग करें, फिर अंतिम पंक्ति को हटा दें: A`(.)(?!\1).+\115 बाइट्स के लिए। कई इनपुट्स के लिए भी काम करता है। ट्रू, इनपुट है, मिथ्या कुछ भी नहीं है। एक व्यक्ति अपनी भाषा में केवल गोल्फ-आउट नहीं करता है। :)
— mbomb007
@ mbomb007 मुझे लगता है कि मैंने वास्तव में इस पर विचार किया था, लेकिन दुर्भाग्य से, चुनौती एक सुसंगत सत्य (और झूठी) मूल्य के लिए पूछती है , इसलिए इनपुट को सचाई के रूप में प्रिंट करने की अनुमति नहीं है।
— मार्टिन एंडर
5

जावा, 161 156 बाइट्स

क्योंकि जावा ...

बेशर्म चोरी से regex उधार इस उत्तर क्योंकि मैं बाहर शुरू कर दिया सरणियों और गणित में गड़बड़ी के साथ ऐसा करने की कोशिश कर रहा है, लेकिन यह घोर रूप से जटिल हो गया, और regex अच्छा के रूप में इस समस्या के लिए किसी भी रूप में एक उपकरण है।

import java.util.regex.*;public class a{public static void main(String[] a){System.out.println(!Pattern.compile("(.)(?!\\1).*\\1").matcher(a[0]).find());}}

Ungolfed:

import java.util.regex.*;

public class a {
    public static void main(String[] args) {
        System.out.println(!Pattern.compile("(.)(?!\\1).*\\1").matcher(args[0]).find());
    }

समझदार जावा व्यक्ति की तरह बाहर निकलना:

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class  {
    public static void main(String[] args) {
        Pattern p = Pattern.compile("(.)(?!\\1).*\\1");
        Matcher m = p.matcher(args[0]);
        System.out.println(!m.find());
    }
}
— JamesENL
स्रोत
3
like a sensible Java personयह होगा, जावा का उपयोग कभी नहीं।
— बिल्ली
अन्य समाधान केवल एक फ़ंक्शन प्रदान कर रहे हैं, यह बहुत छोटा बना देगा। कुछ इस तरहs->s.match("(.)(?!\\1).*\\1")
— एंड्रियास
2
लेकिन तब हम उत्तर के उत्तर में रहस्योद्घाटन नहीं कर सकते थे।
— जेम्सन
4

रूबी, 23 बाइट्स

अनाम फ़ंक्शन। एक स्ट्रिंग स्वीकार करता है। रेगेक्स स्ट्रैट।

->n{/(.)(?!\1).*\1/!~n}

रेगेक्स ब्रेकडाउन

/(.)(?!\1).*\1/
 (.)            # Match a character and save it to group 1
    (?!\1)      # Negative lookahead, match if next character isn't
                #  the same character from group 1
          .*    # Any number of matches
            \1  # The same sequence as group 1

!~इसका मतलब है कि यदि स्ट्रिंग के भीतर रेगेक्स का कोई मेल नहीं है, तो वापस लौटें true, और अन्यथा वापस लौटें false।

— मूल्य स्याही
स्रोत
4

MATL, 13 11 बाइट्स

u"G@=fd2<vA

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

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

व्याख्या

        % Grab the input implicitly
u       % Find the unique characters
"       % For each of the unique characters
    G   % Grab the input again
    @=  % Determine which chars equal the current char
    f   % Find the locations of these characters
    d   % Compute the difference between the locations
    2<  % Find all index differences < 2 (indicating consecutive chars)
    v   % Vertically concatenate all stack contents
    A   % Ensure that they are all true
        % Implicit end of the for loop
— Suever
स्रोत
आप उद्धरण के साथ इनपुट ले सकते हैं (डिफ़ॉल्ट रूप से अनुमत) और हटा सकते हैं j। इसके अलावा, मुझे लगता है कि आप vAलूप के भीतर जा सकते हैं और हटा सकते हैं]
— लुइस मेंडो
@LuisMendo धन्यवाद! मैंने Y&अंदर डालने के साथ गड़बड़ कर दी थी, लेकिन यह काम नहीं किया क्योंकि fd2<खाली हो सकता है। vAअंदर चल रहा है हालांकि महान काम करता है! इसके अलावा, मैं वास्तव में चाहता था कि हमारे पास एक स्थिर uniqueबाइट न हो।
— स्वेअर
अब पूर्वनिर्धारित स्ट्रिंग के बजाय एक संख्या का उपयोग करके स्थिर अद्वितीय थोड़ा कम लेता है। मैं भविष्य में एक छोटा संस्करण जोड़ सकता हूं, हालांकि। या बस uडिफ़ॉल्ट रूप से स्थिर करें (आप हमेशा Sबाद में, दो बाइट्स शामिल कर सकते हैं )। तुम क्या सोचते हो?
— लुइस मेंडो
3

हास्केल, 44 बाइट्स

import Data.List 
((==)<*>nub).map head.group

प्रयोग उदाहरण: ((==)<*>nub).map head.group $ "44999911"-> True।

एक गैर-पॉइंटफ़्री संस्करण:

f x = q == nub q                -- True if q equals q with duplicates removed
  where
  q = map head $ group x        -- group identical digits and take the first
                                -- e.g. "44999911" -> ["44","9999","11"] -> "491"
                                -- e.g  "3443311" -> ["3","44","33","11"] -> "3431"
— नीमी
स्रोत
3

जे, 8 बाइट्स

-:]/:i.~

साथ यह परीक्षण J.js ।

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

-:]/:i.~  Monadic verb. Argument: y (list of digits)

     i.~  Find the index in y of each d in y.
  ]/:     Sort y by the indices.
-:        Match; compare the reordering with the original y.
— डेनिस
स्रोत
1
:] :i :-1
— कैलक्यूलेटरफेलीन
11
यकीन नहीं तो मज़ाक या गोल्फ सुझाव ...
— डेनिस
3

पायथन, 56 55 बाइट्स

a=lambda s:~(s[0]in s.lstrip(s[0]))&a(s[1:])if s else 1
— orlp
स्रोत
पायथन 3.4.1 में विफल ( int not subscriptable)
— कैलकुलेटर
एक अतिरिक्त बाइट के साथ सहेजा गया है ~(जो कि शाब्दिक रूप से इसके बराबर है 1-):a=lambda s:~(s[0]in s.lstrip(s[0]))&a(s[1:])if s else 1
— कैलक्यूलेटरफलिन
3

सी #, 119 बाइट्स

bool m(String s){for(int i=0;i<9;i++){if(new Regex(i.ToString()+"+").Matches(s).Count>1){return false;}}return true;}

Ungolfed

bool m(String s) {
    for(int i=0;i<9;i++) {
        if(new Regex(i.ToString() + "+").Matches(s).Count > 1) {
            return false;
        }
    }

    return true;
}
— auhmaan
स्रोत
1
PPCG में आपका स्वागत है! एक पोस्ट को हटाने और निश्चित संस्करण के साथ एक नया पोस्ट बनाने के बजाय, आप अपने पुराने पोस्ट को भी संपादित कर सकते हैं और फिर इसे हटा सकते हैं। (अब ऐसा करने की आवश्यकता नहीं है कि पहले से ही दो पोस्ट पहले से ही हैं, लेकिन अभी तक आप भविष्य में जानते हैं।)
— मार्टिन एंडर
मेरी गलती। जब मैंने पहली बार इस कोड गोल्फ में भाग लेने का इरादा किया तो मैंने उद्देश्य को गलत बताया और एक और समाधान करने के लिए ज्यादा समय नहीं था (और खुद को जानकर, मैं पिछले पोस्ट किए गए समाधान को सही करने की कोशिश नहीं करूंगा)। लेकिन फिर मुझे बताया गया कि मेरे पास कुछ और समय था और "सही समाधान" पोस्ट करने का प्रयास किया। आपने जो कहा, उसे करने में भी नहीं सोचा था। अगली बार जब मैं मन में होगा!
— auhmaan
कोई समस्या नहीं है, मुझे आशा है कि आपके पास समुदाय में अच्छा समय होगा। :)
— मार्टिन एंडर
2

जूलिया, 35 बाइट्स

s->issorted(s,by=x->findfirst(s,x))

जो भी कारण के लिए, sortएक स्ट्रिंग नहीं लेता है, लेकिन issortedकरता है ...

— डेनिस
स्रोत
... क्या जूलिया में तार पायथन की तरह अपरिवर्तनीय नहीं हैं? इससे मुझे बहुत दुःख होगा।
— बिल्ली
1
हाँ, तार अपरिवर्तनीय हैं। शायद यही कारण है कि issortedकाम करता है, लेकिन sortनहीं करता है।
— डेनिस
1
स्ट्रिंग्स के लिए परिभाषित एक छँटाई विधि नहीं है, लेकिन यह काम नहीं करेगा यदि उन्हें उसी तरह से एक आयामी सरणियों के रूप में संसाधित किया गया हो, क्योंकि वे एक कॉपी के इन-प्लेस सॉर्ट का प्रदर्शन करके सॉर्ट किए जाते हैं, और जैसा कि आपने कहा, तार अपरिवर्तनीय हैं। यह क्रमबद्ध क्रम के लिए जाँच करने के लिए एक समस्या नहीं है, क्योंकि यह एक साधारण से अधिक लूप के रूप में कार्यान्वित किया जाता है, जो तार के लिए ठीक है। बस कुछ सामान्य ज्ञान। ¯ \ _ (ツ) _ / ¯
— एलेक्स ए।
@AlexA। तो वास्तव में अजगर की तरह बहुत ; अंतर यह है कि पाइथन के sortedबिलिन ने एक दुरूह तर्क को अपनी उत्परिवर्तनीय सूची में बदल दिया है - यही कारण है कि sorted(string)तार की सूची लौटाता है
— बिल्ली
2

फैक्टर, 22 बाइट्स

[ dup natural-sort = ]

टिन पर दिये गये निर्देशों का पालन करो। एक अनाम फ़ंक्शन के रूप में, आपको callयह करना चाहिए , या इसे बनाना चाहिए : word ;।

— बिल्ली
स्रोत
4
यह मुझे डराता है जब एक बिल्ली खेल में एक माउस ले
— आती है
@downrep_nation: पी
— बिल्ली
2

लुआ, 107 94 85 बाइट्स

13 बाइट्स @LeakyNun की बदौलत बच गए

कम से कम, यह जावा को हराता है: डी। Lua स्ट्रिंग्स को जोड़ तोड़ कर चूसता है, लेकिन मुझे लगता है कि यह काफी अच्छा है :)।

यह अपने इनपुट को कमांड-लाइन तर्क के रूप में लेता है, और 1सत्य मामलों के लिए और falseझूठे लोगों के लिए आउटपुट देता है।अब इसके एक्जिट कोड का उपयोग कर आउटपुट देता है। सत्य के लिए कोड 0 से बाहर निकलें, और झूठी के लिए 1

o=os.exit;(...):gsub("(.)(.+)%1",function(a,b)if 0<#b:gsub(a,"")then o(1)end end)o(0)

Ungolfed

ध्यान रखें, दो जादू-चर कहलाते हैं ..., पहले वाले में प्रोग्राम का तर्क होता है, दूसरा अनाम फ़ंक्शन के लिए स्थानीय होता है और इसके पैरामीटर होते हैं

o=os.exit;               -- ; mandatory, else it would exit instantly
(...):gsub("(.)(.+)%1",  -- iterate over each group of the form x.*x and apply an anonymous
  function(a,b)          -- function that takes the captured group as parameters
  if 0<#b:gsub(a,"")     -- if the captured group (.+) contain other character than
  then                   -- the one captured by (.)
    o(1)                 -- exit with falsy
  end
end)
o(0)                     -- exit with truthy, reached only when the string is okay
— Katenkyo
स्रोत
यदि यह अनुमति दी है, आप बदल सकते हैं os.exit()साथ i=#0...
— लीकी नून
1

जावास्क्रिप्ट ES6, 71 69 बाइट्स

h=y=>y.match(/(.)\1*/g);x=>h((u=h(x)).sort().join``).length==u.length

या, समकक्ष:

x=>((u=x.match(r=/(.)\1*/g)).sort().join``).match(r).length==u.length
x=>(h=y=>y.match(/(.)\1*/g))((u=h(x)).sort().join``).length==u.length

गोल्फ का काम जारी है।

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

var truthy = `3
51
44999911
123456789
222222222222222222222`.split `
`;
var falsey = `818
8884443334
4545
554553
1234567891`.split `
`;

var Q = x => ((u = x.match(r = /(.)\1*/g)).sort().join ``).match(r).length == u.length;
truthy.concat(falsey).forEach(e => {
  t = document.createTextNode(`${e} => ${Q(e)}`);
  o.appendChild(t);
  o.appendChild(document.createElement("br"));
});
* {
  font-family: Consolas, monospace;
}
<div id=o></div>
स्निपेट का विस्तार करें

— कोनोर ओ ब्रायन
स्रोत
1

C # 111 बाइट्स

bool f(string s){for(int i=0;i<s.Length-1;i++)if(s[i]!=s[i+1]&&s.LastIndexOf(s[i])!=i)return 1==2;return true;}

पुरानी रणनीति 131 बाइट्स

bool s(string i){var f=Regex.Matches(i,@"([0-9])\1{0,}").Cast<Match>().Select(m=>m.Value[0]);return f.Distinct().SequenceEqual(f);}

पहला गोल्फ मुझे लगता है कि मैंने ठीक किया

— downrep_nation
स्रोत
1

सी, 74 73 71 बाइट्स

मुंडा एक @xsot करने के लिए तीन बाइट धन्यवाद!

a[99],c,m;main(d){for(;~c;m|=c^d&&a[d=c]++)c=getchar();putchar(48+!m);}
— mIllIbyte
स्रोत
a[99]मुझे पर्ल का ऑटोवैविफिकेशन बहुत पसंद है! ओह, रुको ...
— बिल्ली
मुझे लगता है कि यह काम करता है:a[99],c,m;main(d){for(;~c;m|=a[d=c]+=c!=d)c=getchar();putchar(48+1/m);}
— xsot
@xsot - बदल कर शेविंग एक बाइट के लिए धन्यवाद !--mके साथ 1/m। के बारे में a[d=c]+=c!=d, मैंने इसे जीसीसी के साथ आजमाया और मूल्यांकन के आदेश के कारण यह मेरे कंप्यूटर पर काम नहीं कर पाया। हमें एक कंपाइलर ढूंढना होगा जो साथ खेलेगा।
— mIllIbyte
ओह, मैंने इसे सिर्फ विचारधारा पर परीक्षण किया और यह ठीक काम किया। इसके बारे में कैसे:a[99],c,m;main(d){for(;~c;m|=c^d&&a[d=c]++)c=getchar();putchar(48+!m);}
— xsot
1

हास्केल, 37 बाइट्स

f l=(==)=<<scanl1 min$(<$>l).(==)<$>l

लुइस मेंडो के MATL उत्तर के समान दृष्टिकोण का उपयोग करता है : प्रत्येक प्रविष्टि के लिए एक वेक्टर बनाता है जो इसे बराबर करता है, और जाँचता है कि परिणाम घटते क्रम में क्रमबद्ध है।

(<$>l).(==)<$>lका छोटा संस्करण है [map(==a)l|a<-l]। जिस फ़ंक्शन (<$>l).(==)को लिया जाता aहै map(==a)l, उस पर मैप किया जाता है l।

scanl1 minसंचयी सबसे छोटे तत्वों को लेता है l, जो मूल के बराबर होता है, यदि lरिवर्स-सॉर्ट किया गया हो। (==)=<<जाँच करता है कि क्या सूची वास्तव में इस ऑपरेशन के तहत अयोग्य है।

एक अलग पुनरावर्ती रणनीति ने 40 बाइट्स दिए:

f(a:b:t)=f(b:t)>(elem a t&&a/=b)
f _=1>0

यह देखने के लिए प्रत्येक प्रत्यय की जाँच करता है कि क्या इसका पहला तत्व शेष, बहाने वाले मामलों में प्रकट नहीं होता है जहाँ पहले दो तत्व एक सन्निहित ब्लॉक के हिस्से के बराबर हैं।

— XNOR
स्रोत
1

रैकेट, 53 बाइट्स

गूंगा, सरल संस्करण।

(λ(s)(let([s(string->list s)])(eq?(sort s char<?)s)))

Ungolfed:

(define (lame-all-together s)
  (let ([s (string->list s)])
    (eq? (sort s char<?) s)))

रैकेट, 86 बाइट्स

यह करने के लिए अधिक कुशल तरीकों के बारे में @ xnor की टिप्पणी को लागू करने वाला संस्करण यहां दिया गया है।

(λ(s)(let([s(string->list(regexp-replace#px"(.)\\1+"s"\\1"))])(eq?(sort s char<?)s)))

Ungolfed:

(define (all-together s)
    (let ([s (string->list (regexp-replace #px"(.)\\1+" s "\\1"))])
      (eq? (sort s char<?) s )))

ठीक है, यह वास्तव में sortफ़ंक्शन से गणना के वजन को शिफ्ट कर सकता है regexp-replace, लेकिन यह एक दिलचस्प समाधान था। मूल रूप से, यह पहले डुप्लिकेट वर्णों के रन निकालता है ( यहां देखें ), फिर परीक्षण करता है यदि शेष लंबाई -1 रन छँटाई फैशन में हैं।

— बिल्ली
स्रोत
1

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

-peइसके बजाय 19, प्लस 1 -e।

$_=!/(.)(?!\1).+\1/
— msh210
स्रोत
1

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

Gather@#==Split@#&

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

Gatherसमान तत्वों के उप सूची में एक सूची इकट्ठा करता है, और Splitलगातार समान तत्वों के उप सूची में एक सूची को विभाजित करता है। वे एक ही परिणाम देते हैं यदि और केवल यदि प्रत्येक मान केवल एक सन्निहित ब्लॉक में प्रकट होता है।

— मिशा लावरोव
स्रोत
0

जाप , 9 बाइट्स

ò¦ mÌ
eUâ

कोशिश करो

व्याख्या

          :Implicit input of string U             :e.g., "8884443334"
ò¦        :Split on inequality                    :["888","444","333","4"]
   mÌ     :Map and return the last digit of each  :["8","4","3","4"]
\n        :Assign to U
  Uâ      :Remove duplicates                      :["8","4","3"]
e         :Test for equality with U               :false
          :Implicit output of result
— झबरा
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.