Autorisations de fichier

26

Autorisations de fichier

code-golf

Adapté de la question à réponse gratuite "Carla" de l'UIL - Programmation en informatique pour le district 2018.

introduction

Dans les systèmes d'exploitation de type UNIX, chaque fichier, répertoire ou lien est "détenu" par un "utilisateur", qui est membre d'un "groupe", et possède certaines "autorisations" représentées par une chaîne de dix caractères telle que " drwxrwxrwx ". Le premier caractère est 'd', '-' ou 'l' (répertoire, fichier ou lien), suivi de trois ensembles de valeurs "rwx", indiquant les autorisations "lecture, écriture, exécution". Le premier ensemble est les droits de l'utilisateur, le milieu définit les droits du groupe et le troisième les droits de tous les autres sur cet objet.

L'autorisation refusée pour l'un de ces droits est représentée par un «-» à la place du «r», du «w» ou du «x». Par exemple, un exemple de chaîne d'autorisation de répertoire serait "drwxr - r--", indiquant les droits de répertoire complets pour l'utilisateur, mais les droits en "lecture seule" pour le membre du groupe et tous les autres.

Chaque combinaison "rwx" peut également être représentée par une valeur octale (0-7) avec le bit le plus significatif représentant la permission de lecture, le bit le plus significatif suivant représentant la permission d'écriture et le bit le moins significatif représentant la permission d'exécution.

Défi

Étant donné une chaîne de code à quatre caractères composée d'un caractère: «D», «F» ou «L», suivi d'une valeur entière octale à trois chiffres, comme 664, sortez la chaîne de 10 caractères résultante qui représente la valeur d'autorisation indiqué.

Contribution

Votre programme ou fonction peut soit lire l'entrée de la norme en (quatre caractères seront entrés, éventuellement suivis d'une nouvelle ligne), soit passer l'entrée en argument.

Votre programme peut accepter des entrées en majuscules ou en minuscules mais doit être cohérent (soit toutes les entrées sont en majuscules, soit toutes les entrées sont en minuscules).

Sortie

Votre programme doit imprimer la chaîne de dix caractères résultante qui représente la valeur d'autorisation indiquée dans le format exact spécifié ci-dessus. Un espace blanc est autorisé.

Cas de test

Entrée: F664Sortie: -rw-rw-r--
Entrée: D775Sortie: drwxrwxr-x
Entrée: L334Sortie: l-wx-wxr--
Entrée: F530Sortie: -r-x-wx---
Entrée: D127Sortie:d--x-w-rwx

Scoring et règles

code-golf Billylegota
la source
Attendez quoi, demandé hier et réponse déjà acceptée? Est-ce à dire qu'aucune autre réponse n'est attendue ou quoi?
Nit
1
@Nit Plus de réponses sont toujours les bienvenues, qu'elles soient acceptées ou non.
isaacg
1
@Nit J'étais sur mobile et j'essayais de voter contre une réponse sans rapport (qui a été supprimée depuis). J'ai accidentellement appuyé sur le bouton Accepter la réponse avec mon gros doigt. Je ne pouvais pas comprendre comment refuser, alors je viens de changer la réponse acceptée par la plus courte à partir de maintenant.
Billylegota
2
@ Non, je veux dire ... il a accepté une réponse de Dennis, donc il peut être honnête.
Urne de poulpe magique

Réponses:

7

Gelée , 19 octets

“rwx“-”Œp⁺;Ṁ⁾f-yị@~

Essayez-le en ligne!

Comment ça marche

“rwx“-”Œp⁺;Ṁ⁾f-yị@~  Main link. Argument: s (string)

“rwx“-”              Set the return value to ["rwx, "-"].
       Œp            Take the Cartesian product, yielding ["r-", "w-", "x-"].
         ⁺           Take the Cartesian product, yielding
                     ["rwx", "rw-", "r-x", "r--", "-wx", "-w-", "--x", "---"].
          ;Ṁ         Append the maximum of s (the letter).
            ⁾f-y     Translate 'f' to '-'.
                  ~  Map bitwise NOT over s.
                     This maps the letter to 0, because it cannot be cast to int,
                     and each digit d to ~d = -(d+1).
                ị@   Retrieve the results from the array to the left at the indices
                     calculated to the right.
                     Indexing is modular and 1-based, so the letter from s is at
                     index 0, "---" at index -1, ..., and "rwx" at index -8.
Dennis
la source
16

bash, 59 53 octets

chmod ${1:1} a>a;stat -c%A a|sed s/./${1:0:1}/|tr f -

Le bon outil pour le travail?

Merci à Dennis pour avoir sauvé 5 octets et HTNW pour en avoir sauvegardé un.

Essayez-le en ligne!

chmod ${1:1} a>a;  # call chmod with the input with its first character removed
                   # note that the redirection creates the file a *before* the
                   #   chmod is run, because of the way bash works
stat -c%A a|       # get the human readable access rights
sed s/./${1:0:1}/  # replace the first character with the first char of input
|tr f -            # transliterate, replacing f with -
Poignée de porte
la source
Eh bien, c'était rapide. Certainement le bon outil pour le travail.
Billylegota
chmod ${1:1} a>a;stat -c%A a|sed "s/-/\L${1:0:1}/;s/f/-/"enregistre deux octets.
Dennis
En partant @Dennis, je pense que vous pouvez vous raser un de plus avec trau lieu de y:chmod ${1:1} a>a;stat -c%A a|sed s/./\\L${1:0:1}/|tr f -
HTNW
2
Est-il légitime de supposer qu'il n'y a pas de fichier aet que l'utilisateur est autorisé à le créer ou qu'il existe aet qu'il est accessible en écriture par l'utilisateur? Parce que s'il existe un fichier aappartenant à rootavec des autorisations 700, cela ne devrait pas fonctionner.
NoOneIsHere
2
@NoOneIsHere Bien que les autorisations en particulier ne soient jamais apparues dans la discussion, la communauté a décidé que la création de fichiers temporaires dans le répertoire actuel est autorisée par défaut . Par extension, on peut supposer que c'est possible.
Dennis
10

Python 2 , 78 octets

lambda a,*b:[a,'-'][a=='f']+''.join('-r'[x/4]+'-w-w'[x/2]+'-x'[x%2]for x in b)

Prend l'entrée en tant que caractère et trois pouces.
Essayez-le en ligne!

Explication

[a,'-'][a=='f']prend le caractère d'entrée ou -, si le caractère est f.
'-r'[x/4]+'-w-w'[x/2]+'-x'[x%2]est essentiellement une conversion octale pour obtenir la rwxchaîne.


la source
5

Perl 5 avec -p, 37 octets

s/\d/(<{-,r}{-,w}{-,x}>)[$&]/ge;y;f;-

Prend l'entrée en minuscules.

Essayez-le en ligne!

Dom Hastings
la source
5

Retina 0.8.2 , 43 octets

\d
$&r$&w$&x
f|[0-3]r|[0145]w|[0246]x
-
\d

Essayez-le en ligne! Le lien inclut des cas de test. Prend l'entrée en minuscules. Explication:

\d
$&r$&w$&x

Chaque chiffre en trois exemplaires, avec suffixant r, wet x.

f|[0-3]r|[0145]w|[0246]x
-

Remplacez toutes les lettres incorrectes par -s.

\d

Supprimez tous les chiffres restants.

Neil
la source
4

Rétine , 51 octets

f
-
0
---
1
--x
2
-w-
3
-wx
4
r--
5
r-x
6
rw-
7
rwx

Essayez-le en ligne!

Je ne sais pas comment utiliser Retina, alors faites-moi savoir comment faire mieux. Je pensais juste que j'essaierais d'apprendre au moins une langue qui n'est pas Pyth.

Explication:

Remplacez fpar -(laissant det linchangé), puis remplacez chaque chiffre par le chiffre approprié rwx.


la source
: / Je peux aller jusque là mais pas plus loin. et la façon intelligente est super indolore
ASCII uniquement
Ce serait tellement golfeur avec une sorte d'opérateur ternaire / logique ou / ajouter et couper
ASCII uniquement
@ ASCII uniquement Votre idée était plutôt sympa, je l'ai utilisée pour cette réponse :)
Leo
4

JavaScript (ES6), 63 octets

Attend la chaîne d'entrée en minuscules.

s=>s.replace(/\d|f/g,c=>1/c?s[c&4]+s[c&2]+s[c&1]:'-',s='-xw-r')

Essayez-le en ligne!

Commenté

s => s.replace(   // replace in the input string s
  /\d|f/g, c =>   //   each character c which is either a digit or the letter 'f'
    1 / c ?       //   if c is a digit:
      s[c & 4] +  //     append '-' or 'r'
      s[c & 2] +  //     append '-' or 'w'
      s[c & 1]    //     append '-' or 'x'
    :             //   else:
      '-',        //     just replace 'f' with '-'
  s = '-xw-r'     //   s holds the permission characters
)                 // end of replace()
Arnauld
la source
4

Fusain , 27 octets

ＦＳ≡ιdιlιf¦-⭆rwx⎇§↨⁺⁸Ｉι²⊕λκ-

Essayez-le en ligne! Le lien est vers la version détaillée du code. Explication:

 Ｓ                          Input string
Ｆ                           Loop over characters
   ι                        Current character
  ≡                         Switch
    d                       Literal `d`
     ι                      Implicitly print current character
      l                     Literal `l`
       ι                    Implicitly print current character
        f                   Literal `f`
         ¦                  (Separator between string literals)
          -                 Implicitly print literal `-`
                            Implicit default case
            rwx             Literal `rwx`
           ⭆                Map over characters
                     ι      Input character
                    Ｉ       Cast to integer
                   ⁸        Literal 8
                  ⁺         Sum
                      ²     Literal 2
                 ↨          Base conversion
                        λ   Inner index
                       ⊕    Incremented
                §           Index into base conversion
                         κ  Inner character
                          - Literal `-`
               ⎇            Ternary
                            Implicitly print
Neil
la source
4

Haskell , 84 83 81 octets

f 'f'='-'
f y=y
t#n=f t:((\x->["-r"!!div x 4,"-w-w"!!div x 2,"-x"!!mod x 2])=<<n)

Essayez-le en ligne!

A fini par être assez similaire dans son concept à la réponse Python 2 de Mnemonic. f crée le type de fichier, le reste est le obtient les autorisations du nombre octal. Celui-ci m'a vraiment fait souhaiter et était un opérateur au niveau du bit et inclus dans le prélude.

aoemica
la source
2
Vous pouvez utiliser à la divplace de quot.
nimi
4

Java 8, 100 octets

s->s.replaceAll("(\\d)","$1r$1w$1x").replaceAll("f|[0-3]r|[0145]w|[0246]x","-").replaceAll("\\d","")

Essayez-le en ligne.

Réponse de Port of @Neil Retina .

Explication:

s->                                 // Method with String as both parameter and return-type
  s.replaceAll("(\\d)","$1r$1w$1x") //  Replace every digit `d` with 'drdwdx'
   .replaceAll("f                   //  Replace every "f",
                |[0-3]r             //  every "0r", "1r", "2r", "3r",
                |[0145]w            //  every "0w", "1w", "4w", "5w",
                |[0246]x",          //  and every "0x", "2x", "4x", "6x"
               "-")                 //  with a "-"
   .replaceAll("\\d","")            //  Remove any remaining digits
Kevin Cruijssen
la source
C'est intelligent! ;)
Olivier Grégoire
@ OlivierGrégoire Eh bien, principalement parce que cela économise sur la déclaration de retour et les boucles. Dommage que trois individus .replaceAllsoient encore moins d'octets qu'une boucle avec .replaceAllet ajoutés returnet String-array .. Mais le mérite revient bien sûr à Neil , qui est la réponse Retina que j'ai utilisée comme base de portage.
Kevin Cruijssen
3

Gelée , 21 octets

Ḣ⁾f-yɓOBṫ€4a“rwx”o”-ṭ

Un programme complet d'impression sur STDOUT. (En tant que lien monadique, la valeur de retour est une liste contenant un caractère et une liste de trois listes de caractères.)

Essayez-le en ligne!Ou consultez la suite de tests .

Comment?

Ḣ⁾f-yɓOBṫ€4a“rwx”o”-ṭ | Main Link: list of characters
Ḣ                     | head & pop (get the 1st character and modify the list)
 ⁾f-                  | list of characters = ['f', '-']
    y                 | translate (replacing 'f' with '-'; leaving 'd' and 'l' unaffected)
     ɓ                | (call that X) new dyadic chain: f(modified input; X)
      O               | ordinals ('0'->48, '1'->59, ..., '7'->55 -- notably 32+16+value)
       B              | convert to binary (vectorises) (getting three lists of six 1s and 0s)
        ṫ€4           | tail €ach from index 4 (getting the three least significant bits)
           “rwx”      | list of characters ['r', 'w', 'x']
          a           | logical AND (vectorises) (1s become 'r', 'w', or 'x'; 0s unaffected)
                 ”-   | character '-'
                o     | logical OR (vectorises) (replacing any 0s with '-'s)
                   ṭ  | tack (prepend the character X) 
                      | implicit print (smashes everything together)
Jonathan Allan
la source
3

Perl 6 -p , 37 octets

s:g[\d]=[X~]('-'X <r w x>)[$/];s/f/-/

Essayez-le en ligne!

Solution Perl 5 du port de Dom Hastings.

nwellnhof
la source
3

Rétine , 38 octets

Inspiré par un commentaire de ASCII uniquement .

\d
---$&*
---____
r--
--__
w-
-_
x
f
-

Essayez-le en ligne!

L'idée est de convertir chaque chiffre en unaire (le chiffre unaire par défaut dans Retina est _) avec trois interlignes -, puis de convertir les chiffres binaires du plus grand au moins significatif.

Leo
la source
2

Python 3 , 71 octets

lambda s:("-"+s)[s[0]!="f"]+stat.filemode(int(s[1:],8))[1:]
import stat

Essayez-le en ligne!

Python 3.3+ a une fonction intégrée pour cela, bien qu'en raison de la nécessité d'une importation et des différences de format d'entrée attendues, il n'est pas très adapté au golf.

Kirill L.
la source
2

Tcl , 139 octets

proc P s {join [lmap c [split $s ""] {expr {[regexp \\d $c]?"[expr $c&4?"r":"-"][expr $c&2?"w":"-"][expr $c&1?"x":"-"]":$c==f?"-":$c}}] ""}

Essayez-le en ligne!

Tcl , 144 octets

proc P s {join [lmap c [split $s ""] {expr {[regexp \\d $c]?[list [expr $c&4?"r":"-"][expr $c&2?"w":"-"][expr $c&1?"x":"-"]]:$c==f?"-":$c}}] ""}

Essayez-le en ligne!

Tcl , 149 octets

proc P s {join [lmap c [split $s ""] {if [regexp \\d $c] {list [expr $c&4?"r":"-"][expr $c&2?"w":"-"][expr $c&1?"x":"-"]} {expr {$c==f?"-":$c}}}] ""}

Essayez-le en ligne!

Tcl , 150 octets

proc P s {join [lmap c [split $s ""] {if [regexp \\d $c] {set v [expr $c&4?"r":"-"][expr $c&2?"w":"-"][expr $c&1?"x":"-"]} {expr {$c==f?"-":$c}}}] ""}

Essayez-le en ligne!

Tcl , 180 octets

proc P s {join [lmap c [split $s ""] {if [regexp \\d $c] {[set R regsub] (..)1 [$R (.)1(.) [$R 1(..) [$R -all 0 [format %03b $c] -] r\\1] \\1w\\2] \\1x} {expr {$c==f?"-":$c}}}] ""}

Essayez-le en ligne!

Encore très peu golfé!

sergiol
la source
2

Java (JDK 10) , 118 octets

s->{var r=s[0]=='f'?"-":""+s[0];var z="-xw r".split("");for(int i=0;++i<4;)r+=z[s[i]&4]+z[s[i]&2]+z[s[i]&1];return r;}

Essayez-le en ligne!

Crédits

Olivier Grégoire
la source
2
Lorsque vous prenez l'entrée en minuscules fdl, vous pouvez changer la var r=s[0]<70?"d":s[0]<72?"-":"l";pour var r=s[0]=='f'?"-":s[0]+"";sauver 6 octets. En outre, .toCharArray()peut consister .split("")à enregistrer 4 octets supplémentaires.
Kevin Cruijssen
2
@KevinCruijssen Votre idée m'a fait économiser 13 octets, pas 10 (car j'ai pu le supprimer ""+plus tard pour "transtyper" un charen a String);) Merci!
Olivier Grégoire
2

Excel, 224 octets

=IF(LEFT(A1,1)="f","-",LEFT(A1,1))&CHOOSE(MID(A1,2,1)+1,"---","--x","-w-","-wx","r--","r-x","rw-","rwx")&CHOOSE(MID(A1,3,1)+1,"---","--x","-w-","-wx","r--","r-x","rw-","rwx")&CHOOSE(MID(A1,4,1)+1,"---","--x","-w-","-wx","r--","r-x","rw-","rwx")

Fait en 4 étapes:

IF(LEFT(A1,1)="f","-",LEFT(A1,1))    Replace "f" with "-".

Et 3 fois:

CHOOSE(MID(A1,2,1)+1,"---","--x","-w-","-wx","r--","r-x","rw-","rwx")

Essayer d'être plus intelligent, ajoute 25 bytespar ensemble de droits, 75 au total:

IF(INT(MID(A1,2,1))>3,"r","-")&IF(MOD(MID(A1,2,1),4)>1,"w","-")&IF(ISODD(MID(A1,2,1)),"x","-")
Wernisch
la source
2

05AB1E , 34 27 octets

ćls8βbvyi…rwx3*Nèë'-}J'f'-:

Essayez-le en ligne!

Golfé 7 octets par @MagicOctopusUrn

ć                           # Remove head from string.
 ls                         # Lowercase swap.
   8βb                      # Octal convert to binary.
      vy                    # For each...
        i        ë  }
         …rwx3*Nè           # If true, push the correct index of rwx.
                  '-        # Else push '-'.
                     J      # Repeatedly join stack inside the loop.
                      'f'-: # Repeatedly replace 'f' with '-' inside the loop.
Geno Racklin Asher
la source
ćls8βbvyi…rwx3*Nèë'-}J'f'-:pour 7 de moins ...
Urne Magic Octopus
Fondamentalement, juste un ordre différent en utilisant les instructions if, et au lieu de supprimer le fje remplace simplement tous fles éléments de la chaîne finale par -.
Urne de poulpe magique
i <CODE FOR TRUE> ë <CODE FOR FALSE> }
Urne Magic Octopus
@MagicOctopusUrn Nice!
Geno Racklin Asher
1

Python 2 , 238 octets

lambda m,r=str.replace,s=str.split,j="".join,b=bin,i=int,z=str.zfill,g=lambda h,y:y if int(h)else "-":r(m[0],"f","-")+j(j([g(z(s(b(i(x)),"b")[1],3)[0],"r"),g(z(s(b(i(x)),"b")[1],3)[1],"w"),g(z(s(b(i(x)),"b")[1],3)[2],"x")])for x in m[1:])

Essayez-le en ligne!

J'avais supposé que ce serait une goutte d'eau, mais j'avais vraiment tort. J'aurais probablement dû réaliser qu'un lambda n'était pas la meilleure idée à un moment donné.

LyricLy
la source
: | trop de buildins = trop long
ASCII uniquement
1

APL + WIN, 55 octets

Invite à saisir une chaîne en minuscules:

('dl-'['dlf'⍳↑t]),⎕av[46+(,⍉(3⍴2)⊤⍎¨⍕1↓t←⎕)×9⍴69 74 75]

Explication:

9⍴69 74 75 create a vector of ascii character codes for rwx -46, index origin 1

1↓t←⎕ prompt for input and drop first character

,⍉(3⍴2)⊤⍎¨⍕ create a 9 element vector by concatenating the binary representation for each digit 

46+(,⍉(3⍴2)⊤⍎¨⍕1↓t←⎕)×9⍴69 74 75 multiply the two vectors and add 46

⎕av[.....] convert back from ascii code to characters, 46 being '-'

('dl-'['dlf'⍳↑t]), append first character from input swapping '-' for 'f'
Graham
la source
1

J , 57 52 octets

5 octets économisés grâce à FrownyFrog!

-&.('-DLld'i.{.),[:,('-',:'rwx'){"0 1&.|:~1#:@}."."0

Essayez-le en ligne!

Encore une autre longue solution ... Je ne sais pas comment faire }fonctionner les verbes tacites et c'est pourquoi j'ai utilisé le plus longtemps{"0 1&.|: pour la sélection.

Explication:

@}. Déposez le premier symbole et

,.&.": convertir le reste en une liste de chiffres décimaux

]:#: convertir chaque chiffre en une liste de chiffres binaires (et coiffer la fourche)

('-',:'rwx') crée un tableau à 2 lignes et utilisez 0 pour sélectionner dans sa première ligne / 1 - dans sa seconde

   '-',:'rwx'
---
rwx

{"0 1&.|:~ utilise les chiffres binaires pour sélectionner dans le tableau ci-dessus

[:, aplatit le résultat

('d-l'{~'DFL'i.{.) formate le premier symbole

, ajoute le premier symbole à la liste des autorisations

Galen Ivanov
la source
1
L'entrée est déjà une chaîne, vous avez besoin1#:@}."."0
FrownyFrog
1
Cela semble fonctionner: ('d-l'{~'DFL'i.{.)→-&.('-DLld'i.{.)
FrownyFrog
@FrownyFrog Très bonne utilisation i.et &.merci beaucoup! Au fait, pouvez-vous m'expliquer comment utiliser select }dans les verbes tacites?
Galen Ivanov
1
2 2 2&#:`('-',:'rwx'"_)}@"."0@}.est exactement de la même longueur
FrownyFrog
Mais ça ne marche pas 333:)
FrownyFrog
1

PHP, 68 octets

<?=strtr(strtr($argn,[f=>_,___,__x,_w_,_wx,r__,r_x,rw_,rwx]),_,"-");

traduit fen entrée minuscule pour souligner et chaque nombre octal à son rwxéquivalent, en utilisant des traits de soulignement au lieu de tirets (pour économiser le besoin de guillemets), puis remplace le _avec- .

Exécuter en tant que pipe avec -nFou l' essayer en ligne .

Titus
la source
1

C (gcc) , 109104 octets

Au moins C peut convertir une entrée octale .... :-)

Edit: j'ai réalisé que le modificateur de taille n'était pas strictement requis, et c'est putchar()plus court que printf()dans ce cas!

f(a,b){char*s="-xwr";scanf("%c%o",&a,&b);putchar(a-70?a:*s);for(a=9;~--a;putchar(s[(1&b>>a)*(a%3+1)]));}

Essayez-le en ligne!

Original:

f(a,b){char*s="-xwr";scanf("%c%3o",&a,&b);putchar(a-70?a:*s);for(a=9;~--a;printf("%c",s[(1&b>>a)*(a%3+1)]));}

Essayez-le en ligne!

ErikF
la source