37

स्टैक ओवरफ्लो पर हटाए गए प्रश्न कभी-कभी महान गोल्फ सामग्री के लिए बनाते हैं।

एक फ़ंक्शन लिखें जो एक nonnegative पूर्णांक को इनपुट के रूप में लेता है, और यह सही है कि यदि उस संख्या के आधार 10 प्रतिनिधित्व में सभी अंक अद्वितीय हैं। उदाहरण:

48778584 -> false
17308459 -> true

वर्ण गणना में केवल फ़ंक्शन शामिल है।

यदि आप C या C ++ में जवाब देना चुनते हैं: कोई मैक्रोज़, कोई अपरिभाषित व्यवहार नहीं; कार्यान्वयन-परिभाषित व्यवहार और संकलक चेतावनी ठीक हैं।

code-golf function

— थॉमस
स्रोत

मैं अभी भी अन्य सी या सी ++ समाधानों में रुचि रखता हूं, जो इस सवाल से प्रेरित हैं।

— थॉमस

1

कोई C या C ++ मैक्रोज़ या अपरिभाषित व्यवहार क्यों नहीं? यह अजीब तरह से सिर्फ दो भाषाओं तक सीमित है।

— dfeuer

31

Golfscript, 8 7 अक्षर:

{`..&=}

` - तर्क को कठोर करें
.. - क्लोन दो बार
& - खुद के साथ प्रतिच्छेदन (डुप्लिकेट निकालें)
= - समानता के लिए जाँच करें।

यदि फ़ंक्शन का नाम होना चाहिए (109 अक्षर ):

{`..&=}:a

अगर एक कार्यक्रम पर्याप्त है (54 अक्षर ):

..&=

— जॉन ड्वोरक
स्रोत

5

इस तरह की चुनौतियों के बारे में कठिन हिस्सा इसे देखने वाला पहला व्यक्ति है।

— प्रिमो

1

@primo अभी तक, किसी भी तरह, वे अभी भी आधे दिन के भीतर +6 स्कोर प्राप्त करते हैं।

— जॉन ड्वोरक

1

काम पर triviality की @JanDvorak पार्किंसंस कानून

— Claudiu

2

@ कलैयुडू आप कानून को समझ सकते हैं। एहसास है कि आप इसके अधीन हो रहे हैं। फिर उत्तर को वैसे भी बढ़ाएँ।

— क्रंचर

1

@ नथन.आप का क्या मतलब है? अगली (और केवल) समय कि खामियों का सुझाव दिया गया था कि यह अगली सुबह सुझावकर्ता द्वारा हटाए जाने से पहले -3 पर गिर गया। यदि आपको गोल्फस्क्रिप्ट के उत्तर पसंद नहीं हैं, तो उन्हें अपवोट न करें।

— जॉन ड्वोरक

24

अजगर 2 (28) (32)

lambda n:10**len(set(`n`))>n

बैकटिक्स स्ट्रिंग का प्रतिनिधित्व करते हैं। एक सेट में बदलने से डुप्लिकेट हटा दिए जाते हैं, और हम यह जांचते हैं कि क्या यह 10 ^ d की तुलना में लंबाई कम हो जाती है, जो सभी d-अंकों की संख्या से बड़ी है, लेकिन नहीं (d + 1) -digit संख्या।

पुराना कोड:

lambda n:len(set(`n`))==len(`n`)

— XNOR
स्रोत

1

हा मैं इस किया था सटीक एक ही जवाब तैयार, बस बदलने के nसाथi

— Claudiu

1

@ कैलाडु ने ऐसा किया थाf=lambda _:len(`_`)==len(set(`_`))

— ओबेरोन

हाँ, इन काटने के आकार की चुनौतियों के साथ, हर कोई एक ही चीज़ पर बहुत अधिक अभिसरण करने जा रहा है। मैं भी कोशिश कर रहा था lambda n:max(map('n'.count,'n'))<2(एकल उद्धरण बैकटिक्स हैं), लेकिन यह दो वर्णों से अधिक लंबा है।

— xnor

16

एपीएल (6)

≡∘∪⍨∘⍕

एपीएल में भी कुछ समय में टैसिट शैली छोटी है।

इसे नाम देने के लिए 8 अक्षर हैं,

f←≡∘∪⍨∘⍕

लेकिन इसका उपयोग करने के लिए आवश्यक नहीं है:

      ≡∘∪⍨∘⍕ 199
0
      ≡∘∪⍨∘⍕ 198
1
      f←≡∘∪⍨∘⍕
      f¨ 198 199 200 201
1 0 0 1
      ≡∘∪⍨∘⍕¨ 198 199 200 201
1 0 0 1

— मारीनस
स्रोत

1

मुझे लगता है कि दूसरा जॉट इसे बनाने के लिए हटाया जा सकता है। 5. यह अभी भी अपने आप में एक वैध कार्य होगा (हालांकि इसे अंतिम उदाहरण में प्रत्येक ऑपरेटर के साथ उपयोग करने के लिए समूह की आवश्यकता होगी)।

— user46915

11

पर्ल, 19 अक्षर

print<>!~/(\d).*\1/

— ताल
स्रोत

यह मानते हुए कि आउटपुट को सही माना जा सकता है और नो-आउटपुट को झूठा माना जा सकता है। यदि कोई पुनरावृत्ति नहीं है, तो आपको सच लौटना चाहिए।

— जॉन ड्वोरक

@JDDvorak सही के बारे में लगता है। मैं ठीक कर दूँगा।

— ताल

नहीं-मैच ऑपरेटर <>!~/(\d).*\1/:।

— Primo

@primo धन्यवाद! इतना सीखने के लिए :)

— ताल

3

इनपुट को गैर-नकारात्मक पूर्णांक के रूप में निर्दिष्ट किया गया है, इसलिए मुझे नहीं लगता कि आपको इसे सत्यापित करने की आवश्यकता है। आप वास्तव में नहीं करते हैं, आप बदल सकते हैं \dकरने के लिए .।

— HVD

9

Rebmμ (10 अक्षर)

e? AtsAuqA

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

तो यह "अनमश" है:

e? a: ts a uq a

अंतरिक्ष की जरूरत है क्योंकि एक बार जब आप बारी-बारी से चलने वाले मामलों की एक श्रृंखला शुरू कर देते हैं, तो आप पहली बार के बाद सेट-शब्द प्राप्त करने के लिए उस चाल का उपयोग नहीं कर सकते जब तक कि आप एक नया रन शुरू नहीं करते। तो e?AtsAuqAतुम्हें मिल गया होता e? a ts a uq a... कोई काम नहीं।

(नोट: क्या विशेष रूप से अच्छा कारण नहीं हो सकता है के लिए, मैं पुनर्विचार समाधान पसंद करना चाहता हूं ताकि कोई स्थान न हो, अगर चरित्र मायने रखता है। चूंकि कोष्ठक, कोष्ठक, और तार स्पष्ट रूप से एक प्रतीक को समाप्त करते हैं ... अक्सर एक निष्पक्ष होते हैं। इसके लिए अवसरों की संख्या।)

किसी भी स्थिति में, जब इसे संक्षिप्त करने के लिए मैप किया जाता है:

equal? a: to-string a unique a

मूल्यांकन के क्रम में मदद करने के लिए कुछ कोष्ठकों में फेंकना:

equal? (a: (to-string a)) (unique a)

तो उपसर्ग समानता ऑपरेटर को दो तर्कों पर लागू किया जाता है - पहला aस्वयं के स्ट्रिंग संस्करण को असाइन करने का परिणाम है, और दूसरा uniqueउस स्ट्रिंग के खिलाफ चलाए जाने का परिणाम है । ऐसा होता है कि अद्वितीय आपको उसी क्रम में तत्वों को वापस दे देगा जो आपने उन्हें पारित किया था ... उदाहरण के लिए "31214" का अद्वितीय "3124" है।

इसे चलाएं:

>> rebmu/args "e? AtsAuqA" 17308459             
== true

कुछ आँकड़े और डिबग जानकारी भी है:

>> rebmu/args/stats/debug "e? AtsAuqA" 48778584 
Original Rebmu string was: 10 characters.
Rebmu as mushed Rebol block molds to: 10 characters.
Unmushed Rebmu molds to: 15 characters.
Executing: [e? a: ts a uq a]
== false

यदि आवश्यकता यह है कि एक नामांकित / पुन: प्रयोज्य फ़ंक्शन को परिभाषित करना चाहिए, तो आप एक "ए-फ़ंक्शन" बना सकते हैं, जो एक नाम के साथ एक पैरामीटर लेता है a|। (एक बी-फंक्शन के साथ बनाया जाएगा b|और ए नाम के एक पैरामीटर लेगा, जिसका नाम बी होगा। ताकि पांच और चरित्र जुड़ जाएं ... मान लें कि आप फ़ंक्शन को "f" कहते हैं

Fa|[e? AtsAugA]

"आप हँसते हैं! वे आइंस्टीन पर हँसे! या प्रतीक्षा करें ... उन्होंने किया? मैं ... नहीं जानता।"

— डॉ। रीबमू
स्रोत

मुझे लगता है कि करने के लिए भाषा की तरह घोषित कर दिया गया इस्तेमाल किया Reb mooहै, लेकिन अब मुझे यकीन है कि अगर यह माना जाता है नहीं कर रहा हूँ Rebum mewया Reb mewया कुछ और।

— जस्टिन

2

Nethack खेलने के बाद, मैंने पढ़ा है Fa|[e? AtsAugA]के रूप मेंFalse? SomeGibberish

— जस्टिन

@Quincunx sवास्तव [में Nethack में क्षय करता है ?

— जॉन ड्वोरक

@JanDvorak मैंने देखा है कुछ पत्रों में क्षय होता है

— जस्टिन

@Quincunx बस लोगो के साथ खेल रहा है। मुझे लगता REBmuहै कि शायद बेहतर है। किसी भी तरह से, दाढ़ी तंग है .. चुटकी। लगता है कि तुम क्या आप के लिए भुगतान मिलता है।

— डॉ। रीबमु

7

FRACTRAN - 53 38 अंश

47/10 3/5 106/47 3599/54272 53/61 2881/27136 2479/13568 2077/6784 1943/3392 1541/1696 1273/848 1139/424 871/212 737/106 469/53 142/3953 67/71 5/67 1/147 1/363 1/507 1/867 1/1083 1/1587 1/2523 1/2883 1/4107 1/5547 1/7 1/11 1/13 1/17 1/19 1/23 1/29 1/31 1/37 1/43

प्रत्येक अंक की घटनाओं की संख्या की गणना करने के लिए विभाजन का उपयोग करता है। रजिस्टर 2 में n लगाकर कॉल करें और रजिस्टर 5 से 1 सेट करें, रजिस्टर 3 में आउटपुट देता है (0 यदि गलत है, तो 1 सच है)। यह भी सुनिश्चित करें कि आपके कार्यक्रम के बाकी लोग केवल रजिस्टर> 71 का उपयोग करते हैं।

25/12/14 को संपादित करें: यह 7 महीने हो गया है और हमने स्टैक स्निपेट्स प्राप्त कर लिया है, इसलिए यहां कोड का परीक्षण करने के लिए (यहां मेरा बेहतर-बेहतर दुभाषिया का उपयोग करके ) है।

var ITERS_PER_SEC=1E5;var TIMEOUT_MILLISECS=5E3;var ERROR_INPUT="Invalid input";var ERROR_PARSE="Parse error: ";var ERROR_TIMEOUT="Timeout";var ERROR_INTERRUPT="Interrupted by user";var running,instructions,registers,timeout,start_time,iterations;function clear_output(){document.getElementById("output").value="";document.getElementById("stderr").innerHTML=""};function stop(){running=false;document.getElementById("run").disabled=false;document.getElementById("stop").disabled=true;document.getElementById("clear").disabled=false}function interrupt(){error(ERROR_INTERRUPT)}function error(msg){document.getElementById("stderr").innerHTML=msg;stop()}function factorise(n){var factorisation={};var divisor=2;while(n>1){if(n%divisor==0){var power=0;while(n%divisor==0){n/=divisor;power+=1}if(power!=0)factorisation[divisor]=power}divisor+=1}return factorisation};function fact_accumulate(fact1,fact2){for(var reg in fact2)if(reg in fact1)fact1[reg]+=fact2[reg];else fact1[reg]=fact2[reg];return fact1};function exp_to_fact(expression){expression=expression.trim().split(/\s*\*\s*/);var factorisation={};for(var i=0;i<expression.length;++i){var term=expression[i].trim().split(/\s*\^\s*/);if(term.length>2)throw"error";term[0]=parseInt(term[0]);if(isNaN(term[0]))throw"error";if(term.length==2){term[1]=parseInt(term[1]);if(isNaN(term[1]))throw"error";}if(term[0]<=1)continue;var fact_term=factorise(term[0]);if(term.length==2)for(var reg in fact_term)fact_term[reg]*=term[1];factorisation=fact_accumulate(factorisation,fact_term)}return factorisation}function to_instruction(n,d){instruction=[];divisor=2;while(n>1||d>1){if(n%divisor==0||d%divisor==0){reg_offset=0;while(n%divisor==0){reg_offset+=1;n/=divisor}while(d%divisor==0){reg_offset-=1;d/=divisor}if(reg_offset!=0)instruction.push(Array(divisor,reg_offset))}divisor+=1}return instruction};function run(){clear_output();document.getElementById("run").disabled=true;document.getElementById("stop").disabled=false;document.getElementById("clear").disabled=true;timeout=document.getElementById("timeout").checked;var code=document.getElementById("code").value;var input=document.getElementById("input").value;instructions=[];code=code.trim().split(/[\s,]+/);for(i=0;i<code.length;++i){fraction=code[i];split_fraction=fraction.split("/");if(split_fraction.length!=2){error(ERROR_PARSE+fraction);return}numerator=parseInt(split_fraction[0]);denominator=parseInt(split_fraction[1]);if(isNaN(numerator)||isNaN(denominator)){error(ERROR_PARSE+fraction);return}instructions.push(to_instruction(numerator,denominator))}try{registers=exp_to_fact(input)}catch(err){error(ERROR_INPUT);return}running=true;iterations=0;start_time=Date.now();fractran_iter(1)};function regs_to_string(regs){reg_list=Object.keys(regs);reg_list.sort(function(a,b){return a-b});out_str=[];for(var i=0;i<reg_list.length;++i)if(regs[reg_list[i]]!=0)out_str.push(reg_list[i]+"^"+regs[reg_list[i]]);out_str=out_str.join(" * ");if(out_str=="")out_str="1";return out_str};function fractran_iter(niters){if(!running){stop();return}var iter_start_time=Date.now();for(var i=0;i<niters;++i){program_complete=true;for(var instr_ptr=0;instr_ptr<instructions.length;++instr_ptr){instruction=instructions[instr_ptr];perform_instr=true;for(var j=0;j<instruction.length;++j){var reg=instruction[j][0];var offset=instruction[j][1];if(registers[reg]==undefined)registers[reg]=0;if(offset<0&&registers[reg]<-offset){perform_instr=false;break}}if(perform_instr){for(var j=0;j<instruction.length;++j){var reg=instruction[j][0];var offset=instruction[j][1];registers[reg]+=offset}program_complete=false;break}}if(program_complete){document.getElementById("output").value+=regs_to_string(registers);stop();return}iterations++;if(timeout&&Date.now()-start_time>TIMEOUT_MILLISECS){error(ERROR_TIMEOUT);return}}setTimeout(function(){fractran_iter(ITERS_PER_SEC*(Date.now()-iter_start_time)/1E3)},0)};

<div style="font-size:12px;font-family:Verdana, Geneva, sans-serif;"><div style="float:left; width:50%;">Code:<br><textarea id="code" rows="4" style="overflow:scroll;overflow-x:hidden;width:90%;">47/10 3/5 106/47 3599/54272 53/61 2881/27136 2479/13568 2077/6784 1943/3392 1541/1696 1273/848 1139/424 871/212 737/106 469/53 142/3953 67/71 5/67 1/147 1/363 1/507 1/867 1/1083 1/1587 1/2523 1/2883 1/4107 1/5547 1/7 1/11 1/13 1/17 1/19 1/23 1/29 1/31 1/37 1/43</textarea><br>Input:<br><textarea id="input" rows="2" style="overflow:scroll;overflow-x:hidden;width:90%;">2^142857 * 5</textarea><p>Timeout:<input id="timeout" type="checkbox" checked="true"></input></p></div><div style="float:left; width:50%;">Output:<br><textarea id="output" rows="6" style="overflow:scroll;width:90%;"></textarea><p><input id="run" type="button" value="Run" onclick="run()"></input><input id="stop" type="button" value="Stop" onclick="interrupt()" disabled="true"></input><input id="clear" type="button" value="Clear" onclick="clear_output()"></input>&nbsp;<span id="stderr" style="color:red"></span></p></div></div>

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

142857दूसरे नंबर से बदलें । उत्पादन 3^1सही होना चाहिए , 1 = 3^0अगर गलत है। बड़ी संख्या के लिए कुछ समय लगता है (अच्छी तरह से, यह है FRACTRAN ...)।

— Sp3000
स्रोत

6

जावास्क्रिप्ट - 23 वर्ण

एक समारोह के रूप में (ECMAScript 6):

f=x=>!/(.).*\1/.test(x)

या एक संकेत से इनपुट (25 अक्षर)

!/(.).*\1/.test(prompt())

— MT0
स्रोत

6

C # 73 60 59

मेरे लिए पहला गोल्फ ...

एक फ़ंक्शन लिखें जो इनपुट के रूप में एक नॉनजेटिव पूर्णांक लेता है

bool f(int i){return(i+"").Distinct().SequenceEqual(i+"");}

में परिवर्तित करके एक और चरित्र को छीन सकता uintहै int, लेकिन मैं कार्य को सचमुच में अन्य तरीकों से भी लेता हूं। ये रहा ...

— न्यूमेरिकल लॉक
स्रोत

1

कुछ विकल्प:i => (i + "").Distinct().SequenceEqual(i + "");

— NPSF3000

@ NPSF3000 धन्यवाद! मेरे उत्तर का संपादन किया। मेरे दिमाग में कुछ ऐसा था, लेकिन अच्छी तरह से ... मैं हुड के नीचे +""कॉल करने ToString()के बारे में पूरी तरह से भूल गया ।

— अंक लॉक

"Nonnegative पूर्णांक" की एक अधिक शाब्दिक व्याख्या बताती है कि एक हस्ताक्षरित पूर्णांक में पारित किया जाएगा, लेकिन यह कभी भी नकारात्मक नहीं होगा।

— शाज़

ठीक है, मुझे लगता है कि यह ठीक हो जाएगा ...

— न्यू लॉक

C # 6 का उपयोग करें और आप उपयोग कर सकते हैं: bool f (int i) => (i + "")। Distinct ()। SequenceEqual (i + ""); (53 बाइट्स)

— Stephan Schinkel

5

रूबी (24 बाइट्स)

"कुछ वर्ण, उसके बाद शून्य या अधिक वर्ण, फिर उसी वर्ण" से मेल खाने के लिए एक नियमित अभिव्यक्ति का उपयोग करें।

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

यदि सत्य या मिथ्या मूल्यों को शाब्दिक trueया के बजाय स्वीकार किया जाता है false, तो हमें 20 वर्ण मिलते हैं:

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

— जॉन फेमिनाला
स्रोत

5

सी (87)

चूंकि मैं जीत नहीं सकता, मैं दक्षता के लिए जाऊंगा।

समारोह कोड:

int u(uint32_t d){short s=0,f;while(d){f=1<<d%10;if(s&f)return 0;s|=f;d/=10;}return 1;}

— DreamWarrior
स्रोत

ओह, और जब से मैं अभी भी अन्य लोगों के पोस्ट पर टिप्पणी नहीं कर सकता हूं - मैं यह कहना चाहता हूं कि यह एक साफ समाधान था, भले ही यह "गलत" होने पर गलत हो।

— ड्रीमवर्यर

5

गणितज्ञ, 35 25 वर्ण

(27 यदि फ़ंक्शन को नाम की आवश्यकता है।)

Unequal@@IntegerDigits@#&

संपादित करें: विश्वासी के लिए 8 वर्ण सहेजे गए!

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

Unequal @@ IntegerDigits@# &मैं कर सकता था, मुझे लगता है

— डॉ। बेलीज़ेरियस

@belisarius ओह अच्छा, मैं ऐसा कुछ ढूंढ रहा था, लेकिन वह नहीं मिला (और यह नहीं सोचा था कि जंजीर ≠गैर-आसन्न तत्वों की तुलना करेगा)। धन्यवाद, यह एक बहुत छोटा!

— मार्टिन एंडर

आपको इसे कोई नाम नहीं देना है, है ना? Unequal@@IntegerDigits@#&25 अक्षर है।

— अकाटर

@ सच, मैं चुनौती में नाम की आवश्यकता नहीं देख सकता। धन्यवाद!

— मार्टिन एंडर

5

आर, 53 51 48 34 बाइट्स

function(n)!grepl("(.).*\\1",n,,T)

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

एक स्ट्रिंग में परिवर्तित करें और विभाजित करें। संख्या 1, योग और ऋण की तालिका में कनवर्ट करें

~~एलेक्स द्वारा सबसे आम संख्या के जवाब से प्रेरित और ह्यूग द्वारा सुझाव।~~

एक जोड़े ने @plannapus को धन्यवाद दिया, @Gregor से एक और एक जोड़े ने इसे एक अनाम फ़ंक्शन बनाने से बचाया

अब @JDoe के लिए अद्भुत रेगेक्स अच्छाई के साथ। यह संख्या में किसी भी एकल चार के लिए दिखता है जो स्ट्रिंग में खुद से और कहीं मेल खाता है। greplआदेश एक तार्किक है कि तब दिया जाता है देता है। पर्ल स्टाइल रेगेक्स ट्रू पर सेट है।

— MickyT
स्रोत

आप 2 वर्णों को सहेजने और सहेजने के paste0बजाय स्ट्रिंग में भी परिवर्तित कर सकते हैं toString।

— प्लेनैपस

आप एक और चरित्र को बचाने के pasteबजाय उपयोग कर सकते हैं paste0।

— ग्रेगर

Utf8ToInt का उपयोग कर 45 बाइट्स

— digEmAll

@ J.Doe: और भी बेहतर! :)

— डाइजेक्जेल

एक अलग दृष्टिकोण का उपयोग किया। रेगेक्स के साथ 35 बाइट्स ।

— जे। सेप

4

जे (9)

मान लिया गया है कि परीक्षण किया जा b ~~रहा है~~ चर में है (मुझे पता है कि यह एक समारोह में बनाया जा सकता है, लेकिन इस बात पर कोई सुराग नहीं है ~~। जम्मू~~ ~~कैसे~~ ~~भ्रमित है। इस पर कोई मदद की सराहना की जाती है)~~ धन्यवाद मारिनस!

(-:~.)@":

यह जांचता है कि हटाए गए सभी डुप्लिकेट के साथ संख्या के स्ट्रिंग प्रतिनिधि का लैंथ नियमित स्ट्रिंग प्रतिनिधि के समान है।

— ɐɔıʇǝɥʇuʎs
स्रोत

एक फ़ंक्शन के लिए आप कर सकते हैं (-:~.)@":।

— मारीनस

@marinus ओह वाह, यह मेरे विचार से भी छोटा है। धन्यवाद!

— atı

HI, मैंने एक छोटा J हल ढूंढा और पोस्ट किया: -: ~ ~। "।:

— Galen Ivanov

4

आर ( 70 , 60 , 53 , 52)

उपयोगी टिप्पणियों के लिए आप सभी का धन्यवाद! आपकी टिप्पणियाँ उत्तर में शामिल हैं।

### Version 70 chars
f=function(x)!any(duplicated(strsplit(as.character(x),split="")[[1]]))

### Version 60 chars
f=function(x)all(table(strsplit(as.character(x),"")[[1]])<2)

### Version 53 chars
f=function(x)all(table(strsplit(paste(x),"")[[1]])<2)

### Version 52 chars
f=function(x)all(table(strsplit(c(x,""),"")[[1]])<2)

f(48778584)
f(17308459)

— djhurio
स्रोत

@plannapus, आप सही हैं। मैं "बेस 10 प्रतिनिधित्व" के बारे में भ्रमित हो गया।

— djhurio

1

तालिका का उपयोग करना और डुप्लिकेट के बजाय 0 के खिलाफ तुलना करने से कुछ पात्रों को बचाया जा सकता है

— दासोन

1

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

— डेसन

1

और जब से आप पहले से ही परिणाम का पहला तत्व ले रहे हैं, तो strsplitx का उपयोग करने वाले वर्ण के साथ क्यों नहीं किया जाता c(x,"")? f=function(x)all(table(strsplit(c(x,""),"")[[1]])<2)1 वर्ण छोटा है :)

— प्लेनैपस

3

गणितज्ञ (20 19)

(22 21 यदि फ़ंक्शन को नाम की आवश्यकता है)

Max@DigitCount@#<2&

या

Max@DigitCount@#|1&

कहाँ | ist को [Esc] विभाजित किया जाता है [Esc]

— ब्रैन्स्लाव
स्रोत

अच्छा लगा। मैं डिजिटाउंट को भूल गया, और स्ट्रिंग्स में रूपांतरण के आधार पर एक समाधान लिखा। तुम्हारा बहुत बेहतर है।

— माइकल स्टर्न

3

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

≠

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

— आउटगोल्फर को एरिक करें
स्रोत

2

C99, 59 वर्ण

a(x){int r=1,f[10]={};for(;x;x/=10)r&=!f[x%10]++;return r;}

— थॉमस
स्रोत

तकनीकी रूप से C99 का निहितार्थ नहीं है।

— पैट्रिकबी

1

न केवल "तकनीकी रूप से", यह विशेष रूप से और जानबूझकर हटा दिया गया था। यह C99 में एक सिंटैक्स त्रुटि है, और एक आवश्यक निदान से अलग, सिंटैक्स त्रुटियां एक ही श्रेणी में अपरिभाषित व्यवहार (प्रश्न में स्पष्ट रूप से अस्वीकृत) के रूप में हैं: यदि कोई कार्यान्वयन इसे स्वीकार करता है, तो मानक को कोई आवश्यकता नहीं है जो प्रोग्राम के व्यवहार के बारे में कुछ भी कहता है।

— hvd

2

ग्रूवी (36 वर्ण)

f={s="$it" as List;s==s.unique(!1)}

इसका उपयोग करके परीक्षण किया गया:

println f(args[0].toInteger())

— विल एल.पी.
स्रोत

'झूठी' को '1 == 0' या संभवत: कुछ अधिक चतुर के माध्यम से गढ़ा जा सकता है। अच्छा जवाब

— माइकल ईस्टर

@MichaelEaster 0>1छोटा है।

— ace_HongKongIndोसेंडेंस

1

@ace हां, हालांकि! 1 भी काम करता है ...

— माइकल ईस्टर

@ace, माइकलएस्टर, मदद के लिए thx :-)

— Lp होगा

माइकलपस्टर द्वारा सुझाए गए के अनुसार ,illillP !1इसके बजाय उपयोग करें ।

— ace_HongKongIndोसेंस

2

हास्केल:

 import Data.List

 all ((== 1) . length) . group . sort . show

— पॉल जॉनसन
स्रोत

पार्टी के लिए थोड़ा देर से, लेकिन जब से आप Data.Listवैसे भी आयात कर रहे हैं nub, तो मैं सुझाव दूंगा , जो एक सूची से डुप्लिकेट को हटा देता है। (\x->nub x==x).show

— फ्लोंक

आपने pl का उपयोग नहीं किया ...main = interact $ show . ap (==) nub . show

— kazagistar

2

जे (8)

मेरे पिछले उत्तर से अलग।

*/@~:@":

— ɐɔıʇǝɥʇuʎs
स्रोत

2

आर, 66 65 वर्ण

f=function(x)!sum(duplicated((x%%10^(i<-1:nchar(x)))%/%10^(i-1)))

पूर्णांक विभाजन और मोडुलो का उपयोग करके अंकों को अलग करें, फिर जांचें कि क्या वे डुप्लिकेट हैं।

उपयोग:

> f(48778584)
[1] FALSE
> f(17308459)
[1] TRUE

या, जैसा कि @MickyT ने सुझाया है, 63 वर्णों के लिए:

f=function(x)!anyDuplicated((x%%10^(i<-1:nchar(x)))%/%10^(i-1))

— plannapus
स्रोत

1

आप इसके anyDuplicatedबजाय sumऔर duplicated2 के लिए उपयोग कर सकते हैं

— मिकी

2

सी, 58 बाइट्स

f;a(x){for(f=0;x;x/=10)f+=1<<x%10*3;return!(f&920350134);}

लुढ़कने से पहले 7 समान अंकों का मिलान रख सकते हैं।

परीक्षण कार्यक्रम में (यह देखना आसान है कि यह अष्टक में स्थिर के साथ कैसे काम करता है)

a(x){int f=0;for(;x;x/=10)f+=1<<x%10*3;return!(f&06666666666);}

main(){
scanf("%d",&r);
printf("%o\n",a(r));}

यदि आपके पास 2 की एक बड़ी शक्ति है तो स्थिरांक की गणना की जा सकती है f&(1<<30)/7*6

— स्तर नदी सेंट
स्रोत

मुझे लगता है कि @xfix की टिप्पणी आपकी जगह मेरी पोस्ट के लिए थी? आपने वास्तव int main(int)में अपने उत्तर में उपयोग नहीं किया ...

— ace_HongKongIndependence

बाहरी जानकारी जो कोड बाइट / चार की गिनती की ओर नहीं होती है, जाहिर तौर पर अनुमति नहीं है। मेरा सुझाव है कि आप पहले संस्करण (53 बाइट्स) को हटा दें।

— 2501

कृपया मेरी टिप्पणी को संपादित सारांश में देखें ।

— 2501

मैंने संपादन को अस्वीकार करने के लिए मतदान किया, लेकिन मैं मानता हूं कि गिनती गलत दिखती है। मैं उन्हें 67 और 63 (61) कर देता हूं।

— पीटर टेलर

मेरे संपादन को अन्य उपयोगकर्ताओं द्वारा अस्वीकार कर दिया गया था। कृपया इसका पुनर्मूल्यांकन करें।

— 2501

2

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

import Data.List
((==)=<<nub).show

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

— OVS
स्रोत

1

जावास्क्रिप्ट 73 वर्ण

function f(n){return !~(n+'').split('').sort().join('').search(/(\d)\1/)}

— pllee
स्रोत

1

Befunge 98, 17 बाइट्स

यह एक गैर-प्रतिस्पर्धात्मक उत्तर है क्योंकि Befunge में फ़ंक्शन नहीं हैं।

~:1g1`j@1\1p3j@.1

प्रिंट 1यदि संख्या के अंक सभी अद्वितीय हैं; अन्यथा, यह समाप्त होता है।

यह फ़ंज स्पेस में एक सेल तक पहुँच कर काम करता है जिसका xनिर्देशांक इनपुट किए गए वर्ण का ASCII मान है (वर्ण द्वारा इनपुट चरित्र लेता है) और जिसका yसमन्वय है 1। यदि अंक पहले नहीं देखा गया है, तो सेल का मान 32(स्पेस कैरेक्टर) है। यदि ऐसा है, तो मैं 1 पर मान सेट करता हूं।

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

— जस्टिन
स्रोत

1

पॉवरशेल - 26

!($args|sls '(.)(?=.*\1)')

— Rynant
स्रोत

1

पर्ल 6 (19 बाइट्स)

{.comb.uniq==.comb}

.combवर्णों में एक स्ट्रिंग को विभाजित करता है (उदाहरण के लिए, 42.combदेता है "4", "2")। .uniqसभी गैर-अद्वितीय वर्णों को निकालता है। .combस्ट्रिंग में वर्ण (मूल रूप से मैंने इस्तेमाल किया था .chars, लेकिन .combकम है)। ==इसमें सूचियों को तत्वों की संख्या में परिवर्तित करता है, और संख्याओं की तुलना करता है। जब .पहले ऑब्जेक्ट के बिना उपयोग किया जाता है, $_जो डिफ़ॉल्ट फ़ंक्शन पैरामीटर माना जाता है। {}फ़ंक्शन शाब्दिक हैं।

— कोनराड बोरोस्की
स्रोत

1

सी, 76

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

c;i;a[99];main(){while(~(c=getchar()))a[c]++;for(;i<99;)a[i++]>1&&puts("");}

अगर झूठी है तो एक नई लाइन छापती है, अगर सच है तो कुछ नहीं छापती।

— ace_HongKongIndependence
स्रोत

इस कार्यक्रम में एक अपरिभाषित व्यवहार है। मुख्य के लिए सही हस्ताक्षर हैं int main(int, char **)या int main(void)। int main(int)मान्य नहीं है।

— कोनराड बोरोस्की

@ मुझे लगता main()है कि तब ठीक है?

— ace_HongKongInd डिपेंडेंस

हां यह ठीक है। इसका मतलब वही है main(void)(जब परिभाषा में उपयोग किया जाता है, तो घोषणा में यह अज्ञात पैरामीटर सूची के साथ एक फ़ंक्शन घोषित करता है)।

— कोनराड बोरोस्की

1

POSIX sh और egrep ( 47 , 43 , 40)

f()([ ! `echo $1|egrep '([0-9]).*\1'` ])

[-1 चार]: उपयोग !के बजाय -zसाथ test- धन्यवाद DigitalTrauma
[-1 चार]:`CODE` इसके बजाय का उपयोग करें $(CODE)- धन्यवाद डिजिटलट्रूमा
[-2 वर्ण]: ^{^{_{1 के}}}fold -1 बजाय का उपयोग करें - धन्यवाद DigitalTrauma।grep -o .
[-3 वर्ण]: एक नियमित संदर्भ के साथ एक बार-बार अंक के लिए जाँच करें।

यदि POSIX अनुपालन महत्वपूर्ण नहीं echo PARAM |है <<<PARAM, तो इसे कार्य की लंबाई को घटाकर 37 तक किया जा सकता है :

f()([ ! `egrep '([0-9]).*\1'<<<$1` ])

उपयोग:

$ if f 48778584; then echo true; else echo false; fi
false
$ if f 17308459; then echo true; else echo false; fi
true

^{^₁} _{^{अंकन के कुछ संस्करणों में हटा दिया गया है}}_^।_{^{fold -Nfold}}

— थोर
स्रोत

f()(! [ `fold -1<<<$1|sort|uniq -d` ])मेरी गिनती से 38 तक नीचे

— डिजिटल ट्रामा

@DigitalTrauma: साझा करने के लिए अच्छा सामान धन्यवाद। मुझे लगता है कि परीक्षण किए गए आदेश को उद्धृत किया जाना चाहिए, अन्यथा एक पंक्ति से अधिक रिटर्न testहोने पर उस पर क्रॉक किया जाता है uniq -d। तो सबसे छोटा गैर-पॉसिक्स संस्करण 40 वर्णों का है। मैं [ !संकेतन के बारे में जानता हूं , लेकिन मैं आश्चर्यचकित हूं कि ! [यह भी काम करता है, क्या आप जानते हैं कि ऐसा क्यों है?

— थोर

आह मैं बैश का उपयोग कर रहा था। यदि आप POSIX अनुरूपता चाहते हैं तो मुझे इसका अनुमान है।

— डिजिटल ट्रामा

1

जावा ( 131 59 57)

57 अक्षर:

निकाले गए ^ और $ as @ n̴̖̋h̷͉̃a andh̷̰̀ĥ̷̳d। ने सुझाव दिया

boolean u(int n){return !(n+"").matches(".*(.).*\\1.*");}

59 अक्षर (नकारात्मक संख्या के साथ भी काम करता है!):

boolean u(int n){return !(n+"").matches("^.*(.).*\\1.*$");}

79 78 वर्ण (धन्यवाद @ n̴̖̋h̷͉̃a charactersh̷̰̀ĥ̷̳d:):

लूप के लिए कुछ सारसों को बचाने के लिए उपयोग करें और बूलियन सरणी के रूप में int का उपयोग करें।

1 वर्ण को बचाने के लिए && के बजाय & का उपयोग करें (यह पता चलता है कि जावा इसे अनुमति देता है)।

boolean u(int n){for(int x=0;n>0&(x>>n%10&1)==0;n/=10)x|=1<<n%10;return n==0;}

131 वर्ण (ऋणात्मक संख्याओं के लिए सही है):

boolean u(int n){int[] p=new int[]{2,3,5,7,11,13,17,19,32,29};double a=9001312320D;while(n>0){a/=p[n%10];n/=10;}return (long)a==a;}

टिप्पणियों के साथ:

boolean unique(int n){
    int[] p=new int[]{2,3,5,7,11,13,17,19,32,29};//list of 10 first primes
    double a=9001312320D;//10 first primes multiplied
    while(n>0){
        a/=p[n%10];//divide by (n%10+1)th prime
        n/=10;//divide n by 10, next digit
    }
    return (long)a==a;//if a is integer then n has all digits unique
}

और जवाब है कि तकनीकी रूप से सही है (वर्ण गणना में केवल फ़ंक्शन शामिल है, वैश्विक चर नहीं), लेकिन मुझे लगता है कि यह धोखा दे रहा है, 29 वर्ण:

boolean u(int i){return m[i];}

एम [] बूलियन सरणी है जिसमें सभी 32-बिट पूर्णांक के लिए सही उत्तर हैं।

— barteks2x
स्रोत

"^.*(.).*\\1.*$"आप ड्रॉप कर सकते हैं ^और $। उनके द्वारा निहित हैmatches()

— n̴̖̋h̷͉̃a implh̷̰̀ĥ̷̳d

2 दृष्टिकोण को एक बूलियन सरणी के रूप में एक इंट में 10 बिट्स का उपयोग करके किया जा सकता है, जो प्राइम टेबल की आवश्यकता को समाप्त कर देगा।

— n --h'a̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳

मुझे पता है कि तीन साल हो गए हैं, लेकिन अगर आप return!सबसे कम उत्तर के बीच के स्थान को हटाते हैं , तो आप 56 बाइट्स प्राप्त कर सकते हैं।

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

निर्धारित करें कि क्या सभी दशमलव अंक अद्वितीय हैं

Golfscript, 8 7 अक्षर:

अजगर 2 (28) (32)

एपीएल (6)

पर्ल, 19 अक्षर

Rebmμ (10 अक्षर)

FRACTRAN - 53 38 अंश

जावास्क्रिप्ट - 23 वर्ण

C # 73 60 59

रूबी (24 बाइट्स)

सी (87)

गणितज्ञ, 35 25 वर्ण

आर, 53 51 48 34 बाइट्स

जे (9)

आर ( 70 , 60 , 53 , 52)

गणितज्ञ (20 19)

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

C99, 59 वर्ण

ग्रूवी (36 वर्ण)

जे (8)

आर, 66 65 वर्ण

सी, 58 बाइट्स

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

Befunge 98, 17 बाइट्स

पॉवरशेल - 26

पर्ल 6 (19 बाइट्स)

सी, 76

POSIX sh और egrep ( 47 , 43 , 40)

जावा ( 131 59 57)

57 अक्षर:

59 अक्षर (नकारात्मक संख्या के साथ भी काम करता है!):

79 78 वर्ण (धन्यवाद @ n̴̖̋h̷͉̃a charactersh̷̰̀ĥ̷̳d:):

131 वर्ण (ऋणात्मक संख्याओं के लिए सही है):