Le défi

Étant donné une chaîne indiquant la notation symbolique de l'autorisation UNIX d'un fichier et sa propriété (ID utilisateur et ID de groupe), décidez si un utilisateur donné Aest autorisé à le lire / écrire / l'exécuter.

Connexes .

Autorisations dans le système UNIX

Sous UNIX, chaque fichier possède trois classes d'autorisations ( utilisateur , groupe et autres ) et de propriété, y compris à quel utilisateur et à quel groupe il appartient.

La notation symbolique se compose de dix caractères. Le premier personnage n'est pas important dans ce défi. Les neuf caractères restants sont répartis en trois ensembles de trois caractères, représentant les autorisations des utilisateurs, des groupes et des autres classes. Les caractères de chaque ensemble indiquent si la lecture / l'écriture / l'exécution est autorisée. Si cela est permis, ce sera le cas r, wou x. Sinon, ça le sera -.

Notez que setuid , setgid et peu collante peut changer le troisième caractère de chaque ensemble s, S, tou T. Voici une règle simple: si le caractère est une lettre minuscule, alors l'autorisation est définie; sinon, ce n'est pas le cas.

(Pour les détails de la notation symbolique des autorisations, veuillez vous référer ici .)

Chaque utilisateur a son ID utilisateur et chaque groupe a son ID de groupe. Tous les ID seront des entiers non négatifs. Un utilisateur appartiendra à au moins un groupe. Si un utilisateur Asouhaite accéder à un fichier, le système vérifiera ses autorisations comme suit:

• Si le fichier appartient à l'utilisateur A, vérifiez les autorisations de la classe d' utilisateurs .

• Si le fichier n'appartient pas A, mais Aappartient au groupe auquel il appartient, vérifiez les autorisations de la classe de groupe .

• Sinon, vérifiez les autorisations des autres classes.

Cependant, il y a une exception: si l'ID utilisateur est 0 (superutilisateur), ils ont l'autorisation de faire quoi que ce soit !

Caractéristiques

• Votre programme / fonction doit les prendre en entrée dans n'importe quel format raisonnable:
  • Autorisations en notation symbolique .
  • ID utilisateur et ID groupe auquel appartient le fichier.
  • L'ID utilisateur de A, et une liste des ID de groupe auxquels Aappartient.
  • Type d'accès. Vous pouvez utiliser trois valeurs différentes à un chiffre ou à un caractère pour la lecture, l'écriture et l'exécution.
• Renvoie / affiche une valeur véridique si elle Aa l'autorisation d'accéder au fichier, ou une valeur fausse si ce n'est pas le cas.
• Vous pouvez supposer que le premier caractère de la notation sera toujours -(fichier normal).
• Il s'agit de code-golf , donc le plus court en octets gagne!

Cas de test

Le format est ici [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 octets

Prend 6 paramètres distincts en entrée, dans l'ordre décrit dans le défi. Attend que le dernier paramètre soit 1en lecture , 2en écriture ou 3en exécution . Renvoie 0ou 1.

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

Cas de 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 octets

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

Essayez-le en ligne!

Prend le type comme 3pour la lecture, l' 2écriture et l' 1exécution

Java (OpenJDK 8) , 60 octets

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

Essayez-le en ligne!

Le mappage pour le type est le suivant: 1moyens r, 2moyens wet 3moyens x.

Pyth, 22 21 octets

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

Essayez-le en ligne. Suite de tests.

Prend l'entrée en six lignes:

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

Explication

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