Decodifica el chmod

26

Reto

Dado un número de permisos octales de tres dígitos, genera los permisos que otorga.

chmod

En sistemas operativos UNIX, los permisos de los archivos se cambian con el chmodcomando Hay pocas formas diferentes de usar chmod, pero la que nos centraremos hoy es usar permisos octales.

Los tres dígitos en el número de permisos representan a una persona diferente:

  • El primer dígito representa los permisos para el usuario.
  • El segundo dígito representa los permisos para el grupo.
  • El último dígito representa los permisos para otros.

A continuación, cada dígito representa un permiso como se muestra a continuación en:

Key: number | permission

7 | Read Write and Execute
6 | Read and Write
5 | Read and Execute
4 | Read only
3 | Write and Execute
2 | Write only
1 | Execute only
0 | None

Entrada

La entrada será el número de tres dígitos como una cadena, por ejemplo:

133

o

007

Esto se transmitirá a través de STDIN o mediante argumentos de función.

Salida

Su salida debe ser los diferentes permisos para cada uno de los usuarios, el grupo y los demás. Debe mostrar esta información así:

User:   ddd
Group:  ddd
Others: ddd

Donde hay tres espacios después User, dos espacios después Groupy un espacio después Others. Reemplaza dddcon la información de permisos.

Su salida puede ser STDOUT o como una cadena devuelta.

Ejemplos

Entrada: 666

Salida:

User:   Read and Write
Group:  Read and Write
Others: Read and Write

Entrada: 042

Salida:

User:   None
Group:  Read only
Others: Write only

Entrada: 644

Salida:

User:   Read and Write
Group:  Read only
Others: Read only

Victorioso

El código más corto en bytes gana.

Decaimiento Beta
fuente
¿Cuáles son las especificaciones de la entrada?
Jonathan Allan
@JonathanAllan Solo el número de tres dígitos
Beta Decay
¿Te refieres solo a un entero decimal, entonces 042 se recibiría como 42?
Jonathan Allan
2
@ Jonathan No, es una entrada de cadena, por lo que sería 042
Decaimiento Beta el
1
El resultado se ve bien con un carácter de tabulación, entonces, ¿por qué no usarlo? ¿Solo para los idiomas penales que necesitan más bytes para rellenar una cadena?
Tito

Respuestas:

3

05AB1E , 89 87 bytes

”‚Ý:‚Ù:ˆ†:”ð¡v”Šª0ÍÃ20‡í20‡í1ÍÃ0‚Ø20‚Ø1ÍÃ0‚Ø1‡í0‚؇í1ÍÔ2ð'€É«:1ð'€ƒ«:0ð«¡¹Nèèð3N-×ìyì,

Invoca la codificación Cthulhu . Utiliza la codificación CP-1252 . Pruébalo en línea!

Adnan
fuente
14

Javascript (ES6), 165 161 bytes

n=>[0,1,2].map(i=>(s='User:  3Group: 68Others:58None576Read48Write476Execute475and4576only'.split(/(\d+)/))[i*2]+s[n[i]*2+1].replace(/./g,c=>' '+s[c*2])).join`
`

Editar: +1 byte para cumplir con la regla de "no tab"

Ejemplos

let f =
n=>[0,1,2].map(i=>(s='User:  3Group: 68Others:58None576Read48Write476Execute475and4576only'.split(/(\d+)/))[i*2]+s[n[i]*2+1].replace(/./g,c=>' '+s[c*2])).join`
`
console.log(f("666"));
console.log(f("042"));
console.log(f("644"));
console.log(f("137"));

Arnauld
fuente
Puede ganar algunos bytes reorganizando la matriz (y tal vez separando los números de las cadenas). +1 por la idea.
Tito
@Titus: debo admitir que no veo una reorganización que ahorre algunos bytes. Además, los números deben tratarse como cadenas para que replace()funcionen en ellos sin coacción. Pero puedo estar perdiendo tu punto.
Arnauld
@Titus: algo así 'User3Group68Others58None576Read48Write476Execute475and4576only'.split(/(\d+)/)podría funcionar. ¿Eso es lo que tenías en mente?
Arnauld
Los estaba malentendiendo; pensaron que eran valores octales. :) Pero tu nueva idea tampoco es mala.
Tito
La salida de desafío requiere espacios en lugar de pestañas como está escrito actualmente.
Mwr247
13

GNU sed, 187163158 (157 + 1) bytes

Ejecutar con -r (ERE regexp). El archivo no contiene una nueva línea final.

s/(.)(.)/User:   \1\nGroup:  \2\nOthers: /g
s/[4-7]/Read &/g
s/[2367]/Write &/g
s/[1357]/Execute &/g
s/(\w) (\w+) [1-7]/\1 and \2/g
s/[1-7]/only/g
s/0/None/g
Luciérnaga
fuente
Buen enfoque, pero puede ahorrar unos 20 bytes eliminando los dígitos cuando agrega el ando only.
Neil
@Neil there :) incorporó su sugerencia para un ahorro muy significativo.
FireFly
1
La primera línea podría ser justo: s/(.)(.)/User: \1\nGroup: \2\nOthers: /. Se podrían guardar algunos bytes más portando a Perl, que tiene \dy \K.
ninjalj
@ninjalj buen punto. Me apegaré a sed ya que no conozco a Perl, y estoy seguro de que habría otros trucos que hacer para hacerlo aún más corto, fuera de s /// reemplazos.
FireFly
6

C # 214 bytes

string h(string y){string e="Execute ",r="Read ",w="Write ",O="Only",a="and ";var z=new[]{"None",e+O,w+O,w+a+e,r+O,r+a+e,r+a+w,r+w+a+e};return$"User:   {z[y[0]-'0']}\nGroup:  {z[y[1]-'0']}\nOthers: {z[y[2]-'0']}";}
pinkfloydx33
fuente
6

Jalea , 100 91 85 bytes

Casi seguro golfable - 91 bytes, ¿qué? ¡8 meses y 6 bytes de sabiduría!
- 1. más compresión de cuerda;
- 2. eliminar el decremento post-ordinal en 48 ya que la indexación es modular;
- 3. use un mejor encadenamiento tácito).

-9 bytes con la amable ayuda de @Lynn ejecutando compresiones de cadena para mí

,“£ɱ~»
Ñ
ṖK,“ and”,Ṫ
LĿK
7RBUT€Uị“ØJƓ“¥Ị£“¤/¡»Ç€“¡*g»ṭ
“ṖŒhJ"ỵd¡»ḲðJ4_⁶ẋ⁸,"j€”:ż⁹Oị¢¤Y

Pruébelo en TryItOnline

¿Cómo?

,“£ɱ~» - Link 1: pair with the string "Only"

Ñ - Link 2: call next link

ṖK,“ and”,Ṫ - Link 3: insert " and" between the last two elements of x
Ṗ           - x[:-1]
 K          - join with spaces
   “ and”   - the string " and"
          Ṫ - x[-1]
  ,      ,  - pair

LĿK - Link 4: call appropriate link and add missing spaces
L   - length
 Ŀ  - call link at that index
  K - join the result with spaces

7RBUT€Uị“ØJƓ“¥Ị£“¤/¡»Ç€“¡*g»ṭ - Link 5: construct all 8 cases
7R                            - range of 7: [1,2,3,4,5,6,7]
  B                           - binary (vectorises): [[1],[1,0],[1,1],[1,0,0],[1,0,1],[1,1,0],[1,1,1]]
   U                          - reverse (vectorises): [[1],[0,1],[1,1],[0,0,1],[1,0,1],[0,1,1],[1,1,1]]
    T€                        - indexes of truthy values for each: [[1],[2],[1,2],[3],[1,3],[2,3],[1,2,3]]
      U                       - reverse (vectorises): [[1],[2],[2,1],[3],[3, 1],[3,2],[3,2,1]]
        “ØJƓ“¥Ị£“¤/¡»         - list of strings: ["Execute","Write","Read"]
       ị                      - item at index (vectorises): [["Execute"],["Write"],["Write","Execute"],["Read"],["Read","Execute",["Read","Write"],["Read","Write","Execute"]]
                     ǀ       - call the previous link for each
                       “¡*g»  - the string "None"
                            ṭ - tack (Jelly is 1-based so the 8th item will be indexed as 0)

“ṖŒhJ"ỵd¡»ḲðJṚ⁶ẋ⁸,"j€”:ż⁹Oị¢¤Y - Main Link: parse input and make the result. e.g.: "042"
“ṖŒhJ"ỵd¡»                     - dictionary compression of "User Group Others"
          Ḳ                    - split at spaces -> ["User","Group","Others"]
           ð                   - dyadic chain separation, call that g (input as right)
            J                  - range of length of g -> [1,2,3]
             Ṛ                 - reverse -> [3,2,1]
              ⁶                - literal space
               ẋ               - repeat -> ["   ","  "," "]
                ⁸              - chain's left argument, g
                  "            - zip with:
                 ,             -   pair -> [["User","   "],["Group","  "],["Others"," "]]
                     ”:        - literal ':'
                   j€          - join for €ach -> ["User:   ","Group:  ","Others: "]
                            ¤  - nilad followed by link(s) as a nilad:
                        ⁹      - chain's right argument, the input string -> "042"
                         O     -   cast to ordinal (vectorises) -> [48, 52, 50]
                           ¢   -   call last link (5) as a nilad  -> ["Execute Only","Write Only","Write and Execute","Read Only","Read and Execute","Read and Write","Read Write and Execute","None"]
                          ị    -   index into (1-based & modular) -> ["None","Read Only","Write Only"]
                       ż       - zip together -> [["User:   ","None"],["Group:  ","Read Only"],["Others: ","Write Only"]]
                             Y - join with line feeds -> ["User:   ","None",'\n',"Group:  ","Read Only",'\n',"Others: ","Write Only"]
                               - implicit print:
                                             >>>User:   None
                                             >>>Group:  Read Only
                                             >>>Others: Write Only
Jonathan Allan
fuente
4

Octava, 185 bytes

@(n)fprintf('User:   %s\nGroup:  %s\nOthers: %s',{'Read Write and Execute','Read and Write','Read and Execute','Read only','Write and Execute','Write only','Execute only','None'}{56-n})

Cree una función anónima que tome la entrada como una cadena: '042'. Convertirlo en una matriz: (56-'042)' = [0 4 2]. Use esto como múltiples índices de celdas para indexar la matriz de celdas con Read Write and Execute','Read and Write', .... Usos fprintfpara dar salida a las tres cadenas, con las categorías apropiadas: User:, Group:y Others:.

He intentado encontrar una manera de almacenar Execute, Write, Readcomo palabras separadas y concatenar como sea necesario, pero esto resultó más largo que el enfoque ingenuo.

Ejemplos:

1> f('000')
User:   None
Group:  None
Others: None
2> f('042')
User:   None
Group:  Read only
Others: Write only

Pruébalo en línea.

Stewie Griffin
fuente
2
Puede guardar algunos bytes usando en strsplit('Read Write and Execute*Read and Write*Read and Execute*Read only*Write and Execute*Write only*Execute only*None','*')lugar del literal de matriz de celdas
Luis Mendo
4

PowerShell v2 +, 189168 bytes

[char[]]$args[0]|%{('User','Group','Others')[$i++]+":`t"+('None','Read','Write','Execute','only','and')[(0,(3,4),(2,4),(2,5,3),(1,4),(1,5,3),(1,5,2),(1,2,5,3))[$_-48]]}

Recorre la entrada $args[0]en forma de charmatriz. Cada iteración, indexamos en una matriz con $i++(por defecto 0) para seleccionar User, Groupo Others, concatenar eso con dos puntos y una pestaña, y concatenar eso con otro índice de matriz.

Aquí está la magia. Implícitamente convertimos chara an inty restamos 48(es decir, convertir ASCII 48( "0") en 0), eligiendo la redacción adecuada como una matriz de ints. Esa matriz se utiliza posteriormente como el índice en la 'None','Read','Write','Execute','only','and'matriz. Como el valor predeterminado $ofs(Separador de campo de salida) es un espacio, esto inserta correctamente espacios entre los elementos de la matriz cuando se encadena (lo que ocurre cuando se concatena a la izquierda).

Estas tres cadenas se dejan en la tubería, y la salida por vía implícita Write-Outputocurre al finalizar el programa.

Ejemplo

PS C:\Tools\Scripts\golfing> .\decode-the-chmod.ps1 '123'
User:   Execute only
Group:  Write only
Others: Write and Execute
AdmBorkBork
fuente
3

Paja , 193 bytes.

((01234567)((None)(Execute only)(Write only)(Write and Execute)(Read only)(Read and Execute)(Read and Write)(Read Write and Execute)))::~<:{-¢(User:   ),+>
>}:{-¢(Group:  ),+>
>}-¢(Others: ),+>

Pruébalo en línea

Presione 3 veces una tabla de conversión en la primera pila, cambie a la segunda pila, convierta cada número usando la tabla de conversación e imprima.

TuxCrafting
fuente
2

Haskell, 186 bytes

s=zip(words"7654 6 7632 753 7531 0 421")(words"Read and Write and Execute None only")
m c=mapM_(\(x,y)->putStrLn(x++unwords[b|(a,b)<-s,elem y a]))$zip["User:   ","Group:  ","Others: "]c

Ejemplo:

Prelude> :r
[1 of 1] Compiling Main             ( decCh.hs, interpreted )
Ok, modules loaded: Main.
*Main> m "654"
User:   Read and Write
Group:  Read and Execute
Others: Read only

Solo Preludio usado. ¿Lo estoy haciendo bien?

Sin golf:

s = zip (words "7654 6 7632 753 7531 0 421")
        (words "Read and Write and Execute None only")

ps y = unwords [b|(a,b)<-s,elem y a] -- build permissions string
pp (x,y) = putStrLn $ x ++ ps y -- print user + permission

m c =   let up = zip ["User:   ","Group:  ","Others: "] c -- pair user and permission
        in mapM_ pp up --print each
michi7x7
fuente
2

Python 2, 190 185 bytes

def f(i):
 r,w,a,x,o,g="Read ","Write ","and ","Execute ","only",["User:  ","Group: ","Others:"];p=["None",x+o,w+o,w+a+x,r+o,r+a+x,r+a+w,r+w+a+x]
 for z in 0,1,2:print g[z],p[int(i[z])]

Deja un espacio final si Ejecutar o Escribir están al final de la línea, pero no vi que esto no estaba permitido.

EDITAR Guarde 5 bytes cambiando el rango (3) a 0,1,2 y verificando el recuento de bytes en mi computadora portátil Linux en lugar de mi Windows (\ n = \ r \ n o al revés. Nunca puedo recordar cuál).

ElPedro
fuente
2

Python 2, 240 239 238 237 228 bytes

Pensé que finalmente le daría una oportunidad a esta cosa fría del golf. Esperemos que se permita el espacio en blanco al final. (arreglado, y en el proceso guardado un byte)

i=0
def a(b):
 for d in 4,2,1:
    if b&d:yield('Execute','Write','Read')[d/2]
for k in raw_input():
 b,q=list(a(int(k))),' and';e=len(b)
 if e:b[~e/2]+=(' only',q,q)[e-1]
 print'UGOsrteohrue:pr :s  :'[i::3],' '.join(b)or None;i+=1
Jack Greenhill
fuente
¡Bienvenido a PPCG, y buena primera respuesta!
ETHproductions
He reemplazado descaradamente el rango (3) en mi respuesta de Python 2 a 0,1,2 después de leer su código. Buena respuesta. +1
ElPedro
2

PHP, 169 159 bytes

foreach([User,Group,Others]as$i=>$u){echo"
$u: ";for($n=[5,33,34,66,35,67,131,531][$i]];$n;$n>>=3)echo["and",Execute,Write,Read,only,None][$n&7]," ";}

toma cadena como argumento de la línea de comandos: php -r '<code>' <argument>,
imprime una nueva línea que lleva en lugar de uno de fuga

Gracias a Jörg por señalar mis errores, y por el \t.

PHP, 169 bytes

con la nueva restricción: (carácter de tabulación prohibido)

foreach(['User:  ','Group: ','Others:']as$i=>$u){echo"
$u";for($n=[5,33,34,66,35,67,131,531][$argv[1][$i]];$n;$n>>=3)echo' ',['and',Read,Write,Execute,only,None][$n&7];}

Esto es 1 byte más corto que con str_pad, debido al espacio en blanco adicional que requeriría.

Descompostura

foreach([User,Group,Others]as$i=>$u)
{
    echo"\n$u:\t";                      // print newline, who, blanks
    for($n=[5,33,34,66,35,67,131,531]   // octal values for words indexes
        [$argv[1][$i]]                  // (last word=highest digit)
        ;$n;$n>>=3)                     // while value has bits left
        echo['and',Execute,Write,Read,only,None][$n&7]," "; // print that word
}

Para crear la matriz para $n, use esto:

$b=[[5],[1,4],[2,4],[2,0,1],[3,4],[3,0,1],[3,0,2],[3,2,0,1]];
foreach($b as$i=>$a){for($v=$j=0;$a;$j+=3)$v+=array_shift($a)<<$j;echo"$v,";}
Titus
fuente
1
foreach (['Usuario', 'Grupo', 'Otros'] como $ i => $ u) {echo "\\ n $ u: \\ t"; guarda algunos bytes y la salida para 3,4,6 es incorrecta
Jörg Hülsermann
1
Este es el orden correcto [5,33,34,66,35,67,131,531] buena idea
Jörg Hülsermann
He olvidado 'Usuario' a Usuario por ejemplo guarda los siguientes 6 Bytes que desea vencer a JavaScript, hágalo
Jörg Hülsermann
@ JörgHülsermann: Estaba a punto de adoptar el "\ t" de todos modos; Gracias. +1 por eso :) ¡Buen ojo en el 33!
Titus
1
para 346 nuestra salida es Usuario: Leer y escribir Grupo: Ejecutar solo Otros: Escribir y Ejecutar debería Usuario: Escribir y Ejecutar Grupo: Leer solo Otros: Leer y escribir
Jörg Hülsermann
2

bash 221 213 bytes

GNU bash, version 4.3.46

l=("User:   " "Group:  " "Others: ")
o=\ only;a=" and ";x=Execute;w=Write;r=Read
b=(None "$x$o" "$w$o" "$w$a$x" "$r$o" "$r$a$x" "$r$a$w" "$r $w$a$x")
for c in `echo $1|grep -o .`;{ echo "${l[$((z++))]}${b[$c]}";}

No está claro si esto se puede condensar más, al menos no sin cambiar fundamentalmente el enfoque aquí (dividir la entrada y usarla como un índice para la matriz ${b}que contiene las cadenas correspondientes).

marcos
fuente
1
Es más corto con \ onlylínea expandida. grep -o .<<<$1es más corto que echo $1|grep -o ., pero leer la entrada de stdin con while read -n1 ces mejor. Los índices de matriz tienen contexto aritmético en bash, por lo que ${l[z++]}funciona. lsería más corto como una cadena, a la que se accedería como ${l:z++*8:8}(desplazamiento y longitud tienen contexto aritmético). Se puede cambiar otro byte leyendo todo el modo c, expandiendo "Usuario:", ... en línea y haciendo un uso juicioso de las expansiones de parámetros.
ninjalj
1
Para un resultado final de: a=" and ";x=Execute;w=Write;r=Read;b=(None $x\ only $w\ only "$w$a$x" $r\ only "$r$a$x" "$r$a$w" "$r $w$a$x");read c;echo "User: ${b[${c%??}]}\nGroup: ${b[${c:1:1}]}\nOthers: ${b[${c:2}]}"(reemplace \ n con nuevas líneas literales).
ninjalj
1

Java 7, 300 284 bytes

String c(String s){char[]a=s.toCharArray();return"User:   "+f(a[0])+"Group:  "+f(a[1])+"Others: "+f(a[2]);}String f(int i){return new String[]{"None","Execute only","Write only","Write and Execute","Read only","Read and Execute","Read and Write","Read Write and Execute"}[i%48]+"\n";}

Enfoque directo por ahora. Intentará idear un enfoque más genérico para reutilizar las palabras.

Sin golf y casos de prueba:

Pruébalo aquí

class M{
  static String c(String s){
    char[] a = s.toCharArray();
    return "User:   " + f(a[0]) + "Group:  " + f(a[1]) + "Others: " + f(a[2]);
  }

  static String f(int i){
    return new String[]{ "None", "Execute only", "Write only", "Write and Execute", "Read only", "Read and Execute", "Read and Write", "Read Write and Execute" }
      [i % 48] + "\n";
  }

  public static void main(String[] a){
    System.out.println(c("666"));
    System.out.println(c("042"));
    System.out.println(c("644"));
  }
}

Salida:

User:   Read and Write
Group:  Read and Write
Others: Read and Write

User:   None
Group:  Read only
Others: Write only

User:   Read and Write
Group:  Read only
Others: Read only
Kevin Cruijssen
fuente
1

Groovy, 217 207 205 bytes

def c(m){def i=0,e='Execute',w='Write',r='Read',o=' only',a=' and ';m.each{println(['User:   ','Group:  ','Others: '][i++]+['None',"$e$o","$w$o","$w$a$e","$r$o","$r$a$e","$r$a$w","$r $w$a$e"][it as int])}}

sin golf:

def c(m) {
  def i=0,e='Execute',w='Write',r='Read',o=' only',a=' and ';
  m.each{
    println(['User:   ','Group:  ','Others: '][i++]+['None',"$e$o","$w$o","$w$a$e","$r$o","$r$a$e","$r$a$w","$r $w$a$e"][it as int])
  }
}
norganos
fuente
1

Mathematica, 211 bytes

{r,w,e,o,a}={"Read ","Write ","Execute ","only ","and "};""<>Transpose@{{"User:   ","Group:  ","Others: "},"None"[{e,o},{w,o},{w,a,e},{r,o},{r,a,e},{r,a,w},{r,w,a,e}][[#]]&/@IntegerDigits[#,10,3],"\n"&~Array~3}&

Una implementación sencilla (probablemente fácil de superar): no computa nada, solo codifica cada salida posible. La entrada es un entero; genera cada línea con un espacio final y una nueva línea general en general.

IntegerDigits[#,10,3]da los tres dígitos de la entrada (incluso si hay ceros a la izquierda). Cada dígito indica un argumento de la "función"

"None"[{e,o},{w,o},{w,a,e},{r,o},{r,a,e},{r,a,w},{r,w,a,e}]

con 0 indicando el nombre de la función en sí. ""<>concatena todas las cadenas en una lista (de listas). "\n"&~Array~3produce las tres nuevas líneas.

Greg Martin
fuente
Acabo de notar que mi respuesta de Python 2 es casi idéntica a la suya, incluso usando los mismos nombres de variables. ¡Honestamente no había visto el tuyo antes de publicar!
ElPedro
1
¡sin preocupaciones! Creo que la coincidencia de nombres de variables es bastante esperable en esta situación :)
Greg Martin
Supongo que tienes razón. Los nombres de las variables eran un poco predecibles ☺
ElPedro
por cierto, +1 porque pensamos de la misma manera :-)
ElPedro
1
por cierto, no conozco Mathematica, pero creo que puede perder un byte eliminando el espacio de "solo". Siempre estará al final de una línea, por lo que no necesita un espacio final.
ElPedro
1

Java 7, 278

Golfizado:

String f(String i){String o="";for(int n=0;n<i.length();)o+=(n<1?"User:   ":n<2?"Group:  ":"Others: ")+new String[]{"None","Execute only","Write only","Write and Execute","Read only","Read and Execute","Read and Write","Read Write and Execute"}[i.charAt(n++)-48]+"\n";return o;}

Sin golf:

  String f(String i) {
    String o = "";
    for (int n = 0; n < i.length();)
      o += (n < 1 ? "User:   " : n < 2 ? "Group:  " : "Others: ")
        + new String[] { "None", "Execute only", "Write only", "Write and Execute", "Read only", "Read and Execute",
            "Read and Write", "Read Write and Execute" }[i.charAt(n++) - 48]
        + "\n";
    return o;
  }

Salida:

User:   Read and Write
Group:  Read and Write
Others: Read and Write

User:   None
Group:  Read only
Others: Write only

User:   Read and Write
Group:  Read only
Others: Read only

fuente
1

Python 3.5, 3.6 - 235 232 228 216 bytes

(debería funcionar en todos los Python 3.x)

Entonces la entrada está en STDIN aquí (guarda una importación ☺).

a=input()
r=range
for i in r(3):
 p=int(a[i]);x=[["Read","Write","Execute"][j]for j in r(3)if 4>>j&p]
 if x[1:]:x[-1:-1]="and",
 if len(x)==1:x+="only",
 print(["User:  ","Group: ","Others:"][i]," ".join(x)or"None")

Haciendo uso de tuplas, omitiendo espacios donde sea posible y precedencia del operador donde normalmente pondría paréntesis para aclarar sus intenciones.

Uso de la muestra:

$ echo -n '666' | python3 golf2.py
User:   Read and Write
Group:  Read and Write
Others: Read and Write
$ echo -n '644' | python3 golf2.py
User:   Read and Write
Group:  Read only
Others: Read only
$ echo '042' | python3 golf2.py
User:   None
Group:  Read only
Others: Write only
$ echo '123' | python3 golf2.py
User:   Execute only
Group:  Write only
Others: Write and Execute
$ echo -n '777' | python3 golf2.py
User:   Read Write and Execute
Group:  Read Write and Execute
Others: Read Write and Execute

Sin golf:

input_perms = list(map(int, input()))

entities = ["User", "Group", "Others"]
perm_names = ["Read", "Write", "Execute"]

for i in range(3):
    bits = input_perms[i]
    perms = [
        perm_names[j]
        for j in range(3)
        if (1 << (2-j)) & bits
    ]

    if len(perms) > 1:
        perms.insert(-1, "and")
    if len(perms) == 1:
        perms.append("only")

    print("{:7} {}".format(
        entities[i]+":",
        " ".join(perms) or "None"
    ))
Jonas Schäfer
fuente
1

Lote, 280 bytes

@echo off
set/pc=
call:l "User:   " %c:~0,1%
call:l "Group:  " %c:~1,1%
call:l "Others: " %c:~2,1%
exit/b
:l
for %%s in (None.0 Execute.1 Write.2 "Write and Execute.3" Read.4 "Read and Execute.5" "Read and Write.6" "Read Write and Execute.7") do if %%~xs==.%2 echo %~1%%~ns

Codificar las cadenas fue 47 bytes más corto que intentar juntarlas. Hubiera sido 267 bytes si las pestañas fueran legales.

Neil
fuente
1

C # 307 241 210 bytes

string X(string s){var z="User: ,Group: ,Others:,5,34,14,123,04,023,021,0123,Read,Write,and,Execute,only,None".Split(',');return string.Join("\n",s.Zip(z,(a,b)=>b+z[a-45].Aggregate("",(x,y)=>x+" "+z[y-37])));}

Formateado

string X(string s)
{
    var z = "User:  ,Group: ,Others:,5,34,14,123,04,023,021,0123,Read,Write,and,Execute,only,None".Split(',');
    return string.Join("\n", s.Zip(z, (a, b) => b + z[a - 45].Aggregate("", (x, y) => x + " " + z[y - 37])));
}
Grax32
fuente
1

C #, 322 337 348 bytes

Esa no es la versión más corta, pero intenté resolver este problema utilizando operadores bit a bit ya que los chmodvalores son en realidad indicadores de bits. Además, C # probablemente no sea el mejor lenguaje de golf: D

string P(string s){Func<int,string>X=p=>{var a=new List<string>();if((p&4)>0)a.Add("Read");if((p&2)>0)a.Add("Write");if((p&1)>0)a.Add("Execute");return a.Count>1?string.Join(" ",a.Take(a.Count-1))+" and "+a.Last():a.Count>0?a.First()+" only":"none";};return string.Join("\n",(new[]{"User:   ","Group:  ","Others: "}).Select((c,i)=>c+X(s[i]-'0')));}

sin golf: (con comentarios)

string P(string s)
{
    // Function that determines the permissions represented by a single digit (e.g. 4 => "Read only")
    Func<int, string> X = p => 
    {
        var a = new List<string>();         // temporary storage for set permissions
        if ((p & 4) > 0) a.Add("Read");     // Read bit set
        if ((p & 2) > 0) a.Add("Write");    // Write bit set
        if ((p & 1) > 0) a.Add("Execute");  // Execute bit set

        // actually just Output formatting ... Takes a lot of bytes *grr*
        return a.Count > 1 
            ? string.Join(" ", a.Take(a.Count - 1)) + " and " + a.Last() 
            : a.Count > 0 
                ? a.First() + " only" 
                : "none";
    };

    // Actual result:
    return string.Join("\n", (new[] { "User:   ", "Group:  ", "Others: " })
        .Select((c, i) => c + X(s[i] - '0'))); // Map "User, .." to its permissions by using above function
}

Este es mi primer código de golf, así que dígame si hice algo mal :)

EDITAR 1:

Se guardaron algunos bytes reemplazándolos s[i]-'0'por s[i]&7(al final) y guardando el recuento de la lista en la variable:

string P(string s){Func<int,string>X=p=>{var a=new List<string>();if((p&4)>0)a.Add("Read");if((p&2)>0)a.Add("Write");if((p&1)>0)a.Add("Execute");var c=a.Count;return c>1?string.Join(" ",a.Take(c-1))+" and "+a.Last():c>0?a[0]+" only":"none";};return string.Join("\n",(new[]{"User:   ","Group:  ","Others: "}).Select((c,i)=>c+X(s[i]&7)));}

EDITAR 2:

Cambiado a la expresión lambda:

s=>{Func<int,string>X=p=>{var a=new List<string>();if((p&4)>0)a.Add("Read");if((p&2)>0)a.Add("Write");if((p&1)>0)a.Add("Execute");var c=a.Count;return c>1?string.Join(" ",a.Take(c-1))+" and "+a.Last():c>0?a[0]+" only":"none";};return string.Join("\n",(new[]{"User:   ","Group:  ","Others: "}).Select((c,i)=>c+X(s[i]&7)));}
Stefan
fuente
1

Javascript, 213 209 208 188 186 bytes

function(d){a=" and ";r="Read";w="Write";e="Execute";v=";";o=" only";c=["None",e+o,w+o,w+a+e,r+o,r+a+e,r+a+w,r+" "+w+a+e];return"User: "+c[d[0]]+"\nGroup: "+c[d[1]]+"\nOthers: "+c[d[2]]}

¡Ahorró 20 bytes gracias a Dada!

Paul Schmitz
fuente
3
Podría estar equivocado, pero ¿no debería su matriz estar en el orden inverso? Si llamo b ("000"), devuelve "Leer Escribir y Ejecutar", mientras que uno podría esperar "Ninguno" ...
Fecha del
Y estoy bastante seguro de que esto podría ser más golf. Por ejemplo, una versión de 191 bytes: function b(p){a=" and ";r="Read";w="Write";e="Execute";v=";";o=" only";c=["None",e+o,w+o,w+a+e,r+o,r+a+e,r+a+w,r+" "+w+a+e];return"User: "+c[p[0]]+"\nGroup: "+c[p[1]]+"\nOthers: "+c[p[2]]}.
Dada
1

Visual Basic, 606 bytes

imports System.Collections
module h
sub main()
Dim i As String=console.readline()
Dim s=new Stack(new String(){"Others: ","Group:  ","User:   "})
for each j as Char in i
dim t=new Stack()
if((asc(j) MOD 2)=1)then t.push("Execute")
if(asc(j)=50 or asc(j)=51 or asc(j)=54 or asc(j)=55)then t.push("Write")
if(asc(J)>51)then t.push("Read")
if t.count=3 then
w(s.pop+t.pop+" "+t.pop+" and "+t.pop)
else
if t.count=2 then
w(s.pop+t.pop+" and "+t.pop)
else
if t.count=0 then
w(s.pop+"None")
else
w(s.pop+t.pop+" only")
end if
end if
end if
next
end sub
sub w(s As String)
console.writeline(s)
end sub
end module
polyglotrealIknow
fuente
1
Bienvenido a PPCG! Nice first answer BTW :)
Beta Decay
1

Cristal, 200 194 Bytes

def m(y)y=y.chars.map &.to_i
a=" and "
o=" only"
r="Read"
w="Write"
x="Execute"
c=["None",x+o,w+o,w+a+x,r+o,r+a+x,r+a+w,r+" "+w+a+x]
"User:   "+c[y[0]]+"
Group:  "+c[y[1]]+"
Others: "+c[y[2]]end

devuelve la cadena resultante para una secuencia octal dada como una cadena. por ejemplo: m("670")resultados a: User: Read and Write\nGroup: Read Write and Execute\nOthers: None.

Pruébalo en línea .

Domii
fuente
0

C #, 371 bytes

public String[] a = {"none","Execute only","Write only","Write and Execute","Read only","Read and Execute","Read and Write","Read Write and Execute"};
public String pA(int i){return a[i];}
public int d(int n,int i){
  n=n/Math.pow(10,i);
  return n%=10;
}
public void main(int i){
  Console.Write("User:\t{0}\nGroup:\t{1},Others:\t{2}",pA(d(i,0)),pA(d(i,1)),pA(d(i,2));
}
Alireza Tabatabaeian
fuente
44
Este es el código de golf, por lo que debe golf su código. Además, agregue un encabezado con el nombre del idioma y el bytecount.
TuxCrafting
He agregado su número de bytes, que es su puntaje. Necesitas obtener tu puntaje lo más bajo posible para ganar
Beta Decay
Por ejemplo, se deshace de todos los espacios en blanco innecesarios en cada función
Beta Decay
1
@BetaDecay Gracias, soy nuevo en esta comunidad y creo que sería mejor usar php en su lugar, lo que podría conducir a más códigos de compactación.
Alireza Tabatabaeian
1
@Alireza Esa es una buena idea. Aunque en este sitio, nos gusta ver respuestas cortas en Java y C # :)
Beta Decay
0

Python 3.5 - 370 294 243 bytes

Golfizado:

import sys
a=lambda o: [print(('User:  ','Group: ','Others:')[n],('None','Execute only','Write only','Write and Execute','Read only','Read and Execute','Read and Write','Read Write and Execute')[int(o[n])]) for n in range(0,3)]
a(sys.argv[1])

Comprobación de tamaño:

$ du -b OctalToHuman.py 
243     OctalToHuman.py

Sin golf:

#!/usr/bin/env python3
from sys import argv as ARGS

types = ('User:  ', 'Group: ', 'Others:')
perms = ('None','Execute only','Write only','Write and Execute','Read only','Read and Execute','Read and Write','Read Write and Execute')

def convert(octal_string):
    for n in range(0,3):
        print(types[n], perms[int(octal_string[n])])

if __name__ == '__main__':
    convert(ARGS[1])

Salida de muestra:

$ python ./OctalToHuman.py 666
User:   Read and Write
Group:  Read and Write
Others: Read and Write

$ python ./OctalToHuman.py 042
User:   None
Group:  Read only
Others: Write only

$ python ./OctalToHuman.py 644
User:   Read and Write
Group:  Read only
Others: Read only
Rayo
fuente
Este no es un candidato serio para los criterios ganadores. Requerimos que todas las respuestas hagan un intento serio de optimizar su puntaje para los criterios ganadores (por ejemplo, en desafíos de código de golf como este, los envíos deben hacer un intento serio de minimizar el conteo de bytes del programa).
Mego
Puede guardar bastantes bytes eliminando import sysy simplemente haciendo que el programa sea una función anónima ( lambda o:...).
NoOneIsHere
0

F #, 204203 bytes

mi primer golf, así que perdone cualquier error;)
La versión golfizada (basada en 1: 1 en la respuesta de pinkfloydx33 ):

fun(y:string)->let e,r,w,o,a="Execute ","Read ","Write ","only","and ";let z=["None";e+o;w+o;w+a+e;r+o;r+a+e;r+a+w;r+w+a+e;];let(!-)a=z.[int y.[a]-48];sprintf"User:   %s\nGroup:  %s\nOthers: %s"!-0!-1!-2

La versión sin golf:

fun (y : string) ->
    let e, r, w, o, a = "Execute ", "Read ", "Write ", "only", "and "
    let z = [
                "None";
                e + o;
                w + o;
                w + a + e;
                r + o;
                r + a + e;
                r + a + w;
                r + w + a + e;
            ]
    let (!-) a = z.[int(y.[a]) - 48]
    sprintf "User:   %s\nGroup:  %s\nOthers: %s" !-0 !-1 !-2

Ejemplo de uso:

let k =  ...... // function definition goes here

printf"%s"<|k"755"
printf"%s"<|k"042"
// etc ...


Esto es solo para verificar si puedo 'mejorar' la respuesta de pinkfloydx33 : no me atribuyo ningún crédito por el algoritmo

desconocido6656
fuente
0

PHP, 199 bytes

foreach([User,Group,Others]as$i=>$u){$a=[];foreach([Read,Write,Execute]as$k=>$s)if($argv[1][$i]&4>>$k)$a[]=$s;$a[]=($x=array_pop($a))?$a?"and $x":"$x only":None;echo str_pad("\n$u:",9).join(" ",$a);}

PHP, 189 Bytes con \ t

foreach([User,Group,Others]as$i=>$u){$a=[];foreach([Read,Write,Execute]as$k=>$s)if($argv[1][$i]&4>>$k)$a[]=$s;$a[]=($x=array_pop($a))?$a?"and $x":"$x only":None;echo"\n$u:\t".join(" ",$a);}
Jörg Hülsermann
fuente
Oye, deberías usar espacios en lugar de pestañas
Beta Decay
En este caso, \ t parece str_repeat ("", 3- $ i) o str_pad ("", 3- $ i, "") pero no importa con mi idea, no tengo ninguna posibilidad de ganar. Si debo tomar otro espacio cs.tut.fi/~jkorpela/chars/spaces.html
Jörg Hülsermann
1
13 + 34 bytes para guardar. En la versión larga: Use en echo str_pad("$u:",8)lugar de echo"$u:".str_repeat(" ",3-$i)(-9); esto hace $i=>obsoleto (-4). En ambas versiones: use en $a[$z-1]="and $a[$z-1]";lugar de {$a[]=$a[$z-1];$a[$z-1]="and";}(-7) y en else$a[]=$a?Only:None;lugar de elseif($z<1)$a[]=None;else$a[]=Only;(-14). Conviértase if(1<$z=count($a))$a[$z-1]="and $a[$z-1]";else$a[]=$a?Only:None;en if($x=array_pop($a))$a[]=$a?"and $x":"$x Only";else$a[]=None;(-3) y luego en $a[]=($x=array_pop($a))?$a?"and $x":"$x Only":None;(-10)
Tito
@Titus echo str_pad ("$ u:", 8), $ a [$ z-1] = "y $ a [$ z-1]" ;, de lo contrario $ a [] = $ a? Solo: Ninguno; Hecho $ i => obsoleto No puedo hacer, entonces $ m = $ argv [1] [$ i] es necesario. Por lo demás, probaría primero de otra manera. Gracias por el aporte
Jörg Hülsermann
1
Más ideas: en if(4&$m=$argv[1][$i])lugar de $m=$argv[1][$i];if(4&$m)(-3) O reemplazar $m=;if();if();if();con un bucle: foreach([Read,Write,Execute]as$k=>$s)if($argv[1][$i]&4>>$k)$a[]=$s;(-7)
Titus
0

Python 3, 191 bytes

def d(n):a,b,c,d,e=' and ',' only',"Execute","Write","Read";l=["None",c+b,d+b,d+a+c,e+b,e+a+c,e+a+d,e+" "+d+a+c];y,u,i=map(int,n);return"User:   %s\nGroup:  %s\nOthers: %s\n"%(l[y],l[u],l[i])

sin golf

def d(n):
    a,b,c,d,e=' and ',' only',"Execute","Write","Read"
    l=["None",c+b,d+b,d+a+c,e+b,e+a+c,e+a+d,e+" "+d+a+c]
    y,u,i=map(int,n)
    return"User:   %s\nGroup:  %s\nOthers: %s\n"%(l[y],l[u],l[i])
Aleksandr Smirnov
fuente
1
Bienvenido a PPCG! bonito primer post!
Rɪᴋᴇʀ
Hmm, tengo mucha curiosidad de cómo el moderador obtuvo 151bytes cuando solo obtengo 191: D ¿Es un error? Verificar ediciones
Aleksandr Smirnov
Ese era yo, lo siento. Escribí en la edición. Corregido ahora.
Rɪᴋᴇʀ
0

Javascript (ES6), 159 bytes

a=>`User:  ${(b=[' None',(c=' Execute')+(d=' only'),(e=' Write')+d,f=e+(g=' and')+c,(h=' Read')+d,h+g+c,h+g+e,h+f])[a[0]]}\nGroup: ${b[a[1]]}\nOthers:`+b[a[2]]

Ejemplo:

(a=>`User:  ${(b=[' None',(c=' Execute')+(d=' only'),(e=' Write')+d,f=e+(g=' and')+c,(h=' Read')+d,h+g+c,h+g+e,h+f])[a[0]]}\nGroup: ${b[a[1]]}\nOthers:`+b[a[2]])("042")
Ian
fuente