La sfida

Data una stringa che indica la notazione simbolica dell'autorizzazione UNIX di un file e la sua proprietà (ID utente e ID gruppo), decidere se un determinato utente Adispone dell'autorizzazione per leggerlo / scriverlo / eseguirlo.

Correlato .

Autorizzazioni nel sistema UNIX

In UNIX, ogni file ha tre classi di autorizzazioni ( utente , gruppo e altri ) e proprietà, incluso l'utente e il gruppo a cui appartiene.

La notazione simbolica è composta da dieci caratteri. Il primo personaggio non è importante in questa sfida. I rimanenti nove caratteri sono in tre set di tre caratteri, che rappresentano le autorizzazioni dell'utente, del gruppo e di altre classi. I caratteri in ogni set indicano se è consentita la lettura / scrittura / esecuzione. Se consentito, sarà r, wo x. Altrimenti lo sarà -.

Si noti che setuid , setgid e sticky bit può cambiare il terzo carattere di ciascun insieme a s, S, to T. Ecco una semplice regola: se il personaggio è una lettera minuscola, viene impostata l'autorizzazione; altrimenti non lo è.

(Per i dettagli sulla notazione simbolica delle autorizzazioni, fare riferimento qui .)

Ogni utente ha il suo ID utente e ogni gruppo ha il suo ID gruppo. Tutti gli ID saranno numeri interi non negativi. Un utente apparterrà ad almeno un gruppo. Se un utente Adesidera accedere a un file, il sistema controllerà le proprie autorizzazioni come segue:

• Se il file appartiene all'utente A, controllare le autorizzazioni della classe utente .

• Se il file non appartiene A, ma Aappartiene al gruppo a cui appartiene il file, controllare le autorizzazioni della classe di gruppo .

• Altrimenti, controlla le autorizzazioni di altre classi.

Tuttavia, c'è un'eccezione: se l'ID utente è 0 (superutente), hanno il permesso di fare qualsiasi cosa !

specificazioni

• Il tuo programma / funzione dovrebbe prenderli come input in qualsiasi formato ragionevole:
  • Autorizzazioni in notazione simbolica .
  • ID utente e ID gruppo a cui appartiene il file.
  • L'ID utente di Ae un elenco di ID gruppo a cui Aappartiene.
  • Tipo di accesso. È possibile utilizzare tre diversi valori di una cifra o di un carattere per leggere, scrivere ed eseguire.
• Restituisce / genera un valore veritiero se Aha il permesso di accedere al file, oppure un valore falso in caso contrario.
• Si può presumere che il primo carattere della notazione sarà sempre -(file normale).
• Questo è code-golf , quindi vince il byte più corto!

Casi test

Il formato qui è [permissions, user ID of file, group ID of file, user ID of A, group IDs of A, type(r/w/x)].

[-rwx------, 13, 15, 13, [15, 24], r]: True   # user
[-rwxr-xr-x, 13, 24, 24, [15, 24], w]: False  # group 
[-rwxr-Sr-T, 13, 15, 24, [15, 35], x]: False  # group
[-rwsr-xr-t, 13, 15, 24, [24, 35], x]: True   # others
[----------, 13, 15, 0, [0, 1, 2], r]: True   # superuser
[----------, 13, 15, 1, [0, 1, 2], r]: False  # others
[----rwxrwx, 13, 15, 13, [15, 24], r]: False  # user

JavaScript (ES6), 61 51 50 byte

Accetta 6 parametri distinti come input, nell'ordine descritto nella sfida. Si aspetta che l'ultimo parametro di essere 1per la lettura , 2per scrittura o 3per l'esecuzione . Restituisce 0o 1.

(p,u,g,a,G,P)=>!a|p[u-a?6-3*G.includes(g)+P:P]>'Z'

Casi test

let f =

(p,u,g,a,G,P)=>!a|p[u-a?6-3*G.includes(g)+P:P]>'Z'

//            p             u   g   a   G          P
console.log(f('-rwx------', 13, 15, 13, [15, 24],  1)) // True  (user)
console.log(f('-rwxr-xr-x', 13, 24, 24, [15, 24],  2)) // False (group)
console.log(f('-rwxr-Sr-T', 13, 15, 24, [15, 35],  3)) // False (group)
console.log(f('-rwsr-xr-t', 13, 15, 24, [24, 35],  3)) // True  (others)
console.log(f('----------', 13, 15,  0, [0, 1, 2], 1)) // True  (superuser)
console.log(f('----------', 13, 15,  1, [0, 1, 2], 1)) // False (others)
console.log(f('----rwxrwx', 13, 15, 13, [15, 24],  1)) // False (user)

Python 2 , 76 70 67 63 59 58 56 55 52 49 48 byte

lambda p,u,g,A,G,t:A*'_'<p[~(u==A)*3*(g in G)-t]

Provalo online!

Prende il tipo 3per read, 2per write e 1per execute

Java (OpenJDK 8) , 60 byte

(p,u,g,U,G,t)->U<1|p.charAt(t+(u==U?0:G.contains(g)?3:6))>90

Provalo online!

La mappatura per il tipo è la seguente: 1mezzi r, 2mezzi we 3mezzi x.

Pyth, 22 21 byte

|!Q}@@c3tw*nEQ-2}EEEG

Provalo online. Suite di test.

Accetta input come sei righe:

user id
permissions
file user id
file group
user groups
permission (0 = read, 1 = write, 2 = execute)

Spiegazione

|!Q}@@c3tw*nEQ-2}EEEG     Implicit: read user id to Q
 !Q                       True if user id is 0, false otherwise
|                         If true, just return it
         w                Read permission string
        -                 Omit first -
      c3                  Split in 3 parts
            E             Read file user id
           n Q            See if it doesn't equal Q
                          -> False (0) if user matches, true (1) otherwise
                 E        Read file group
                  E       Read user groups
                }         -> True (1) if group matches, false (0) otherwise
              -2          Subtract from 2
                          -> 1 if group matches, 2 otherwise
          *               Multiply the two numbers
                          -> 0 if user matches, 1 if group matches, 2 otherwise
     @                    Take correct part of permission string
    @                     Take correct character of that part
   }                G     See if it is in lowercase alphabet