फ़ाइल अनुमतियाँ

26

फ़ाइल अनुमतियाँ

कोड गोल्फ

2018 जिले के लिए यूआईएल - कंप्यूटर साइंस प्रोग्रामिंग नि: शुल्क प्रतिक्रिया प्रश्न "कार्ला" से अनुकूलित।

परिचय

UNIX- जैसे ऑपरेटिंग सिस्टम में, प्रत्येक फ़ाइल, निर्देशिका या लिंक एक "उपयोगकर्ता" के पास "स्वामित्व" है, जो "समूह" का सदस्य है, और कुछ "अनुमतियाँ" जैसे दस-वर्ण स्ट्रिंग द्वारा प्रतिनिधित्व किया गया है " drwxrwxrwx "। पहला वर्ण 'd', '-', या 'l' (डायरेक्टरी, फाइल या लिंक) है, इसके बाद "rwx" मानों के तीन सेट होते हैं, जो "रीड, राइट, एग्जीक्यूट" को दर्शाता है। पहला सेट उपयोगकर्ता के अधिकार हैं, मध्य समूह के अधिकारों को सेट करता है, और तीसरा उस वस्तु के लिए अन्य सभी के अधिकार हैं।

इनमें से किसी भी अधिकार के लिए अस्वीकृत अनुमति को 'r', 'w', या 'x' के स्थान पर '-' द्वारा दर्शाया गया है। उदाहरण के लिए, एक नमूना निर्देशिका अनुमति स्ट्रिंग "drwxr - r--" होगी, जो उपयोगकर्ता के लिए पूर्ण निर्देशिका अधिकारों का संकेत देती है, लेकिन समूह के सदस्य और अन्य सभी के लिए "केवल पढ़ने के लिए" अधिकार।

प्रत्येक "rwx" संयोजन को सबसे महत्वपूर्ण बिट के साथ एक ऑक्टिकल मान (0-4) द्वारा दर्शाया जा सकता है, जो पढ़ने की अनुमति का प्रतिनिधित्व करता है, अगला सबसे महत्वपूर्ण बिट लेखन अनुमति का प्रतिनिधित्व करता है, और कम से कम महत्वपूर्ण बिट निष्पादन की अनुमति का प्रतिनिधित्व करता है।

चुनौती

एक वर्ण से बने चार-वर्ण कोड स्ट्रिंग को देखते हुए: 'D', 'F', या 'L', इसके बाद 664 की तरह तीन-अंकीय पूर्णांक मान होता है, जिसके परिणामस्वरूप 10 वर्ण स्ट्रिंग अनुमति मान का प्रतिनिधित्व करता है। संकेत दिया।

इनपुट

आपका कार्यक्रम या फ़ंक्शन या तो मानक से इनपुट पढ़ सकता है (चार वर्णों को दर्ज किया जाएगा, वैकल्पिक रूप से एक नई पंक्ति द्वारा) या इनपुट को एक तर्क के रूप में पारित किया जा सकता है।

आपका प्रोग्राम अपरकेस या लोअरकेस इनपुट को स्वीकार कर सकता है लेकिन सुसंगत होना चाहिए (या तो सभी इनपुट अपरकेस हैं या सभी इनपुट कम हैं)।

उत्पादन

आपके कार्यक्रम को परिणामी दस-वर्ण स्ट्रिंग को प्रिंट करना होगा जो ऊपर निर्दिष्ट सटीक प्रारूप में इंगित अनुमति मूल्य का प्रतिनिधित्व करता है। सफ़ेद स्थान रखने की अनुमति है।

परीक्षण के मामलों

इन: F664आउट: -rw-rw-r--
इन: D775आउट: drwxrwxr-x
इन: L334आउट: l-wx-wxr--
इन: F530आउट: -r-x-wx---
इन: D127आउट:d--x-w-rwx

स्कोरिंग और नियम

  • मानक लूप-होल निषिद्ध हैं।
  • मानक नियम लागू होते हैं।
  • कृपया अपने कोड के साथ-साथ स्पष्टीकरण के लिए एक लिंक प्रदान करें।
  • यह कोड-गोल्फ है , इसलिए बाइट्स में सबसे कम जवाब जीतता है!
code-golf 
— Billylegota
स्रोत
रुको, कल क्या पूछा और जवाब पहले से ही स्वीकार कर लिया? इसका मतलब यह है कि कोई और उत्तर अपेक्षित नहीं है या क्या है?
— नाइट
1
@ और अधिक जवाब हमेशा स्वागत है, चाहे एक उत्तर स्वीकार कर लिया जाए।
— isaacg
1
@ मैं मोबाइल पर था और एक असंबंधित उत्तर को समाप्त करने की कोशिश कर रहा था (जो तब से हटा दिया गया है)। मैंने गलती से स्वीकार जवाब बटन को अपनी मोटी उंगली से मारा। मैं समझ नहीं पाया कि कैसे अस्वीकार कर दूं इसलिए मैंने स्वीकार किए गए उत्तर को अब तक के सबसे छोटे हिस्से में बदल दिया।
— बिलीगोट्टा
2
@ मेरा मतलब है ... उन्होंने डेनिस का जवाब स्वीकार कर लिया, इसलिए वह ईमानदारी से सही हो सकते हैं।
— मैजिक ऑक्टोपस Urn

जवाबों:

7

जेली , 19 बाइट्स

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

इसे ऑनलाइन आज़माएं!

यह काम किस प्रकार करता है

“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.
— डेनिस
स्रोत
16

बैश, 59 53 बाइट्स

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

नौकरी के लिए सही उपकरण?

5 बाइट्स और HTNW को बचाने के लिए डेनिस को धन्यवाद ।

इसे ऑनलाइन आज़माएं!

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 -
— Doorknob
स्रोत
खैर वो तेज था। निश्चित रूप से नौकरी के लिए सही उपकरण।
— बिलीगोट्टा
chmod ${1:1} a>a;stat -c%A a|sed "s/-/\L${1:0:1}/;s/f/-/"दो बाइट बचाता है।
— डेनिस
@ डेनिस से हटकर, मुझे लगता है कि आप trइसके बजाय एक और को शेव कर सकते हैं y:chmod ${1:1} a>a;stat -c%A a|sed s/./\\L${1:0:1}/|tr f -
— HTNW
2
क्या यह मानना ​​वैध है कि कोई फ़ाइल नहीं है aऔर उपयोगकर्ता के पास इसे बनाने की अनुमति है या फ़ाइल है aऔर यह उपयोगकर्ता द्वारा लिखने योग्य है? क्योंकि अगर वहाँ एक फाइल है aके स्वामित्व में rootअनुमति के साथ 700, यह काम नहीं करना चाहिए।
— NoOneIsHere
2
@NoOneIsHere जबकि विशेष रूप से अनुमति चर्चा में कभी नहीं आई, समुदाय ने निर्णय लिया कि वर्तमान निर्देशिका में अस्थायी फाइलें बनाने की अनुमति डिफ़ॉल्ट रूप से है । विस्तार से, हम यह मान सकते हैं कि यह संभव है।
— डेनिस
10

पायथन 2 , 78 बाइट्स

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

एक चरित्र और तीन ints के रूप में इनपुट लेता है।
इसे ऑनलाइन आज़माएं!

व्याख्या

[a,'-'][a=='f']या तो इनपुट चरित्र लेता है या -, यदि चरित्र है f। स्ट्रिंग
'-r'[x/4]+'-w-w'[x/2]+'-x'[x%2]प्राप्त करने के लिए अनिवार्य रूप से एक अष्टाधारी रूपांतरण है rwx।

5

रेटिना 0.8.2 , 43 बाइट्स

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

इसे ऑनलाइन आज़माएं! लिंक में परीक्षण के मामले शामिल हैं। लोअर केस में इनपुट लेता है। स्पष्टीकरण:

\d
$&r$&w$&x

प्रत्येक अंक को त्रिगुणित करें r, साथ प्रत्यय wऔर x।

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

सभी गलत अक्षरों को बदल दें -।

\d

शेष अंक हटाएं।

— नील
स्रोत
4

रेटिना , 51 बाइट्स

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

इसे ऑनलाइन आज़माएं!

रेटिना का उपयोग करने का कोई विचार नहीं है, इसलिए कृपया मुझे बताएं कि यह बेहतर कैसे करें। मुझे लगा कि मैं कम से कम एक ऐसी भाषा सीखने की कोशिश करूंगा जो पाइथ की नहीं है।

स्पष्टीकरण:

(छोड़ने और अपरिवर्तित) के fसाथ बदलें , फिर प्रत्येक अंक को उचित के साथ बदलें ।-dlrwx

: / मैं इस के रूप में दूर हो सकता है, लेकिन आगे नहीं। और स्मार्ट तरीका सुपर ungolfy है
— केवल
यह किसी न किसी प्रकार के टर्नरी / लॉजिकल / / एड और ट्रिम ऑपरेटरों के साथ इतना गोल्फर होगा
— ASCII-only
@ ASCII- केवल आपका विचार काफी अच्छा था, मैंने इसे इस उत्तर के लिए उपयोग किया है :)
— सिंह
4

जावास्क्रिप्ट (ईएस 6), 63 बाइट्स

लोअरकेस में इनपुट स्ट्रिंग की अपेक्षा करता है।

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

इसे ऑनलाइन आज़माएं!

टिप्पणी की गई

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
स्रोत
4

चारकोल , 27 बाइट्स

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

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। स्पष्टीकरण:

 Ｓ                          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
— नील
स्रोत
4

हास्केल , 84 83 81 बाइट्स

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

इसे ऑनलाइन आज़माएं!

Mnemonic के पायथन 2 उत्तर की अवधारणा में काफी समान है। f फ़ाइल प्रकार बनाता है, बाकी ऑक्टल नंबर से अनुमतियाँ प्राप्त करता है। यह वास्तव में मुझे कामना करता है और प्रस्तावना में शामिल एक बिटवाइज़ और ऑपरेटर था।

— aoemica
स्रोत
2
आप उपयोग कर सकते हैं divके बजाय quot।
— nimi
4

जावा 8, 100 बाइट्स

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

इसे ऑनलाइन आज़माएं।

पोर्ट ऑफ @ नील का रेटिना उत्तर ।

स्पष्टीकरण:

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
— केविन क्रूज़सेन
स्रोत
यह स्मार्ट है! ;)
— ओलिवियर ग्रेजायर
@ ओलिवियरग्रेयर खैर, मुख्य रूप से क्योंकि यह रिटर्न स्टेटमेंट और लूप पर बचाता है। बहुत बुरा तीन व्यक्ति .replaceAllअभी भी एक लूप की तुलना में कम बाइट्स है .replaceAllऔर जोड़ा returnऔर स्ट्रिंग-सरणी के साथ .. लेकिन निश्चित रूप से क्रेडिट नील को जाता है , जो रेटिना का उत्तर देता था जिसे मैं आधार से पोर्ट के रूप में इस्तेमाल करता था।
— केविन क्रूज़सेन
3

जेली , 21 बाइट्स

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

STDOUT में एक पूरा प्रोग्राम प्रिंटिंग। (एक विवादास्पद लिंक के रूप में रिटर्न वैल्यू एक सूची है जिसमें एक चरित्र होता है और तीन पात्रों की सूची होती है।)

इसे ऑनलाइन आज़माएं! या परीक्षण-सूट देखें ।

कैसे?

Ḣ⁾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)
— जोनाथन एलन
स्रोत
3

रेटिना , 38 बाइट्स

केवल ASCII की एक टिप्पणी से प्रेरित है ।

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

इसे ऑनलाइन आज़माएं!

यह विचार _तीन अंकों के साथ प्रत्येक अंक को यूनिरी (रेटिना में डिफ़ॉल्ट यूनिरी डिजिट ) में -परिवर्तित कर रहा है, और फिर सबसे अधिक महत्वपूर्ण से बाइनरी अंकों को परिवर्तित कर रहा है।

— सिंह
स्रोत
2

पायथन 3 , 71 बाइट्स

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

इसे ऑनलाइन आज़माएं!

पायथन 3.3+ में इसके लिए एक अंतर्निहित है, हालांकि आयात की आवश्यकता, और अपेक्षित इनपुट प्रारूप में अंतर के कारण, यह बहुत गोल्फ के अनुकूल नहीं है।

— किरिल एल।
स्रोत
2

टीईसीएल , 139 बाइट्स

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

इसे ऑनलाइन आज़माएं!

टीईसी , 144 बाइट्स

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

इसे ऑनलाइन आज़माएं!

Tcl , 149 बाइट्स

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

इसे ऑनलाइन आज़माएं!

Tcl , 150 बाइट्स

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

इसे ऑनलाइन आज़माएं!

Tcl , 180 बाइट्स

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

इसे ऑनलाइन आज़माएं!

अभी भी बहुत ही अनगढ़!

— sergiol
स्रोत
2

जावा (JDK 10) , 118 बाइट्स

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

इसे ऑनलाइन आज़माएं!

क्रेडिट

— ओलिवियर ग्रेजायर
स्रोत
2
जब आप इनपुट को लोअरकेस के रूप में लेते हैं fdl, तो आप 6 बाइट्स को बचाने के var r=s[0]<70?"d":s[0]<72?"-":"l";लिए बदल सकते हैं var r=s[0]=='f'?"-":s[0]+"";। इसके अलावा, एक अतिरिक्त 4 बाइट्स को बचाने के लिए .toCharArray()किया जा सकता .split("")है।
— केविन क्रूज़सेन
2
@KevinCruijssen आपके विचार ने मुझे १३ बाइट्स बचाए, १० नहीं (क्योंकि मैं ""+बाद charमें "क" में क String) में निकाल सकता था ;) धन्यवाद!
— ओलिवियर ग्रेजायर
2

एक्सेल, 224 बाइट्स

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

4 चरणों में किया गया:

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

और 3 बार:

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

होशियार होने की कोशिश कर रहा है, 25 bytesअधिकारों के प्रति सेट, कुल में 75:

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
स्रोत
2

05AB1E , 34 27 बाइट्स

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

इसे ऑनलाइन आज़माएं!

द्वारा 7 बाइट्स नीचे golfed @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.
— जेनो रैकिन अशर
स्रोत
ćls8βbvyi…rwx3*Nèë'-}J'f'-:के लिए 7 से कम ...
— जादू ऑक्टोपस कलश
मूल रूप से अगर बयानों का उपयोग करते हुए सिर्फ एक अलग क्रम है, और fमैं हटाने के बजाय बस fअंतिम स्ट्रिंग में सभी की जगह ले रहा हूं -।
— मैजिक ऑक्टोपस Urn
i <CODE FOR TRUE> ë <CODE FOR FALSE> }
— मैजिक ऑक्टोपस Urn
@MagicOctopusUrn अच्छा लगा!
— जेनो रैकिन एशर
1

पायथन 2 , 238 बाइट्स

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

इसे ऑनलाइन आज़माएं!

मैंने मान लिया था कि यह बाल्टी में एक बूंद होगी, लेकिन मैं वास्तव में गलत था। शायद महसूस किया जाना चाहिए कि कुछ बिंदु पर एक लंबोदर सबसे अच्छा विचार नहीं था।

— LyricLy
स्रोत
: | बहुत सारे बिलिन = बहुत लंबा
— एएससीआईआई-केवल
1

एपीएल + विन, 55 बाइट्स

प्रमुख चरित्र कम मामले के साथ इनपुट स्ट्रिंग के लिए संकेत:

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

स्पष्टीकरण:

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'
— ग्राहम
स्रोत
1

जम्मू , 57 52 बाइट्स

5 बाइट्स FrownyFrog के लिए धन्यवाद बचा लिया!

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

इसे ऑनलाइन आज़माएं!

फिर भी एक और लंबा समाधान ... मैं नहीं जानता कि कैसे }टैटिट क्रियाओं में काम करना है और यही कारण है कि मैंने {"0 1&.|:चयन के लिए लंबे समय तक उपयोग किया ।

स्पष्टीकरण:

@}. पहले प्रतीक को गिराओ और

,.&.": शेष को दशमलव अंकों की सूची में बदलें

]:#: प्रत्येक अंक को बाइनरी अंकों की सूची में परिवर्तित करें (और कांटा को कैप करें)

('-',:'rwx') एक 2-पंक्ति तालिका बनाता है और इसकी पहली पंक्ति / 1 से चयन करने के लिए 0 का उपयोग करता है - इसके दूसरे से

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

{"0 1&.|:~ ऊपर दी गई तालिका से चयन करने के लिए द्विआधारी अंकों का उपयोग करता है

[:, परिणाम को समतल करता है

('d-l'{~'DFL'i.{.) पहला प्रतीक स्वरूप

, अनुमतियों की सूची के लिए fisrt प्रतीक जोड़ता है

— गैलेन इवानोव
स्रोत
1
इनपुट पहले से ही एक स्ट्रिंग है, आपको जरूरत है1#:@}."."0
— FrownyFrog
1
यह काम करने लगता है: ('d-l'{~'DFL'i.{.)→-&.('-DLld'i.{.)
— FrownyFrog
@FrownyFrog बहुत अच्छा उपयोग i.और &.बहुत बहुत धन्यवाद! वैसे, क्या आप मुझे बता सकते हैं कि कैसे चुनिंदा }क्रियाओं में चयन करें ?
— गैलेन इवानोव
1
2 2 2&#:`('-',:'rwx'"_)}@"."0@}.वास्तव में एक ही लंबाई है
— FrownyFrog
हालाँकि यह 333:) पर नहीं टूटता है
— FrownyFrog
1

पीएचपी, 68 बाइट्स

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

fअंडरस्कोर इनपुट और हर अष्टक संख्या में इसके rwxसमतुल्य इनपुट का अनुवाद डैश के बजाय अंडरस्कोर का उपयोग करके (उद्धरणों की आवश्यकता को बचाने के लिए) करता है, फिर इसके _साथ बदल देता है -।

ऑनलाइन के साथ पाइप के रूप में चलाएं -nFया इसे आज़माएं ।

— टाइटस
स्रोत
1

सी (जीसीसी) , 109 104 बाइट्स

कम से कम C अष्टक इनपुट को परिवर्तित कर सकता है .... :-)

संपादित करें: मुझे एहसास हुआ कि आकार संशोधक की सख्त आवश्यकता नहीं थी, और यह इस मामले में putchar()कम है printf()!

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

इसे ऑनलाइन आज़माएं!

मूल:

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

इसे ऑनलाइन आज़माएं!

— ErikF
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.