Permisos de archivo

código-golf

Adaptado de la UIL - Programa de Ciencias de la Computación pregunta de respuesta gratuita "Carla" para el Distrito 2018.

Introducción

En los sistemas operativos tipo UNIX, cada archivo, directorio o enlace es "propiedad" de un "usuario", que es miembro de un "grupo" y tiene ciertos "permisos" representados por una cadena de diez caracteres como " drwxrwxrwx ". El primer carácter es 'd', '-' o 'l' (directorio, archivo o enlace), seguido de tres conjuntos de valores "rwx", que indican permisos de "lectura, escritura, ejecución". El primer conjunto son los derechos del usuario, el medio establece los derechos del grupo y el tercero los derechos de todos los demás sobre ese objeto.

El permiso denegado para cualquiera de estos derechos está representado por un '-' en lugar de 'r', 'w' o 'x'. Por ejemplo, una cadena de permiso de directorio de muestra sería "drwxr - r--", que indica derechos de directorio completos para el usuario, pero derechos de "solo lectura" para el miembro del grupo y todos los demás.

Cada combinación "rwx" también se puede representar mediante un valor octal (0-7) con el bit más significativo que representa el permiso de lectura, el siguiente bit más significativo que representa el permiso de escritura y el bit menos significativo que representa el permiso de ejecución.

Reto

Dada una cadena de código de cuatro caracteres compuesta por un carácter: 'D', 'F' o 'L', seguido de un valor entero octal de tres dígitos, como 664, genera la cadena de 10 caracteres resultante que representa el valor del permiso indicado.

Entrada

Su programa o función puede leer la entrada del estándar en (se ingresarán cuatro caracteres, opcionalmente seguidos de una nueva línea) o pasar la entrada como argumento.

Su programa puede aceptar entradas en mayúsculas o minúsculas, pero debe ser coherente (todas las entradas son mayúsculas o todas las entradas son minúsculas).

Salida

Su programa debe imprimir la cadena de diez caracteres resultante que representa el valor de permiso indicado en el formato exacto especificado anteriormente. Se permite el espacio en blanco de cola.

Casos de prueba

Entrada: F664Salida: -rw-rw-r--
Entrada: D775Salida: drwxrwxr-x
Entrada: L334Salida: l-wx-wxr--
Entrada: F530Salida: -r-x-wx---
Entrada: D127Salida:d--x-w-rwx

Puntaje y Reglas

• Los agujeros de bucle estándar están prohibidos.
• Aplican reglas estándar .
• Proporcione un enlace para probar su código, así como una explicación.
• Este es el código de golf , por lo que gana la respuesta más corta en bytes.

Jalea , 19 bytes

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

Pruébalo en línea!

Cómo funciona

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

bash, 59 53 bytes

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

¿Herramienta adecuada para el trabajo?

Gracias a Dennis por guardar 5 bytes y HTNW por guardar uno.

Pruébalo en línea!

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 -

Python 2 , 78 bytes

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

Toma entrada como personaje y tres entradas.
Pruébalo en línea!

Explicación

[a,'-'][a=='f']toma el carácter de entrada o -, si el carácter es f.
'-r'[x/4]+'-w-w'[x/2]+'-x'[x%2]es esencialmente una conversión octal para obtener la rwxcadena.

Perl 5 con -p37 bytes

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

Toma entrada en minúsculas.

Pruébalo en línea!

Retina 0.8.2 , 43 bytes

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

Pruébalo en línea! El enlace incluye casos de prueba. Toma entrada en minúsculas. Explicación:

\d
$&r$&w$&x

Por triplicado cada dígito, con sufijo r, wy x.

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

Cambia todas las letras incorrectas a -s.

\d

Eliminar los dígitos restantes.

Retina , 51 bytes

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

Pruébalo en línea!

No tengo idea de cómo usar Retina, así que hágame saber cómo hacerlo mejor. Solo pensé que intentaría aprender al menos un idioma que no sea Pyth.

Explicación:

Reemplace fcon -(saliente dy lsin cambios), luego reemplace cada dígito con el apropiado rwx.

JavaScript (ES6), 63 bytes

Espera la cadena de entrada en minúsculas.

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

Pruébalo en línea!

Comentado

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

Carbón , 27 bytes

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

Pruébalo en línea! El enlace es a la versión detallada del código. Explicación:

 Ｓ                          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

Haskell , 84 83 81 bytes

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

Pruébalo en línea!

Terminó siendo bastante similar en concepto a la respuesta de Python 2 de Mnemonic. f crea el tipo de archivo, el resto son los permisos obtenidos del número octal. Este realmente me hizo desear y fue un bit a bit y operador incluido en el preludio.

Java 8, 100 bytes

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

Pruébalo en línea.

Puerto de la respuesta de Retina de @Neil .

Explicación:

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

Jalea , 21 bytes

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

Un programa completo de impresión a STDOUT. (Como enlace monádico, el valor de retorno es una lista que contiene un carácter y una lista de tres listas de caracteres).

Pruébalo en línea! O vea el conjunto de pruebas .

¿Cómo?

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

Perl 6 -p , 37 bytes

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

Pruébalo en línea!

Solución Perl 5 del puerto de Dom Hastings.

Retina , 38 bytes

Inspirado en un comentario de solo ASCII .

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

Pruébalo en línea!

La idea es convertir cada dígito a unario (el dígito unario predeterminado en Retina es _) con tres iniciales -, y luego convertir los dígitos binarios del más significativo al menos significativo.

Python 3 , 71 bytes

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

Pruébalo en línea!

Python 3.3+ tiene una función incorporada para eso, aunque debido a la necesidad de una importación y las diferencias en el formato de entrada esperado, no es muy amigable para el golf.

Tcl , 139 bytes

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

Pruébalo en línea!

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

Pruébalo en línea!

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

Pruébalo en línea!

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

Pruébalo en línea!

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

Pruébalo en línea!

Todavía muy poco golfista!

Java (JDK 10) , 118 bytes

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

Pruébalo en línea!

Créditos

• 13 bytes guardados gracias a Kevin Cruijssen

Excel, 224 bytes

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

Hecho en 4 etapas:

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

Y 3 veces:

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

Intentando ser más inteligente, agrega 25 bytespor conjunto de derechos, 75 en 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","-")

05AB1E , 34 27 bytes

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

Pruébalo en línea!

Golfed 7 bytes por @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.

Python 2 , 238 bytes

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

Pruébalo en línea!

Asumí que esto sería una gota en el cubo, pero me equivoqué. Probablemente debería haberse dado cuenta de que una lambda no era la mejor idea en algún momento.

APL + WIN, 55 bytes

Solicita una cadena de entrada con minúsculas de caracteres iniciales:

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

Explicación:

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'

Python 3 , 77 bytes

lambda a,*b,k='-xw-r':f'{a}-'[a=='f']+''.join(k[x&4]+k[x&2]+k[x&1]for x in b)

Pruébalo en línea!

J , 57 52 bytes

¡5 bytes guardados gracias a FrownyFrog!

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

Pruébalo en línea!

Sin embargo, otra solución larga ... No sé cómo hacer que el }trabajo en verbos tácitos y por eso usé mucho más tiempo {"0 1&.|:para la selección.

Explicación:

@}. Suelta el primer símbolo y

,.&.": convertir el resto a una lista de dígitos desimales

]:#: Convierta cada dígito en una lista de dígitos binarios (y tape la bifurcación)

('-',:'rwx') crea una tabla de 2 filas y usa 0 para seleccionar desde su primera fila / 1 - desde su segunda

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

{"0 1&.|:~ usa los dígitos binarios para seleccionar de la tabla de arriba

[:, aplana el resultado

('d-l'{~'DFL'i.{.) formatea el primer símbolo

, agrega el símbolo fisrt a la lista de permisos

PHP, 68 bytes

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

se traduce fen una entrada en minúscula al guión bajo y cada número octal a su rwxequivalente, usando guiones bajos en lugar de guiones (para ahorrar la necesidad de comillas), luego reemplaza _con -.

Ejecutar como tubería con -nFo probarlo en línea .

C (gcc) , 109104 bytes

Al menos C puede convertir la entrada octal .... :-)

Editar: me di cuenta de que el modificador de tamaño no era estrictamente necesario, ¡y eso putchar()es más corto que printf()en este caso!

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

Pruébalo en línea!

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

Pruébalo en línea!