जांचें कि क्या कोई यूयूआईडी रेगेक्स का उपयोग किए बिना वैध है

Question

एक स्ट्रिंग इनपुट को देखते हुए, एक प्रोग्राम लिखें जो कि रिजेक्स का उपयोग किए बिना इनपुट मान्य UUID है, तो STDOUT या समकक्ष के लिए एक सत्य मान प्रिंट करता है ।

एक वैध यूयूआईडी है

32 हेक्साडेसिमल अंक, हाइफ़न द्वारा अलग किए गए पांच समूहों में प्रदर्शित किए गए, कुल 36 वर्णों (32 अल्फ़ान्यूमेरिक वर्ण और चार हाइफ़न) के लिए 8-4-4-4-12 के रूप में।

_{स्रोत}

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

0FCE98AC-1326-4C79-8EBC-94908DA8B034
    => true
00000000-0000-0000-0000-000000000000
    => true
0fce98ac-1326-4c79-8ebc-94908da8b034
    => true
0FCE98ac-1326-4c79-8EBC-94908da8B034
    => true

{0FCE98AC-1326-4C79-8EBC-94908DA8B034}
    => false (the input is wrapped in brackets)
0GCE98AC-1326-4C79-8EBC-94908DA8B034
    => false (there is a G in the input)
0FCE98AC 1326-4C79-8EBC-94908DA8B034
    => false (there is a space in the input)
0FCE98AC-13264C79-8EBC-94908DA8B034
    => false (the input is missing a hyphen)
0FCE98AC-13264-C79-8EBC-94908DA8B034
    => false (the input has a hyphen in the wrong place)
0FCE98ACD-1326-4C79-8EBC-94908DA8B034
    => false (one of the groups is too long)
0FCE98AC-1326-4C79-8EBC-94908DA8B034-
    => false (has a trailing hyphen)
0FCE98AC-1326-4C79-8EBC-94908DA8B034-123
    => false (too many groups)
0FCE98AC13264C798EBC94908DA8B034
    => false (there is no grouping)

नियम

• नियमित अभिव्यक्ति की अनुमति नहीं है
• शाब्दिक पैटर्न मिलान जो एक रेगेक्स की तरह है, की अनुमति नहीं है। उदाहरण के लिए, [0-9a-fA-F]हेक्साडेसिमल आइडेंटिवर्स (हम इसे कॉल करेंगे n) nnnnnnnn-nnnn-nnnn-nnnn-nnnnnnnnnnnnया फिर मिलान या उपयोग करने n[8]-n[4]-n[4]-n[4]-n[12]की अनुमति नहीं है
• इनपुट या तो STDINकिसी फ़ंक्शन से तर्क के रूप में लिया जा सकता है
• इनपुट असंवेदनशील है
• यह मान लेना सुरक्षित है कि इनपुट में लाइनफीड या न्यूलाइन नहीं होंगे ।
• इनपुट में किसी भी मुद्रण योग्य ASCII वर्ण (रिक्त स्थान शामिल) हो सकते हैं
• यदि एक वैध यूआईडी है, तो एक सत्य मान को मुद्रित STDOUTया समकक्ष होना चाहिए
• एक falsey मूल्य के लिए मुद्रित किया जाना चाहिए STDOUTया समकक्ष यदि इनपुट है नहीं एक वैध UUID
• यदि फ़ंक्शन का उपयोग किया जाता है STDOUT, तो उपयोग करने के बजाय , आउटपुट फ़ंक्शन का रिटर्न मान हो सकता है
• सत्य / गलत मूल्य को मुद्रित नहीं किया जा सकता है STDERR।
• मानक खामियां लागू होती हैं
• यह कोड-गोल्फ है , इसलिए बाइट्स में सबसे छोटा कार्यक्रम जीत जाता है। सौभाग्य!

लीडरबोर्ड

यह एक स्टैक स्निपेट है जो लीडरबोर्ड और भाषा द्वारा विजेताओं के अवलोकन दोनों को उत्पन्न करता है।

अपने उत्तर को सुनिश्चित करने के लिए, कृपया निम्नलिखित मार्काडाउन टेम्पलेट का उपयोग करके अपना उत्तर शीर्षक से शुरू करें

## Language Name, N bytes

जहाँ N आकार में है, बाइट्स में, आपके सबमिशन का

यदि आप अपने हेडर में कई संख्याओं को शामिल करना चाहते हैं (उदाहरण के लिए, पुराने स्कोर के माध्यम से, या बाइट काउंट में झंडे सहित), तो बस यह सुनिश्चित कर लें कि वास्तविक शीर्षक आपके हेडर में अंतिम संख्या है।

## Language Name, <s>K</s> X + 2 = N bytes

var QUESTION_ID=66496;var OVERRIDE_USER=20634;function answersUrl(e){return"//api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(e,s){return"//api.stackexchange.com/2.2/answers/"+s.join(";")+"/comments?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){answers.push.apply(answers,e.items),answers_hash=[],answer_ids=[],e.items.forEach(function(e){e.comments=[];var s=+e.share_link.match(/\d+/);answer_ids.push(s),answers_hash[s]=e}),e.has_more||(more_answers=!1),comment_page=1,getComments()}})}function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){e.items.forEach(function(e){e.owner.user_id===OVERRIDE_USER&&answers_hash[e.post_id].comments.push(e)}),e.has_more?getComments():more_answers?getAnswers():process()}})}function getAuthorName(e){return e.owner.display_name}function process(){var e=[];answers.forEach(function(s){var r=s.body;s.comments.forEach(function(e){OVERRIDE_REG.test(e.body)&&(r="<h1>"+e.body.replace(OVERRIDE_REG,"")+"</h1>")});var a=r.match(SCORE_REG);a&&e.push({user:getAuthorName(s),size:+a[2],language:a[1],link:s.share_link})}),e.sort(function(e,s){var r=e.size,a=s.size;return r-a});var s={},r=1,a=null,n=1;e.forEach(function(e){e.size!=a&&(n=r),a=e.size,++r;var t=jQuery("#answer-template").html();t=t.replace("{{PLACE}}",n+".").replace("{{NAME}}",e.user).replace("{{LANGUAGE}}",e.language).replace("{{SIZE}}",e.size).replace("{{LINK}}",e.link),t=jQuery(t),jQuery("#answers").append(t);var o=e.language;/<a/.test(o)&&(o=jQuery(o).text()),s[o]=s[o]||{lang:e.language,user:e.user,size:e.size,link:e.link}});var t=[];for(var o in s)s.hasOwnProperty(o)&&t.push(s[o]);t.sort(function(e,s){return e.lang>s.lang?1:e.lang<s.lang?-1:0});for(var c=0;c<t.length;++c){var i=jQuery("#language-template").html(),o=t[c];i=i.replace("{{LANGUAGE}}",o.lang).replace("{{NAME}}",o.user).replace("{{SIZE}}",o.size).replace("{{LINK}}",o.link),i=jQuery(i),jQuery("#languages").append(i)}}var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk",answers=[],answers_hash,answer_ids,answer_page=1,more_answers=!0,comment_page;getAnswers();var SCORE_REG=/<h\d>\s*([^\n,]*[^\s,]),.*?(-?\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/,OVERRIDE_REG=/^Override\s*header:\s*/i;

body{text-align:left!important}#answer-list,#language-list{padding:10px;width:290px;float:left}table thead{font-weight:700}table td{padding:5px}

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script> <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"> <div id="answer-list"> <h2>Leaderboard</h2> <table class="answer-list"> <thead> <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr></thead> <tbody id="answers"> </tbody> </table> </div><div id="language-list"> <h2>Winners by Language</h2> <table class="language-list"> <thead> <tr><td>Language</td><td>User</td><td>Score</td></tr></thead> <tbody id="languages"> </tbody> </table> </div><table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table> <table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table>

Comments

बेचारा रेटिना । डी:

— ब्रेनसैट

संबंधित

— FryAmTheEggman

केवल संदर्भ के लिए, मैं 28-बाइट रेटिना समाधान के साथ आ सकता हूं । (तो गोल्फ भाषाओं पर एक पागल लाभ नहीं है, हालांकि यह वर्तमान में अग्रणी होगा।)

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

क्या लुआ के पैटर्न की अनुमति है? वे निश्चित रूप से नियमित अभिव्यक्ति नहीं हैं।

— मैनेटवर्क

@JacobKrall मुझे पूरा यकीन है कि यह आपके सभी सवालों के लिए "गलत" है। मुझे लगता है कि चुनौती पूरी तरह से स्पष्ट है कि केवल फॉर्म के तार \h{8}-\h{4}-\h{4}-\h{4}-\h{12}(जहां \hएक हेक्साडेसिमल अंक है) मान्य हैं।

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

Answer 1

CJam, 31 30 29 बाइट्स

8 4__C]Nf*'-*qA,s'G,_el^+Ner=

सभी परीक्षण मामलों को यहां चलाएँ।

व्याख्या

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

8 4__C] e# Push the array of segment lengths, [8 4 4 4 12].
Nf*     e# Turn that into strings of linefeeds of the given length.
'-*     e# Join them by hyphens, giving "NNNNNNNN-NNNN-NNNN-NNNN-NNNNNNNNNNNN".
q       e# Read the input.
A,s     e# Push the string "0123456789".
'G,_el^ e# Push the string "ABCDEFabcdef".
+       e# Concatenate the two strings.
N       e# Push a linefeed.
er      e# Replace all hexadecimal digits with linefeeds.
=       e# Check for equality with the pattern string.

Answer 2

जावास्क्रिप्ट ईएस 6, 73 55 56 वर्ण

s=>s.split`-`.map(x=>x.length+`0x${x}0`*0)=="8,4,4,4,12"

पिछले 55 वर्ण संस्करण में समूह में अनुगामी रिक्त स्थान की समस्या है:

s=>s.split`-`.map(x=>x.length+("0x"+x)*0)=="8,4,4,4,12"
// "00000000-0000-0000-000 -000000000000" true

परीक्षा:

f=s=>s.split`-`.map(x=>x.length+`0x${x}0`*0)=="8,4,4,4,12"
;`0FCE98AC-1326-4C79-8EBC-94908DA8B034
0fce98ac-1326-4c79-8ebc-94908da8b034
0FCE98ac-1326-4c79-8EBC-94908da8B034
0GCE98AC-1326-4C79-8EBC-94908DA8B034
0FCE98AC-13264C79-8EBC-94908DA8B034
0FCE98AC-13264-C79-8EBC-94908DA8B034
0FCE98ACD-1326-4C79-8EBC-94908DA8B034
0FCE98AC-1326-4C79-8EBC-94908DA8B034-123
00000000-0000-0000-0000-000000000000
D293DBB2-0801-4E60-9141-78EAB0E298FF
0FCE98AC-1326-4C79-8EBC-94908DA8B034-
00000000-0000-0000-000 -000000000000`.split(/\n/g).every(s=>f(s)==/^[0-9A-F]{8}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{12}$/i.test(s))

Comments

बहुत बढ़िया (और मेरे लिए

— मुरझाया

@ edc65, "विरलिंग" से आपका क्या अभिप्राय है?

— Qwertiy

अंतर्निहित कास्टिंग +1 का भयानक दुरुपयोग

— 1

अपमानजनक, अवमानना, अपमानजनक, चुभने वाला, विनाशकारी, अपमानजनक, नश्वर बनाने वाला - (मेरे जवाब की मेरी तुलना करें)

— edc65

Answer 3

पॉवरशेल, 29 21 84 49 37 बाइट्स

param($g)@{36=$g-as[guid]}[$g.length]

बदलते नियमों के साथ रखने के लिए इस गोल्फिंग की सहायता करने वाली टिप्पणियों में लोगों को बहुत धन्यवाद - TessellatingHeckler , iFreilicht , Jacob Krall , और Joey । कृपया संशोधन और पुराने संस्करणों के लिए संपादित इतिहास देखें।

यह संशोधन इनपुट के रूप में लेता है $g, फिर @{}एक तत्व के साथ एक नई हैश तालिका बनाता है , सूचकांक के 36बराबर सेट किया जाता है $g-as[guid]। यह अंतर्निहित .NET -asऑपरेटर का उपयोग दो .NET डेटा प्रकारों से - के बीच रूपांतरण का प्रयास करने के [string]लिए करता है [guid]। यदि रूपांतरण सफल होता है, तो एक [guid]ऑब्जेक्ट वापस किया जाता है, और फिर $nullवापस लौटाया जाता है। यह भाग सुनिश्चित करता है कि इनपुट स्ट्रिंग एक वैध .NET GUID है।

अगला चरण हैश तालिका में अनुक्रमित करना है [$g.length]। यदि $gलंबाई में वास्तव में 36 वर्ण नहीं हैं, तो हैश तालिका वापस आ जाएगी $null, जो कि फाल्सी मूल्य के रूप में आउटपुट होगा। यदि $gलंबाई में 36 वर्ण हैं, तो .NET कॉल का परिणाम आउटपुट होगा। यदि $gकोई मान्य .NET GUID (किसी भी रूप में) नहीं है, तो यह $nullएक गलत मूल्य के रूप में आउटपुट करेगा । अन्यथा यह .NET GUID ऑब्जेक्ट को एक सत्य मान के रूप में आउटपुट करेगा - आउटपुट का एकमात्र तरीका यह हो सकता है कि यह चुनौती के अनुरोधित प्रारूप से मेल खाता है या नहीं।

उदाहरण

यहां मैं स्क्रिप्ट कॉल को पैरेन्स में एनकैप्सुलेट कर रहा हूं और स्पष्टता के लिए बूलियन के रूप में स्पष्ट रूप से कास्टिंग कर रहा हूं।

PS C:\Tools\Scripts\golfing> [bool](.\check-if-a-uuid-is-valid.ps1 '0FCE98AC-1326-4C79-8EBC-94908DA8B034')
True

PS C:\Tools\Scripts\golfing> [bool](.\check-if-a-uuid-is-valid.ps1 '0FCE98AC-1326-4C79-8EBC-94908DA8B034D')
False

PS C:\Tools\Scripts\golfing> [bool](.\check-if-a-uuid-is-valid.ps1 '0FCE98AC13264C798EBC94908DA8B034')
False

Comments

मैं !!($args[0]-as[guid])21 बाइट में फेंक दूँगा ।

— TessellatingHeckler

क्या आप सिर्फ 4 बाइट्स बचाकर बाहर नहीं निकाल सकते थे !!()? मूल्यों के रूप में $NULLऔर [guid]पारस्परिक रूप से अनन्य हैं, वे truthey और गलत मूल्यों का प्रतिनिधित्व करने के लिए अर्हता प्राप्त करते हैं, है न? वैसे भी, बूलियन में परिवर्तित करने का शानदार तरीका, समाधान से प्यार करें!

— 14:फ्रिलिचट

@iFreilicht जो एक बिंदु है; लिंक की गई "सत्य / गलत व्याख्या" पोस्ट को देखते हुए - मैं मानता हूं कि यह मान्य है।

— TessellatingHeckler

यह समाधान गलत तरीके से देता Trueहै 0FCE98AC13264C798EBC94908DA8B034, जिसमें कोई हाइफ़न नहीं है

— याकूब क्राल

@TessellatingHeckler नहीं, यह सच होने के लिए बहुत अच्छा है। एक अंक को लागू करना, जैसे कि 0FCE98AC-1326-4C79-8EBC-94908DA8B034D(अंत में अतिरिक्त डी) $TRUE, गलत रिटर्न देता है , क्योंकि यह केवल आक्रामक अंक को दूर कर देता है और पहले 36 अक्षर मान्य होते हैं।

— AdmBorkBork

Answer 4

एमएसीएस लिस्प, 236 बाइट्स

(lambda(s)(and(eq(string-bytes s)36)(let((l(string-to-list s))(i 0)(h '(8 13 18 23))(v t))(dolist(c l v)(set'v(and v(if(member i h)(and v(eq c 45))(or(and(> c 47)(< c 58))(and(> c 64)(< c 91))(and(> c 96)(< c 123))))))(set'i(+ i 1))))))

Ungolfed:

(lambda (s)
  (and (eq (string-bytes s) 36) ; check length
       (let ((l (string-to-list s))
             (i 0)
             ; location of hyphens
             (h '(8 13 18 23))
             (v t))
         (dolist (c l v)
           (set 'v (and v (if (member i h)      ; check if at hyphen position
                              (and v (eq c 45)) ; check if hyphen
                            (or (and (> c 47) (< c 58))      ; check if number
                                (and (> c 64) (< c 91))      ; check if upper case letter
                                (and (> c 96) (< c 123)))))) ; check if lower case letter
           (set 'i (+ i 1)))))) ; increment

Answer 5

नियमों में बदलाव के कारण , यह जवाब अब प्रतिस्पर्धी नहीं है :(

सी, 98

main(a,n){printf("%d",scanf("%8x-%4hx-%4hx-%4hx-%4hx%8x%n%c",&a,&a,&a,&a,&a,&a,&n,&a)==6&&n==36);}

ज्यादातर काफी आत्म व्याख्यात्मक। %nफॉर्मेट स्पेसिफायर बाइट की संख्या अब तक पढ़ा देता है, 36. होना चाहिए जो scanf()रिटर्न का मिलान नहीं हुआ मदों की संख्या है, जो होना चाहिए 6. अंतिम %cकुछ भी मेल नहीं करना चाहिए। यदि ऐसा होता है, तो अनुगामी पाठ होता है, और scanf()7 वापस आ जाएगा।

-wPesky चेतावनियों को दबाने के लिए संकलन करें (कई हैं)।

Answer 6

जावास्क्रिप्ट ईएस 6, 70 83

बग ढूंढने के लिए @Qwertiy को नोट करें (और कुछ सुधार और सुधारों का सुझाव दें)

Thx @ C .O'Bʀɪᴇɴ 2 बाइट्स सहेजे गए

अन्य 9 बाइट्स ने लंबाई की जांच को सरल बना दिया ( पहले ड्राफ्ट में जटिल तरीका छोटा था , लेकिन अब नहीं)

u=>u.split`-`.every((h,l,u)=>u[4]&&-`0x${h}1`&&h.length-'40008'[l]==4)

व्याख्या की

u=>u.split`-` // make an array splitting at '-'
.every( // for every element the following must be true
 (h,l,u)=> // h is the element, l is the index, u is the whole array
 u[4] // element 4 must be present (at least 5 element in array)
 && -`0x${h}1` // element must be a valid hex string with no extraneous blanks (else NaN that is falsy)
 // get requested length from index (8,4,4,4,12 sub 4 to put in 1 char)
 // a 6th elements will be rejected as undefined != 4
 && h.length-'40008'[l]==4// then check element length
)

टेस्ट स्निपेट

f=u=>u.split`-`.every((h,l,u)=>u[4]&&-`0x${h}1`&&h.length-'40008'[l]==4)

console.log=x=>O.innerHTML+=x+'\n'

;[
  ['0FCE98AC-1326-4C79-8EBC-94908DA8B034',true],
  ['0fce98ac-1326-4c79-8ebc-94908da8b034',true],
  ['0FCE98ac-1326-4c79-8EBC-94908da8B034',true],
  ['00000000-0000-0000-0000-000000000000', true],
  ['ffffffff-ffff-ffff-ffff-ffffffffffff', true],
  ['0GCE98AC-1326-4C79-8EBC-94908DA8B034',false],
  ['0FCE98AC-13264C79-8EBC-94908DA8B034',false],
  ['0FCE98AC-13264-C79-8EBC-94908DA8B034',false],
  ['0FCE98ACD-1326-4C79-8EBC-94908DA8B034',false],
  ['0FCE98AC-1326-4C79-8EBC',false],
  ['0FCE98AC-1326-4C79-8EBC-94908DA8B034-',false],
  ['00000000-0000-0000-000 -000000000000', false],
  ['0FCE98AC-1326-4C79-8EBC-94908DA8B034-123',false],
].forEach(x=>{
  var t=x[0], r=f(t), k=x[1]
  console.log('Test '+t+' result '+r+(r==k?' ok':' fail'))
})

<pre id=O></pre>

Comments

-1-('0x'+h)=>1/('0x'+h)

— क्वर्टी

मेरे पिछले संस्करण की तरह ही समस्या: के लिए सच है00000000-0000-0000-000 -000000000000

— Qwertiy

नहीं, लेकिन आपने एक गलत परीक्षण जोड़ा है। अंतरिक्ष का नेतृत्व करना कोई समस्या नहीं है, लेकिन एक को पीछे छोड़ते हुए, एक संख्या के रूप में परिवर्तित करते समय एक स्ट्रिंग को ट्रिम किया जाता है। एक परीक्षण के साथ ऊपर मेरी टिप्पणी देखें।

— Qwertiy

'00000000-0000-0000-000-00000000000' अब मैं इसे देखता हूं @ क्वर्टी को मैं 4 की बजाय 3 शून्य से चूक गया

— edc65

@Stefnotch मैं सहमत नहीं हूँ। everyकॉल के बाहर uएक स्ट्रिंग है, एक सरणी नहीं

— edc65

Answer 7

नियमों में बदलाव के कारण , यह जवाब अब प्रतिस्पर्धी नहीं है :(

शुद्ध बैश (कोई बाहरी उपयोगिताओं नहीं), 78

printf -vv %8s-%4s-%4s-%4s-%12s
p=${v// /[[:xdigit:]]}
[ "$1" -a ! "${1/$p}" ]

कमांड लाइन से इनपुट लेता है।

• printfनिम्न स्ट्रिंग बनाता है - - - -।
• p=लाइन निम्नलिखित पैटर्न को यह बदल देती है: [[:xdigit:]][[:xdigit:]][[:xdigit:]][[:xdigit:]][[:xdigit:]][[:xdigit:]][[:xdigit:]][[:xdigit:]]-[[:xdigit:]][[:xdigit:]][[:xdigit:]][[:xdigit:]]-[[:xdigit:]][[:xdigit:]][[:xdigit:]][[:xdigit:]]-[[:xdigit:]][[:xdigit:]][[:xdigit:]][[:xdigit:]]-[[:xdigit:]][[:xdigit:]][[:xdigit:]][[:xdigit:]][[:xdigit:]][[:xdigit:]][[:xdigit:]][[:xdigit:]][[:xdigit:]][[:xdigit:]][[:xdigit:]][[:xdigit:]]। ध्यान दें कि यह एक नियमित अभिव्यक्ति की तरह एक बहुत कुछ दिखता है। हालाँकि, यह इस संदर्भ में नहीं है। यह शेल पैटर्न मिलान के लिए एक पैटर्न है । यह अवधारणा में एक नियमित अभिव्यक्ति के समान है , लेकिन एक अलग निर्माण (और वाक्यविन्यास) है।
• अंतिम पंक्ति यदि जाँच करती है
  • इनपुट नॉन-खाली है
  • यदि इनपुट स्ट्रिंग से पैटर्न को खींचना एक खाली स्ट्रिंग पैदा करता है

शेल के लिए मुहावरेदार, 0 का रिटर्न कोड सफलता / TRUE को इंगित करता है और 1 विफलता / FALSE को दर्शाता है। echo $?स्क्रिप्ट चलाने के बाद रिटर्न कोड का निरीक्षण किया जा सकता है ।

Comments

मेल पैटर्न मिलान रेगेक्स के सिंटैक्स का पालन नहीं कर सकता है, लेकिन चरित्र वर्ग निश्चित रूप से पॉसिक्स रिजेक्ट से परिभाषा और वाक्यविन्यास का उपयोग करता है। वैसे भी, यह तय करना ओपी पर निर्भर है कि वह स्वीकार्य है या नहीं।

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

@ n @h maya̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳ नियमित अभिव्यक्तियों में पॉज़िक्स वर्ण वर्ग शामिल हो सकते हैं, लेकिन मुझे नहीं लगता कि इसका अर्थ यह है कि जो कुछ भी एक पॉज़िक्स चरित्र वर्ग का उपयोग करता है वह एक रेगीक्स है। एक अन्य उदाहरण के रूप में trभी Posix वर्ण वर्गों का उपयोग करता है, लेकिन एक रेगीक्स पार्सर नहीं है।

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

आप बेकार दोहरे उद्धरण चिह्नों से बचकर कुछ वर्णों को शेव कर सकते हैं, जैसे कि प्रिंटफ प्रारूप में।

— जेन्स

मैंने स्पष्ट करने के लिए चुनौती को अपडेट किया है - कारण regexes को अस्वीकार कर दिया गया था ताकि इसे बनाने के लिए हेक्स पैटर्न का उपयोग uuids से मेल खाने के लिए नहीं किया जा सके

— जोजोड्मो

Answer 8

जोल्फ, 32 बाइट्स

यहाँ कोशिश करो !

 eGi'-DN&bH*28=lH.[8,4,4,4,12]S}
 e                               Property "e"very of next object
  Gi'-                           Split i at hyphen
      DN                       } every comparison function
        &                        logical conjugation of next two arguments
         bH*28                   base 16 of H (first arg); is NaN (falsey) if invalid
              =                  equality of next two items
               lH                the length of H (first arg)
                 .            S  the Sth (index) member of the object inbetween
                  [8,4,4,4,12]   array of lengths

मेरे कोड में त्रुटि के कारण, यह उससे अधिक होना चाहिए। :( समान [8,4,4,4,12] होना चाहिए{8444*26} , लेकिन }यह भी एक समारोह का समापन है: पी

Comments

तो यह होने की तुलना में लंबे समय तक है क्योंकि आपके पास आपके द्वारा बनाई गई भाषा में अस्पष्ट आदेश हैं? : P

— R

@ रिकरव माइनर अर्थ संबंधी गलती। यह अब तय हो गया है।

— कॉनर ओ'ब्रायन

Answer 9

MATL , 55 बाइट्स

jttn36=?[9,5,5,5]XsXK)45=?36:Km~)4Y2'A':'F'hm?}F]]]N~1$

मैं Ybफ़ंक्शन ( strsplit) का उपयोग करने से बचता हूं क्योंकि यह कुछ हद तक समान है regexp(..., 'split')। यह केवल अनुक्रमण और चरित्र तुलना का उपयोग करता है।

उदाहरण

>> matl
 > jttn36=?[9,5,5,5]XsXK)45=?36:Km~)4Y2'A':'F'hm?}F]]]N~1$
 > 
> This is a test
0

>> matl
 > jttn36=?[9,5,5,5]XsXK)45=?36:Km~)4Y2'A':'F'hm?}F]]]N~1$
 > 
> D293DBB2-0801-4E60-9141-78EAB0E298FF
1

व्याख्या

jt                     % input string, duplicate
tn36=?                 % if length is 36
  [9,5,5,5]XsXK        % build and copy indices of required '-' positions
  )45=?                % if those entries are indeed '-'
    36:Km~)            % logical index of remaining positions
    4Y2'A':'F'h        % allowed chars in those positions
    m?                 % if all those entries are legal: do nothing
    }                  % else
      F                % false value
    ]                  % end
  ]                    % end
]                      % end
N~                     % true if stack is empty
1$                     % display last result only

Answer 10

CJam, 52 42 बाइट्स

qeu__{A7*)<},\'-/83 3b{)4*}%.{\,=}[1]5*=*=

इसे ऑनलाइन आज़माएं । यदि सही है तो मूल स्ट्रिंग आउटपुट करता है, यदि गलत है तो खाली स्ट्रिंग आउटपुट करता है )।

स्पष्टीकरण:

qeu__                                      e# Take input, make 2 copies
     {A7*)<},\                             e# Remove invalid characters from first copy
              '-/                          e# Split top of stack on '-
                 83 3b{)4*}%               e# Array of group lengths: [8 4 4 4 12]
                            .{\,=}[1]5*=   e# Compare two arrays, return true if group lengths are correct
                                        *= e# Multiply this value by original string (0 = empty string, 1 = same string)

Comments

A7*)<रिक्त स्थान जैसे कई अमान्य वर्णों को नहीं हटाया जाएगा +, ?...

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

@ मार्टिनबटनर ओह शूट ... मुझे महसूस नहीं हुआ कि, इल कुछ मिनटों में ठीक कर देंगे।

— गेमक्रॉप्स

Answer 11

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

s->(t=split(s,"-");map(length,t)==[8,4,4,4,12]&&all(i->!isnull(tryparse(Int,i,16)),t))

यह एक अनाम फ़ंक्शन है जो एक स्ट्रिंग को स्वीकार करता है और एक बूलियन देता है। इसे कॉल करने के लिए, इसे एक नाम दें, उदा f=s->...।

Ungolfed:

function f(s::AbstractString)
    # Split the input into an array on dashes
    t = split(s, "-")

    # Ensure the lengths are appropriate
    ok1 = map(length, t) == [8, 4, 4, 4, 12]

    # Ensure each element is a valid hexadecimal number
    ok2 = all(i -> !isnull(tryparse(Int, i, 16)), t)

    return ok1 && ok2
end

Answer 12

सी # 196 बाइट्स

using System.Linq;class P{bool T(string v){var r=v.Length==36;for(var i=0;i<v.Length;i++)r&=new[]{8,13,18,23}.Any(t=>t==i)?v[i]=='-':v[i]>47&&v[i]<58|v[i]>64&&v[i]<71|v[i]>96&&v[i]<103;return r;}}

Ungolfed:

using System.Linq;
class P
{
    public bool T(string v)
    {
        var r = v.Length == 36;
        for (var i = 0; i < v.Length; i++)
            r &= new[] { 8, 13, 18, 23 }.Any(t => t == i) 
                ? v[i] == '-' 
                : v[i] > 47 && v[i] < 58 | v[i] > 64 && v[i] < 71 | v[i] > 96 && v[i] < 103;
        return r;
    }
}

विधि Tकिसी भी गैर-शून्य स्ट्रिंग के साथ मंगाया जा सकता है और trueमान्य GUID के लिए वापस आ जाएगा , falseअन्यथा। यह एक निरंतर समय मान्यता है; तीन वर्णों की लागत पर आप विधि (परिवर्तन) से जल्दी बाहर निकल सकते हैंi < v.Length करने के लिए i < v.Length && r)।

बाद में और नीचे आने की कोशिश करेंगे।

मैंने स्पष्ट रूप से Guid.ParseExactरास्ता छोड़ दिया है क्योंकि उस में मज़ा कहाँ है? यहाँ यह है, यह बहुत अधिक 86 बाइट्स में नीचे गोल्फ की कोशिश के बिना है :

using System;class P{bool T(string v){Guid x;return Guid.TryParseExact(v,"D",out x);}}

Ungolfed:

using System;
class P
{
    bool T(string v)
    {
        Guid x;
        return Guid.TryParseExact(v, "D", out x);
    }
}

Answer 13

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

def f(u):
 try:u=u.split()[0];int(u.replace('-',''),16);print[8,4,4,4,12]==map(len,u.split('-'))
 except:print 0

एक वैध इनपुट पर, यह प्रिंट करता है True। अमान्य इनपुट पर यह प्रिंट करता है Falseया 0, इस पर निर्भर करता है कि यह अमान्य क्यों था।Falseऔर 0दोनों पाइथन में गलत हैं।

फ़ंक्शन को 3 चीज़ों की जाँच करनी है:

• प्रत्येक गैर-हाइफ़न वर्ण एक अंक है या अंदर है ABCDEF
• ठीक 4 हाइफ़न हैं
• पहले हाइफ़न से पहले 8 वर्ण, अंतिम के बाद 12 और किसी भी अन्य दो के बीच 4 वर्ण होते हैं

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

def f(u):
    try:
        int(u.replace('-',''),16) # Remove all hyphens from the string and parse what's
                                  # left as a base 16 number. Don't do anything with this
                                  # number, but throw an exception if it can't be done.

        return[8,4,4,4,12]==map(len,u.split('-')) # Split the string at each hyphen and
                                                  # get the length of each resulting
                                                  # string. If the lengths == [8,4,4,4,12],
                                                  # there are the right number of groups
                                                  # with the right lengths, so the string
                                                  # is valid.
    except:
        return 0 # The only way to get here is if the string (minus hyphens) couldn't be
                 # parsed as a base 16 int, so there are non-digit, non-ABCDEF characters
                 # and the string is invalid.

Comments

मुझे लगता है कि आप 2 बाइट्स बचा सकते हैं अगर आप की दोनों मामलों की जगह returnके साथ print। (जिस स्थिति में आप निश्चित रूप से अजगर 2 में रहना चाहते हैं, क्योंकि printअजगर 3. में अलग तरीके से काम करता है)

— गणितम्

यह पायथन 3 में काम नहीं करता है, क्योंकि mapअब एक सूची नहीं बल्कि "मैप ऑब्जेक्ट" देता है।

— टिम पैडरिक

यह अजगर 2 (शायद 3 भी) में काम नहीं करता है क्योंकि intफ़ंक्शन रिक्त स्थान की अनुमति देता है - 0FCE98ac-1326-4c79-8EBC-94908da8B03एक अनुगामी स्थान के साथ। हटाए गए Pyth जवाब में टिप्पणी देखें यहां सक्षम है।

— ब्लू

Answer 14

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

बिल्ट-इन के लिए धन्यवाद! - उद्धरणों में तार संलग्न करना सुनिश्चित करें।

import uuid
try:uuid.UUID(input());print 1
except:print 0

Comments

आपके द्वारा लिंक किए गए डॉक्स के अनुसार, वह 1इनपुट के लिए प्रिंट करेगा 12345678123456781234567812345678।

— डेनिस

यदि यह काम करता है तो आप बाइट्स को करने में सक्षम होंगे try:print uuid.UUID(input())क्योंकि यह आवश्यक है कि आप एक सत्य मूल्य प्रिंट करें

— अंडरग्राउंडोरेल

यह कार्यक्रम कई यूयूआईडी प्रारूपों को स्वीकार करता है, लेकिन सवाल केवल 36-वर्ण यूयूआईडी प्रारूप चाहता है, जिसमें हाइफ़न है।

— याकूब क्राल

आप इसे अपडेट कर सकते हैं, अपडेट किए गए नियमों का मुकाबला करते हुए, जाँच कर सकते हैं कि इनपुट स्ट्रिंग वापस स्ट्रिंग में परिवर्तित किए गए uuid के बराबर है या नहीं। आपको तुरंत एक सत्य मूल्य देता है।

— agtoever

Answer 15

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

&&!+1xzd.xi:zK\-k16ZqxKc+zK1mid36"8dinz

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

Comments

आपकी "यह कोशिश करो" लिंक में \चरित्र गायब है K\-k, इसलिए यह चलाने में विफल है।

— एलेक्स

अब इसे ठीक कर दिया गया है

— ब्लू

Answer 16

पर्ल 6 ,  83   67 बाइट्स

# 83 bytes
{
  (
    my@a=.uc.split('-')
  ).map(*.comb)⊆('0'..'9','A'..'F')
&&
  @a».chars~~(8,4,4,4,12)
}

# 67 bytes
{
  (
    $/=.split('-')
  ).map({:16($_)//|()})==5
&&
  $/».chars~~(8,4,4,4,12)
}

(काउंट्स में नई सूची या इंडेंट शामिल नहीं हैं क्योंकि उनकी जरूरत नहीं है)

उपयोग:

# give it a name
my &code = {...}

say map &code, «
  D293DBB2-0801-4E60-9141-78EAB0E298FF
  0FCE98AC-1326-4C79-8EBC-94908DA8B034
  0fce98ac-1326-4c79-8ebc-94908da8b034
  0FCE98ac-1326-4c79-8EBC-94908da8B034
  00000000-1326-4c79-8EBC-94908da8B034
»;
# (True True True True True)

say map &code, «
  0GCE98AC-1326-4C79-8EBC-94908DA8B034
 '0FCE98AC 1326-4C79-8EBC-94908DA8B034'
  0FCE98AC-13264C79-8EBC-94908DA8B034
  0FCE98AC-13264-C79-8EBC-94908DA8B034
  0FCE98ACD-1326-4C79-8EBC-94908DA8B034
  0FCE98AC-1326-4C79-8EBC-94908DA8B034-
  0FCE98AC-1326-4C79-8EBC-94908DA8B034-123
»;
# (False False False False False False False)

Answer 17

आम लिस्प - 161

(lambda(s &aux(u(remove #\- s)))(and(=(length s)36)(=(length u)32)(every(lambda(p)(char=(char s p)#\-))'(8 13 18 23))(ignore-errors(parse-integer u :radix 16))))

लौटाया गया मान यदि सही हैश है, एक संख्या के रूप में, जो एक उपयोगी परिणाम है।

Ungolfed

(defun uuid-p (string &aux (undashed (remove #\- string)))
  (and
   ;; length of input string must be 36
   (= (length string) 36)

   ;; there are exactly 4 dashes
   (= (length undashed) 32)

   ;; We check that we find dashes where expected
   (every (lambda (position)
            (char= (char string position) #\-))
          '(8 13 18 23))

   ;; Finally, we decode the undashed string as a number in base 16,
   ;; but do not throw an exception if this is not possible.
   (ignore-errors
    (parse-integer undashed :radix 16))))

Comments

@ जोजोडमो हां, निश्चित रूप से! धन्यवाद

— coredump

Answer 18

एफ # 44 अक्षर

fun s->System.Guid.TryParseExact(s,"D")|>fst

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

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

सही प्रारूप के लिए एक जांच के रूप में, हम trueकेवल तभी वापस आते हैं जब स्ट्रिंग 36 वर्ण लंबा हो।

इससे पहले कि मैं RobIII का C # उत्तर देखता, मैंने TryParseExact का उपयोग करने के बारे में नहीं सोचा था, इसलिए मेरा उत्तर तीन वर्णों से अधिक लंबा था:

fun s->System.Guid.TryParse s|>fst&&s.Length=36

TryParse(string, Guid) निम्नलिखित स्वरूपों में इनपुट स्वीकार करता है:

00000000000000000000000000000000 
00000000-0000-0000-0000-000000000000 
{00000000-0000-0000-0000-000000000000} 
(00000000-0000-0000-0000-000000000000)
{0x00000000,0x0000,0x0000,{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00}}

इनमें से, केवल दूसरा 36 वर्ण लंबा है।

Answer 19

पायथन 2, 93 89 85 बाइट्स

lambda u:(set(u)<=set("-0123456789abcdefABCDEF"))*map(len,u.split("-"))==[8,4,4,4,12]

map()कॉल गारंटी देता है कि वर्गों सही लंबाई के हैं, और all()परीक्षण या तो एक हाइफन या एक मनमाना दर-मामला हेक्स अंकों होने के लिए प्रत्येक चरित्र। जनरेटर की अभिव्यक्ति प्रत्येक अक्षर को उस पूरे स्ट्रिंग के माध्यम से पुनरावृत्त करके परीक्षण कर रही है, इसलिए यह सबसे अधिक प्रदर्शन करने वाला तरीका नहीं है, मुझे डर है, लेकिन इसे परीक्षण मामलों को संतुष्ट करना चाहिए:

>>> f=lambda u:(set(u)<=set("-0123456789abcdefABCDEF"))*map(len,u.split("-"))==[8,4,4,4,12]
>>> testcases = """\
... D293DBB2-0801-4E60-9141-78EAB0E298FF
... 0FCE98AC-1326-4C79-8EBC-94908DA8B034
... 0fce98ac-1326-4c79-8ebc-94908da8b034
... 0FCE98ac-1326-4c79-8EBC-94908da8B034
... 00000000-0000-0000-0000-000000000000""".splitlines()
>>> failcases = """\
... 0GCE98AC-1326-4C79-8EBC-94908DA8B034
... 0FCE98AC 1326-4C79-8EBC-94908DA8B034
... 0FCE98AC-13264C79-8EBC-94908DA8B034
... 0FCE98AC-13264-C79-8EBC-94908DA8B034
... 0FCE98ACD-1326-4C79-8EBC-94908DA8B034
... 0FCE98AC-1326-4C79-8EBC-94908DA8B034-
... 0FCE98AC-1326-4C79-8EBC-94908DA8B034-123
... 00000000-0000-0000-000 -000000000000
... 00000000-0000-0000- 000-000000000000""".splitlines()
>>> all(f(u) for u in testcases)
True
>>> any(f(u) for u in failcases)
False
>>> 

Comments

किसी को भी इस बात का कोई अंदाजा नहीं है कि सबसे कम सही पायथन जवाब को क्यों ठुकराया गया है? पर्याप्त व्याख्या नहीं?

— rsandwick3

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

— rsandwick3

आप ब्लॉक f=में स्ट्रिंग के चारों ओर और रिक्त स्थान निकाल सकते हैं all।

— FryAmTheEggman

ओह कमाल, अच्छी पकड़ - संपादित

— rsandwick3

आप 8 (या 6 को बचा सकते हैं, आपको अपने all(..)शामिल समावेशन परीक्षण को परिवर्तित करके कोष्ठक जोड़ने की आवश्यकता हो सकती है) set(u)<=set("-0123456789abcdefABCDEF"):।

— 409_Conflict

Answer 20

एसएएस, 171 144 141

data;infile stdin;file stdout;input a$9b$14c$19d$24;e=(a!!b!!c!!d='----')*length(_infile_)=36*(1-missing(put(input(compress(_infile_,,'adk'),$hex32.),$hex32.)));put e;run;

दरअसल स्टडिन और स्टडआउट का उपयोग करता है - इस विशेष भाषा की कम ज्ञात विशेषताओं में से एक। अब तक दिए गए उदाहरणों के लिए काम करता है, लेकिन संभवतः सभी मामलों में नहीं। शायद में सुधार किया जा सकता है।

बेहतर दृष्टिकोण - एक समय में एक चरित्र:

data;infile stdin;file stdout;do i=1 to 37;input@i c$1.@;a+ifn(i in(9,14,19,24),c='-',n(input(c,hex.))-36*(i>36&c^=''));end;b=a=36;put b;run;

केंद्रीय अभिव्यक्ति से एक और 6 वर्ण गढ़े!

Ungolfed:

data;
infile stdin;
file stdout;
do i=1 to 37;
input@i c$1.@;
a+ifn(i in(9,14,19,24),c='-',n(input(c,hex.))-36*(i>36&c^=''));
end;
b=a=36;
put b;
run;

यह लॉग में काफी कुछ चेतावनी और नोट्स उत्पन्न करता है, लेकिन यह उन्हें stdout या stderr पर नहीं छापता है, इसलिए मुझे लगता है कि यह उचित खेल है।

Answer 21

सी, 391 बाइट्स

#include<stdio.h>
#include<string.h>
#include<ctype.h>
#define F printf("0")
#define T printf("1")
#define E return 0
main(){char s[99],*t;int k=1,l,i;scanf("%99[^\n]",s);if(s[strlen(s)-1]=='-'){F;E;}t=strtok(s,"-");while(t!=NULL){for(i=0,l=0;t[i]!=0;i++,l++){if(!isxdigit(t[i])){F;E;}}if((k==1&&l!=8)||((k>1&&k<5)&&l!=4)||(k==5&&l!=12)){F;E;}k++;t=strtok(NULL,"-");}if(k==6){T;E;};F;}

Answer 22

MATLAB, 126 बाइट्स

function f(a)
b='-';if length(a)==36&&a(9)==b&&a(13)==b&&a(17)==b&&a(21)==b;a(a==b)=[];if any(isnan(hex2dec(a)));0;end;1;end;0

Answer 23

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

def a(i):
 try:l=[1+int(k,16)and(len(k)==c)for k,c in zip(i.split("-"),[8,4,4,4,12])];return(len(l)==5)&(0 not in l)
 except:return 0

int (k, 16) k को आधार -16 int में डालने का प्रयास करता है। 0-9a-fA-F- के अलावा अन्य वर्ण पर, यह विफल हो जाता है, जिस स्थिति में हम 0 पर लौटते हैं, जो गलत है। उस int में 1 जोड़ें और हमें एक गारंटीकृत सत्य मूल्य मिलता है - हमने str.split () के साथ सभी हाइफ़न को हटा दिया है, इसलिए हम मान -1 प्राप्त नहीं कर सकते हैं और सभी गैर-0 ints सत्य हैं।

Answer 24

सी फ़ंक्शन, 102

एक नियम परिवर्तन ने मेरे पिछले सी- scanf()आधारित उत्तर को रोक दिया , इसलिए यहां एक और सी उत्तर का उपयोग किया गया है isxdigit()जिसके बारे में मुझे लगता है कि प्रतिस्पर्धा करने की अनुमति दी जानी चाहिए :

i;f(char *s){for(i=8;i<24;i+=5)s[i]=s[i]-45?1:s[i]+3;for(i=0;isxdigit(s[i]);i++);return i==36&&!s[i];}

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

• -प्रासंगिक पदों पर पात्रों (एएससीआईआई 45) की जांच करें - यदि हां, तो उन्हें बदलें0 s (ASCII 48 (= 453/3)) से
• साथ प्रत्येक चर की जाँच स्ट्रिंग चलो isxdigit()
• यदि स्ट्रिंग की लंबाई 36 और अंतिम वर्ण NUL है तो TRUE लौटाएं।

Answer 25

बैच, 148 139 + 2 = 150 141 बाइट्स

@set/pu=
@for %%d in (1 2 3 4 5 6 7 8 9 A B C D E F)do @set u=!u:%%d=0!
@if -!u!==-00000000-0000-0000-0000-000000000000 exit/b0
@exit/b1

2 बाइट्स जोड़े गए क्योंकि आपको /vस्विच का उपयोग करने की आवश्यकता है CMD.EXE।

सफलता पर ERRORLEVEL 0 के साथ बाहर, विफलता पर 1।

संपादित करें: मुख्य रूप से :=असंवेदनशील होने के कारण कुछ बाइट्स को सहेजा गया था, लेकिन अन्य ट्वीक भी थे।

Answer 26

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

interface q{static void main(String[]a){int i=-1;char[]b=a[0].toCharArray();java.io.PrintStream u=System.out;if(b.length>36||b.length<36)u.print(1<0);if(b[8]!='-'||b[13]!='-'||b[18]!='-'||b[23]!='-')u.print(1<0);while(++i<b.length){if(i!=8&&i!=13&&i!=18&&i!=23){if(!((b[i]>='0'&&b[i]<='F')||(b[i]>='a'&&b[i]<='f')))u.print(1<0);}}u.print(1>0);}}

इनपुट पहली कमांड लाइन तर्क है। आउटपुट त्रुटि कोड है (0 का अर्थ वैध यूयूआईडी है, 1 का अर्थ वैध नहीं है)

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

interface q {
    static void main(String[] a) {
        int i = -1;                                                             // Index
        char[] b = a[0].toCharArray();                                          // Characters from input
        java.io.PrintStream u = System.out;                                     // STDOUT
        if (b.length > 36||b.length < 36)                                       // If input length is not 36
            u.print(1<0);                                                       // Invalid
        if (b[8]!='-'||b[13]!='-'||b[18]!='-'||b[23]!='-')                      // If hasn't got separators at correct positions
            u.print(1<0);                                                       // Invalid
        while (++i<b.length) {                                                  // Iterate over all characters
            if (i!=8 && i!=13 & i!=18 && i!=23) {                               // If not at separator indexes
                if ( !( (b[i]>='0'&&b[i]<='F') || (b[i]>='a'&&b[i]<='f') ))     // If incorrect hexadecimal number
                    u.print(1<0);                                               // Invalid
            }
        }
        u.print(1>0);                                                           // Valid
    }
}

संपादित करें: STDOUT भाग को नोटिस नहीं किया। उफ़, अब तय हो गया।

Comments

अच्छा! आप if(b.length>36||b.length<36)बस के साथ बदल सकते हैं if(b.length!=36)। इसके अलावा, क्योंकि आप सत्य मूल्यों को मुद्रित कर सकते हैं , आप केवल और इसके 0बजाय मुद्रित कर सकते हैं । 1<011>0

— जोजोडो

@Jojodmo वोटों के आधार पर, एक सत्य मूल्य के रूप में है if(truthy_value){ doSomethingOnYes(); } else{ doSomethingOnFalse(); }तो जावा में एक बूलियन एक सत्य मूल्य है, लेकिन 1या 0नहीं। केवल तभी जब चुनौती का ओपी कुछ कहता है: " आपका आउटपुट सही / गलत हो सकता है, 0/1, खाली / गैर-खाली; जब तक आप निर्दिष्ट करते हैं कि आप क्या उपयोग करते हैं। " तब आप वास्तव में उपयोग कर सकते हैं 0और 1इसके बजाय true/falseसत्य के रूप में। / गलत मूल्य।

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

कुकी के लिए गोल्फ टिप्स के रूप में: @ जोजोडो वास्तव में इसके लिए प्रतिस्थापित करने के साथ सही है if(b.length!=36); ||हो सकता है |कई स्थानों पर है, साथ ही &&करने के लिए &; if(...!='-')हो सकता है if(...!=45); int i=-1; ... while(++i<b.length){के साथ प्रतिस्थापित किया जा सकता है for(int i=-1;++i<b.length;){; 'F'हो सकता है 70( 'f'102 हो सकता है, लेकिन इससे कोई फर्क नहीं पड़ता क्योंकि यह एक ही बाइट-काउंट है)। मुझे पसंद है कि आपने कैसे java.io.PrintStream u=System.out;btw का उपयोग किया है , मुझे याद रखना चाहिए कि एक! तो धन्यवाद।

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

Answer 27

स्विफ्ट 3, 50 बाइट्स

एक स्ट्रिंग में पास s

import Foundation
print(UUID(uuidString:s) != nil)

Answer 28

PHP, 109 बाइट्स

सच्चे के लिए 1 प्रिंट और झूठ के लिए 0

for($t=($l=strlen($a=$argn))==36;$i<$l;$i++)$t*=$i>7&$i<24&!($i%5-3)?$a[$i]=="-":ctype_xdigit($a[$i]);echo$t;

$i>7&$i<24&!($i%5-3) 5 बाइट्स तब छोटी होती है in_array($i,[8,13,18,23])

112 बाइट्स

echo array_filter(str_split($argn),function($i){return!ctype_xdigit($i);})==[8=>"-",13=>"-",18=>"-",23=>"-"]?:0;

113 बाइट्स

echo array_diff(str_split(strtolower($argn)),array_map(dechex,range(0,15)))==[8=>"-",13=>"-",18=>"-",23=>"-"]?:0;

Answer 29

जावा, 172 बाइट्स 168 बाइट्स (धन्यवाद गेहूं जादूगर)

जब से मैंने java.util.UUID का उपयोग किया है, लेकिन यहाँ जाने पर किंडा धोखा देता है:

import java.util.UUID;class ValidUUID{public static void main(String[] a){try{UUID.fromString(a[0]);System.out.println(1);}catch(Exception e){System.out.println(0);}}}

Ungolfed संस्करण:

import java.util.UUID;

class ValidUUID {

    public static void main(String[] a) {
        try {
            UUID.fromString(a[0]);
            System.out.println(1);
        } catch(Exception e) {System.out.println(0);}
    }
}

Comments

साइट पर आपका स्वागत है! मुझे लगता है कि आप tryऔर के बीच की जगह निकाल सकते हैं {।

— गेहूं जादूगर

@WheatWizard धन्यवाद: D ने यह भी देखा कि मैं "लगभग 0 और 1 को हटा सकता हूँ

— ryxn

आप के बीच की जगह को दूर करने में सक्षम होना चाहिए String[]और a। इसके अलावा, आप के printlnसाथ बदलने में सक्षम होना चाहिए print।

— मौसमी

कक्षा का नाम 1 वर्ण हो सकता है। आप java.util.UUID.fromStringआयात करने के बजाय उपयोग कर सकते हैं ।

— प्रहार

Answer 30

AWK, 98 बाइट्स

BEGIN{FS=""}{for(j=4;k<NF;){h+=(j+=5)<25?$j=="-":0
s+=strtonum("0x"$++k 1)>0}$0=h+s==36&&NF==36}1

बस हर चरित्र पर लाइन को विभाजित करता है और जांचता है कि क्या प्रत्येक वर्ण एक हेक्स अंक है और उचित स्थानों पर हाइफ़न हैं। strtonumअमान्य वर्णों को धर्मान्तरित करता है 0। के बीच तुलना करना ( 0और m(और मनमाने ढंग से चुना गया अमान्य चरित्र) अतिरिक्त चरणों की आवश्यकता होती है। सौभाग्य 01से एक वैध हेक्स संख्या है, लेकिनm1 नहीं है।

शुरू में मैंने दो लिखे for लूप , लेकिन मैंने उन्हें एक साथ निचोड़कर 1 बाइट बचाई। :)

नोट: GAWKहेक्स संख्या के रूप में इनपुट पढ़ सकते हैं, लेकिन इसके लिए एक बहुत लंबी कमांड लाइन विकल्प की आवश्यकता होती है।