Wenn Sie eine Zeichenfolge eingeben , schreiben Sie ein Programm, das einen Wahrheitswert an STDOUT oder einen entsprechenden Wert ausgibt, wenn die Eingabe eine gültige UUID ist, ohne reguläre Ausdrücke zu verwenden.

Eine gültige UUID ist

32 hexadezimale Ziffern, angezeigt in fünf durch Bindestriche getrennten Gruppen, in der Form 8-4-4-4-12 für insgesamt 36 Zeichen (32 alphanumerische Zeichen und vier Bindestriche).

_Quelle

Testfälle

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)

Regeln

• Reguläre Ausdrücke sind nicht erlaubt
• Literaler Mustervergleich, der einem regulären Ausdruck gleicht, ist nicht zulässig. Verwenden Sie beispielsweise [0-9a-fA-F]oder andere hexadezimale Bezeichner (wir nennen dies n) und stimmen Sie dann überein nnnnnnnn-nnnn-nnnn-nnnn-nnnnnnnnnnnnoder n[8]-n[4]-n[4]-n[4]-n[12]sind nicht zulässig
• Die Eingabe kann entweder STDINeiner Funktion entnommen oder als Argument für eine Funktion verwendet werden
• Die Eingabe unterscheidet nicht zwischen Groß- und Kleinschreibung
• Es ist davon auszugehen, dass die Eingabe keine Zeilenvorschübe oder Zeilenumbrüche enthält.
• Die Eingabe kann beliebige druckbare ASCII-Zeichen enthalten (einschließlich Leerzeichen)
• Ein wahrer Wert muss auf STDOUToder gleichwertig gedruckt werden, wenn die Eingabe eine gültige UUID ist
• Ein falsey-Wert muss auf STDOUToder gleich gedruckt werden, wenn die Eingabe keine gültige uuid ist
• Bei Verwendung einer Funktion STDOUTkann die Ausgabe anstelle der Funktion der Rückgabewert der Funktion sein
• Der Wert für Wahr / Falsch kann nicht gedruckt werden STDERR.
• Es gelten Standardlücken
• Das ist Code-Golf , also gewinnt das kürzeste Programm in Bytes. Viel Glück!

Bestenliste

Dies ist ein Stack-Snippet, das sowohl eine Rangliste als auch eine Übersicht der Gewinner nach Sprache generiert.

Um sicherzustellen, dass Ihre Antwort angezeigt wird, beginnen Sie Ihre Antwort mit einer Überschrift unter Verwendung der folgenden Markdown-Vorlage

## Language Name, N bytes

Wobei N die Größe Ihrer Übermittlung in Byte ist

Wenn Sie mehrere Zahlen in Ihre Kopfzeile aufnehmen möchten (z. B. alte Punkte durchstreichen oder Flags in die Byteanzahl aufnehmen möchten), stellen Sie sicher, dass die tatsächliche Punktzahl die letzte Zahl in Ihrer Kopfzeile ist

## 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>

CJam, 31 30 29 Bytes

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

Führen Sie hier alle Testfälle aus.

Erläuterung

Anstatt die Eingabe direkt mit einem Muster abzugleichen, wandeln wir sie zunächst in eine einfachere Form um, die leicht mit einer einzelnen Musterzeichenfolge verglichen werden kann.

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.

JavaScript ES6, 73 55 56 Zeichen

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

In der vorherigen Version mit 55 Zeichen ist ein Problem mit nachgestellten Leerzeichen in der Gruppe aufgetreten:

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

Prüfung:

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))

PowerShell, 29 21 84 49 37 Bytes

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

Vielen Dank an die Leute in den Kommentaren, die beim Golfen geholfen haben , mit den sich ändernden Regeln Schritt zu halten - TessellatingHeckler , iFreilicht , Jacob Krall und Joey . Informationen zu Überarbeitungen und älteren Versionen finden Sie im Bearbeitungsverlauf.

Diese Revision nimmt Eingaben als $gund erstellt dann eine neue Hash-Tabelle @{}mit einem Element. Der Index 36wird gleich gesetzt $g-as[guid]. Dies verwendet den eingebauten -asOperator , um die Konvertierung zwischen zwei .NET-Datentypen zu versuchen - von [string]nach [guid]. Wenn die Konvertierung erfolgreich ist, wird ein [guid]Objekt zurückgegeben, andernfalls $nullwird zurückgegeben. Dieser Teil stellt sicher, dass die Eingabezeichenfolge eine gültige .NET-GUID ist.

Der nächste Schritt ist die Indizierung in die Hash-Tabelle mit [$g.length]. Wenn die $gLänge nicht genau 36 Zeichen beträgt, wird die Hash-Tabelle zurückgegeben $null, die als Falsey-Wert ausgegeben wird. Bei einer $gLänge von 36 Zeichen wird das Ergebnis des .NET-Aufrufs ausgegeben. Wenn $ges sich nicht um eine gültige .NET-GUID (in irgendeiner Form) handelt, wird sie $nullals Falsey-Wert ausgegeben. Andernfalls wird ein .NET-GUID-Objekt als Wahrheitswert ausgegeben. Die einzige Möglichkeit, die ausgegeben werden kann, besteht darin, dass es dem angeforderten Format der Abfrage entspricht.

Beispiele

Hier kapsele ich den Skriptaufruf in Parens und verwende ihn aus Gründen der Klarheit explizit als Booleschen Wert.

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

Emacs Lisp, 236 Bytes

(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

Aufgrund von Änderungen der Regeln ist diese Antwort nicht mehr wettbewerbsfähig :(

C 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);}

Meist ziemlich selbsterklärend. Der %nFormatbezeichner gibt die Anzahl der bisher gelesenen Bytes an, die 36 sein sollte. scanf()Gibt die Anzahl der übereinstimmenden Elemente zurück, die 6 sein sollte. Das Finale %csollte mit nichts übereinstimmen. Wenn dies der Fall ist, wird nachgestellter Text angezeigt und scanf()7 zurückgegeben.

Kompilieren Sie mit -w, um die nervigen Warnungen zu unterdrücken (es gibt mehrere).

JavaScript ES6, 70 83

HINWEIS thx an @Qwertiy für die Suche nach einem Fehler (und was darauf hindeutet , einige Verbesserungen und Korrekturen)

Thx @ CᴏɴᴏʀO'Bʀɪᴇɴ 2 Bytes gespeichert

Weitere 9 Bytes gespart, um die Längenprüfung zu vereinfachen (der komplexe Weg war im ersten Entwurf kürzer, aber nicht jetzt)

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

Erklärt

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
)

Testschnipsel

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>

Aufgrund von Änderungen der Regeln ist diese Antwort nicht mehr wettbewerbsfähig :(

Pure Bash (keine externen Dienstprogramme), 78

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

Übernimmt Eingaben von der Kommandozeile.

• Das erstellt printfdie folgende Zeichenfolge - - - -.
• Die p=Linie wandelt diese das folgende Muster: [[: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:]]. Beachten Sie, dass dies sehr nach einem regulären Ausdruck aussieht. Dies ist jedoch nicht der Fall. Es ist ein Muster für den Shell-Pattern-Matching . Dies ähnelt im Konzept einem regulären Ausdruck, ist jedoch ein anderes Konstrukt (und eine andere Syntax).
• Die letzte Zeile prüft, ob
  • Die Eingabe ist nicht leer
  • Wenn Sie das Muster aus der Eingabezeichenfolge ziehen, wird eine leere Zeichenfolge erstellt

Ein Rückkehrcode von 0 gibt Erfolg / WAHR und 1 Fehler / FALSCH an. Der Rückkehrcode kann echo $?nach dem Ausführen des Skripts überprüft werden .

Jolf, 32 Bytes

Probieren Sie es hier aus!

 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

Aufgrund eines Fehlers in meinem Code ist dieser länger als es sein sollte. :( [8,4,4,4,12] sollte dasselbe sein wie {8444*26}, ist aber }auch das Schließen einer Funktion: P

MATL , 55 Bytes

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

Ich habe auf die Verwendung von Ybfunction ( strsplit) verzichtet, da es etwas ähnlich ist wie function ( ) regexp(..., 'split'). Dies verwendet nur Indexierung und Zeichenvergleiche.

Beispiel

>> 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

Erläuterung

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

CJam, 52 42 Bytes

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

Probieren Sie es online aus . Gibt die ursprüngliche Zeichenfolge aus, wenn sie wahr ist, und gibt eine leere Zeichenfolge aus, wenn sie falsch ist ( dies ist zulässig ).

Erläuterung:

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)

Julia, 86 Bytes

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

Dies ist eine anonyme Funktion, die eine Zeichenfolge akzeptiert und einen Booleschen Wert zurückgibt. Um es zu nennen, geben Sie ihm einen Namen, z 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

C # 196 Bytes

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;
    }
}

Die Methode Tkann mit einer beliebigen Nicht-Null-Zeichenfolge aufgerufen werden und wird andernfalls truefür gültige GUIDs zurückgegeben false. Dies ist eine zeitlich konstante Validierung. Auf Kosten von drei Zeichen können Sie die Methode vorzeitig beenden (wechseln i < v.Lengthzu i < v.Length && r).

Ich werde später versuchen, den Bytecount weiter zu reduzieren.

Ich habe offensichtlich den Guid.ParseExactWeg ausgelassen , denn wo ist der Spaß dabei? Hier ist es, ohne viel zu versuchen, es in 86 Bytes weiter herunterzuspielen :

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);
    }
}

Python 2, 99 112 Bytes

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

Bei einer gültigen Eingabe wird gedruckt True. Bei einer ungültigen Eingabe wird gedruckt Falseoder 0, je nachdem, warum die Eingabe ungültig war. Falseund 0sind beide in Python falsch.

Die Funktion muss 3 Dinge überprüfen:

• Jedes Zeichen, das kein Bindestrich ist, ist eine Ziffer oder steht in ABCDEF
• Es gibt genau 4 Bindestriche
• Es gibt 8 Zeichen vor dem ersten Bindestrich, 12 nach dem letzten und 4 zwischen den anderen beiden

Hier ist eine Aufschlüsselung, um zu zeigen, wie nach ihnen gesucht wird. Es ist etwas veraltet, aber ich habe Hunger und werde es später aktualisieren.

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.

Python 2, 57 Bytes

Gott sei Dank für eingebaut! - Stellen Sie sicher, dass Sie die Zeichenfolgen in Anführungszeichen setzen.

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

Pyth, 39 Bytes

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

Probieren Sie es hier aus .

Perl 6 ,  83   67 Bytes

# 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)
}

(Zeilenumbrüche oder Einrückungen sind nicht enthalten, da sie nicht benötigt werden.)

Verwendungszweck:

# 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)

Common Lisp - 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))))

Der zurückgegebene Wert, wenn true, ist der Hash als Zahl, was ein nützliches Ergebnis ist.

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))))

F # 44 Zeichen

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

In F # können Funktionen mit outParametern aufgerufen werden, indem der out-Parameter weggelassen wird. Sein Rückgabewert wird mit dem tatsächlichen Rückgabewert der Funktion zu einem Tupel kombiniert.

Hier wird das Tupel an die fstFunktion weitergeleitet, die ihr erstes Element zurückgibt, in diesem Fall den booleschen Rückgabewert von TryParseExact, der den Erfolg oder Misserfolg des Aufrufs anzeigt.

Zur Überprüfung des richtigen Formats geben wir truenur zurück, wenn die Zeichenfolge 36 Zeichen lang ist.

Bevor ich RobIIIs C # -Antwort sah, hatte ich nicht daran gedacht, TryParseExact zu verwenden. Meine Antwort sollte also drei Zeichen länger sein:

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

TryParse(string, Guid) akzeptiert Eingaben in folgenden Formaten:

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}}

Davon ist nur die zweite 36 Zeichen lang.

Python 2, 93 89 85 Bytes

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

Der map()Aufruf garantiert, dass die Abschnitte die richtige Länge haben, und all()testet jedes Zeichen als Bindestrich oder Hex-Ziffer in willkürlicher Schreibweise. Der Generator-Ausdruck testet jedes Zeichen, indem er die gesamte Zeichenfolge durchläuft. Dies ist leider nicht die performanteste Methode, sollte aber die folgenden Testfälle erfüllen:

>>> 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
>>> 

SAS, 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;

Verwendet eigentlich stdin und stdout - eine der weniger bekannten Funktionen dieser bestimmten Sprache. Funktioniert für die bisher angegebenen Beispiele, aber möglicherweise nicht in allen Fällen. Kann wahrscheinlich verbessert werden.

Besserer Ansatz - ein Charakter nach dem anderen:

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;

Golf weitere 6 Zeichen aus dem zentralen Ausdruck!

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;

Dies erzeugt einige Warnungen und Notizen im Protokoll, aber es druckt sie nicht auf stdout oder stderr aus, daher halte ich dies für ein faires Spiel.

C 391 Bytes

#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;}

MATLAB, 126 Bytes

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

Python 3, 134 Bytes

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) versucht, k auf eine Basis von 16 int zu werfen. Bei einem anderen Zeichen als 0-9a-fA-F- schlägt dies fehl. In diesem Fall geben wir 0 zurück, was falsch ist. Wenn Sie diesem int 1 hinzufügen, erhalten Sie einen garantierten Wahrheitswert - wir haben alle Bindestriche mit str.split () entfernt, sodass wir den Wert -1 nicht erhalten können und alle Nicht-0-Ints wahr sind.

C-Funktion, 102

Eine Regeländerung hat meine vorherige c- scanf()basierte Antwort nicht zugelassen . Hier ist eine weitere c-Antwort, mit isxdigit()der ich antreten sollte :

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];}

Probieren Sie es online aus.

• Suchen Sie -an den entsprechenden Stellen nach Zeichen (ASCII 45). Wenn ja, ersetzen Sie diese durch 0s (ASCII 48 (= 45 + 3)).
• Gehen Sie die Zeichenkette durch und überprüfen Sie jedes Zeichen mit isxdigit()
• Gibt TRUE zurück, wenn die Zeichenfolge 36 ist und das letzte Zeichen NUL ist.

Batch, 148 139 + 2 = 150 141 Bytes

@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 Bytes hinzugefügt, da Sie den /vSchalter zu verwenden müssen CMD.EXE.

Beendet mit ERRORLEVEL 0 bei Erfolg, 1 bei Misserfolg.

Bearbeiten: Einige Bytes wurden gespeichert, hauptsächlich, weil :=die Groß- und Kleinschreibung nicht berücksichtigt wird, aber es gab auch andere Verbesserungen.

Java, 345 Bytes

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);}}

Die Eingabe ist das erste Befehlszeilenargument. Ausgabe ist Fehlercode (0 bedeutet gültige UUID, 1 bedeutet nicht gültig)

Ungolfed mit Kommentaren:

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
    }
}

EDIT: Habe den STDOUT Teil nicht bemerkt. Ups, jetzt behoben.

Schnelle 3, 50 Bytes

Geben Sie eine Zeichenfolge ein s

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

PHP, 109 Bytes

Gibt 1 für wahr und 0 für falsch aus

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) ist dann 5 Bytes kürzer in_array($i,[8,13,18,23])

112 Bytes

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

113 Bytes

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

Java, 172 Bytes 168 Bytes (Danke Weizen Assistent)

Irgendwie betrogen, seit ich java.util.UUID verwendet habe, aber hier ist:

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-Version:

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);}
    }
}

AWK, 98 Bytes

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

Teilen Sie einfach die Zeile bei jedem Zeichen auf und überprüfen Sie, ob jedes Zeichen eine hexadezimale Ziffer ist und ob an den entsprechenden Stellen Bindestriche vorhanden sind. strtonumkonvertiert ungültige Zeichen nach 0. Der Vergleich zwischen 0und m(und einem willkürlich gewählten ungültigen Zeichen) erfordert zusätzliche Schritte. Zum Glück 01ist eine gültige Hex-Zahl, aber m1nicht.

Anfangs habe ich zwei forLoops geschrieben, aber ich habe 1 Byte gespart, indem ich sie zusammengedrückt habe. :)

HINWEIS: GAWKKann Eingaben als Hex-Zahlen lesen, erfordert jedoch eine sehr lange Befehlszeilenoption.