इन तारों को मिलाएं

42

इस टिप्पणी श्रृंखला से प्रेरित ...

मैं enklactइस चुनौती से बाहर निकलना चाहता हूं लेकिन मैं ऐसा नहीं कर सकता ...

@ETHproductions को संलग्न करना (v): अद्वितीय तत्वों से युक्त उपधारा का उपयोग करके लुकअप तालिका को लागू करना।

लुकअप टेबल को संपीड़ित करने के लिए एक बहुत उपयोगी तरीका है। उदाहरण के लिए, मान लें कि आपके पास रंगों की सूची है:

red
green
blue
yellow
purple
orange

यदि आप इनपुट के रूप में एक रंग लेने में सक्षम होना चाहते हैं और इस सूची में यह सूचकांक है, तो स्पष्ट रूप से सीधा तरीका है:

["red", "green", "blue", "yellow", "purple", "orange"].index(input())

लेकिन एक तरीका है जिससे हम इस तरह से कम बाइट्स कर सकते हैं:

"rgbypo".index(input()[0])

यह काम करता है क्योंकि प्रत्येक स्ट्रिंग का पहला (या 0'th) सूचकांक अद्वितीय है। यह उदाहरण स्पष्ट है, लेकिन कभी-कभी यह थोड़ा कठिन होता है। क्या होगा अगर हम इस सूची के लिए एक लुकअप टेबल बनाना चाहते हैं?

Sweet Onion Chicken Teriyaki
Oven Roasted Chicken
Turkey Breast
Italian BMT
Tuna
Black Forest Ham
Meatball Marinara

इस मामले में, हम ऐसा नहीं कर सकते:

"SOTITBM".index(input()[0])

क्योंकि दो अलग-अलग इनपुट हैं, जो कि 'T'"टूना" और "टर्की" से शुरू होते हैं। हमें एक अलग सूचकांक देखना चाहिए। यदि आप प्रत्येक स्ट्रिंग के 4 वें इंडेक्स को देखते हैं, तो आप देखेंगे कि वे सभी अद्वितीय हैं। तो हम यह कर सकते हैं ...

"enklact".index(input()[3])

इस मामले में, "एन्क्लेवेशन स्ट्रिंग" "एनक्लैक्ट" है।

यही हमें आज की चुनौती की ओर ले जाता है ...

स्ट्रिंग्स की एक सूची को देखते हुए, कोई भी मान्य एन्हालेशन स्ट्रिंग लौटाएं। या दूसरे शब्दों में, स्ट्रिंग की एक सूची दी गई है, किसी भी नए स्ट्रिंग को लौटाएं जहां प्रत्येक अक्षर अद्वितीय है, और स्ट्रिंग प्रत्येक स्ट्रिंग के i'th पत्र से जुड़कर बनाई गई है।

यदि कोई मान्य संचय स्ट्रिंग नहीं है, तो आपके सबमिशन के बदले एक रिक्त स्ट्रिंग या एक सुसंगत नकली मान वापस करना होगा। हमेशा की तरह, या तो फ़ंक्शन या पूर्ण कार्यक्रमों की अनुमति है, और इनपुट / आउटपुट प्रारूप अनुमत हैं (कारण के भीतर)।

प्रत्येक स्ट्रिंग में केवल मुद्रण योग्य ASCII होगा, और यह चुनौती संवेदनशील है।

यह कोड-गोल्फ है , इसलिए अपनी पसंद की भाषा में सबसे छोटा कार्यक्रम संभव लिखने की कोशिश करें!

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

Input:
Programming
Puzzles
Code
Golf

Output (any one of these):
"ozdl"
"gzef"


Input:
the quick
brown fox
jumped over
lazy dogs

Output:
"tbjl"
"hrua"
"eomz"
" wpy"
"qne "
"if o"
"kxvs"

Note that "u dd" and "coog" are not valid.


Input:
Sunday
Monday
Tuesday
Wednesday
Thursday
Friday
Saturday

Output:
""


Input:
AbC
aBc
bbC

Output:
"Aab"


Input:
@#$%^_
Hello_World
How are you?

Output:
"#eo"
"$lw"
"%l "
"^oa"


Input:
a
ab
ac

Output:
""
code-golf  string 
— DJMcMayhem
स्रोत
क्या हम वैध तारों की सूची वापस कर सकते हैं?
— LyricLy
@LyricLy हम्म, अब जब कि मैं इसके बारे में सोचता हूं, तो यह समझ में आता है। लेकिन चूंकि पहले से ही उत्तर हैं और पहले एक को वापस करने के लिए बहुत अधिक बॉयलरप्लेट नहीं है, इसलिए मैं नहीं कहने जा रहा हूं, यह कोई भी वैध स्ट्रिंग होना चाहिए।
— DJMcMayhem
क्या हम गारंटी दे सकते हैं कि इनपुट किए गए तार में से कोई भी खाली नहीं है?
— संगीतज्ञ 523
6
क्या सुसंगत मिथ्या मूल्य संगत प्रकार की त्रुटि हो सकती है?
— स्टीवी ग्रिफिन
2
क्षमा करें, लेकिन मुझे लगता है कि सही क्रिया समृद्ध है ।
— एग्री आउटफोलर

जवाबों:

8

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

lambda l:{len({*d}):''.join(d)for d in zip(*l)}.get(len(l))

एनक्लैक्ट के साथ एक स्ट्रिंग लौटाता है, अन्यथा कोई नहीं

— PieCot
स्रोत
8

पायथन 2 , 68 67 61 बाइट्स

lambda a:`{0:j for j in zip(*a)if len(set(j))==len(j)}`[6::5]

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

सुधार

  • जो किंग द्वारा 68 बाइट्स से 67 बाइट्स तक
  • लिन द्वारा 66 से 65 बाइट्स तक

यदि आउटपुट में स्ट्रिंग नहीं होगी:

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

lambda a:[j for j in zip(*a)if len({*j})==len(j)]

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

— नील
स्रोत
— जो किंग
@JoKing सुरुचिपूर्ण और कार्यान्वित।
— नील
मुझे लगता है कि max(`j`[2::5]for j in[""]+zip(*a)if len(set(j))==len(j))एक बाइट को बचाने के लिए काम करता है।
— लिन
@Lynn धन्यवाद और अद्यतन।
— नील
7

रेटिना , 43 32 बाइट्स

+/^(.).+^\1|^$/ms&m`^.

|""Lm`^.

इसे ऑनलाइन आज़माएं! संपादित करें: @MartinEnder के लिए धन्यवाद 11 बाइट्स सहेजे गए। स्पष्टीकरण:

+

इनपुट बदलते समय दोहराएं ...

/^(.).+^\1|^$/ms&

... केवल अगर एक लाइन खाली है या दो लाइनें एक ही चरित्र से शुरू होती हैं ...

m`^.

... हर पंक्ति का पहला वर्ण हटाएं। इसलिए पुनरावृत्ति रुक ​​जाती है यदि या तो) सभी लाइनें अलग-अलग वर्णों से शुरू होती हैं, जिस स्थिति में स्थिति विफल हो जाती है और इनपुट परिवर्तित नहीं होता है, या b) कम से कम एक पंक्ति खाली हो जाती है, जिस स्थिति में सभी वर्ण अंततः नष्ट हो जाते हैं। किस बिंदु पर इनपुट बदलना बंद हो जाता है।

|""L`^.

हर लाइन का पहला किरदार लीजिए। (यदि कोई समाधान नहीं था, तो उपरोक्त लूप ने सब कुछ हटा दिया होगा और इकट्ठा करने के लिए कुछ भी नहीं होगा।)

— नील
स्रोत
रेगेक्स विकल्प रेगेक्स संशोधक भी लेते हैं (समापन सीमांकक के बाद सीधे लिखकर): tio.run/##K0otycxLNPz/-
— मार्टिन
वास्तव में, यह आपको दूसरे चरण से पूरी तरह छुटकारा दिलाता है : tio.run/##K0otycxLNPz/X1s/… (किसी तरह mयहां समूह के साथ आवेदन नहीं किया जा सकता है, ऐसा लगता है कि सशर्त चरण विकल्प का प्रचार नहीं करता है)।
— मार्टिन एंडर
आह, बेशक, एक सशर्त लूप के बजाय एक सशर्त लूप, जो आपके पहले संस्करण में अनंत लूप बग को हल करता है। बहुत साफ़!
— नील
5

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

f x|elem""x=""|y<-head<$>x,and[filter(==a)y==[a]|a<-y]=y|1<2=f$tail<$>x

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

बीएमओ ने any null x→ के साथ 3 बाइट्स बचाए elem""x।

अर्जन जोहानसन ने sum[1|b<-y,a==b]<2→ के साथ एक बाइट को बचाया filter(==a)[y]==[a]।

व्याख्या

f x|elem""x=""                      -- Once any of the strings is empty, return "".
   |y<-head<$>x                     -- Otherwise, let y be all the first letters...
   ,and[                 |a<-y]     -- If, for all a in y,
        filter(==a)y==[a]           -- a occurs just once in y:
                               =y   -- return y.
   |1<2=f$tail<$>x                  -- Else, chop off all the first letters and recurse.

यदि Prelude.head: empty listकोई समाधान नहीं है, तो त्रुटि ( ) फेंकने पर , 61 बाइट्स के|elem""x="" लिए मिटाया जा सकता है ।

— लिन
स्रोत
1
शॉर्टर टेस्ट:filter(==a)y==[a]
— अर्जन जोहान्स
4

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

->x,*y{x.zip(*y).find{|z|z==z-[p]|[]}}

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

एक बग को इंगित करने के लिए GB का धन्यवाद।

— किरिल एल।
स्रोत
अगर कोई मैच नहीं होता है और पहला तार सबसे छोटा नहीं है।
— जीबी
@GB क्या आप एक उदाहरण प्रदान कर सकते हैं, कृपया? मैंने आपके विवरण के अनुसार अपने अंतिम परीक्षण को संशोधित किया, और इसने काम किया।
— किरिल एल
कोशिश करें ["एबीसी", "एसी", "एसीडी"]
— जीबी
अब मैं देख रहा हूँ, तुम सही हो। तय होना चाहिए।
— किरिल एल
4

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

>1{I#C

परीक्षण सूट।

आउटपुट एक सिंगलटन सूची है, जैसा कि डिफ़ॉल्ट रूप से अनुमति है ; सूची [] (खाली सूची, falsy) मामले में दिया जाता है स्ट्रिंग नहीं किया जा सकता enklactified ।

व्याख्या

> 1 {I # C - पूर्ण कार्यक्रम।
     सी - इनपुट को स्थानांतरित करें, फसल की अनुपस्थिति।
    # - के द्वारा छनित:
  {मैं - समर्पण के तहत अपरिवर्तनीय।
> 1 - स्लाइस टू 1. लिस्ट [: 1] पाइथन में।

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

यदि दुर्घटनाग्रस्त होना एक मिथ्या मूल्य के रूप में गिना जाता तो यह मान्य होता।

h{I#C

परीक्षण सूट।

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

हास्केल , 76 74 बाइट्स

f t=last$"":(id=<<foldr(zipWith(#))([[]]<$t)t)
x#[s]=[x:s|all(/=x)s]
x#e=e

इसे ऑनलाइन आज़माएं! यदि ऐसा कोई स्ट्रिंग मौजूद नहीं है, तो अंतिम मान्य लुकअप स्ट्रिंग या एक रिक्त स्ट्रिंग लौटाता है।

71 69 बाइट्स

यदि फ़ॉसी मूल्य के रूप में एक सुसंगत अपवाद को फेंकने की अनुमति है:

f t=head$id=<<foldr(zipWith(#))([[]]<$t)t
x#[s]=[x:s|all(/=x)s]
x#e=e

इसे ऑनलाइन आज़माएं! empty listयदि कोई स्ट्रिंग नहीं मिली है, तो एक अपवाद को फेंकता है, अन्यथा पहला वैध स्ट्रिंग लौटाता है।

-2 बाइट्स अर्जन जोहान्सन को धन्यवाद

— Laikoni
स्रोत
1
notElem x को छोटा किया जा सकता है all(/=x)।
— अर्जन जोहान्सन
2

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

z0Q€fZḢ

पूर्णांक 0 लौटाता है, अगर तार को शामिल नहीं किया जा सकता है।

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

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

z0Q€fZḢ  Main link. Argument: A (string array)

z0       Zip/transpose, filling shorter rows with 0.
  Q€     Unique each deduplicate resulting string.
     Z   Zip/transpose, without using a filler.
    f    Filter; keep only string that appear in the results to both sides.
      Ḣ  Head; extract the first string. Returns 0 if the array is empty.
— डेनिस
स्रोत
2

Stax , 9 8 बाइट्स

åτIⁿs↓µg

इसे चलाएं और डीबग करें

स्पष्टीकरण (अनपैक्ड):

M{c0-u=}j Full program, implicit input
          e.g. ["Programming", "Puzzles", "Code", "Golf"]
M         Transpose
                ["PPCG", "ruoo", "ozdl", "gzef", "rl\0\0", "ae\0\0", "ms\0\0", "m\0\0\0", "i\0\0\0", "n\0\0\0", "g\0\0\0"]
 {     }j Find first matching element:
            e.g. "PPCG"
  c0-       Copy and remove zero bytes (padding)
                 "PPCG" "PPCG"
     u      Unique
                 "PPCG" "PCG"
      =     Check if equal:
                 1
          First matching here: "ozdl". If none is found, the stack is empty
          Implicit output if anything on stack
— wastl
स्रोत
2

आर , 127 बाइट्स

function(S,s=sapply(S,substring,x<-1:max(nchar(S)+1),x))cat(rbind(s[!apply(s,1,anyDuplicated)&!rowSums(s==""),],"")[1,],sep="")

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

sapplyआम तौर पर matrixजब सभी length(FUN(X[[i]]))समान होते हैं, तो कब length(FUN(X[[i]]))==1, किस स्थिति में वापस आ जाता है vector। मैट्रिक्स ऑपरेशंस का उपयोग करने के लिए, हमें substringएक की गारंटी देने की आवश्यकता है matrix, जिसके कारण इसका xविस्तार करने की आवश्यकता है max(nchar(S)+1)।

फिर हम उन पंक्तियों के लिए फ़िल्टर करते हैं जिनमें कोई डुप्लिकेट नहीं है और कोई खाली स्ट्रिंग नहीं है। चूंकि हम केवल एक स्ट्रिंग वापस कर सकते हैं, हम पहले एक को लेते हैं, सिवाय इसके कि जब कोई पंक्तियां नहीं होती हैं जो मानदंडों को पूरा करती हैं, तो हम एक त्रुटि फेंक देंगे, इसलिए हम अंत में एक अतिरिक्त पंक्ति जोड़ते हैं ""।

फिर हम enklactified स्ट्रिंग या खाली स्ट्रिंग प्रिंट करते हैं ।

— ग्यूसेप
स्रोत
2

आर , 116 107 95 बाइट्स

आर + pryr 

pryr::f(for(i in 1:min(nchar(v)))`if`(anyDuplicated(t<-substr(v,i,i)),0,{cat(t,sep="")
break}))

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

आधार आर 

function(v)for(i in 1:min(nchar(v)))`if`(anyDuplicated(t<-substr(v,i,i)),0,{cat(t,sep="")
v=0})

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

Giuseppe के लिए 9 बाइट्स बचाने वाले ये दो वेरिएंट हैं ।

स्पष्टीकरण:

यह प्रभावी रूप से वेक्टर में सभी डंडों vको सबसे छोटी और बाद के अनुक्रमित के माध्यम से पुनरावृत्त करता है। फिर जांचता है कि चुने गए पत्रों के भीतर कोई डुप्लिकेट हैं या नहीं और नहीं, उन्हें एक साथ चिपकाता है और प्रिंट करता है cat। यदि सभी अनुक्रमित डुप्लिकेट परिणाम लौटाते हैं, तो यह रिक्त स्ट्रिंग प्रिंट करता है।
सभी एक अनाम pryrफ़ंक्शन में लिपटे breakहुए लूप को रोकते हैं, या बेस आर फ़ंक्शन लूप को तोड़ने के लिए वेक्टर को शून्य करते हैं।

— pajonk
स्रोत
1
अच्छा है! यह करने के लिए किया जा सकता है golfed 107 बाइट्स में R+pryrया 107 बाइट्स आधार आर में
— ग्यूसेप
2

जाप, 9 बाइट्स

चरित्र सरणियों के एक सरणी के रूप में इनपुट लेता है, वर्णों की एक सरणी देता है या undefined

y æ_f eZâ

इसे आज़माएँ (प्रोग्राम की शुरुआत में एक नई पंक्ति जोड़ें qR mq, एक नई पंक्तिबद्ध स्ट्रिंग के रूप में इनपुट लेने के लिए, आपको ऐरे बनाने की परेशानी से बचाने के लिए।)

व्याख्या

y             :Transpose
  æ_          :Pass each array Z through a function and return the first that returns true
    f         :  Filter nulls (used for padding when transposing)
      e       :  Test for equality with
       Zâ     :  Z deduplicated
— झबरा
स्रोत
मैं अपने समाधान पढ़ने से पहले चुनौती बाहर की कोशिश की और एक लगभग समान समाधान मिल गया:z æ_¬eZ¬â
— लीख
बिल्कुल समान, इनपुट प्रारूप के अलावा अन्य।
— झबरा
1

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

def f(t):c=[s.pop(0)for s in t];return all(t)and(f(t),c)[len(t)==len({*c})]

तार के बजाय चरित्र सूचियों पर कार्य करता है। यदि कोई वैध संश्लिष्ट स्ट्रिंग मौजूद है, तो गलत रिटर्न देता है।

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

— musicman523
स्रोत
मुझे लगता है कि यह पुनरावृत्ति करता है, जो इसे तब तक अमान्य बना देगा जब तक f=कि बाइट गिनती में शामिल न हो ।
— LyricLy
@LyricLy फिक्स्ड :)
— musicman523
1

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

f(s,i)char**s;{char**t,a[255],*u=a;for(i=0;memset(a,0,255),u&&~i;i+=!!~i&&u)for(t=s;(u=u?*t++:0)&&~(i=u[i]?i:-1)&&!a[u[i]]++;);while(~i&&(u=*s++))putchar(u[i]);}

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

डुप्लिकेट के लिए प्रत्येक वर्ण स्थिति का परीक्षण किया जाता है और यदि डुप्लिकेट का पता लगाया जाता है तो उसे छोड़ दिया जाता है; यह तब तक जारी रखा जाता है जब तक कि सबसे छोटी स्ट्रिंग समाप्त नहीं हो जाती। यह केवल ASCII है, दुख की बात है: DBCS / UTF-8 तार इस फ़ंक्शन को बुरी तरह से तोड़ते हैं!

— ErikF
स्रोत
— सीलिंगकैट
1

जाप , 12 बाइट्स

undefinedगैर-एनक्लेक्टिक स्ट्रिंग्स के लिए रिटर्न ।

y ·æ_¬n ä¦ e

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

स्पष्टीकरण:

y ·æ_¬n ä¦ e
y             // Split the input at newlines and transpose
  ·           // Join on newlines 
   æ_         // Return the first item that returns truthy when ran through:
     ¬n       //   Sort
        ä¦    //   Reduce with !=
           e  //   All items are truthy (unique)
— ओलिवर
स्रोत
आपको वर्ण बख्शो की एक सरणी के रूप में इनपुट लेने और दो splitएस को डिच करने के द्वारा 2 बाइट्स को बचाने में सक्षम होना चाहिए ।
— झबरा
1

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

#&@@Select[PadRight@#,#~FreeQ~0&&Union@#==Sort@#&]&

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

इनपुट के रूप में वर्णों की सूची की सूची लेता है, वर्णों की सूची लौटाता है। इसमें "ट्रांसपोज़" ऑपरेटर के अनुसार U + F3C7 शामिल है।

#1उपयुक्त स्ट्रिंग नहीं होने पर आग्नेय त्रुटियों का एक गुच्छा देता है और फेंकता है।

स्पष्टीकरण:

PadRight@#

इनपुट को पैड करें ताकि प्रत्येक "स्ट्रिंग" (वर्णों की सूची) समान लंबाई हो। यह पूर्णांक 0s (न कि स्ट्रिंग "0"s) को जोड़ता है । फिर पारगमन करें।

Select[ ... ,#~FreeQ~0&&Union@#==Sort@#&]

उन स्ट्रिंग्स का चयन करें, जिनमें कोई पूर्णांक नहीं 0है और सभी अद्वितीय वर्ण हैं।

#&@@

पहले वाला हो जाओ।

— जंगवान मिन
स्रोत
1

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

रिटर्न या तो एक स्ट्रिंग या undefinedयदि कोई समाधान मौजूद नहीं है।

f=(a,i=0)=>a.every(s=>(o[k+=c=s[i],c]^=1)&&c,o=k=[])?k:c&&f(a,i+1)

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

टिप्पणी की गई

f = (           // f = recursive function taking:
  a,            //   a[] = input array
  i = 0         //   i   = pointer
) =>            //
  a.every(s =>  // for each string s in a[]:
    (o[k +=     //   append to the key string k
      c = s[i], //   the character c at position i in s
      c] ^= 1   //   and toggle o[c] (undefined -> 1 -> 0)
    ) && c,     //   additionally, make sure that c is defined
    o = k = []  //   start with o = k = empty array
  ) ?           // every() is true if all characters were distinct and defined:
    k           //   in which case we return k
  :             // else:
    c &&        //   provided that every() didn't fail because of an undefined character,
    f(a, i + 1) //   try again at the next position
— Arnauld
स्रोत
1

चारकोल , 23 21 बाइट्स

-2 @ बाइट के लिए धन्यवाद !

§ΦＥ⌊ＥθＬι⭆θ§λι⬤ι⁼¹№ιλ⁰

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

— ASCII-केवल
स्रोत
हुह, जब (क) qहमेशा एक स्ट्रिंग बी होना बंद हो जाता है) स्ट्रिंगपिंग नॉन-स्ट्रिंग्स पर काम करना शुरू कर देता है? वैसे भी, आपका Rangeअनावश्यक है, आपको 2 बाइट्स बचा रहा है।
— नील
@ नई क) जब मैंने सरणी / ऑब्जेक्ट इनपुट b जोड़ा)> _> मुझे यकीन नहीं है। शायद उस समय के आसपास जब मैंने लूप तय किया (क्षमा करें, उन दोनों में से किसी का भी उल्लेख करना भूल गया)
— ASCII-only
1

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

ḟS=UḞz:∞ø

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

व्याख्या

fS=UḞz:∞ø
    Ḟz:∞ø  Transpose the input dropping characters of longer strings
    Ḟ        Fold right
     z:      Zip with prepend
       ∞ø    Infinite list of empty lists
ḟS=U       Find the first string without duplicates, returns an empty string if none
ḟ            Return first value satisfying predicate
  =          Equal
 S U         to itself with duplicates removed
— FYR
स्रोत
←ġLTओवर का उपयोग करके Ḟz:∞øएक बाइट को बचाना चाहिए।
— ბიმო
1

रेटिना , 81 56 बाइट्स

m`$
$.=*£¢
N$`.
$.%`
¶

~`(.*?¢)+
L`.{$#1}
A`(.).*\1|£|¢

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

-25 बाइट्स @ @ नील को धन्यवाद

रेटिना में आयताकार पाठ को स्थानांतरित करना आश्चर्यजनक रूप से कठिन है।

— TwiNight
स्रोत
काश, मैं आयताकार ट्रांसपोज़ेशन करने का एक बेहतर तरीका जानता, लेकिन इस बीच, 25 बाइट्स बचा सकता था ।
— नील
@ नील अहह ... eval स्टेज। मैं हमेशा भूल जाता हूं कि रेटिना 1.0 में ये सभी नए अच्छे फीचर्स हैं
— ट्विनइट
1

पर्ल 6 , 27 बाइट्स

{([Z] $_).first:{.Set==$_}}

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

यह देखने के बाद कि माणिक संस्करण को उखाड़ दिया गया है, मैंने तार के बजाय दृष्टिकोण और प्रयुक्त चरित्र सूचियों की नकल की है। मुझे यह पसंद नहीं है।

मेरे पुराने, और अधिक सही सबमिशन इस प्रकार है:

पर्ल 6 , 38 बाइट्स

स्प्लिट, जिप, अनूठेपन की जांच करें, जुड़ें। 

{[~] ([Z] @_>>.comb).first:{.Set==$_}}

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

— जारोद फननेल
स्रोत
1

सी (जीसीसी) , 121 113 110 बाइट्स

i;d;f(s)char**s;{char**_=s,x[255]={0},y[99]={0};for(d=i=0;*_;)d+=x[y[i++]=*(*_++)++]++;d=d?*x?0:f(s):puts(y);}

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

Ungolfed

void enklactify(char *strings[]) {
    int quit = 0;
    while (!quit) {
        char **arg = strings;      // current row
        int exists[255] = {0};     // which characters exist in the column
        char output[99] = {0};     // will hold output string
        int index = 0;             // where to insert in output
        int duplicates = 0;        // have we found any duplicates?
        while (*arg != NULL) {
            char *word = *arg;     // current word
            char first = *word;    // first letter of current word
            if (exists[first])
                duplicates = 1;    // we found a duplicate
            exists[first] = 1;     // mark it as in our string
            output[index] = first; // add it to our output
            index++;
            (*arg)++;              // advances the current word to the next
                                   // character by reference (chops first char)
            arg++;                 // advance to next whole argument
        }

        if (!duplicates) {         // This is a valid solution
            puts(output);
            quit = 1;
        }

        if (exists[0]) {           // We hit the null terminator of one of the
                                   // input strings, so we failed
            quit = 1;
        }
    }
}

-3 सीटिंग के लिए धन्यवाद

यह स्ट्रिंग की 'टेल' प्राप्त करने के लिए C में एक स्ट्रिंग पॉइंटर में सिर्फ 1 जोड़ने की क्षमता का दुरुपयोग करता है। मुख्य बाइट सेवर्स हैं:

  • d+=x[y[i++]=*(*_)++]++जिनमें से पहले स्ट्रिंग के प्रथम वर्ण संलग्न कर देता है _के लिए y, अग्रिम के पहले स्ट्रिंग _अपनी पहली चरित्र को दूर करने, कहते xहै कि चरित्र पर प्रवेश d, और वेतन वृद्धि कहा xप्रविष्टि
  • q=d?*x:puts(y)जो प्रिंट yअगर dहै गैर शून्य सेट करते समय qएक गैर शून्य मान के लिए, या सेट qकरने के लिए गैर शून्य अगर के पहले तत्व xगैर-शून्य है (यदि हम तार में से एक के अंत में थे तो कहा तत्व गैर होगा शून्य)

संपादित करें: लूप के लिए पुनरावर्ती टेल कॉल और ब्रैकेट को लूप के लिए हटाने से स्विच करके बाइट्स।

— LambdaBeta
स्रोत
के for(d=i=0;*_;)बजाय का सुझाव दें for(d=0,i=0;*_;++_)और के *(*_++)++]++;d=d?!*x*f(s)बजाय*(*_)++]++;d=d?*x?0:f(s)
— छत पर
0

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

e+kf{IT@.TQ.t

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

e+kf{IT@.TQ.t
           .tQ   Transpose the (implicit) input with padding.
        .TQ      Transpose the input without padding.
       @         Take the strings in both.
   f{IT          Find the ones that have no duplicates.
e+k              Get the last, or an empty string.
— स्मृति सहायक
स्रोत
1
ऐसा लगता है कि सभी वैध स्ट्रिंग्स की सूची वापस करना मान्य नहीं है।
— LyricLy
@LyricLy फिक्स्ड।
— मेमनोनिक
0

लाल , 139 बाइट्स

func[b][m: length? first b foreach a b[m: min m length? a]repeat n m[c: copy[]foreach a b[append c a/(n)]if c = unique c[return rejoin c]]]

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

स्पष्टीकरण:

इनपुट को स्ट्रिंग्स के ब्लॉक (सूची) के रूप में लेता है। इनक्लूजन स्ट्रिंग लौटाता है या noneअन्यथा।

f: func[b][
    m: length? first b                   ; the minimal length of the first string  
    foreach a b[m: min m length? a]      ; find the minimal length of all strings
    repeat n m[                          ; limit the search to the minimal length
        c: copy[]                        ; an empty block  
        foreach a b[append c a/(n)]      ; for each string append the current char
        if c = unique c[return rejoin c] ; if all chars are unique, return the block
    ]  
]
— गैलेन इवानोव
स्रोत
0

रोड़ा , 80 77 बाइट्स

f a{a|seq 0,#_|try{{|i|a|[_[i:i+1]]|orderedUniq|concat|[_]if[#_1=#a]}_|head}}

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

गायों की बोली के लिए -1 बाइट

स्पष्टीकरण:

f a{
  a|         /* Push the strings in a to the stream */
             /* For each string (_): */
  seq 0,#_|     /* Push a range from 0 to the length of _ to the stream */
  try{       /* Ignore errors during the following block */
    {|i|        /* For each i in the stream: */
      a|           /* Push strings in a to the stream */
      [_[i:i+1]]|  /* For each string, push the ith character to the stream */
      orderedUniq| /* Remove duplicate characters */
      concat|      /* Join the characters into a string */
      [_]if        /* Push the string to the stream if */
      [#_1=#a]     /* Its length is the length of a */
    }_|
    head        /* Take the first string in the stream and return it */
  }
}

tryकीवर्ड त्रुटियों है कि हो अगर खारिज करने के लिए प्रयोग किया जाता है iमें सबसे छोटी स्ट्रिंग की लंबाई से भी बड़ा है a, या वहाँ कोई जवाब नहीं है और headएक त्रुटि का कारण बनता है।

— fergusq
स्रोत
आप seqएक बाइट को बचाने के लिए
— पार्न्स
@ सहवास धन्यवाद!
— फर्ग्यूसक
0

जावा 10, 106 बाइट्स

a->{for(int i=0;;i++){var r="";for(var s:a)r+=s[i];if(r.length()==r.chars().distinct().count())return r;}}

खाली स्ट्रिंग वापस करने के बजाय एक त्रुटि देगा यदि कोई समाधान नहीं मिल सकता है। इनपुट एक चरित्र-मैट्रिक्स है।

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

स्पष्टीकरण:

a->{                  // Method with character-matrix parameter and String return-type
  for(int i=0;;i++){  //  Loop `i` upwards
    var r="";         //   Result-String, starting empty
    for(var s:a)      //   Loop over the character-arrays of the input
      r+=s[i];        //    And append every `i`'th character to `r`
    if(r.length()==r.chars().distinct().count())
                      //   If `r` only contains unique characters
      return r;}}     //    Return `r` as result
— केविन क्रूज़सेन
स्रोत
ओपी त्रुटियों की अनुमति नहीं देना चाहता था, हालाँकि उसने स्वीकार नहीं किया कि उसे पोस्ट में ही रखा जाए।
— अर्जन जोहान्सन
0

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

#(for[s(apply map list %):when(=(count(set s))(count %))]s)

पात्रों की सूची की एक सूची देता है।

— NikoNyrh
स्रोत
0

एपीएल + विन, 35 33 बाइट्स

2 बाइट्स ने Adám को धन्यवाद दिया

एक चरित्र मैट्रिक्स के रूप में पाठ की लाइनों के लिए संकेत:

⊃((↑⍴¨a)=+/¨((a⍳¨a)=⍳¨⍴¨a))/a←,⌿⎕

इसे ऑनलाइन आज़माएं! दरियाल क्लासिक के सौजन्य से

स्पष्टीकरण:

a←,⌿⎕ prompts for input and creates a nested vector of the input matrix columns

((a⍳¨a)=⍳¨⍴¨a) creates a binary vector for each nested element with a 1 for each unique element

((↑⍴¨a)=+/¨ sums each binary vector and compares to number of characters in each element

(...)/a←⊂[1]⎕ selects only those elements where number of uniques = column length

⊃ converts nested vector back to a matrix of each valid enklaction string
— ग्राहम
स्रोत
— एडम
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.