Autorizzazioni file

26

Autorizzazioni file

code-golf

Adattato dalla UIL - Computer Science Programming domanda di risposta gratuita "Carla" per il Distretto 2018.

introduzione

Nei sistemi operativi simili a UNIX, ogni file, directory o collegamento è "posseduto" da un "utente", che è un membro di un "gruppo" e dispone di determinate "autorizzazioni" rappresentate da una stringa di dieci caratteri come " drwxrwxrwx". Il primo carattere è 'd', '-' o 'l' (directory, file o collegamento), seguito da tre serie di valori "rwx", che indicano le autorizzazioni "lettura, scrittura, esecuzione". Il primo set sono i diritti dell'utente, il centro imposta i diritti del gruppo e il terzo i diritti di tutti gli altri su quell'oggetto.

L'autorizzazione negata per uno di questi diritti è rappresentata da una "-" al posto della "r", "w" o "x". Ad esempio, una stringa di autorizzazione della directory di esempio sarebbe "drwxr - r--", che indica i diritti di directory completi per l'utente, ma i diritti di "sola lettura" per il membro del gruppo e tutti gli altri.

Ogni combinazione "rwx" può anche essere rappresentata da un valore ottale (0-7) con il bit più significativo che rappresenta l'autorizzazione in lettura, il bit più significativo che rappresenta l'autorizzazione in scrittura e il bit meno significativo che rappresenta l'autorizzazione all'esecuzione.

Sfida

Data una stringa di codice di quattro caratteri composta da un carattere: 'D', 'F' o 'L', seguito da un valore intero ottale a tre cifre, come 664, genera la stringa di 10 caratteri risultante che rappresenta il valore dell'autorizzazione indicato.

Ingresso

Il tuo programma o funzione può leggere l'input dallo standard in (verranno inseriti quattro caratteri, facoltativamente seguiti da una nuova riga) o passare l'input come argomento.

Il tuo programma può accettare input maiuscoli o minuscoli ma deve essere coerente (o tutti gli input sono maiuscoli o tutti gli input sono minuscoli).

Produzione

Il programma deve stampare la stringa di dieci caratteri risultante che rappresenta il valore di autorizzazione indicato nel formato esatto sopra specificato. È consentito lo spazio bianco in coda.

Casi test

In: F664Out: -rw-rw-r--
In: D775Out: drwxrwxr-x
In: L334Out: l-wx-wxr--
In: F530Out: -r-x-wx---
In: D127Out:d--x-w-rwx

Punteggio e regole

  • Sono vietati i fori standard .
  • Si applicano le regole standard .
  • Fornisci un link per testare il tuo codice e una spiegazione.
  • Questo è code-golf , quindi vince la risposta più breve in byte!
code-golf 
— Billylegota
fonte
Aspetta cosa, chiesto ieri e risposta già accettata? Questo significa che non ci si aspettano più risposte o cosa?
— Nit
1
@Nit Altre risposte sono sempre ben accette, indipendentemente dal fatto che una risposta sia accettata.
— isaacg
1
@Nit Ero sul cellulare e cercavo di sottovalutare una risposta non correlata (che è stata rimossa da allora). Ho accidentalmente premuto il pulsante Accetta risposta con il dito grasso. Non sono riuscito a capire come accettare, quindi ho appena cambiato la risposta accettata in quella più breve al momento.
— Billylegota,
2
@Nen voglio dire ... ha accettato una risposta di Dennis, quindi onestamente potrebbe essere corretto.
— Magic Octopus Urn

Risposte:

7

Gelatina , 19 byte

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

Provalo online!

Come funziona

“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
fonte
16

bash, 59 53 byte

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

Lo strumento giusto per il lavoro?

Grazie a Dennis per aver salvato 5 byte e HTNW per averne salvato uno.

Provalo online!

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 -
— Maniglia
fonte
Beh, è ​​stato veloce. Certamente lo strumento giusto per il lavoro.
— Billylegota,
chmod ${1:1} a>a;stat -c%A a|sed "s/-/\L${1:0:1}/;s/f/-/"salva due byte.
— Dennis,
Uscendo da @Dennis, penso che puoi rasartene un altro con trinvece di y:chmod ${1:1} a>a;stat -c%A a|sed s/./\\L${1:0:1}/|tr f -
— HTNW
2
È lecito ritenere che non vi sia alcun file ae l'utente disponga dell'autorizzazione per crearlo oppure esiste il file aed è scrivibile dall'utente? Perché se esiste un file di aproprietà rootcon autorizzazioni 700, questo non dovrebbe funzionare.
— NoOneIsHere
2
@NoOneIsHere Sebbene in particolare le autorizzazioni non siano mai emerse nella discussione, la comunità ha deciso che la creazione di file temporanei nella directory corrente è consentita per impostazione predefinita . Per estensione, possiamo presumere che sia possibile.
— Dennis,
10

Python 2 , 78 byte

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

Accetta input come carattere e tre ints.
Provalo online!

Spiegazione

[a,'-'][a=='f']accetta il carattere di input o -, se il personaggio lo è f.
'-r'[x/4]+'-w-w'[x/2]+'-x'[x%2]è essenzialmente una conversione ottale per ottenere la rwxstringa.

5

Retina 0.8.2 , 43 byte

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

Provalo online! Il link include casi di test. Riceve input in lettere minuscole. Spiegazione:

\d
$&r$&w$&x

Triplica ogni cifra, con il suffisso r, we x.

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

Cambia tutte le lettere errate in -s.

\d

Elimina le cifre rimanenti.

— Neil
fonte
4

Retina , 51 byte

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

Provalo online!

Non ho idea di come usare Retina, quindi per favore fatemi sapere come farlo meglio. Ho solo pensato di provare ad imparare almeno una lingua che non è Pyth.

Spiegazione:

Sostituisci fcon -(lasciando de linvariato), quindi sostituisci ogni cifra con quella appropriata rwx.

: / Posso arrivare fino a questo, ma non oltre. e il modo intelligente è super ungolfy
— solo ASCII il
Sarebbe molto più golfista con una sorta di operatori ternari / logici o / add e trim
— solo ASCII il
@ ASCII-only La tua idea è stata abbastanza carina, l'ho usata per questa risposta :)
— Leo
4

JavaScript (ES6), 63 byte

Prevede la stringa di input in minuscolo.

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

Provalo online!

Commentate

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
fonte
4

Carbone , 27 byte

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

Provalo online! Il collegamento è alla versione dettagliata del codice. Spiegazione:

 Ｓ                          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
fonte
4

Haskell , 84 83 81 byte

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

Provalo online!

Finì per essere piuttosto simile nel concetto alla risposta di Python 2 di Mnemonic. f crea il tipo di file, il resto è il ottiene le autorizzazioni dal numero ottale. Questo mi ha fatto davvero desiderare ed è stato un po 'e un operatore incluso nel preludio.

— aoemica
fonte
2
Puoi usare divinvece di quot.
— nimi,
4

Java 8, 100 byte

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

Provalo online.

Port of @Neil 's Retina answer .

Spiegazione:

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
fonte
Questo è intelligente! ;)
— Olivier Grégoire il
@ OlivierGrégoire Bene, principalmente perché consente di risparmiare sulla dichiarazione di ritorno e sui cicli. Peccato che tre individui .replaceAllsiano ancora meno byte di un loop con .replaceAlle aggiunto returne String-array. Ma il merito ovviamente va a Neil , che è la risposta di Retina che ho usato come base da cui partire.
— Kevin Cruijssen,
3

Gelatina , 21 byte

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

Un programma completo che stampa su STDOUT. (Come collegamento monadico il valore restituito è un elenco contenente un carattere e un elenco di tre elenchi di caratteri.)

Provalo online! Oppure vedi la suite di test .

Come?

Ḣ⁾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
fonte
3

Retina , 38 byte

Ispirato da un commento solo da ASCII .

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

Provalo online!

L'idea è di convertire ogni cifra in unaria (la cifra unaria predefinita in Retina è _) con tre cifre iniziali -, quindi convertire le cifre binarie dal più al meno significativo.

— Leo
fonte
2

Python 3 , 71 byte

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

Provalo online!

Python 3.3+ ha un built-in per questo, anche se a causa della necessità di un'importazione e delle differenze nel formato di input previsto, non è molto adatto per il golf.

— Kirill L.
fonte
2

Tcl , 139 byte

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

Provalo online!

Tcl , 144 byte

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

Provalo online!

Tcl , 149 byte

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

Provalo online!

Tcl , 150 byte

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

Provalo online!

Tcl , 180 byte

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

Provalo online!

Ancora molto non golfato!

— sergiol
fonte
2

Java (JDK 10) , 118 byte

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

Provalo online!

Crediti

— Olivier Grégoire
fonte
2
Quando si prende l'input in minuscolo fdl, è possibile modificare var r=s[0]<70?"d":s[0]<72?"-":"l";in var r=s[0]=='f'?"-":s[0]+"";per salvare 6 byte. Inoltre, .toCharArray()può essere .split("")per salvare altri 4 byte.
— Kevin Cruijssen,
2
@KevinCruijssen La tua idea mi ha fatto risparmiare 13 byte, non 10 (poiché potrei rimuovere il ""+successivo per "lanciare" a charin a String);) Grazie!
— Olivier Grégoire il
2

Excel, 224 byte

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

Fatto in 4 fasi:

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

E 3 volte:

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

Cercando di essere più intelligente, aggiunge 25 bytesper serie di diritti, 75 in totale:

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
fonte
2

05AB1E , 34 27 byte

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

Provalo online!

Golfato di 7 byte da @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
fonte
ćls8βbvyi…rwx3*Nèë'-}J'f'-:per 7 in meno ...
— Magic Octopus Urn
Fondamentalmente solo un diverso ordinamento usando istruzioni if, e invece di rimuovere il fsto solo sostituendo tutto fnella stringa finale con -.
— Magic Octopus Urn
i <CODE FOR TRUE> ë <CODE FOR FALSE> }
— Magic Octopus Urn
@MagicOctopusUrn Nice!
— Geno Racklin Asher,
1

Python 2 , 238 byte

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

Provalo online!

Avevo pensato che sarebbe stata una goccia nel secchio, ma mi sbagliavo davvero. Probabilmente avrebbe dovuto rendersi conto che una lambda non era la migliore idea ad un certo punto.

— LyricLy
fonte
: | troppi builtin = troppo lungo
— solo ASCII il
1

APL + WIN, 55 byte

Richiede una stringa di input con lettere minuscole:

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

Spiegazione:

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
fonte
1

J , 57 52 byte

5 byte salvati grazie a FrownyFrog!

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

Provalo online!

Ancora un'altra soluzione lunga ... Non so come }lavorare in verbi taciti ed è per questo che ho usato molto più tempo {"0 1&.|:per la selezione.

Spiegazione:

@}. Rilascia il primo simbolo e

,.&.": converti il ​​resto in un elenco di cifre desimali

]:#: converti ogni cifra in un elenco di cifre binarie (e blocca il fork)

('-',:'rwx') crea una tabella a 2 righe e usa 0 per selezionare dalla sua prima riga / 1 - dalla sua seconda

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

{"0 1&.|:~ utilizza le cifre binarie per selezionare dalla tabella sopra

[:, appiattisce il risultato

('d-l'{~'DFL'i.{.) formatta il primo simbolo

, aggiunge il primo simbolo all'elenco delle autorizzazioni

— Galen Ivanov
fonte
1
L'input è già una stringa, è necessario1#:@}."."0
— FrownyFrog
1
Questo sembra funzionare: ('d-l'{~'DFL'i.{.)→-&.('-DLld'i.{.)
— FrownyFrog
@FrownyFrog Molto bello i.e &.grazie mille! A proposito, puoi spiegarmi come usare select }nei verbi taciti?
— Galen Ivanov,
1
2 2 2&#:`('-',:'rwx'"_)}@"."0@}.è esattamente la stessa lunghezza
— FrownyFrog
Tuttavia non si rompe 333:)
— FrownyFrog
1

PHP, 68 byte

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

si traduce fin caratteri minuscoli per sottolineare il carattere di sottolineatura e ogni numero ottale nel suo rwxequivalente, usando i trattini bassi anziché i trattini (per salvare la necessità di virgolette), quindi sostituisce _con -.

Esegui come pipe -nFo provalo online .

— Titus
fonte
1

C (gcc) , 109 104 byte

Almeno C può convertire l'input ottale .... :-)

Modifica: mi sono reso conto che il modificatore di dimensione non era strettamente richiesto, e che putchar()è più breve che printf()in questo 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)]));}

Provalo online!

Originale:

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

Provalo online!

— ErikF
fonte
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.