Immagina questo, abbiamo un ambiente con un ambito globale contenente solo un singolo oggetto, chiamato codegolf. Questo oggetto ha un singolo figlio chiamato stackexchange, che ha una proprietà chiamata com.
L'accesso a questa proprietà sarebbe simile codegolf.stackexchange.com.

La sfida

L'input del tuo programma / funzione sarà una stringa che tenta di accedere a una proprietà nell'ambito globale. Ogni volta che questa proprietà viene trovata, è necessario stampare / restituire un valore di verità. Se la proprietà non viene trovata, verrà stampato / restituito un valore errato. Il problema: quando si tenta di accedere a una proprietà su un oggetto inesistente, il programma dovrebbe generare qualsiasi tipo di errore¹.

Per rendere le cose un po 'più semplici, puoi presumere che l'input sarà sempre [a-z.], non sarà mai vuoto, non avrà mai ripetizioni .e non inizierà o finirà mai con a .. Quindi codegolf.è un input non valido.

Casi test

codegolf.stackexchange.com => 1 // or any other truthy value
codegolf.stackexchange.net => 0 // or any other falsy value
codegolf.stackexchange => 1
codegolf.foo => 0
codegolf => 1
foo => 0
codegolf.com => 0
codegolf.constructor => 0

codegolf.foo.bar => Error (since foo is undefined)
codegolf.stackexchange.com.foo => Error (since com is a value, not an object)
codegolf.stackexchange.com.foo.bar => Error
foo.stackexchange.com => Error
foo.bar => Error
foo.bar.baz => Error

Questo è code-golf , vince il codice più corto in byte

¹ se (e solo se) lingua di propria scelta non supporta gli errori a tutti , è necessario qualcosa in uscita che rende chiaro che questo è un errore. Ad esempio, se si utilizza 1 per verità e 0 per falsa, è possibile utilizzare "e" per un errore. Sii coerente nei valori di ritorno e spiega il comportamento nel tuo post.

JavaScript, 135 byte

v=>(c=(p,i)=>new Proxy({}, {get:(o,q)=>(r=q==p[i]?c(p,i+1):o.$,i==3?r||z:r)}),x=c(["codegolf","stackexchange","com"],0),!!eval("x."+v))

Rielaborato il primo tentativo di impedire l'accesso alle chiavi integrate, a questo punto sarà meglio utilizzare un approccio diverso, ma hey!

Restituisce vero per valido, falso per mancante ed errori in caso di errore.

JavaScript (ES6), 87 byte

Restituisce false/ trueo lancia ReferenceError.

s=>s.split`.`.map((w,i)=>e|['codegolf','stackexchange','com'][i]!=w&&e++,e=0)&&e>1?X:!e

let f =
    
s=>s.split`.`.map((w,i)=>e|['codegolf','stackexchange','com'][i]!=w&&e++,e=0)&&e>1?X:!e

console.log(f('codegolf.stackexchange.com')); // => true
console.log(f('codegolf.stackexchange.net')); // => false
console.log(f('codegolf.stackexchange'));     // => true
console.log(f('codegolf.foo'));               // => false
console.log(f('codegolf'));                   // => true
console.log(f('foo'));                        // => false
console.log(f('codegolf.com'));               // => false

console.log(f('codegolf.foo.bar'));           // => Error

Versione probabilistica, 78 byte (non competitiva)

Poiché tutte le proprietà sono garantite per corrispondere [a-z], possiamo provarlo:

s=>s.split`.`.map((w,i)=>e|[162,6,2][i]-parseInt(w,36)%587&&e++,e=0)&&e>1?X:!e

A parte il fatto che 587è un numero primo e porta a valori piuttosto brevi per le parole a cui siamo interessati, questa è una scelta modulo piuttosto casuale.

Sebbene superi tutti i casi di test, è probabile che restituisca falsi positivi.

let f =
    
s=>s.split`.`.map((w,i)=>e|[162,6,2][i]-parseInt(w,36)%587&&e++,e=0)&&e>1?X:!e

console.log(f('codegolf.stackexchange.com')); // => true
console.log(f('codegolf.stackexchange.net')); // => false
console.log(f('codegolf.stackexchange'));     // => true
console.log(f('codegolf.foo'));               // => false
console.log(f('codegolf'));                   // => true
console.log(f('foo'));                        // => false
console.log(f('codegolf.com'));               // => false

console.log(f('codegolf.foo.bar'));           // => Error

Lotto, 269 231 byte

@echo off
set/ps=
set w=1codegolf
for %%a in (%s:.= %)do call:l %%w
echo %w:~0,1%
exit/b
:g
if
:l
if %w:~-1%==. goto g
if not %1==%w% set w=0.&exit/b
set w=1com
if %1==com set w=1.
if %1==codegolf set w=1stackexchange

Accetta input su STDIN; genera un errore di sintassi per una proprietà non valida. Funziona usando wcome una macchina a stati. Se wtermina con un .significa che l'accesso alla proprietà successivo non è valido. Modifica: salvato 17 byte utilizzando l'errore di sintassi per interrompere lo script batch. Ho salvato 21 byte rendendomi conto che uno dei miei compiti poteva essere incondizionato.

Javascript, 84 82 byte

Non abbastanza corto per vincere, ma dato che sono un principiante ho pensato che sarebbe stato divertente condividerlo. Forse qualcuno ha un suggerimento per il miglioramento.

s=>s.split`.`.length>3&&e||!!eval('codegolf={stackexchange:{com:true}};window.'+s)

Supera tutti i test nella domanda, ritorna trueper valore esistente, falseper inesistente e genera un errore se si tenta di ottenere una proprietà di una variabile inesistente o non oggetto. Tuttavia ora mi rendo conto che anche questa soluzione presenta alcuni problemi. Come sottolineato da @Florent nei commenti, restituisce true quando le proprietà del prototipo di stringa come.toString vengono chiamate .

modificare : 2 byte in meno grazie a @MamaFunRoll

Snippet di prova:

var f =
s=>s.split`.`.length>3&&e||!!eval('codegolf={stackexchange:{com:true}};window.'+s)

console.log(f('codegolf.stackexchange.com')) //true
console.log(f('codegolf.stackexchange.net')) //false
console.log(f('codegolf.stackexchange')) //true
console.log(f('codegolf.foo')) //false
console.log(f('codegolf')) //true
console.log(f('foo')) //false
console.log(f('codegolf.com')) //false

console.log(f('codegolf.foo.bar')) // TypeError
console.log(f('codegolf.stackexchange.com.foo')) //ReferenceError
console.log(f('codegolf.stackexchange.com.foo.bar')) //ReferenceError
console.log(f('foo.stackexchange.com')) // TypeError
console.log(f('foo.bar')) // TypeError
console.log(f('foo.bar.baz')) // TypeError

JavaScript, 173 byte

function d(a){var b="codegolf",u="stackexchange",c=a.split("."),e="e";return c.length==1?c[0]==b:c.length==2?c[0]==b?c[1]==u:e:c.length==3?c[0]==b?c[1]==u?c[2]=="com":e:e:e}

Funziona con IE 10, quindi dovrebbe funzionare sui principali browser moderni.

Provalo qui (+ ungolfed)

C #, 155 byte

Non sarebbe stato il più breve, ma ho pensato che sarebbe stato divertente provarlo in C # ...

bool f(string s){var a=s.Split('.');int e=0,l=a.Length-1,i=l;for(;0<=i;i--){e+=a[i]!=new[]{"codegolf","stackexchange","com"}[i]?i<l?s[-1]:1:0;}return e<1;}

• Divide la stringa e inverte iterando il risultato.
• Un elemento non corrispondente più di 1 iterazione in profondità, errori (lanciando un IndexOutOfRangeException accedendo a un carattere in posizione -1 nella stringa).
• In caso contrario, restituisce false se non sono presenti elementi corrispondenti.

.NET Fiddle

Rubino, 84 80 byte

Funzione anonima che restituisce trueo false, o divide per zero per generare errore:

->s{k=1;s.split(?.).zip(%w[codegolf stackexchange com]){|i,o|1/0if !k;k=i==o};k} 

Provalo online

C, 98 112 113 byte

f(char*a){char*c="codegolf.stackexchage.com";while(*c&&*c==*a)++a,++c;return strchr(a,46)?*(a=0):!(*a|*c&*c-46);}

ungolfed

f(char*a){char*c="codegolf.stackexchage.com";
          while(*c&&*c==*a)++a,++c;
          return strchr(a,46)?*(a=0):!(*a|*c&*c-46);
         }

f(codegolf.stackexchage.com)=1
f(codegolf.stackexchage.net)=0
f(codegolf.stackexchage)=1
f(codegolf.foo)=0
f(codegolf)=1
f(foo)=0

per il seguito deve segare l'errore

f(codegolf.stackexchage.com.foo)
f(foo.bar)
f(foo.bar.baz)
f(codegolf.foo.bar)
f(foo.v)

Java, 187 138 byte

Versione 2.0 ( 138 byte): Idea spudoratamente rubata da @Jamie.

l->{for(String []a=l.split,int l=i=a.length-1,e=0;i>=0;e+=a[i]!=new String[]{"codegolf","stackexchange","com"}[i]?i<l?s[-1]:1:0)return e;}

Versione 1.0 ( 187 byte):

l->{String[]a=l.split(".");return a[0].equals("codegolf")?(a.length<2?1:(a[1].equals("stackexchange")?(a.length<3?1:(a[2].equals("com")?1:0)):(a.length<3?0:a[-1]))):(a.length<2?0:a[-1]);}

Spiegazione della parte di ritorno:

return a[0].equals("codegolf")?(a.length<2?1:(a[1].equals("stackexchange")?(a.length<3?1:(a[2].equals("com")?1:0)):(a.length<3?0:a[-1]))):(a.length<2?0:a[-1]);
return                                                                                                                                                        ;
       a[0].equals("codegolf")?                                                                                                          :
                               (a.length<2? :                                                                                           ) (a.length<2? :     )
                                           1 (a[1].equals("stackexchange")?                                       :                    )              0 a[-1]
                                                                           (a.length<3? :                        ) (a.length<3? :     )
                                                                                       1 (a[2].equals("com")? : )              0 a[-1]
                                                                                                             1 0