भेदभाव रहित प्रोग्रामिंग

74

हम कहते हैं कि एक स्ट्रिंग गैर-भेदभावपूर्ण है यदि स्ट्रिंग के प्रत्येक अक्षर समान संख्या में और कम से कम दो बार दिखाई देते हैं।

उदाहरण

  • "aa!1 1 !a !1"है गैर भेदभाव पात्रों में से प्रत्येक क्योंकि , !, aऔर 1तीन बार दिखाई देते हैं।
  • "abbaabb"है न गैर भेदभाव क्योंकि bअधिक बार दिखाई देता है a।
  • "abc"भी है नहीं गैर भेदभाव क्योंकि पात्रों में कम से कम दो बार नहीं दिखाई देते।

कार्य

एक लिखें गैर भेदभाव कार्यक्रम या समारोह जो एक रिटर्न truthy मूल्य यदि किसी विशेष स्ट्रिंग है गैर भेदभाव , और एक falsy मूल्य अन्यथा।

यही है, अपने स्वयं के स्रोत कोड पर चलाए गए कार्यक्रम को एक सत्य मान वापस करना चाहिए।

प्रत्येक सबमिशन को प्रिंट करने योग्य ASCII वाले गैर-खाली तारों को संभालने में सक्षम होना चाहिए , साथ ही सभी वर्णों को प्रस्तुत करने के स्रोत कोड में दिखाई देना चाहिए।

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

Truthy:

<your program's source code>
"aaaa"
"aa!1 1 !a !1"
"aabbccddeeffgg"
"1Q!V_fSiA6Bri{|}tkDM]VjNJ=^_4(a&=?5oYa,1wh|R4YKU #9c!#Q T&f`:sm$@Xv-ugW<P)l}WP>F'jl3xmd'9Ie$MN;TrCBC/tZIL*G27byEn.g0kKhbR%>G-.5pHcL0)JZ`s:*[x2Sz68%v^Ho8+[e,{OAqn?3E<OFwX(;@yu]+z7/pdqUD"

Falsy:

"a"
"abbaabb"
"abc"
"bQf6ScA5d:4_aJ)D]2*^Mv(E}Kb7o@]krevW?eT0FW;I|J:ix %9!3Fwm;*UZGH`8tV>gy1xX<S/OA7NtB'}c u'V$L,YlYp{#[..j&gTk8jp-6RlGUL#_<^0CCZKPQfD2%s)he-BMRu1n?qdi/!5q=wn$ora+X,POzzHNh=(4{m`39I|s[+E@&y>"
code-golf  string  decision-problem  restricted-source 
— Laikoni
स्रोत
4
@ लैकोनी क्या हम टिप्पणियों का दुरुपयोग कर सकते हैं ताकि यह काम कर सके?
— मैजिक ऑक्टोपस Urn
6
एक साइड नोट के रूप में, मुझे चुनौतियां पसंद हैं जहां मैं अपनी प्रविष्टि की वैधता का परीक्षण करने के लिए अन्य प्रविष्टियों का उपयोग कर सकता हूं।
— मैजिक ऑक्टोपस Urn
3
@MagicOctopusUrn मुझे लगता है कि उसने सैंडबॉक्स में कहा है कि इसकी अनुमति है, क्योंकि यह अवलोकन से निर्धारित नहीं किया जा सकता है।
— एर्ग आउटफोलर
11
ठीक ठीक। यहां तक ​​कि अगर आप किसी तरह से उद्देश्यपूर्ण शैली में टिप्पणियों पर प्रतिबंध लगाने का प्रबंधन करते हैं, तो अप्रयुक्त स्ट्रिंग शाब्दिक ect के बारे में क्या? वैसे भी, मुझे लगता है कि स्कोरिंग टिप्पणियों को जितना संभव हो सके बचने के लिए प्रोत्साहन देता है।
— लैकोनी
4
मुझे लगता है कि यह सिर्फ एक पहेली है, लेकिन "सभी गैर-समान भागों में मौजूद सभी पहचाने जाने वाले लेबल सदस्य प्रकार" के साथ "गैर-भेदभाव" का भ्रम हल्के से परेशान कर रहा है ... "भेदभाव" का अर्थ है "और" के बीच का अंतर बताना गलत तरीके से इसका मतलब यह है कि किसी व्यक्ति के दूसरे वर्ग से अलग दिखने के आधार पर किसी के साथ गलत व्यवहार करना या उसका न्याय करना। बेशक, मज़े के साथ चलते रहो!
— ErikE

जवाबों:

25

जावा 8, 198 192 186 174 168 165 160 बाइट्स (चार-गिनती 6 5)

o->{byte x[]=new byte[+333-3|2],u=-0,i,fe,fi,w; s:w:no0r3sswwyyy:for(int s:o){{u=++x[s];}};for(int b:x){if(!!!(2>b||u==b)|2>u|2>2){x[0]++;}}return!!(0>--x[0]);}

इसे ऑनलाइन आज़माएं।
पात्रों की घटनाओं को सत्यापित करने के लिए कोड का उपयोग किया जाता था, जो इस चुनौती के लिए मेरा जवाब था ।

-5 बाइट्स @ OlivierGrégoire को फिर से टिप्पणी से छुटकारा पाने और एक गड़बड़ करने के लिए धन्यवाद । ;)

पुराने 168 बाइट्स (चार-गिनती 6) उत्तर :

o->{int w[]=new int[2222],u=0,f=0;for(int r:o)u=++w[r];for(int e:w)if(!(2>e|u==e)|2>u)f++;return!(f>0);}//[[[]]]  !!!!e(i)++,,,,-----oo////000tuww::::{{{{{;;||||}}}}}>>

इसे ऑनलाइन आज़माएं।
कोड ने टिप्पणी को छोड़कर पात्रों की घटनाओं को सत्यापित करने के लिए उपयोग किया , जो इस चुनौती के लिए मेरा जवाब था ।

-6 बाइट्स के लिए धन्यवाद @ OliverGrégoire< चेक को स्वैप करके हटा रहा है >।

बेस गोल्फ कार्यक्रम (98 बाइट्स) का स्पष्टीकरण:
इसे ऑनलाइन आज़माएं।

s->{                     // Method with character-array parameter and boolean return-type
  int a[]=new int[256],  //  Occurrences integer-array containing 256 zeroes
      t=0,               //  Temp integer, starting at 0
      f=0;               //  Flag integer, starting at 0
  for(int c:s)           //  Loop over the input
    t=++a[c];            //   Increase the occurrence-counter of the current character
                         //   And set the temp integer to this value
  for(int i:a)           //  Loop over the integer-array
    if(i>1               //   If the value is filled (not 0) and at least 2,
       &i!=t             //   and it's not equal to the temp integer
       |t<2)             //   Or the temp integer is lower than 2
      f++;               //    Increase the flag-integer by 1
  return f<1;}           //  Return whether the flag integer is still 0

कुछ चीजें जो मैंने उपयोग किए गए पात्रों की मात्रा को कम करने के लिए की हैं:

  • चर नाम o, w, u, f, r, और eकरने के लिए फिर से उपयोग पात्रों हम पहले से ही था उद्देश्य पर चुने गए हैं (लेकिन 6 से अधिक नहीं)।
  • 2222के बजाय प्रयोग किया जाता है 256।
  • 6x को हटाने के लिए इफ -चेक e>0&u!=e|u<2को बदल दिया ।!(e<2|u==e)|u<2&
  • दो अलग-अलग रिटर्न को हटा दिया और एक ध्वज का उपयोग किया f, और हम वापसी करते हैं कि क्या यह अभी भी अंत में 0 है (इसका मतलब है कि मैं अब byसे 6x निकाल सकता हूं byteजिसे हम केवल 8 के बजाय 6 बार nमें उपयोग करते हैं int)।
  • e<2और u<2करने के लिए बदल 2>eऔर 2>u6x दूर करने के लिए <।

मैंने चार-गिनती 6 से 5 को कम करने के लिए क्या किया:

  • 2x intकरने के लिए byteइतना की राशि nका इस्तेमाल किया 4 के बजाय 6 है।
  • प्रयुक्त x[0]एक नया वेरिएबल के बजाय f=0इतना की राशि =का इस्तेमाल किया 5 के बजाय 6 है।
  • बदल गया 2222है 3333इसलिए 2प्रयुक्त राशि 6 के बजाय 2 है।
  • परिवर्तित चर fऔर rफिर से वे अब 6 भी नहीं हैं।

क्या @ OlivierGrégoire ने टिप्पणी से छुटकारा पाने के लिए किया, और इसलिए 5x /:

  • अप्रयुक्त चर जोड़ना ,i,fe,fi,w;।
  • अप्रयुक्त लेबल जोड़ना s:w:no0r3sswwyyy::।
  • अप्रयुक्त जोड़ना |2>2
  • फ़ोर {}-लूप्स और {}इफ़्स के आसपास जोड़ना , और एक अप्रयुक्त- जोड़ दिया।
  • को बदल रहा !है !!!।
  • को बदल रहा |है ||।
  • बदलने 333के लिए +333-3|2बचे हुए अंकगणितीय ऑपरेटर से छुटकारा पाने के +-|और 2।
  • को बदल रहा !(x[0]>0)है !!(0>--x[0])।
— केविन क्रूज़सेन
स्रोत
1
180 बाइट्स : सभी<मेंपरिवर्तित>।
— ओलिवियर ग्राएगोइरे
@ OlivierGrégoire क्षमा करें, मैं पहले से ही 174 पर हूं :) लेकिन देखेंगे कि क्या आपकी चाल अभी भी लागू हो सकती है।
— केविन क्रूज़सेन
6 बाइट्स को बचाने के लिए परिवर्तन अभी भी लागू हो सकता है।
— ओलिवियर ग्राएगोइरे
निकटतम मैं 162 पात्रों (161 वर्ण) का हूं । मैं टिप्पणी को हटाने की कोशिश कर रहा हूं, लेकिन मुझे अभी भी एक अल्पविराम लगाने की आवश्यकता है। मुझे अभी कोई जगह नहीं मिली।
— ओलिवियर ग्राएगोइरे
1
160 बाइट्स ( प्रमाण )। बहुत अधिक गोल्फ की संभावना है।
— ओलिवियर ग्रैगोइरे
15

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

Ġ¬zḊḊ¬zĠȦȦ

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

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

Ġ¬zḊḊ¬zĠȦȦ  Main link. Argument: s (string)

Ġ           Group the indices of s by their corresponding elements.
            "abcba" -> [[1, 5], [2, 4], [3]]

 ¬          Take the logical NOT of each 1-based(!) index.
            [[1, 5], [2, 4], [3]] -> [[0, 0], [0, 0], [0]]

   Ḋ        Dequeue; yield s without its fist element.
            "abcba" -> "bcba"

  z         Zip-longest; zip the elements of the array to the left, using the
            string to the right as filler.
            ([[0, 0], [0, 0], [0]], "bcba") -> [[0, 0, 0], [0, 0, "bcba"]]

    Ḋ       Dequeue; remove the first array of the result.
            This yields an empty array if s does not contain duplicates.
            [[0, 0, 0], [0, 0, "bcba"]] -> [[0, 0, "bcba"]]

    ¬       Take the logical NOT of all zeros and characters.
            [[0, 0, "bcba"]] -> [[1, 1, [0, 0, 0, 0]]]

      Ġ     Group.

     z      Zip-longest. Since all arrays in the result to the left have the same
            number of elements, this is just a regular zip.
            [[1, 1, [0, 0, 0, 0]]] -> [[1], [1], [[0, 0, 0, 0]]

       Ȧ    Any and all; test if the result is non-empty and contains no zeroes,
            at any depth. Yield 1 if so, 0 if not.
            [[1], [1], [[0, 0, 0, 0]] -> 0

        Ȧ   Any and all.
            0 -> 0
— डेनिस
स्रोत
13

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

ọtᵐℕ₂ᵐ==tℕ₂ọ

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

व्याख्या

ọ   Occurrences. Gives a list of [char, count] pairs for the entire input.
tᵐ  Map "tail" over this list, giving each character count.
ℕ₂ᵐ Make sure that each count is at least 2.
=   Make sure that all counts are equal.
    At this point we're done with the actual code, but we need another copy
    of each character (except ᵐ). We can just put them after this, as long as
    we make sure that they can never cause the predicate to fail.
=   Make sure that all counts are equal, again...
t   Extract the last count.
ℕ₂  Make sure that it's at least 2, again...
ọ   Get the digit occurrences in that count, this can't fail.

वैकल्पिक 12-बाइट समाधान जो tइसके बजाय पुन ᵐ: उपयोग करता है :

ọtᵐ==tℕ₂ℕ₂ọᵐ
— मार्टिन एंडर
स्रोत
13

टी-एसक्यूएल, 320 बाइट्स (32 चार x 10 प्रत्येक)

इनपुट हमारे आईओ मानकों के अनुसार , पहले से मौजूद टेबल के FILLसाथ है ।STEW

WITH BUMPF AS(SeLeCT GYP=1
UNION ALL
SeLeCT GYP+1FROM BUMPF
WHeRe GYP<=1000)SeLeCT
IIF(MIN(WAXBY)<MAX(WAXBY)OR
MAX(WAXBY)<=1,+0,+1)FROM(SeLeCT
WAXBY=COUNT(1),WHICH=+1+0,HEXCHANGE=+01,HUNG=+0+1,CHLUB=+0,GEFF=+0FROM
BUMPF,FILL WHERE
GYP<=LEN(STEW)GROUP BY
SUBSTRING(STEW,GYP,1))CHEXX
OPTION(MAXRECURSION 0)----------<<<<<<

मैं कभी भी अधिक प्रसन्न नहीं हुआ, फिर भी कोड के एक टुकड़े से भयभीत हो गया।

केस-सेंसिटिव कॉलेशन के लिए सेट किए गए सर्वर या डेटाबेस पर चलना चाहिए। ऊपरी और निचले हिस्से E(SQL कमांड केस-असंवेदनशील हैं, इसलिए ज़रूरत के अनुसार कुछ फ़्लिप किए गए) सहित 32 अलग-अलग वर्णों के 10 प्रत्येक होते हैं , रिक्त स्थान और टैब (टैब पठनीयता के लिए ऊपर कोड में लाइन ब्रेक के रूप में दिखाए जाते हैं)।

मुझे + = ,कोड में 10 अन्य प्रतीकों में से प्रत्येक को शामिल करने के तरीके मिले , लेकिन दुर्भाग्य से ऐसा करने का कोई तरीका नहीं मिला <, इसलिए मुझे टिप्पणी चरित्र जोड़ना पड़ा -।

इससे पहले कि मैं सभी अतिरिक्त भरावों में crammed हो, यहां प्रारूपित कोड है:

WITH b AS (SELECT g=1 UNION ALL SELECT g+1 FROM b WHERE g<1000)
SELECT IIF(MIN(w)<MAX(w) OR MAX(w)<1+1,0,1)
FROM(
    SELECT w=COUNT(1), --extra constant fields here are ignored
    FROM b, fill
    WHERE g < 1+LEN(stew)
    GROUP BY SUBSTRING(stew,g,1)
)a OPTION(MAXRECURSION 0)

शीर्ष पंक्ति एक पुनरावर्ती CTE है जो एक संख्या तालिका बनाता है b, जिसे हम चरित्र द्वारा अलग करने के लिए स्रोत स्ट्रिंग में शामिल होते हैं। उन वर्णों को समूहीकृत और गिना जाता है, और यह IIFकथन 0 या 1 पर निर्भर करता है कि इनपुट स्ट्रिंग गैर-भेदभावपूर्ण है या नहीं।

— BradC
स्रोत
11

सी (जीसीसी) ,  333  168 बाइट्स

9 बाइट बचाने के लिए @ केविन क्रूज़सेन को धन्यवाद और 45 बाइट बचाने के लिए @ लिकोनी को धन्यवाद!

f(r,h,a){char*o=r,c[222]={!o};for(a=!o;*o;)++c[*o++];for(h=!o;222/++h;c[h]&&c[h]!=a&&(a=!*c))!a&&c[h]&&(a=c[h]);r=!(2/2/a);}/////!(())****++,,,,,[[]]fffffrr{{{{{{}}}}}}

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

सी, 333 बाइट्स

i,v;f(S){char*s=S,L[128]={0};for(v=0;*s;)++L[*s++];for(i=-1;++i<128;L[i]&&L[i]-v?v=-1:0)!v&&L[i]?v=L[i]:0;return-v<-1;}/////////!!!!!!!!&&&&&(((((())))))******+++,,,,,,,----00000111122222228888888:::::::<<<<<<<===???????LLLSSSSSSS[[[]]]aaaaaaaacccccccceeeeeeeeffffffhhhhhhhhiinnnnnnnnooooooorrrrssssssttttttttuuuuuuuuvv{{{{{{{}}}}}}}

यहां तक ​​कि बाइटकाउंट गैर-भेदभावपूर्ण है!

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

— Steadybox
स्रोत
अवध ... मैं पहली टिप्पणी करने वाला बनना चाहता था। हालांकि एक अच्छी बात है, मुझे पसंद है कि आप टिप्पणी के लिए वर्णों को कैसे छांटते हैं ^ _ ^
— मैजिक ऑक्टोपस उरन
1
आप करने के लिए इसे कम कर सकते हैं 324 बाइट्स बदलते दोनों द्वारा 128करने के लिए 222इतना 8छोड़ा जा सकता है।
— केविन क्रूज़सेन
1
नाम बदलकर 279 बाइट्स i, v, S, sऔर Lवर्ण जो पहले से मौजूद कीवर्ड में प्रदर्शित करने char, forऔर return: यह ऑनलाइन कोशिश करो!
— लैकोनी
@ लायकोनी धन्यवाद! मेरे पास यह कल ठीक से गोल्फ करने का समय नहीं था।
— स्टैडिएबॉक्स
@MagicOctopusUrn उन्हें हल किया गया है क्योंकि मैं उन्हें हाथ से जोड़ने के लिए बहुत आलसी था ।
— स्टेडियबॉक्स
9

05AB1E , 20 18 16 14 बाइट्स

S¢Z≠sË*sZ¢≠SË*

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

कार्यक्रम को अनिवार्य रूप से 2 भागों में विभाजित किया गया है जहां पहले भाग का लक्ष्य वास्तविक कार्य करना है और दूसरे भाग का लक्ष्य है कि परिणाम में परिवर्तन किए बिना पहले भाग के रूप में समान कार्यों का उपयोग करना।

स्पष्टीकरण (पहला भाग)

S          # push input split into list of chars
 ¢         # count the occurrence of each char in input
  Z≠       # check that the max count is not 1
    sË     # check if all counts are equal
      *    # multiply

स्पष्टीकरण (दूसरा भाग)

s          # swap input to top of stack
 Z¢        # count the number of occurrences of the largest element
   ≠       # check that the count isn't 1
    SË     # split into list and check that each element are equal (always true)
      *    # multiply (as it is with 1, the original result is left unchanged)
— Emigna
स्रोत
{γ€gDË*P≠qq{γ€gDË*P≠20 के लिए एक और है;)।
— मैजिक ऑक्टोपस Urn
1
@MagicOctopusUrn: अच्छा! मेरे साथ 20 में भी कुछ और थे। मेरे पास 18 में से एक है :)
— एमिग्ना
2
जादू टोना! कोई और व्याख्या नहीं!
— मैजिक ऑक्टोपस Urn
1
¢... अच्छा विचार आदमी, मुझे यह देखकर खुशी हुई कि मैं ≠जितना उपयोगी था, मुझे लगा कि यह हाहाकार हो सकता है!
— मैजिक ऑक्टोपस Urn
9

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

§<ε#εu§m#u
m
<

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

व्याख्या

दो छोटी लाइनें नो-ऑप हैं, क्योंकि मुख्य फ़ंक्शन उन्हें कभी नहीं बुलाता है।

§<ε#εu§m#u  Implicit input, say S = "asasdd"
         u  Remove duplicates: "asd"
      §m#   For each, get number of occurrences in S: [2,2,2]
     u      Remove duplicates: L = [2]
   #ε       Number of elements in L that are at most 1: 0
  ε         1 if L is a singleton, 0 otherwise: 1
§<          Is the former value smaller than the latter?
— Zgarb
स्रोत
लेकिन यह 'मी' से अधिक 'यू' है, इसलिए यह आवश्यकताओं को पूरा नहीं करता है।
— WGroleau
@ पेट्रोल mभी दो बार होता है: पहली लाइन पर और दूसरी लाइन पर। स्पष्टीकरण में दो छोटी पंक्तियों को शामिल नहीं किया गया है क्योंकि वे कार्यक्रम के व्यवहार को प्रभावित नहीं करते हैं।
— जरगब
मुझे लगता है कि ओपी को स्पष्ट करना चाहिए कि क्या कार्यक्रम की व्याख्या कार्यक्रम के साथ-साथ स्कैन की जा सकती है। लेकिन वास्तव में, यदि आप इसे शामिल करते हैं, तो आपके पास चार 'यू' और दो 'एम' हैं
— विंग्लू
कोई बात नहीं; इसने मुझे उसी तरह भ्रमित किया जैसे एक और जवाब दिया।
— WGroleau
9

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

def f(s):len({2<<s.count(c)-2for c,in s})<2or{{e.dil:-tu,r.dil:-tu,}}

आउटपुट किसी त्रुटि की उपस्थिति या अनुपस्थिति के माध्यम से होता है । त्रुटि या तो एक ValueError है (एक या अधिक वर्ण केवल एक बार होते हैं) या NameError (वर्ण गणना असमान हैं)।

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

— डेनिस
स्रोत
नकारात्मक बदलाव त्रुटि चाल साफ है! मुझे पसंद है कि यह शिफ्ट ऑपरेटर कम पूर्वता का लाभ कैसे उठाता है।
— विंसेंट
1
{{e.dil:-tu,r.dil:-tu,}} अच्छा स्वामी वह क्या है?
— एडम बार्न्स
1
@AdamBarnes सिंथेटिक रूप से वैध गिब्रिश जो मूल्यांकन किए जाने पर NameError फेंकता है ।
— डेनिस
मुझे नहीं मिला। मैंने इसे बदलने की कोशिश की aऔर सब कुछ टूट गया। क्या आप आगे बता सकते हैं?
— एडम बार्न्स
@ अदमबर्न्स को तब तक काम करना चाहिए, जब तक आप एक जगह छोड़ देते हैं or। कंप्यूटर पर होने पर मैं एक स्पष्टीकरण जोड़ूंगा।
— डेनिस
9

Brachylog v2, 8 बाइट्स (Brachylog के चरित्र सेट में)

oḅ\k\koḅ

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

ऐसा लगता है कि ब्रेकीलॉग में इस सवाल पर एक गोल्फ युद्ध चल रहा है, इसलिए मैंने सोचा कि मैं इसमें शामिल हो जाऊंगा, अगले कुछ सबसे अच्छे उत्तर पर बाइट्स की बचत होगी।

यह एक पूर्ण कार्यक्रम है जो इनपुट को वर्ण कोड की सूची के रूप में लेता है। (यह आंशिक रूप से है क्योंकि Brachylog को कुछ बहुत ही विचित्र कीड़े दिखाई देते हैं जो स्ट्रिंग्स में बैकस्लैश से संबंधित हैं, और आंशिक रूप से क्योंकि \कमांड स्ट्रिंग्स की सूची पर काम नहीं करता है।)

व्याख्या

oḅ\k\koḅ
o          Sort {standard input}
 ḅ         Group identical adjacent values
  \        Assert rectangular; if it is, swap rows and columns
   k       Delete last element
    \      Assert rectangular; (rest of the program is irrelevant)

koḅअंत में अप्रासंगिक है, kहमेशा एक तत्व पर काम करते हैं और करना होगा oऔर ḅअसफल नहीं हो सकता है, तो इनपुट के रूप में एक सूची दी।

शुरू करने का कारण oḅस्पष्ट होना चाहिए; यह मूल्य द्वारा इनपुट सूची का विभाजन करता है, जैसे [1,2,1,2,4,1]बन जाएगा [[1,1,1],[2,2],[4]]। प्रत्येक वर्ण के लिए समान संख्या में बार-बार प्रदर्शित होने के लिए, इनमें से प्रत्येक सूची की लंबाई समान होनी चाहिए, अर्थात परिणामी सूची एक आयत है। हम इस आयताकारता का उपयोग कर सकते हैं \, जो साइड इफेक्ट के रूप में पंक्तियों और स्तंभों को भी स्थानांतरित करता है।

अब हमारे पास वर्ण सेट की कई प्रतियों से युक्त एक वर्तमान मूल्य है, उदाहरण के लिए यदि इनपुट [4,2,1,2,4,1]वर्तमान मान होगा [[1,2,4],[1,2,4]]। यदि हम एक प्रतिलिपि हटाते हैं, तो परिणामस्वरूप मैट्रिक्स अभी भी आयताकार है, इसलिए हम इसका उपयोग करके वापस कर सकते हैं \। हालांकि, यदि कारण मैट्रिक्स आयताकार था, तो यह था कि सभी इनपुट वर्ण अलग-अलग थे, परिणामस्वरूप मैट्रिक्स में कोई तत्व नहीं बचा होगा, और एक "0 × 0" मैट्रिक्स को आयताकार के रूप में नहीं\ मानता है (बल्कि, यह विफल होता है)। इसलिए प्रभावी रूप से दावा किया गया है कि इनपुट में दिखाई देने वाला प्रत्येक वर्ण एक ही समय में प्रकट होता है, और उस समय की संख्या 1 नहीं है।oḅ\k\

यह हमारे कार्यक्रम की पूरी कार्यक्षमता है (एक पूर्ण कार्यक्रम के रूप में, हम प्राप्त करते हैं trueयदि कोई जोरदार विफलता नहीं हुई, falseअगर कुछ किया गया)। हमें स्रोत लेआउट प्रतिबंध का पालन करना होगा, हालांकि, इसलिए मैंने एक अतिरिक्त जोड़ा जिसका koḅकोई उद्देश्य नहीं है लेकिन जो विफल नहीं हो सकता है (इसके विपरीत \, oऔर ḅखाली सूचियों पर कार्य करने के लिए खुश हैं)।

— रीस ais523
स्रोत
1
— एर्गेल्फ़र
7

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

o=>!(a=o.split``.map(i=>o.split(i||aeehhhlmmnnnpst)[`length`]-1)).some(g=>![g>1][-!1]||a[-!1]-g)

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

24 अलग-अलग वर्ण * 6 बार प्रत्येक

28 अलग-अलग वर्ण * 5 बार प्रत्येक

27 अलग-अलग वर्ण * 5 बार प्रत्येक

27 अलग-अलग वर्ण * 4 बार प्रत्येक

26 अलग-अलग वर्ण * 4 बार प्रत्येक

25 अलग-अलग वर्ण * 4 बार प्रत्येक

24 अलग-अलग वर्ण * 4 बार प्रत्येक

व्याख्या 

o=>!(
 a=o.split``.map(                            // Split the input into character array and
  i=>o.split(i||aeehhhlmmnnnpst)[`length`]-1 // count the occurrences of each character.
 )
).some(                                      // Then check
 g=>![g>1][-!1]                              // If each character appears at least twice
 ||a[-!1]-g                                  // and the counts are all the same number.
)                                            

More to add:
1. Using {s.split``} instead of {[...s]} is to reduce the number of {.} that dominates
   the count.
2. Using {!c.some} instead of {c.every} to reduce the number of inefficient characters 
   (v,r,y in every)
3. Still one unavoidable inefficient character left ({h}).

Update:
1. Got rid of one {.} by replacing {.length} by {["length"]}.
2. Got rid of one {=} by replacing {c[-!1]!=g} by {c[-!1]-g}.
3. Got rid of one {()} by replacing {!(g>1)} by {![g>1][-!1]}.
4. Finally, because count per character is now 4, the backslashes can be taken out.

Update:
1. Got rid of all {"} by replacing {"length"} by {`length`} and exploiting shortcut
   evaluation. 
   {aaaeehhhlmmnnnpst} is not defined but is not evaluated either because of {c} which
   must be evaluated to true.

Update:
1. Got rid of all {c} by shortcutting the undefined variable at {split(i)} and replacing 
   all {c} by {a}.
   Since {i} is never an empty string, it is always evaluated true (except compared 
   directly to true).

Update:
1. Got rid of all {,} by moving the assignment after the argument list. The {()} at the
   front can therefore be moved to the assignment, retaining same number of {()}s.
— शायरु असकोतो
स्रोत
6

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

($qe=$args[0]| group |sort count|% count)[0]-eq$qe[-1]-and$qe[0]-gt1####((()))%%%pppddd===aaccss11nu|0gr

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

यह गोल्फ के लिए बहुत मजेदार था। सीमा थी $, जिसे हमें न्यूनतम चार की आवश्यकता थी (इनपुट के $argsलिए एक, गणना परिणाम को निर्दिष्ट करने के $qeलिए एक, अंतिम चरित्र की $qe[-1]जांच के लिए एक और पहले चरित्र की जांच के लिए एक $qe[0], ताकि काम करने की अधिकतम संख्या हो।

वहाँ से, यह गोल्फ (और नहीं-गोल्फिंग, दो-अक्षर चर नाम होने की तरह) कार्यक्रम को चार से अच्छी तरह से विभाज्य होने की बात थी। ध्यान दें कि हमारे पास #कुछ लापता तत्वों के लिए एक छोटी टिप्पणी (सब कुछ निम्नलिखित ) है, लेकिन मैंने टिप्पणी को यथासंभव छोटा रखने की कोशिश की।

— AdmBorkBork
स्रोत
6

हास्केल, 90 75 72 बाइट्स

a[i]|d:n<-[[i|n<-i,n==a]|a<-i]=and[[i]<d,[d|i<-n]==n]--aadd,,,,:::::<=||

प्रत्येक वर्ण 6 बार प्रकट होता है। इनपुट स्ट्रिंग को एकल सूची के रूप में लिया जाता है ।

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

संदर्भ के लिए, पुराने संस्करण:

75 बाइट्स, प्रत्येक चार बार

n(l)|d<-[[0|n<-l,n==a]|a<-l]=and[[0]<d!!0,all(==d!!0)d]--an!((())),,,0<[]||

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

90 बाइट्स, प्रत्येक चार बार:

a x|h:u<-[sum[1|d<-x,not(d/=c)]|c<-x],"  \"\\&,../1::>acdlmmnosst">[]=h>1&&all(not.(/=h))u

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

— nimi
स्रोत
6

पायथन 2 , 108 104 92 88 बाइट्स

-12 बाइट्स रॉड
-4 बाइट्स के लिए धन्यवाद केविन क्रूज़सेन को धन्यवाद

s=input();c=s.count;print[all(c(s[[]>[1]])==c(o)>1. for o in s)];aaafffillpprrtuu>1.>1.;

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

— OVS
स्रोत
1
आपका कार्यक्रम गैर-भेदभाव वाला होना चाहिए।
— user202729
1
कार्यक्रम को गैर-भेदभावपूर्ण होना चाहिए।
— हाइपरनेत्रिनो
@ user202729 मुझे बताने के लिए धन्यवाद, मैंने अपना उत्तर अपडेट किया।
— ओग्स
1
— केविन क्रूज़सेन
1
— विंसेंट
6

MATL , 12 बाइट्स

q&=sqt&=tsvv

इनपुट एकल उद्धरण में संलग्न एक स्ट्रिंग है। स्ट्रिंग में एकल उद्धरण डुप्लिकेट द्वारा बच गए हैं।

आउटपुट एक गैर-रिक्त मैट्रिक्स है, जो सत्य है यदि इसमें शून्य नहीं है, और कम से कम शून्य होने पर मिथ्या है।

इसे ऑनलाइन आज़माएं! या सुविधा के लिए मानक सत्यता / मिथ्या परीक्षण सहित सभी परीक्षण मामलों को सत्यापित करें ।

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

इसके साथ चिह्नित विवरण (*)न तो आवश्यक हैं और न ही हानिकारक हैं, और केवल स्रोत कोड को गैर-भेदभावपूर्ण बनाने के लिए शामिल किया गया है।

q     % Implicit input. Convert chars to code points and subtract 1 from each (*)
&=    % Square matrix of all pairwise equality comparisons
s     % Sum of each column. Gives a row vector
q     % Subtract 1 from each value. An entry equal to 0 indicates the input string
      % is discriminating because some character appears only once
t     % Duplicate
&=    % Square matrix of all pairwise equality comparisons. An entry equal to 0
      % indicates the input string is discriminating because some character is
      % more repeated than some other
t     % Duplicate (*)
s     % Sum of each column (*) (all those sums will be positive if the previous
      % matrix doesn't contain zeros)
v     % Vertically concatenate the matrix and the vector of its column sums
v     % Vertically concatenate the resulting matrix with nothing (*)
      % Implicit display
— लुइस मेंडो
स्रोत
5

पर्ल 5 , -p57 बाइट्स

प्रत्येक वर्ण 3 बार प्रकट होता है। केवल एक ही 1कुछ भी नहीं करता है

गैर-भेदभाव करने के लिए एक बुनियादी 45 वर्ण समाधान में 12 बाइट्स जोड़े गए

s{.}[@m[@1{$&}+=$.].=g]eg;$\=s()(e@m;1)&&m[e(\sg+)\1+;]}{

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

— टन हास्पेल
स्रोत
5

आर , 90 बाइट्स

"?"=`u\164f8ToI\x6Et`;'!'=prod;!{y<-xtabs(~?readLines())}%in%{z<-y[1]}&z>T##&[]>~48bEfILpu

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

TRUEएक भेदभाव रहित स्ट्रिंग के लिए आउटपुट , और FALSEएक भेदभावपूर्ण स्ट्रिंग के लिए। मैंने इस साइट पर चुनौतियों के लिए बहुत सारे बदसूरत कोड लिखे हैं, लेकिन मुझे लगता है कि यह अब तक का सबसे बदसूरत कोड है।

45 अक्षर, दो बार प्रत्येक (एक टिप्पणी में कुछ सहित) का इस्तेमाल किया। पिछला सबसे अच्छा आर उत्तर 116 बाइट्स था , जिसमें 29 अक्षर प्रत्येक में 4 बार उपयोग किए गए थे; मैं इसे अलग से पोस्ट कर रहा हूं क्योंकि यह काफी हद तक अलग है।

कोड के बराबर है

y = table(utf8ToInt(readLines()))
z = y[1]
all(y == z) & (z > 1)

जो इनपुट को पूर्णांक के वेक्टर में परिवर्तित करता है y, मानों की एक आकस्मिक तालिका की गणना करता है , फिर जाँचता है कि उस तालिका की सभी गणना पहली गणना के बराबर है, और पहली गणना 1 से अधिक है।

प्रारंभिक कठिनाई केवल 2 जोड़े कोष्ठक का उपयोग करने में थी। यह एकल कार्यों को पुनर्परिभाषित द्वारा हासिल की है !और ?होना करने के लिए utf8ToIntऔर prodक्रमशः। (मैं उपयोग नहीं कर सकता allक्योंकि मुझे आवश्यकता है a)। चार असाइनमेंट हैं: दो के साथ =और दो के साथ <-। इसका मतलब है कि समानता परीक्षण yऔर zन y==zही उपयोग कर सकते हैं और न ही y-z; y%in%zबचाव के लिए आता है।

इन कार्यों को परिभाषित करना सभी संभव उद्धरणों का उपयोग करता है: दो दोहरे उद्धरण, दो एकल उद्धरण, और मुझे अगले पैराग्राफ में दो बैकटिक्स की आवश्यकता होगी, इसलिए मुझे readLines()इसके बजाय सहारा लेना पड़ा scan(,"")। (अन्य विकल्प, जैसे कि scan(,letters)या scan(,month.abb)सभी ने एक कीमती का उपयोग किया t जिसे मैं नहीं छोड़ सकता।)

: इस बिंदु पर, मैं बिल्डिंग ब्लॉक के सबसे था utf8ToInt, prod, table, readLines, %in%। तीन वर्ण उन नामों में तीन बार दिखाई देते हैं ent:। सबसे पहले, मैंने पाया कि बचत के table(foo)बराबर है । मैं हेक्स / ऑक्टल कोड चाल के साथ और बचाव कर सकता हूं ; के लिए (backticks में) का उपयोग करने के लिए golfiest समाधान है ।xtabs(~foo)entu\164f8ToI\x6Etutf8ToInt

— रॉबिन राइडर
स्रोत
यह प्रभावशाली है कि आप 90 बाइट्स में दो मामलों में भेदभाव कर सकते हैं (और मदद ऑपरेटर का अच्छा दुरुपयोग), लेकिन अफसोस NAएक सत्य मूल्य नहीं माना जाता है (आर में, अगर (एनए) x और एक त्रुटि का कारण बनता है, तो NAन तो सत्य और न ही गलत है) )
— JDL
1
@JDL धन्यवाद, आप सही कह रहे हैं। नवीनतम संपादन इस समस्या को हल करता है।
— रॉबिन राइडर
1
@JDL टिप्पणियों से पता चलता है कि सत्य और झूठे के लिए सुसंगत, अलग-अलग उत्तर ठीक हैं।
— ग्यूसेप
@Giuseppe वास्तव में, मैंने कुछ सेकंड पहले इस मुद्दे को हल किया था (नया संस्करण देखें, जो काफी अलग है लेकिन एक ही बाइट काउंट है); अब TRUE और FALSE आउटपुट करता है।
— रॉबिन राइडर
4

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

oḅlᵐ=h≥2
oḅlᵐ=h≥2

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

दुर्भाग्य से, मैं लाइनफीड्स को हटा नहीं सकता, क्योंकि ḅएक नंबर पर एक विफल हो जाता है।

— आउटग्रॉफर को एरिक
स्रोत
यह निश्चित रूप से कुछ छोटा करने के लिए संभव है जिसमें लाइनफीड्स की आवश्यकता नहीं है (लेकिन आपको कुछ चीजों को बदलने की आवश्यकता हो सकती है);)
— घातक करें
@Fatalize वर्तमान में कोई समय नहीं है, और हाँ मैंने वह चर्चा पढ़ी है। :)
— आउटगोल्फ
4

रूबी , 87 78 बाइट्स

c=->m{y=m.chars;x=y.map{|d|y.count d}|[];x[-1]>1and not x[1]};->{pushrortpush}

26 वर्णों को 3 बार दोहराया गया

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

— आसोन तुहिद
स्रोत
@ मिमी इसे इंगित करने के लिए धन्यवाद, मुझे लगता है कि इसके साथ कुछ अजीब था getsऔर ;। इसे बदल दिया, यह वैसे भी एक
— लंबोदर के
3

आर, 132 116 बाइट्स

crudcardounenforceableuploads<-function(b){{pi&&pi[[1-!1]];;;"";{1<{f<<-table(strsplit(b,"",,,)[[1]])}}&&!!!sd(-f)}}

इसमें या तो कोई टिप्पणी नहीं होती है या फिर बहुत ही शानदार तार होते हैं, हालांकि, यह शायद एक फ़ंक्शन कॉल करने वाले कोड गोल्फ में मेरा एकमात्र समय होगा crudcardounenforceableuploads। समारोह नाम के लिए कहीं न कहीं वहाँ एक महान विपर्यय है! जॉन एवरकॉक का धन्यवाद, जो एक अच्छे एनाग्राम सॉल्वर की ओर इशारा करते हैं, जिसका मैंने नाम लिया था।

चरित्र तालिका:

- , ; ! " ( ) [ ] { } & < 1 a b c d e f i l n o p r s t u 
4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4

उदाहरण:

> crudcardounenforceableuploads("aaabbbccc")
[1] TRUE
> crudcardounenforceableuploads("aaabbbcc")
[1] FALSE
> crudcardounenforceableuploads("abc")
[1] FALSE
> crudcardounenforceableuploads("crudcardounenforceableuploads<-function(b){{pi&&pi[[1-!1]];;;\"\";{1<{f<<-table(strsplit(b,\"\",,,)[[1]])}}&&!!!sd(-f)}}")
[1] TRUE
— JDL
स्रोत
पता नहीं कि बाइट गिनती महत्वपूर्ण है, लेकिन हम >तुलना के साथ गोल स्विच करके, शायद 2 एस और एस को हटा सकते हैं f। के =बजाय भी उपयोग कर सकते हैं <<-। strsplitहालांकि यह अपरिहार्य है, जो कि अन्य पात्रों में से अधिकांश का स्रोत है।
— JDL
क्या आपको रिक्त स्थान की आवश्यकता है? आप भी utf8ToIntइसके बजाय कोशिश कर सकते हैं strsplit, लेकिन यकीन नहीं है कि अगर यह मदद करेगा। भी शायद TIO के लिए एक लिंक शामिल हैं?
— ग्यूसेप
यह भी सभी .अति सुंदर लग रहे हैं।
— Giuseppe
यह कोड-गोल्फ है , इसलिए आपकी टिप्पणी के अनुसार बाइट गिनती महत्वपूर्ण है।
— ग्यूसेप
2
कुछ संभावित विपर्ययण: कोई पाइप-बॉन्ड अलमारी ब्यूरोक्रेसी नहीं; आरआईपी कार्बोनेस बारबेक्यूड पाउंड डिप। मिली का उपयोग कर wordplays.com/anagrammer
— जॉन ड्वोरक
2

BASH 144 बाइट्स

grep -o .|sort|uniq -c|awk '{s=$1}{e[s]=1}END{print((s>1)*(length(e)==1))}##>>>#|'#wwwuuutrqqqppooNNNnlllkkkiihhhggEEEDDDcccaaa1***{}[[[]]]...--''

कोड की यह लाइन इनपुट के रूप में एक स्टड स्ट्रिंग लेती है। "ग्रेप -ओ।" प्रत्येक चरित्र को एक नई पंक्ति में रखता है। "uniq -c" प्रत्येक अध्याय के उपयोग को गिनाता है। Awk script प्रत्येक सरणी को एक अलग तत्व के रूप में उपयोग करती है, और केवल 1 सरणी इंडेक्स होने पर आउटपुट को सही करती है और मान कम से कम 2. प्रत्येक वर्ण 4 बार उपयोग किया जाता है, इसलिए यह स्रोत सही है

— कालेब
स्रोत
2

स्टैक्स , 26 24 18 बाइट्स

:u{m*_{y#m:u_hy#h*

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

अब तक का सबसे छोटा समाधान, MATL द्वारा केवल मुद्रण योग्य ASCIIs का उपयोग किया जाता है।

लगता है कि मैं समस्या को गलत तरीके से ले रहा था। वर्किंग ब्लॉक को दोहराना न तो गोल्फ है और न ही दिलचस्प। अब कम से कम यह बेहतर लग रहा है ...

व्याख्या

:u{m* कुछ कचरा पैदा करता है जो आउटपुट को प्रभावित नहीं करता है।

_{y#m:u_hy#h*
_{y#m           map each character to its number of occurences in the string
     :u         all counts are equal (result 1)
       _hy#     get the count of appearance for the first character
           h    halve it and take the floor, so that 1 becomes 0(result 2)
            *   multiply the two results
— वीजुन झोउ
स्रोत
@Groleau कौन से अक्षर एक बार दिखाई देते हैं? क्या आपने मेरा उत्तर ध्यान से पढ़ा?
— वीजुन झोउ
'#' अधिक बार ':' (केवल एक उदाहरण) से प्रकट होता है। उफ़,
— ग़लतफ़हमी
@Groleau बिल्कुल दो #और दो :s हैं, क्या आपने दूसरी पंक्ति में मेरा उत्तर पढ़ा है? क्या आपने मेरे "स्पष्टीकरण" में पहले पैराग्राफ को छोड़ दिया?
— वीजुन झोउ
क्षमा करें, सोचा कि स्पष्टीकरण के ऊपर की रेखा पूरी बात थी।
— WGroleau
1

पिप , 22 बाइट्स

I1&MY$=_Y_NaMa$=y&1NIy

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

व्याख्या

प्रत्येक वर्ण दो बार होता है।

                        a is first command-line argument
I1&MY$=_                No-ops to make the program non-discriminating
            Ma          Map this function to the characters of a:
         _Na             Count occurrences of each character in a
        Y               Yank the result into y
              $=y       Fold y on equals: truthy if all elements are equal
                 &      Logical and
                  1NIy  1 is not in y
                        Autoprint the result of the last expression

वैकल्पिक 22-बाइट संस्करण जिसमें कम ऑप्स हैं:

$&MY_Y_NaMa$=y&--1=1Ny
— DLosc
स्रोत
1

स्माइलबासिक, 164 152 148 140 बाइट्स

DeF M(X)DIM W[#R]WHILE""<X
INC w[ASC(x)]X[n]=""wEND
FOR F=e#TO--nOT-LEN(W)U=w[F]H=H||U&&U<MAx(W)neXT-!!!AASSS#&&Oxx||CCLL<<wIM#
RETURN!H
enD

35 अलग-अलग वर्ण, प्रत्येक में 4 बार दोहराया गया।

कोई टिप्पणी का उपयोग नहीं किया गया था (लेकिन neXTवास्तव में मूल्यांकन कभी नहीं किया गया है)

उत्तर देखने के लिए स्क्रिप्ट:

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

— 12Me21
स्रोत
1

रेटिना 0.8.2 , 168 90 बाइट्स

असत्य होने पर आउटपुट खाली होगा या यदि सत्य है तो गैर-रिक्त।

***???;;;;```!!$$$$MMMMOOOO..1111ssss222{{{{\^^^^

s;{O`.
M!*\`^((.)\2(?!\2))*$
(.)(?!\1)

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

मुख्य कार्यक्रम (39 बाइट्स)

s;{O`.
M!*\`^((.)\2(?!\2))*$
(.)(?!\1)

व्याख्या

संपूर्ण कोर प्रोग्राम एक मूक पाश में है। पहला चरण इनपुट को सॉर्ट करता है। दूसरा चरण वर्तमान स्ट्रिंग को प्रिंट करेगा यदि इसमें विभिन्न पात्रों के क्रमिक जोड़े शामिल हैं। तीसरा चरण हर वर्ण की अंतिम घटना को हटाता है (स्ट्रिंग में प्रत्येक वर्ण को हटाता है)।

शीर्ष पर कबाड़ के बारे में: आदेश महत्वपूर्ण है। सिंटैक्टिक रूप से वैध होने की आवश्यकता के अलावा, अर्धविराम तारांकन के बाद और बैकटिक्स से पहले होना चाहिए, ताकि लॉन्ग *स्ट्रिंग में लंबे समय तक हो, ताकि प्रिंट न हो सके।

— mbomb007
स्रोत
अच्छा, मेरा उत्तर छोटा है, लेकिन मुझे यकीन नहीं है कि इसे आउटपुट के रूप में 0/1 के
— FryAmTheEggman
@FryAmTheEggman मैं एक पंक्ति में एक ही लंबाई के चरित्र समूहों से मेल खाने के लिए एक शुद्ध रेगेक्स समाधान की तलाश में था, लेकिन मैं इसका पता नहीं लगा सका।
— mbomb007
@FryAmTheEggman ने किया बड़ा सुधार! मैं वास्तव में आपके पास क्या था का उपयोग नहीं किया, लेकिन मैं एक बेहतर विधि के बारे में सोचने की कोशिश कर रहा हूं।
— mbomb007 15
अच्छी तरह से किया! और मुझे लगता है कि यह मेरे कार्यक्रम के बारे में पर्याप्त नहीं था, लेकिन कम से कम आपको एक बेहतर मिला :)
— FryAmTheEggman
1

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

  "&8<MQSlqr{"&q1lJ{hMrSz8<1hJ

रिक्त स्थान आवश्यक है।

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

वास्तविक कार्यक्रम सिर्फ है &q1lJ{hMrSz8<1hJ। मैंने "&8<MQSlqr{"इसे गैर-भेदभावपूर्ण बनाने के लिए सिर्फ स्ट्रिंग को प्रीपेड किया । लेकिन स्ट्रिंग को स्वयं प्रिंट न करने के लिए, मुझे एक स्थान जोड़ना पड़ा, इसलिए मैंने 2 स्थान जोड़े।

&q1lJ{hMrSz8<1hJ

 q1l                (1 == len(
    J{                  J = deduplicate(
      hM                  map(lambda a: a[0],
        r  8                length_encode(
         Sz                   sorted(input())
                            )
                          )
                        )
                    )
&                     and
            <1hJ    (1 < J[0])

length_encodeयहाँ ( r <any> 8) एक अनुक्रम लेता है और उसी वर्ण के प्रत्येक रन की लंबाई को आउटपुट करता है, पूर्व। "aaabbcc"बन जाता है [[3, "a"], [2, "b"], [2, "c"]]।

तो यह इनपुट लेता है, इसे लंबाई में सांकेतिक शब्दों में बदलने के लिए सॉर्ट करता है, और परिणामस्वरूप सूची में प्रत्येक सूची का पहला तत्व लेता है (उदाहरण के लिए पूर्व उदाहरण बन जाएगा [3, 2, 2])। इससे यह पता चलता है कि वर्ण कितनी बार होते हैं। फिर इसे काट दिया जाता है (पहले का उदाहरण बन जाएगा [3, 2]), और जे उस पर सेट है।

फिर यह जाँच करता है कि लंबाई 1 है, अर्थात एक वर्ण होने पर केवल 1 अद्वितीय संख्या है, और यदि वह> 1, अर्थात = 2 है।

वहाँ एक जगह में बनाया जा सकता है rSz8या hMrSz8मैं एक नहीं मिल सकता है।

— आर।
स्रोत
1

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

f(h,a,c,f){{{{{{{char*o=f=h,*r;for(a=!h;*o;o++){for(c=!h,r=h;*r;c+=!(*r++^*o)){}f*=!!(c^!!h)*(!a+!(a^c));a=c;}(a^c^c^f^f^h)+o,a+r,o,o,+h^*r;(a=f);}}}}}}}

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

सत्य के मूल्य के रूप में स्ट्रिंग का पता देता है, और मिथ्या के रूप में शून्य।

f(
h,                              Address of string.
a,                              # instances of previous character
c,                              # instances of current character
f                               Return value
){{{{{{{                        
char*o=f=h,*r;                  Point o to string, while giving f a non-zero value.
for(a=!h;*o;o++){               Set previous char count to 0, and then traverse the string.
for(c=!h,r=h;*r;                Set current char count to 0 and r to string,
                                and start counting instances of current character.
c+=!(*r++^*o))                  Add to counter if current character matches.
{}                              Lower the amount of semi-colons
f*=                             Multiply (AND) return value with:
   !!(c^!!h)                    Is current count not 1? (Must be 2 or above.)
            *(!a+!(a^c));       AND, is previous count valid (meaning this is not the first
                                character counted), and matches current count?
a=c;}                           Previous count = current count.
(a^c^c^f^f^h)+o,a+r,o,o,+h^*r;  Spend surplus characters to make source code valid.
(a=f);}}}}}}}                   Return value.
— gastropner
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.