41

मुद्रण योग्य ASCII वर्णों से मिलकर एक स्ट्रिंग को देखते हुए , मूल क्रम में इसके अनूठे वर्णों से मिलकर एक आउटपुट का उत्पादन करें । दूसरे शब्दों में, आउटपुट इनपुट के समान होता है सिवाय इसके कि अगर कोई चार पहले हटा दिया गया है तो उसे हटा दिया जाता है।

किसी सरणी में अद्वितीय तत्वों को खोजने के लिए कोई बिल्ट-इन का उपयोग नहीं किया जा सकता है (उदाहरण के लिए, MATLAB में एक uniqueफ़ंक्शन है जो ऐसा करता है)। विचार इसे मैन्युअल रूप से करना है।

आगे की जानकारी:

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

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

स्टड और स्टडआउट मानते हुए कुछ उदाहरण :

इनपुट स्ट्रिंग:
```
Type unique chars!
```
आउटपुट स्ट्रिंग:
```
Type uniqchars!
```
इनपुट स्ट्रिंग
```
"I think it's dark and it looks like rain", you said
```
आउटपुट स्ट्रिंग
```
"I think'sdarloe,yu
```
इनपुट स्ट्रिंग
```
3.1415926535897932384626433832795
```
आउटपुट स्ट्रिंग
```
3.14592687
```

code-golf string

— लुइस मेंडो
स्रोत

5

बस दोहरी जांच करने के लिए: क्या कोई बिलिन नियम का मतलब यह नहीं है कि सेट की गई वस्तुएं अस्वीकृत हैं?

— Sp3000

@ Sp3000 सेट ऑब्जेक्ट्स की अनुमति है। बस एक फ़ंक्शन या विधि (यदि यह मौजूद है) का उपयोग न करें जो आपको इसके अद्वितीय तत्व प्रदान करता है। और इनपुट / आउटपुट स्ट्रिंग्स होना चाहिए, टोबेग्ज सेट नहीं

— लुइस

@ Sp3000 क्या आपको लगता है कि यदि सेट कार्यों का उपयोग नहीं किया जाता है तो बाइट की संख्या को आधे से कम करना अधिक दिलचस्प होगा? या चुनौती तय होने के बाद नियमों में बदलाव करना बेहतर नहीं है?

— लुइस मेंडो

5

मुझे लगता है कि वर्तमान में केवल मेरा उत्तर सेट का उपयोग करता है, और अगर आपने इसे बदल दिया तो मुझे कोई आपत्ति नहीं होगी। हालाँकि, मुझे वास्तव में यकीन नहीं है कि इस तरह एक बोनस बहुत बदल जाएगा, उदाहरण के लिए मुझे संदेह है कि सीजेएम बिना सेट के <6 बाइट्स में उल्लेखनीय होगा। इसके अलावा, मुझे यकीन नहीं है कि लाइन एक बेसिन के बीच है जहां अद्वितीय तत्व मिलते हैं, और कई तत्वों से एक सेट का निर्माण होता है ...

— 15:

1

@ Sp3000 हाँ, यह धुंधली सीमा है। मैंने अपेक्षित कार्य नहीं किए थे। मुझे लगता है कि मैं चुनौती को छोड़ दूंगा क्योंकि यह अब है

— लुइस मेंडो

13

गोल्फस्क्रिप्ट, 2 बाइट्स

.&

या, वैकल्पिक रूप से:

.|

मैंने इसे कुछ समय पहले टिप्स इन गोल्फिंग थ्रेड में गोल्फिंग के लिए पोस्ट किया था । यह इनपुट स्ट्रिंग (जो कि गोल्फस्क्रिप्ट दुभाषिया द्वारा स्वचालित रूप से स्टैक पर लगाई जाती है, और जो वर्णों की एक सरणी की तरह सबसे अधिक व्यवहार करती है) और फिर सेट चौराहे ( &) या यूनियन ( |) को स्वयं के साथ लेकर काम करती है। एक सेट ऑपरेटर को एक सरणी (या स्ट्रिंग) पर लागू करना किसी भी डुप्लिकेट को ध्वस्त करता है, लेकिन तत्वों के क्रम को संरक्षित करता है।

— इल्मरी करोनें
स्रोत

23

सीजाम, 3 बाइट्स

qL|

खाली सूची के साथ सेटवाइज़ या इनपुट। CJam सेट ऑपरेशन तत्व आदेश को संरक्षित करते हैं।

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

— Sp3000
स्रोत

मुझे लगता है कि यह मान्य है क्योंकि सेट की अनुमति है, लेकिन मुझे यकीन नहीं है ...

— Sp3000

बहुत चालाक! मुझे पता था कि सीजेएम सर्वश्रेष्ठ में से एक होगा, लेकिन मुझे सिर्फ 3 बाइट्स की उम्मीद नहीं थी!

— लुइस मेंडो

19

सी # 6, 18 + 67 = 85 बाइट्स

इस usingकथन की आवश्यकता है :

using System.Linq;

वास्तविक विधि:

string U(string s)=>string.Concat(s.Where((x,i)=>s.IndexOf(x)==i));

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

string Unique(string input)
{
    return string.Concat(input.Where((x, i) => input.IndexOf(x) == i));
}

यह कैसे काम करता है: मैं दो तर्कों के साथ एक मेमने के साथ स्ट्रिंग पर Whereविधि को बुलाता हूं : xवर्तमान तत्व का iप्रतिनिधित्व करना , उस तत्व के सूचकांक का प्रतिनिधित्व करना। IndexOfहमेशा अपने पास दिए गए चार वर्णों में से पहला सूचकांक लौटाता है, इसलिए यदि iइसके पहले सूचकांक के बराबर नहीं है , तो xयह एक डुप्लिकेट चार है और इसे शामिल नहीं किया जाना चाहिए।

— ProgramFOX
स्रोत

3

मैंने ईमानदारी से C # इस छोटे होने की उम्मीद नहीं की होगी। बहुत ही उत्तम कार्य!

— एलेक्स ए।

Uhm। मुझे लगता है कि आपको एक पूरा कार्यक्रम (साथ में static void Main) प्रस्तुत करना चाहिए ।

— टिमवी

3

@ टिमी इस चुनौती में कहा गया है "या तो कार्य या कार्यक्रम की अनुमति है।"

— hvd

C # एक छोटे दृष्टिकोण के लिए अनुमति देता है, LINQ का उपयोग करके भी। मैंने एक प्रतिस्पर्धी उत्तर पोस्ट किया है। :)

— hvd

@hvd अच्छा लगा! +1

— प्रोग्राम फॉक्स

14

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

+`((.).*)\2
$1

प्रत्येक पंक्ति को अपनी अलग फ़ाइल में जाना चाहिए, या आप -sएक फ़ाइल से पढ़ने के लिए ध्वज का उपयोग कर सकते हैं ।

इसे समझाने के लिए, हम अब और अधिक सरल संस्करण का उपयोग करेंगे:

+`(.)(.*)\1
$1$2

पहली पंक्ति के साथ मैच करने के लिए रेगेक्स है ( +`कॉन्फ़िगरेशन स्ट्रिंग है जो सभी प्रतिस्थापन किए जाने तक चालू रहता है)। रेगेक्स एक चरित्र की तलाश करता है (हम इसे C कहेंगे), जिसके बाद शून्य या अधिक मनमानी अक्षर हैं, उसके बाद C. कोष्ठक कैप्चरिंग समूहों को दर्शाते हैं, इसलिए हम मैच को C ( $1) और बीच के अक्षर ( ) से प्रतिस्थापित करते हैं $2, सी। का डुप्लिकेट निकाल रहा है।

उदाहरण के लिए, यदि इनपुट स्ट्रिंग था unique, पहली बार चलाने से मेल खाएंगे uniqu, साथ uऔर niqके रूप में $1और $2, क्रमशः। यह तो साथ मूल इनपुट में मिलान-स्ट्रिंग की जगह लेंगे uniqदे रही है, uniqe।

— NinjaBearMonkey
स्रोत

3

मैं ऐसा करने के लिए एक रेगेक्स की तलाश में था; मुझे एहसास नहीं था कि यह बहुत छोटा था! +1

— ETHproductions 22

13

पर्ल, 21 (20 बाइट्स + `-p`)

s/./!$h{$&}++&&$&/eg

उपयोग:

perl -pe 's/./!$h{$&}++&&$&/eg' <<< 'Type unique chars!'
Type uniqchars!

— डोम हेस्टिंग्स
स्रोत

1

आप 1 बाइट की उपेक्षा $h{$&}और एक तर्क का उपयोग कर सकते हैं और एक टर्नरी ऑपरेटर के बजाय बचा सकता है :s/./!$h{$&}++&&$&/eg

— kos

@ अगर आपने मुझसे पूछा है, तो मैंने आपको बताया था कि मैंने 100% कोशिश की और 1आउटपुट में एस के साथ समाप्त हो गया , लेकिन यह नहीं है! धन्यवाद, अद्यतन!

— डोम हेस्टिंग्स 15

1

पहले से ही उकेरा गया :) मुझे लगता है कि आपने कोशिश की s/./$h{$&}++||$&/eg(मैं उसके लिए पहले भी गिर गया था)। शर्म आनी चाहिए क्योंकि वह एक और बचा हुआ बाइट होगा।

— कोस

11

मैकरोनी 0.0.2 , 233 बाइट्स

set i read set f "" print map index i k v return label k set x _ set _ slice " " length index f e 1 1 set f concat f wrap x return label e set _ slice " " add _ multiply -1 x 1 1 return label v set _ unwrap slice i _ add 1 _ 1 return

"एंटी-गोल्फिंग" भाषा बनाएं: चेक करें
वैसे भी गोल्फ: चेक

यह एक पूर्ण कार्यक्रम है, जो STDIN से इनपुट करता है और STDOUT पर आउटपुट करता है।

सौंदर्य मूल्य के लिए लिपटा संस्करण,

set i read set f "" print map index i k v return label k set x _ set _ slice "
" length index f e 1 1 set f concat f wrap x return label e set _ slice " " add
_ multiply -1 x 1 1 return label v set _ unwrap slice i _ add 1 _ 1 return

और एक भारी "टिप्पणी" और असम्पीडित संस्करण (मैकरोनी में कोई टिप्पणी नहीं है, इसलिए मैं सिर्फ नंगे तार का उपयोग करता हूं:)

set input read                  "read line from STDIN, store in 'input' var"
set found ""                    "we need this for 'keep' below"
print map index input keep val  "find indeces to 'keep', map to values, print"
return

label keep
    "we're trying to determine which indeces in the string to keep. the special
     '_' variable is the current element in question, and it's also the value
     to be 'returned' (if the '_' variable is '0' or empty array after this
     label returns, the index of the element is *not* included in the output
     array; otherwise, it is"
    set x _ set _ slice
        " "
        length index found exists
        1
        1
    "now we're using 'index' again to determine whether our '_' value exists in
     the 'found' array, which is the list of letters already found. then we
     have to apply a boolean NOT, because we only want to keep values that do
     NOT exist in the 'found' array. we can 'invert' a boolean stored as an
     integer number 'b' (hence, 'length') with 'slice(' ', b, 1, 1)'--this is
     equivalent to ' '[0:1], i.e. a single-character string which is truthy, if
     'b' was falsy; otherwise, it results in an empty string if 'b' was truthy,
     which is falsy"
    set found concat found wrap x  "add the letter to the 'found' array"
return

label exists
    set _ slice
        " "
        add _ multiply -1 x
        1
        1
    "commentary on how this works: since 0 is falsy and every other number is
     truthy, we can simply subtract two values to determine whether they are
     *un*equal. then we apply a boolean NOT with the method described above"
return

label val
    set _ unwrap slice input _ add 1 _ 1  "basically 'input[_]'"
return

(यह पहला वास्तविक मैकरोनी कार्यक्रम है (जो वास्तव में कुछ करता है)! \ O /)

— Doorknob
स्रोत

5

• भाषा को एक मजाकिया और उपयुक्त नाम दें: चेक

— लुइस मेंडो

11

जावास्क्रिप्ट ईएस 7, 37 33 25 बाइट्स

ईएस 6 Setऔर ईएस 7 ~~एरे कॉम्प्रिहेंशन~~ फैलाने वाले ऑपरेटर का उपयोग करते हुए बहुत सरल दृष्टिकोण :

s=>[...new Set(s)].join``

22 बाइट्स indexOfदृष्टिकोण से कम । मुट्ठी भर परीक्षण मामलों पर काम किया।

— azz
स्रोत

चारों ओर forकी अभिव्यक्ति आवश्यक नहीं है और आप इसे अन्य प्रकार के समाधानों के रूप में कर सकते हैं s=>[for(c of Set(s))c].join``। (पेल अपडेट: 100% निश्चित नहीं, लेकिन newकीवर्ड भी अनावश्यक लगता है।)

— मैनटवर्क

एनोन फ़ंक्शंस के साथ नियमों का यकीन नहीं था, और अंतरिक्ष पर अच्छी पकड़ थी।

— azz

Google Chrome में newपरिणाम के बिना कोडित कोड Uncaught TypeError: Constructor Set requires 'new'।

— azz

कृपया मेरी अज्ञानता का बहाना करें लेकिन यह किस स्तर पर अद्वितीय मूल्यों को फ़िल्टर करता है? ऐसा लगता है कि यह एक स्ट्रिंग को एक सेट में एक सरणी में बदल देता है और फिर मूल स्ट्रिंग में जिसके परिणामस्वरूप मूल्यों को जोड़ता है।

— पैट्रिक रॉबर्ट्स

@PatrickRoberts यह एक सेट में रूपांतरण है। परिभाषा के अनुसार एक सेट में कोई द्वैध नहीं है

— edc65

8

सी # 6 - 18 + 46 = 64

using System.Linq;

और फिर

string f(string s)=>string.Concat(s.Union(s));

Enumerable.Unionविस्तार विधि निर्दिष्ट करता है कि तत्वों को मूल क्रम में वापस आ रहे हैं:

जब इस विधि द्वारा लौटाए गए ऑब्जेक्ट को एन्यूमरेट किया जाता है, तो यूनियन उस क्रम में पहले और दूसरे स्थान पर गणना करता है और प्रत्येक तत्व की पैदावार करता है जो पहले से ही उपज नहीं हुआ है।

ऐसे ऑपरेशन सेट करें जो विशेष रूप से अद्वितीय मानों को खोजने के उद्देश्य से नहीं हैं, अन्य उत्तरों को देखते हुए अनुमति दी जाती है।

— HVD
स्रोत

एक अच्छा, मैं सोच रहा था, string u(string s)=>String.Join("",s.Distinct());लेकिन यह थोड़ा लंबा है।

— जर्मिनी

@germi धन्यवाद Distinct()पहले से ही उपयोग कर एक उत्तर दिया गया है , लेकिन इसे हटा दिया गया है क्योंकि Distinct()इस चुनौती को अस्वीकार कर दिया गया है, क्योंकि यह विशेष रूप से अद्वितीय मूल्यों को खोजने के लिए एक विधि है।

— hvd

आह ठीक है ... उस बिट को नजरअंदाज कर दिया;)

— जर्मिनी

है s => string.Concat(s.Union(s))मान्य है? यह Func<string, string>एक तर्क के रूप में पारित प्रतिनिधि होगा ।

— टायलर स्टैंडिशमैन

@TylerStandishMan यदि यह मान्य है, तो मैं इसका उपयोग करने के लिए अधिक लोगों से अपेक्षा करूंगा, और मैंने इसे पहले नहीं देखा है, इसलिए मुझे नहीं लगता कि यह है। लेकिन शायद यह मान्य होना चाहिए - यदि आप रुचि रखते हैं तो यह मेटा पर जाँच के लायक कुछ लगता है।

— hvd

7

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

f=s=>s.replace(/./g,(e,i)=>s.indexOf(e)<i?'':e)

नीचे दिया गया परीक्षण सभी ब्राउज़रों पर काम करता है।

f=function(s){
  return s.replace(/./g,function(e,i){
    return s.indexOf(e)<i?'':e
  })
}

run=function(){document.getElementById('output').innerHTML=f(document.getElementById('input').value)};document.getElementById('run').onclick=run;run()

<input type="text" id="input" value="Type unique chars!" /><button id="run">Run</button><br />
<pre id="output"></pre>

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

— NinjaBearMonkey
स्रोत

<i?'':eभाग क्या करता है?

— DanTheMan

1

यह एक टर्नरी ऑपरेटर है। यदि चरित्र eका पहला उदाहरण वर्तमान सूचकांक से पहले है i, तो यह एक खाली स्ट्रिंग लौटाता है, इस प्रकार चरित्र से छुटकारा मिलता है। यदि यह पहला उदाहरण है, तो यह केवल रिटर्न करता है eऔर कोई बदलाव नहीं किया जाता है।

— निन्जाबियरनौक

7

MATLAB, 23

 @(n)union(n,n,'stable')

इनपुट स्ट्रिंग का "सेट यूनियन" अपने आप से, 'स्थिर' विधि का उपयोग करता है जो सॉर्ट नहीं करता है, और फिर प्रिंट करता है।

यह काम करता है क्योंकि unionमर्ज के बाद केवल गैर-डुप्लिकेट मान लौटाता है। तो अनिवार्य रूप से यदि आप unionस्वयं के साथ स्ट्रिंग करते हैं, तो यह पहले एक स्ट्रिंग का उत्पादन करता है Type unique chars!Type unique chars!, और फिर बिना छँटाई के सभी डुप्लिकेट को हटा देता है।

कोई ज़रूरत नहीं है unique:)

— टॉम बढ़ई
स्रोत

uniqueअनुमति नहीं है, क्षमा करें! यह हेलेन्ज परिभाषा में है

— लुइस मेंडो

याद किया कि, कोई बात नहीं।

— टॉम कारपेंटर

Sp3000 के उत्तर के बाद, क्या मैं विकल्प के setdiffसाथ सुझाव दे सकता हूं 'stable'?

— लुइस मेंडो

1

अच्छा! और हाँ, आप हटा सकते हैं dispक्योंकि तब आपके पास एक फ़ंक्शन है जो एक स्ट्रिंग लौटाता है, जिसकी अनुमति है

— लुइस मेंडो

1

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

— रेयरेंग - मोनिका

7

> <> , 16 बाइट्स

i:0(?;:::1g?!o1p

> <> तार नहीं है, इसलिए हम कोडबॉक्स का उपयोग करते हैं। टॉरॉयडल प्रकृति के कारण> <>, निम्नलिखित एक लूप में चलता है:

i         Read a char
:0(?;     Halt if EOF
:::       Push three copies of the char
1g        Get the value at (char, 1), which is 0 by default
?!o       Print the char if the value was nonzero
1p        Set the value at (char, 1) to char

ध्यान दें कि यह इस तथ्य का उपयोग करता है कि इनपुट में केवल मुद्रण योग्य ASCII शामिल है, क्योंकि ASCII 0 मौजूद होने पर यह काम नहीं करेगा।

— Sp3000
स्रोत

1

.......ये जबरदस्त है। काश मैंने ऐसा सोचा होता। मैं अपने उत्तर में इसका एक Befunge संस्करण शामिल करूंगा, लेकिन प्राथमिक के रूप में नहीं। संपादित करें: दूसरे विचार पर, यह काम नहीं करेगा क्योंकि बेफुंज में अनंत कोड स्थान नहीं है। धत तेरे की!

— एलेंडिया स्ट्राटन

@ El'endiaStarman मुझे लगता है कि बीम का उत्तर भी यही काम करता है, इसलिए दुर्भाग्य से मैं यह नहीं कह सकता कि मैं पहले था: P

— Sp3000

आह, हाँ, मुझे लगता है कि तुम सही हो। आपका स्पष्टीकरण हालांकि स्पष्ट है।

— एलेंडिया स्ट्राटन

7

बीम , 23 18 बाइट्स

v<H
vs)
rS
g@S
>u^

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

— MickyT
स्रोत

5

तत्व , 22 19 18 बाइट्स

_'{"(3:~'![2:`];'}

उदाहरण इनपुट / आउटपुट: hello world->helo wrd

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

_'{"(3:~'![2:`];'}
_                        input line
 '                       use as conditional
  {              }       WHILE loop
   "                     retrieve string back from control (c-) stack
    (                    split to get the first character of (remaining) string
     3:                  a total of three copies of that character
       ~                 retrieve character's hash value
        '                put on c-stack
         !               negate, gives true if undef/empty string
          [   ]          FOR loop
           2:`           duplicate and output
               ;         store character into itself
                '        put remaining string on c-stack as looping condition

— PhiNotPi
स्रोत

5

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

कुछ अनाम कार्यों का उपयोग करता है और reduce।

lambda s:reduce(lambda x,y:x+y[y in x:],s)

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

— mbomb007
स्रोत

4

पायथन 3, 44

r=''
for c in input():r+=c[c in r:]
print(r)

rचरित्र द्वारा आउटपुट स्ट्रिंग चरित्र बनाता है , cइनपुट से चरित्र सहित केवल अगर हमने इसे पहले से ही नहीं देखा है।

पाइथन 2 47 होगा, 4 चरों को खोना raw_inputऔर 1 को बचाने के लिए पेरेंट्स की जरूरत नहीं है print।

— XNOR
स्रोत

अब सर्वसम्मति से प्रतीत होता है कि आप inputपायथन 2 में उपयोग कर सकते हैं , जिससे आप अपने बाइट को छोटा बना सकते हैं।

— mbomb007

4

एपीएल, ३

∊∪/

यह वेक्टर के प्रत्येक तत्व के बीच संघ (∪) को लागू करता है, एक पुनरावृत्ति प्राप्त करता है जिसमें डुप्लिकेट को हटाने का प्रभाव होता है।

यह tryapl.org पर परीक्षण करें

पुराना वाला:

~⍨\

यह तर्क के प्रत्येक तत्व के बीच लागू ~ (उल्टे तर्कों के साथ, ersed का उपयोग करता है)। नतीजा यह है कि प्रत्येक तत्व के लिए, यदि यह पहले से ही सूची में है, तो यह मिट जाता है।

— मोरिस ज़ुक्का
स्रोत

लुइस का कहना है कि "नथपिंग:" और इनपुट / आउटपुट स्ट्रिंग्स होना चाहिए। "यूनियन कम" एक नेस्टेड सरणी देता है, न कि एक स्ट्रिंग। O :-)

— lstefano

आप सही हैं, शुरुआत में, को सही करने के लिए जोड़ रहे हैं।

— मोरिस ज़ूका

3

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

map{$h{$_}||=print}<>=~/./g
123456789012345678901234567

परीक्षा:

$ echo Type unique chars! | perl -e 'map{$h{$_}||=print}<>=~/./g'
Type uniqchars!
$

— स्टीव
स्रोत

1

print exists($h{$_})?"":$_→$h{$_}||print

— मैनटवर्क

क्या एसओ ने एक यूनिकोड डाला है → इसमें रेंडरिंग टूटी हुई है?

— स्टीव

1

स्टेटमेंट मॉडिफ़ायर का $h{$_}||=printउपयोग करने से आपको कुछ बाइट्स बचती हैं, साथ ही @ manatwork के सुझाव और उपयोग करने के साथ-साथ <>=~/./gकुछ और बचाने में मदद करनी चाहिए!

— डोम हेस्टिंग्स

1

नहीं, मैंने इसे "परिवर्तन" के अर्थ के साथ डाला।

— मैनटवर्क

1

बदलने से mapबचत में भी सुधार होगा: map{$h{$_}||=print}<>=~/./g

— manatwork

3

PHP, 72 बाइट्स 84 बाइट्स

<?foreach(str_split($argv[1])as$c)$a[$c]=0;echo join('',array_keys($a));

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

str_splitसुझाव के लिए धन्यवाद इस्माईल मिगुएल ।

— फेबियन शेंगलर
स्रोत

1

<?foreach(str_split($argv[1])as$c)$a[$c]=0;echo join('',array_keys($a));छोटा और वही करता है।

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

एक छोटा लूप मिला while($c=$argv[1][$i++*1]):। यह पूरे की जगह foreach। बाकी सब कुछ वैसा ही है

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

मैंने पहले भी ऐसा ही कुछ करने की कोशिश की थी, लेकिन इससे बच गया क्योंकि यह एक ऐसे चरित्र पर रोक लगाता है जो "झूठे" यानि की झूठ बोलता है "0"। इनपुट के रूप में "abc0def" आज़माएं।

— फैबियन शेंगलर

तुम इसके बारे में सही हो। निश्चित रूप से इसके लिए एक समाधान है जिसमें 2 बाइट्स से अधिक खर्च नहीं होता है।

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

3

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

soxzN{z

स्यूडोकोड:

z = इनपुट

z के सेट पर N के z में ऑर्डर-बाय इंडेक्स का योग।

— isaacg
स्रोत

3

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

s->(N="";[i∈N?N:N=join([N,i])for i=s];N)

पुराना संस्करण:

s->(N={};for i=s i∈N||(N=[N,i])end;join(N))

कोड उस पर नए पात्रों को जोड़कर नया स्ट्रिंग बनाता है, फिर joinउन्हें अंत में एक उचित स्ट्रिंग के साथ जोड़ते हैं । नया वर्जन एरे कॉम्प्रिहेंशन के माध्यम से पुनरावृति करके कुछ पात्रों को बचाता है। इसके ?:बजाय का उपयोग करके एक बाइट बचाता है ||(जैसा कि यह असाइनमेंट के आसपास कोष्ठक की आवश्यकता को हटाता है)।

वैकल्पिक समाधान, 45 बाइट्स, रिकर्सियन और रेगेक्स का उपयोग करते हुए:

f=s->s!=(s=replace(s,r"(.).*\K\1",""))?f(s):s

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

(वैकल्पिक संस्करण)

s->join(union(s))

यह unionमूल रूप से एक विकल्प के रूप में उपयोग करता है unique- मैं इसे "वास्तविक" उत्तर नहीं मानता, क्योंकि मैं व्याख्या करता हूं "का उपयोग नहीं करता unique" का अर्थ है "एक एकल निर्मित फ़ंक्शन का उपयोग न करें जिसमें अद्वितीय को वापस करने का प्रभाव हो। तत्वों "।

— ग्लेन हे
स्रोत

मेरे पास एक समान विचार था लेकिन यह उतना संक्षिप्त नहीं था। अच्छा काम!

— एलेक्स ए।

3

जावा, 78 बाइट्स

String f(char[]s){String t="";for(char c:s)t+=t.contains(c+"")?"":c;return t;}

पहले से मौजूद पात्रों के लिए आउटपुट की जाँच करते समय एक साधारण लूप। एक के रूप में इनपुट स्वीकार करता है char[]।

— Geobits
स्रोत

3

सी, 96 बाइट्स

#include<stdio.h> 
int c,a[128];main(){while((c=getchar())-'\n')if(!a[c])a[c]=1,putchar(c);}

यह ASCII वर्ण संख्या द्वारा अनुक्रमित पूर्णांक की एक सरणी का उपयोग करता है। वर्ण केवल तभी मुद्रित होते हैं यदि सरणी में वह स्थान FALSE पर सेट किया गया हो। प्रत्येक नए वर्ण के पाए जाने के बाद सरणी में जगह TRUE पर सेट हो जाती है। यह मानक इनपुट से पाठ की एक पंक्ति लेता है, जिसे एक नई पंक्ति द्वारा समाप्त किया जाता है। यह गैर-ASCII वर्णों की उपेक्षा करता है।

Ungolfed:

#include<stdio.h>
#include<stdbool.h>

int main(void)
{
  int i, c;
  int ascii[128];
  for (i = 0; i < 128; ++i) {
    ascii[i] = false;
  }
  while ((c = getchar()) != '\n') {
    if (ascii[c] == false) {
      ascii[c] = true;
      putchar(c);
    }
  }
  puts("\n");
  return(0);
}

— musarithmia
स्रोत

3

सी - 58

वर्णों के एक समूह को बचाने के लिए @hvd और @AShelly का धन्यवाद। मूल की तुलना में इसे बहुत कम बनाने के कई तरीके सुझाए गए थे:

// @hvd     - always copy to q but only increment q if not found
g(char*s,char*r){char*q=r;for(;*q=*s;q+=q==strchr(r,*s++));}

// @AShelly - keep a histogram of the usage of each character
h(char*s){int a[128]={0};for(;*s;s++)a[*s]++||putchar(*s);}

// @hvd     - modify in place
i(char*s){char*q=s,*p=s;for(;*q=*p;q+=q==strchr(s,*p++));}

// original version - requires -std=c99
void f(char*s,char*r){for(char*q=r;*s;s++)if(!strchr(r,*s))*q++=*s;}

जैसा कि आप देख सकते हैं कि जगह में संशोधन सबसे छोटा (अब तक!) लगता है कि परीक्षण कार्यक्रम बिना चेतावनियों का उपयोग किए हुए है gcc test.c

#include <stdlib.h> // calloc
#include <string.h> // strchr
#include <stdio.h>  // puts, putchar

// 000000111111111122222222223333333333444444444455555555556666666666
// 456789012345678901234567890123456789012345678901234567890123456789

// @hvd     - always copy to q but only increment q if not found
g(char*s,char*r){char*q=r;for(;*q=*s;q+=q==strchr(r,*s++));}

// @AShelly - keep a histogram of the usage of each character
h(char*s){int a[128]={0};for(;*s;s++)a[*s]++||putchar(*s);}

// @hvd     - modify in place
i(char*s){char*q=s,*p=s;for(;*q=*p;q+=q==strchr(s,*p++));}

/* original version - commented out because it requires -std=c99
void f(char*s,char*r){for(char*q=r;*s;s++)if(!strchr(r,*s))*q++=*s;}
*/

// The test program:
int main(int argc,char*argv[]){
  char *r=calloc(strlen(argv[1]),1); // make a variable to store the result
  g(argv[1],r);                      // call the function
  puts(r);                           // print the result

  h(argv[1]);                        // call the function which prints result
  puts("");                          // print a newline

  i(argv[1]);                        // call the function (modifies in place)
  puts(argv[1]);                     // print the result
}

पूरी सहायताके लिए शुक्रिया। मैं इतना छोटा करने के लिए दी गई सभी सलाह की सराहना करता हूं!

— जेरी यिर्मयाह
स्रोत

ठीक है, के बाद से अपने कोड पहले से ही वैध सी नहीं, बस उदार सी compilers द्वारा स्वीकार कर लिया है: आप घोषणा कर सकते हैं rके रूप में int(और छोड़ देते हैं int) कुछ बाइट्स को बचाने के लिए: f(s,r)char*s;{...}। लेकिन यह आपके कोड को उन प्लेटफ़ॉर्मों तक सीमित करता char*है, जहां आकार समान है int, और निश्चित रूप से जहां कंपाइलर आपके और मेरे जैसे ही उदार हैं।

— hvd

@hvd यह बुराई है! मैं वापसी मूल्य को डिफ़ॉल्ट करने के लिए तैयार था क्योंकि मैं इसका उपयोग नहीं करता। लेकिन यह थोड़ा अधिक है जो मैं होना चाहूंगा। मुझे लगता है कि मैं इसे दूर जाने के बजाय इसका अनुपालन करना पसंद करूंगा! प्रकाश पक्ष में वापस लाने के लिए धन्यवाद।

— जेरी यिर्मयाह

आप की जगह के बाद एक चार को बचा सकता है if(x)yके साथx?y:0

— ugoren

यहाँ एक 60 char फंक्शन है जो एक सरणी पैरामीटर के बजाय stdout को लिखता है: f(char*s){int a[128]={0};for(;*s;s++)a[*s]++?0:putchar(*s);}

— AShelly

आप बिना शर्त कॉपी कर सकते हैं *q, और केवल वेतन वृद्धि कर सकते हैं qयदि चरित्र पहले दिखाई देता है, एक साथ थोड़ा और भराई की अनुमति देता है: void f(char*s,char*r){for(char*q=r;*q=*s;strchr(r,*s++)<q||q++);}(ध्यान दें कि strchr(r,*s++)<qहमेशा अच्छी तरह से परिभाषित किया गया है, वहाँ कोई यूबी नहीं है, क्योंकि इस संस्करण में strchrवापस नहीं आ सकता है NULL।) वापसी के प्रकार को छोड़कर। यह @ AShelly के संस्करण से भी छोटा है।

— hvd

2

रूबी, 30 24 अक्षर

(23 वर्ण कोड + 1 वर्ण कमांड लाइन विकल्प।)

gsub(/./){$`[$&]?"":$&}

नमूना रन:

bash-4.3$ ruby -pe 'gsub(/./){$`[$&]?"":$&}' <<< 'hello world'
helo wrd

— आदमी काम पर है
स्रोत

2

CJam, 9

Lq{1$-+}/

यह एक स्ट्रिंग को सेट में परिवर्तित नहीं करता है, लेकिन यह निर्धारित करने के लिए एक प्रकार का सेट अंतर करता है कि क्या एक स्ट्रिंग में एक चरित्र पाया जाता है। इसे ऑनलाइन आज़माएं

स्पष्टीकरण:

L       push an empty array/string
q       read the input
{…}/    for each character in the input
  1$    copy the previous string
  -     subtract from the character (set difference),
         resulting in the character or empty string
  +     append the result to the string

एक और संस्करण, 13 बाइट्स:

Lq{_2$#)!*+}/

यह सेट से संबंधित कुछ भी नहीं करता है। इसे ऑनलाइन आज़माएं

स्पष्टीकरण:

L       push an empty array/string
q       read the input
{…}/    for each character in the input
  _     duplicate the character
  2$    copy the previous string
  #)    find the index of the character in the string and increment it
  !     negate, resulting in 0 if the character was in the string and 1 if not
  *     repeat the character that many times
  +     append the result to the string

— aditsu
स्रोत

2

टीआई-बेसिक, 49 बाइट्स

Input Str1
"sub(Str1,X,1→Y₁
Y₁(1
For(X,2,length(Str1
If not(inString(Ans,Y₁
Ans+Y₁
End
Ans

समीकरण चर शायद ही कभी उपयोगी होते हैं क्योंकि वे स्टोर करने के लिए 5 बाइट लेते हैं, लेकिन स्ट्रिंग Y₁के Xवें चरित्र के रूप में यहां काम आता है , जिससे 3 बाइट बचती हैं। चूंकि हम TI-BASIC में खाली तारों को नहीं जोड़ सकते हैं, हम स्ट्रिंग को Str1 के पहले वर्ण से शुरू करते हैं, फिर बाकी स्ट्रिंग के माध्यम से लूप करते हैं, जो पहले से ही सामने नहीं आए सभी वर्णों को जोड़ते हैं।

prgmQ
?Why no empty st
rings? Because T
I...
Why noemptysrig?Bcau.

— lirtosiast
स्रोत

2

मतलाब, 46 बाइट्स

यह इनपुट और आउटपुट के रूप में फ़ंक्शन तर्कों के साथ एक अनाम फ़ंक्शन का उपयोग करता है:

@(s)eval('s(~any(triu(bsxfun(@eq,s,s''),1)))')

(मैं एक ऑक्टेव ऑनलाइन दुभाषिया में काम करने के लिए इसे प्राप्त नहीं कर सका।)

उदाहरण का उपयोग करें:

>> @(s)eval('s(~any(triu(bsxfun(@eq,s,s''),1)))')
ans = 
    @(s)eval('s(~any(triu(bsxfun(@eq,s,s''),1)))')

>> ans('Type unique chars!')
ans =
Type uniqchars!

— लुइस मेंडो
स्रोत

यह मेरा विचार भी होगा :) - आपको btw के ,1साथ की जरूरत नहीं है any।

— जोनास

@ जोनास धन्यवाद! कम से कम यह कोष्ठक की गंदगी के माध्यम से देखना मुश्किल है, के 1लिए है triu (मुझे विकर्ण को दूर करने की आवश्यकता है), इसके लिए नहींany

— लुइस मेंडो

2

Befunge -93, 124 बाइट्स

v
<v1p02-1
0_v#`g00: <0_@#+1::~p
 1>:1+10p2+0g-!#v_v
g `#v_10g0^       >:10g00
 ^0g 00$        <
 ^  >:,00g1+:00p1+:1+01-\0p

इस ऑनलाइन दुभाषिया में इसका परीक्षण करें ।

यह मेरी अपेक्षा से अधिक कठिन था। अगर कोई मुझे चाहता है, तो मैं कल एक पूर्ण विवरण पोस्ट करूँगा, लेकिन यहाँ मेरा कोड क्या है इसका अवलोकन है।

अब तक देखे गए अनूठे पात्र पहली पंक्ति में संग्रहीत हैं, जो शुरू से 2,0और दाईं ओर फैले हुए हैं। यह देखने के लिए जाँच की जाती है कि क्या वर्तमान वर्ण डुप्लिकेट है।
अब तक देखे गए अद्वितीय पात्रों की संख्या 0,0और चेक-इन-डुप्लिकेट लूप काउंटर में संग्रहीत है 1,0।
जब कोई विशिष्ट वर्ण देखा जाता है, तो उसे पहली पंक्ति में संग्रहीत किया जाता है, प्रिंट आउट किया जाता है, और काउंटर 0,0को इंक्रीमेंट किया जाता है।
उपस्थित स्थानों (एएससीआईआई 32) में पढ़ने के साथ समस्याओं से बचने के लिए, मैंने अगले अद्वितीय चरित्र के लिए चरित्र को अगले स्लॉट में -1 (वास्तव में, 65536) के अनुरूप रखा।

— एलेंडिया स्ट्राटन
स्रोत

2

पीएचपी, 56 54

// 56 bytes
<?=join('',array_flip(array_flip(str_split($argv[1]))));

// 54 bytes
<?=join(!$a='array_flip',$a($a(str_split($argv[1]))));

@ Fschmengler के उत्तर का array_flipदो बार - दूसरे संस्करण में उपयोग करके परिवर्तन करना, चर विधि का उपयोग करता है और स्ट्रिंग को सही करने के लिए निर्भर करता है, इसे झूठे की उपेक्षा करता है, फिर दूसरे तर्क में बाइट्स को बचाने के लिए पहले तर्क में खाली स्ट्रिंग पर वापस कास्टिंग करता है। सस्ते!

— नीट द डार्क एबसोल
स्रोत

2

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

नेस्टेबल, नो-वेरिएबल-नाम वन-लाइनर:

foldr(\x->(x:).filter(x/=))[]

समान गणना, fशीर्ष-स्तरीय घोषणा के रूप में नामित फ़ंक्शन में सहेजी गई :

f(x:t)=x:f[y|y<-t,x/=y];f_=[]

ध्यान दें कि थोड़ा-सा धोखा देने वाला अनुकूलन है जो मैंने निकनेस की भावना में नहीं किया है: यह तकनीकी रूप से इस चुनौती के नियमों द्वारा एक स्ट्रिंग के लिए एक अलग इनपुट और आउटपुट एन्कोडिंग का उपयोग करने की अनुमति है। stringआंशिक रूप से लागू चर्च एन्कोडिंग द्वारा किसी भी का प्रतिनिधित्व करने से \f -> foldr f [] string :: (a -> [b] -> [b]) -> [b](फ़ंक्शन द्वारा प्रदान की गई ($ (:))आपत्ति के दूसरे पक्ष के साथ ) यह ($ \x->(x:).filter(x/=))केवल 24 वर्णों तक नीचे हो जाता है ।

मैंने अपने आधिकारिक एक के रूप में 24-चरित्र की प्रतिक्रिया पोस्ट करने से परहेज किया क्योंकि उपरोक्त व्याख्याकर्ता पर उपरोक्त समाधान की कोशिश की जा सकती है foldr(\x->(x:).filter(x/=))[]"Type unique chars!"जबकि गोल्फ समाधान को इसके बजाय लिखा जाएगा:

($ \x->(x:).filter(x/=))$ foldr (\x fn f->f x (fn f)) (const []) "Type unique chars!"

शाब्दिक घोषणा के लिए एक शॉर्टहैंड के रूप में जो अधिक पागल होगा:

($ \x->(x:).filter(x/=))$ \f->f 'T'.($f)$ \f->f 'y'.($f)$ \f->f 'p'.($f)$ \f->f 'e'.($f)$ \f->f ' '.($f)$ \f->f 'u'.($f)$ \f->f 'n'.($f)$ \f->f 'i'.($f)$ \f->f 'q'.($f)$ \f->f 'u'.($f)$ \f->f 'e'.($f)$ \f->f ' '.($f)$ \f->f 'c'.($f)$ \f->f 'h'.($f)$ \f->f 'a'.($f)$ \f->f 'r'.($f)$ \f->f 's'.($f)$ \f->f '!'.($f)$ const[]

लेकिन यह शुद्ध कार्यों के रूप में प्रस्तुत डेटा संरचना का पूरी तरह से मान्य संस्करण है। (बेशक, आप भी उपयोग कर सकते हैं \f -> foldr f [] "Type unique chars!", लेकिन यह वास्तव में नाजायज है क्योंकि यह वास्तव में डेटा को संग्रहीत करने के लिए सूचियों का उपयोग करता है, इसलिए इसके तह हिस्से को संभवतः "उत्तर" फ़ंक्शन में बनाया जाना चाहिए, जिससे 24 से अधिक वर्ण हो सकते हैं।)

— सीआर ड्रॉस्ट
स्रोत

टाइप करें uniqchars!

गोल्फस्क्रिप्ट, 2 बाइट्स

सीजाम, 3 बाइट्स

सी # 6, 18 + 67 = 85 बाइट्स

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

पर्ल, 21 (20 बाइट्स + -p)

मैकरोनी 0.0.2 , 233 बाइट्स

जावास्क्रिप्ट ईएस 7, 37 33 25 बाइट्स

सी # 6 - 18 + 46 = 64

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

MATLAB, 23

> <> , 16 बाइट्स

बीम , 23 18 बाइट्स

तत्व , 22 19 18 बाइट्स

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

पायथन 3, 44

एपीएल, ३

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

PHP, 72 बाइट्स 84 बाइट्स

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

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

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

जावा, 78 बाइट्स

सी, 96 बाइट्स

सी - 58

रूबी, 30 24 अक्षर

CJam, 9

एक और संस्करण, 13 बाइट्स:

टीआई-बेसिक, 49 बाइट्स

मतलाब, 46 बाइट्स

Befunge -93, 124 बाइट्स

पीएचपी, 56 54

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

पर्ल, 21 (20 बाइट्स + `-p`)