चामोद को डिकोड करें

Question

चुनौती

तीन अंकों वाली ऑक्टल परमिशन संख्या को देखते हुए, उन अनुमतियों को आउटपुट करें जो इसे अनुदान देती हैं।

chmod

UNIX OSes पर फ़ाइल अनुमतियों को chmodकमांड का उपयोग करके बदल दिया जाता है । Chmod का उपयोग करने के कुछ अलग तरीके हैं, लेकिन आज हम जिस पर ध्यान केंद्रित करेंगे, वह है ऑक्टेल परमिशन का उपयोग करना।

अनुमतियों की संख्या में तीन अंक एक अलग व्यक्ति का प्रतिनिधित्व करते हैं:

• पहला अंक उपयोगकर्ता के लिए अनुमतियों का प्रतिनिधित्व करता है
• दूसरा अंक समूह के लिए अनुमतियों का प्रतिनिधित्व करता है
• अंतिम अंक दूसरों के लिए अनुमतियों का प्रतिनिधित्व करता है

अगला, प्रत्येक अंक एक अनुमति का प्रतिनिधित्व करता है जैसा कि नीचे दिखाया गया है:

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

इनपुट

इनपुट एक स्ट्रिंग के रूप में तीन अंकों की संख्या होगी, जैसे:

133

या

007

यह या तो STDIN के माध्यम से या फ़ंक्शन तर्क के माध्यम से पारित किया जाएगा।

उत्पादन

आपका आउटपुट प्रत्येक उपयोगकर्ता, समूह और अन्य के लिए अलग-अलग अनुमतियाँ होनी चाहिए। आपको इस जानकारी को इस तरह दिखाना होगा:

User:   ddd
Group:  ddd
Others: ddd

जहां तीन स्पेस के बाद Userदो स्पेस Groupऔर उसके बाद एक स्पेस है Others। आप dddअनुमतियों की जानकारी से प्रतिस्थापित करते हैं।

आपका आउटपुट STDOUT या एक लौटे स्ट्रिंग के रूप में हो सकता है।

उदाहरण

इनपुट: 666

आउटपुट:

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

---

इनपुट: 042

आउटपुट:

User:   None
Group:  Read only
Others: Write only

---

इनपुट: 644

आउटपुट:

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

जीतना

बाइट्स में सबसे छोटा कोड जीतता है।

Comments

इनपुट के विनिर्देश क्या हैं?

— जोनाथन एलन

@JonathanAllan बस तीन अंकों की संख्या

— बीटा डिके

आपका मतलब केवल दशमलव पूर्णांक के रूप में है, इसलिए 042 को 42 के रूप में प्राप्त किया जाएगा?

— जोनाथन एलन

@ जोनाथन नहीं, यह एक स्ट्रिंग इनपुट है, इसलिए यह 042

— बीटा डेके

आउटपुट टैब कैरेक्टर के साथ सही लगता है, तो इसका उपयोग क्यों न किया जाए? बस एक दंड पैड करने के लिए और अधिक बाइट्स की आवश्यकता है कि दंड भाषाओं के लिए?

— टाइटस

Answer 1

05AB1E , 89 87 बाइट्स

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

Cthulhu एन्कोडिंग को समन करता है । CP-1252 एन्कोडिंग का उपयोग करता है । इसे ऑनलाइन आज़माएं!

Answer 2

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

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`
`

संपादित करें: "कोई टैब" नियम को पूरा करने के लिए +1 बाइट

उदाहरण

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

Comments

आप सरणी को पुनर्व्यवस्थित करके (और शायद स्ट्रिंग्स से संख्याओं को अलग करके) कुछ बाइट्स प्राप्त कर सकते हैं। विचार के लिए +1।

— टाइटस

@ टिट्स - मुझे स्वीकार करना है कि मैं एक पुनर्व्यवस्था को देखने में विफल हूं जो कुछ बाइट्स बचाता है। इसके अलावा, संख्याओं को स्ट्रिंग्स के रूप में माना जाना चाहिए ताकि replace()उन पर बिना किसी जोर-जबरदस्ती के काम किया जा सके। लेकिन मुझे आपकी बात याद आ रही होगी।

— Arnauld

@ टिट्स - ऐसा कुछ 'User3Group68Others58None576Read48Write476Execute475and4576only'.split(/(\d+)/)काम कर सकता है। क्या आपके मन में ऐसा था?

— अरनौलद

मैं उन्हें गलत समझ रहा था; उन्होंने सोचा कि वे अष्टाधारी मूल्य थे। :) लेकिन आपका नया विचार बुरा भी नहीं है।

— टाइटस

चुनौती आउटपुट के लिए टैब के बजाय रिक्त स्थान की आवश्यकता होती है क्योंकि यह वर्तमान में लिखा गया है।

— Mwr247

Answer 3

GNU sed, 187 163 158 (157 + 1) बाइट्स

-R (ERE regexp) के साथ चलाएँ । फ़ाइल में कोई अनुगामी न्यूलाइन नहीं है।

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

Comments

अच्छा दृष्टिकोण है, लेकिन आप 20 बाइट के बारे में जब आप जोड़ने के अंक को हटाने के द्वारा बचा सकता है andया only।

— नील

@ वहां मौजूद :) ने एक बहुत महत्वपूर्ण बचत के लिए अपने सुझाव को शामिल किया।

— जुगनू

पहली पंक्ति बस हो सकती है s/(.)(.)/User: \1\nGroup: \2\nOthers: /:। कुछ और बाइट्स पर्ल से पोर्ट करके बचाए जा सकते हैं, जो है \dऔर \K।

— नवजलज

@ninjalj अच्छी बात है। जब से मैं पर्ल को नहीं जानता हूं, मैं उनसे चिपक जाऊंगा, और मुझे यकीन है कि एस /// रिप्लेसमेंट के बाहर इसे और भी छोटा बनाने के लिए अन्य चालें चलेंगी।

— फायरफली

Answer 4

सी # 214 बाइट्स

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

Answer 5

जेली , 100 91 85 बाइट्स

^{लगभग निश्चित रूप से गोल्फ - 91 बाइट्स, क्या ?!} 8 महीने और 6 ज्ञान बाइट्स!
- 1. अधिक स्ट्रिंग संपीड़न;
- 2. अनुक्रमणिका मॉड्यूलर होने के बाद से 48 के बाद के अध्यादेश में कमी को हटा दें;
(3. बेहतर टैसिट चेनिंग का उपयोग करें)।

-9 बाइट्स मेरे लिए @Lynn रनिंग स्ट्रिंग कंप्रेशन्स की मदद से

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

यह TryItOnline पर परीक्षण करें

कैसे?

,“£ɱ~» - 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

Answer 6

ऑक्टेव, 185 बाइट्स

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

अनाम फ़ंक्शन बनाएं जो इनपुट को स्ट्रिंग के रूप में लेता है: '042'। इसे एक सरणी में बदलें (56-'042)' = [0 4 2]:। सेल सरणी को अनुक्रमित करने के लिए एकाधिक सेल सूचकांकों के रूप में इसका उपयोग करें Read Write and Execute','Read and Write', ...। उपयोग fprintfउत्पादन के लिए तीन तार, उचित श्रेणियों के साथ: User:, Group:और Others:।

मैं दुकान के लिए एक रास्ता खोजने की कोशिश की Execute, Write, Readअलग शब्द और CONCATENATE की जरूरत है, लेकिन इसमें अधिक समय निकला अनुभवहीन दृष्टिकोण से के रूप में।

उदाहरण:

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

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

Comments

आप strsplit('Read Write and Execute*Read and Write*Read and Execute*Read only*Write and Execute*Write only*Execute only*None','*')सेल सरणी के बजाय कुछ बाइट्स बचा सकते हैं

— लुइस मेंडो सेप

Answer 7

PowerShell v2 +, 189 168 बाइट्स

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

इनपुट के माध्यम से लूप $args[0]एक char-रे के रूप में । प्रत्येक यात्रा के साथ एक सरणी में हम सूचकांक $i++(डिफ़ॉल्ट रूप में 0चुनें) करने के लिए User, Groupया Others, CONCATENATE है कि एक बृहदान्त्र और एक टैब, और CONCATENATE साथ कि एक और सरणी सूचकांक के साथ।

यहाँ जादू है। हम परोक्ष डाली charएक को intऔर घटाने के 48(यानी, मोड़ ASCII 48( "0") में 0), की एक सरणी के रूप में उपयुक्त शब्दों का चयन intहै। उस सरणी को बाद में अनुक्रम में 'None','Read','Write','Execute','only','and'सरणी के रूप में उपयोग किया जाता है । चूंकि डिफ़ॉल्ट $ofs(आउटपुट फील्ड सेपरेटर) एक स्थान है, यह सही ढंग से स्ट्रिंग तत्वों के बीच रिक्त स्थान सम्मिलित करता है जब (जो तब होता है जब यह बाईं ओर समवर्ती होता है)।

इन तीन तारों को पाइप लाइन पर छोड़ दिया जाता है, और निहितार्थ के माध्यम से आउटपुट Write-Outputप्रोग्राम पूरा होने पर होता है।

उदाहरण

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

Answer 8

स्ट्रॉ , 193 बाइट्स

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

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

पहले स्टैक पर रूपांतरण तालिका को 3 बार पुश करें, दूसरे स्टैक पर स्विच करें, वार्तालाप तालिका और प्रिंट का उपयोग करके प्रत्येक संख्या को परिवर्तित करें।

Answer 9

हास्केल, 186 बाइट्स

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

उदाहरण:

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

केवल Prelude का उपयोग किया। क्या मैं इसे ठीक से कर रहा हूं?

Ungolfed:

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

Answer 10

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

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

यदि अनुरेखण या लिखें पंक्ति के अंत में हैं, तो एक अनुगामी स्थान छोड़ता है, लेकिन मैंने नहीं देखा कि यह अनुमति नहीं थी।

EDIT ने रेंज (3) को 0,1,2 में बदलकर 5 बाइट्स की बचत की और अपने विंडोज एक (\ n = \ r \ n या अन्य तरह के राउंड के बजाय अपने लिनक्स लैपटॉप पर बाइट काउंट की जाँच की। मुझे याद नहीं है कि कौन सा)।

Answer 11

पायथन 2, 240 239 238 237 228 बाइट्स

मैंने सोचा कि मैं इस कोल्ड गोल्फ चीज़ को आखिरकार दे दूंगा। उम्मीद है कि व्हाट्सएप को पीछे करने की अनुमति है। (निश्चित किया गया, और इस प्रक्रिया में एक बाइट बचाई गई)

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

Comments

PPCG में आपका स्वागत है, और पहला अच्छा जवाब!

— ETHproductions

मैंने बेशर्मी से आपके कोड के माध्यम से पढ़ने के बाद मेरे पायथन 2 के उत्तर में 0,1,2 की सीमा (3) को बदल दिया है। अच्छा जवाब। +1

— ElPedro

Answer 12

PHP, 169 159 बाइट्स

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

स्ट्रिंग कमांड लाइन तर्क के रूप में लेता है: php -r '<code>' <argument>,
एक अनुगामी एक के बजाय एक अग्रणी न्यू लाइन प्रिंट

मेरे कीड़े को इंगित करने के लिए Jörg को धन्यवाद - और के लिए \t।

PHP, 169 बाइट्स

नए प्रतिबंध के साथ: (वर्जित चरित्र)

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

यह 1 बाइट के साथ की तुलना में छोटा है str_pad, क्योंकि अतिरिक्त रिक्त की आवश्यकता होगी।

टूट - फूट

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
}

इसके लिए सरणी बनाने के लिए $n, इसका उपयोग करें:

$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,";}

Comments

foreach ([ 'उपयोगकर्ता', 'समूह', 'दूसरों'] $ के रूप में मैं => $ यू) {गूंज "\\ n यू $: \\ टी"; कुछ बाइट्स बचाता है और 3,4,6 के लिए आउटपुट गलत है

— जोर्ज हल्सरमैन सेप

यह सही क्रम है [5,33,34,66,35,67,131,531] अच्छा विचार है

— Jörg Hülsermann

मैं भूल गया हूं कि उपयोगकर्ता को 'उपयोगकर्ता' भूल जाते हैं, अगले 6 बाइट्स बचाता है, जिसे आप हराना चाहते हैं, जावास्क्रिप्ट करते हैं

— Jörg Hülsermann

@ JörgHülsermann: मैं वैसे भी "\ t" अपनाने वाला था; धन्यवाद। उस के लिए +1 :) पर अच्छी नज़र 33!

— टाइटस

346 के लिए हमारा आउटपुट उपयोगकर्ता है: पढ़ें और लिखें समूह: केवल दूसरों को निष्पादित करें: इसे लिखें और निष्पादित करें उपयोगकर्ता को यह लिखना चाहिए: लिखें और निष्पादित करें समूह: केवल अन्य लोगों को पढ़ें: पढ़ें और लिखें

— Jörg Hülsermann

Answer 13

दे घुमा के - 221 213 बाइट्स

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

अस्पष्ट अगर यह किसी भी आगे संघनित हो सकता है, तो कम से कम मौलिक रूप से यहां दृष्टिकोण को बदलने के बिना नहीं (इनपुट को विभाजित करना और इसे अनुक्रमणिका के रूप में उपयोग करना ${b}जो संबंधित तारों को पकड़ता है)।

Comments

यह \ onlyविस्तारित इनलाइन के साथ छोटा है । grep -o .<<<$1से कम है echo $1|grep -o ., लेकिन स्टड से इनपुट पढ़ना while read -n1 cबेहतर है। ऐरे इंडेक्स में बैश में अंकगणित का संदर्भ होता है, इसलिए ${l[z++]}काम करता है। lएक स्ट्रिंग के रूप में छोटा होगा, जिसे ${l:z++*8:8}(ऑफसेट और लंबाई में अंकगणितीय संदर्भ होता है) के रूप में एक्सेस किया जाएगा । c"उपयोगकर्ता:", ... इनलाइन का विस्तार करते हुए और पूरी तरह से पैरामीटर विस्तार का विवेकपूर्ण उपयोग करते हुए एक और बाइट को पूरी विधा में पढ़ा जा सकता है ।

— नवजाल

के अंतिम परिणाम के लिए: 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}]}"(शाब्दिक newlines के साथ \ n बदलें)।

— नवजाल

Answer 14

जावा 7, 300 284 बाइट्स

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

अब के लिए प्रत्यक्ष दृष्टिकोण। शब्दों का पुन: उपयोग करने के लिए अधिक सामान्य दृष्टिकोण के साथ आने की कोशिश करेंगे।

अनगढ़ और परीक्षण के मामले:

इसे यहाँ आज़माएँ।

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

आउटपुट:

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

Answer 15

ग्रूवी, 217 207 205 बाइट्स

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

ungolfed:

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

Answer 16

गणितज्ञ, 211 बाइट्स

{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}&

एक सीधा कार्यान्वयन (शायद आसानी से हरा सकने योग्य): कुछ भी गणना नहीं करता है, बस प्रत्येक संभावित आउटपुट को हार्ड-कोड करता है। इनपुट एक पूर्णांक है; एक अनुगामी स्थान और एक अनुगामी न्यूलाइन के साथ प्रत्येक पंक्ति को आउटपुट करता है।

IntegerDigits[#,10,3]इनपुट के तीन अंक देता है (भले ही अग्रणी शून्य हो)। प्रत्येक अंक "फ़ंक्शन" के एक तर्क को इंगित करता है

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

0 फ़ंक्शन के नाम को इंगित करने के साथ ही। ""<>एक सूची में (सूची के) सभी तार को सम्‍मिलित करता है। "\n"&~Array~3तीन newlines पैदा करता है।

Comments

मैंने अभी देखा कि मेरे पायथन 2 का उत्तर लगभग समान है, यहां तक ​​कि समान चर नामों का उपयोग भी। इससे पहले कि मैं पोस्ट करता मैं ईमानदारी से तुम्हारा नहीं देखा था!

— एलपेड्रो

कोई चिंता नहीं! मुझे लगता है कि वैरिएबल के नाम का मिलान इस स्थिति में होने की बहुत उम्मीद है :)

— ग्रेग मार्टिन

आप सही समझे। चर नाम थोड़ा सा अनुमानित थे names

— एलपेड्रो

btw, +1 cos हम यही सोचते हैं :-)

— ElPedro

btw, मैं गणितज्ञ को नहीं जानता लेकिन मुझे लगता है कि आप "केवल" से अंतरिक्ष को हटाकर एक बाइट खो सकते हैं। यह हमेशा एक पंक्ति के अंत में होगा ताकि एक अनुगामी स्थान की आवश्यकता न हो।

— एलपेड्रो

Answer 17

जावा 7, 278

golfed:

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

Ungolfed:

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

आउटपुट:

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

Answer 18

पायथन 3.5, 3.6 - 235 232 228 216 बाइट्स

(सभी पायथन 3.x पर काम करना चाहिए)

तो यहाँ इनपुट STDIN पर है (आयात saves बचाता है)।

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

ट्यूपल्स का उपयोग करना, रिक्त स्थान को छोड़ना जहां संभव हो और ऑपरेटर पूर्वता है जहां आप अपने इरादों को स्पष्ट करने के लिए आमतौर पर कोष्ठक डालते हैं।

नमूना उपयोग:

$ 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

संयुक्त राष्ट्र के golfed:

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

Answer 19

बैच, 280 बाइट्स

@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

स्ट्रिंग्स को हार्डकोड करना 47 बाइट्स को एक साथ टुकड़े करने की कोशिश से कम था। यदि टैब कानूनी थे, तो 267 बाइट्स होंगे।

Answer 20

सी # 307 241 210 बाइट्स

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

प्रारूपित

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

Answer 21

सी #, 322 337 348 बाइट्स

यह निश्चित रूप से सबसे छोटा संस्करण नहीं है, लेकिन मैंने बिटवाइज़ ऑपरेटरों का उपयोग करके इस समस्या को हल करने की कोशिश की है क्योंकि chmodमूल्य वास्तव में बिट फ्लैग हैं। इसके अलावा C # शायद सबसे अच्छी गोल्फिंग भाषा नहीं है: 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')));}

अपुष्ट: (टिप्पणियों के साथ)

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
}

यह मेरी पहली बार कोड गोल्फिंग है, इसलिए कृपया मुझे बताएं, अगर मैंने कोई गलत काम किया है :)

संपादित करें 1:

बदल कर कुछ बाइट्स सहेजा s[i]-'0'द्वारा s[i]&7(अंत में) और चर में सूची गिनती की बचत:

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

संपादित करें 2:

लंबोदर अभिव्यक्ति में परिवर्तन:

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

Answer 22

जावास्क्रिप्ट, 213 209 208 188 186 बाइट्स

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

दादा को धन्यवाद दिया 20 बाइट्स बचाए!

Comments

मुझसे गलती हो सकती है, लेकिन क्या आपकी सरणी विपरीत क्रम में नहीं होनी चाहिए? अगर मैं b ("000") कहता हूं, तो यह "Read Write and Execute" देता है, जबकि कोई भी "कोई नहीं" की उम्मीद कर सकता है ...

— Dada

और मुझे पूरा यकीन है कि यह अधिक गोल्फ हो सकता है। उदाहरण के लिए, एक 191 बाइट संस्करण 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]]}:।

— दादा

Answer 23

विजुअल बेसिक, 606 बाइट्स

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

Comments

PPCG में आपका स्वागत है! अच्छा पहला जवाब बीटीडब्ल्यू :)

— बीटा डेके

Answer 24

क्रिस्टल, 200 194 बाइट्स

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

स्ट्रिंग के रूप में दिए गए अष्टक-अनुक्रम के लिए परिणामी स्ट्रिंग लौटाता है। जैसे: m("670")परिणाम User: Read and Write\nGroup: Read Write and Execute\nOthers: None:।

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

Answer 25

सी #, 371 बाइट्स

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

Comments

यह कोड-गोल्फ है, इसलिए आपको अपना कोड गोल्फ करना होगा। इसके अलावा, भाषा के नाम और बाइटकाउंट के साथ एक हेडर जोड़ें।

— 12

मैंने आपका बाइट काउंट जोड़ा है, जो आपका स्कोर है। आपको अपना स्कोर जीतने के लिए जितना संभव हो उतना कम पाने की आवश्यकता है

— बीटा डेके

उदाहरण के लिए, आपको प्रत्येक फ़ंक्शन में अनावश्यक व्हाट्सएप से छुटकारा मिल जाता है

— बीटा डेके

@ BetaDecay धन्यवाद, मैं इस समुदाय के लिए नया हूं और मुझे लगता है कि मैं php का उपयोग करना बेहतर समझूंगा, जिससे अधिक कॉम्पैक्ट कोड हो सकते हैं।

— अलिर्ज़ा तबातबाईयन

@Alireza यह एक अच्छा विचार है। हालाँकि इस साइट पर, हम जावा और C # :) में संक्षिप्त जवाब देखना पसंद करते हैं

— बीटा डेके

Answer 26

पायथन 3.5 - 370 294 243 बाइट्स

golfed:

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

आकार की जांच:

$ du -b OctalToHuman.py 
243     OctalToHuman.py

संयुक्त राष्ट्र के golfed:

#!/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])

नमूना उत्पादन:

$ 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

Comments

यह जीत के मापदंड का गंभीर दावेदार नहीं है। हमें जीतने के मानदंड के लिए उनके स्कोर को अनुकूलित करने के लिए एक गंभीर प्रयास करने के लिए सभी उत्तरों की आवश्यकता है (उदाहरण के लिए, कोड गोल्फ चुनौतियों में इस एक के रूप में, सबमिशन को प्रोग्राम की बाइट की संख्या को कम करने के लिए एक गंभीर प्रयास करना होगा)।

— Mego

आप काफी कुछ बाइट्स को हटाकर बचा सकते हैं import sys, और बस प्रोग्राम को एक अनाम फ़ंक्शन ( lambda o:...) बना सकते हैं।

— NoOneIsHere

Answer 27

एफ #, 204 203 बाइट्स

मेरा पहला गोल्फ, इसलिए कृपया किसी भी गलतियों को माफ करें;)
गोल्फ संस्करण (1: 1 गुलाबीफ्लोक्स 3333 के उत्तर पर आधारित ):

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

अनगोल्ड संस्करण:

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

उदाहरण का उपयोग:

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

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

---

यह पूरी तरह से जांच करने के लिए है, कि क्या मैं ' पिंकफ्लोक्सएक्स 33 ' के जवाब में सुधार कर सकता हूं - मैं एल्गोरिथ्म के लिए कोई क्रेडिट नहीं लेता हूं

Answer 28

PHP, 199 बाइट्स

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 बाइट्स with \ 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);}

Comments

अरे, आपको टैब के बजाय रिक्त स्थान का उपयोग करना चाहिए

— बीटा डेके

इस मामले में \ t str_repeat ("", 3- $ i) या str_pad ("", 3- $ i, "") की तरह दिखता है, लेकिन मेरे विचार से मुझे जीतने का कोई मौका नहीं है। एक अन्य स्थान cs.tut.fi/~jkorpela/chars/spaces.html

— जोर्ग हल्सरमैन

बचाने के लिए 13 + 34 बाइट्स। लंबे संस्करण में: (-9 के echo str_pad("$u:",8)बजाय echo"$u:".str_repeat(" ",3-$i)) का उपयोग करें ; यह $i=>अप्रचलित (-4) प्रदान करता है। उपयोग: दोनों संस्करणों में $a[$z-1]="and $a[$z-1]";के बजाय {$a[]=$a[$z-1];$a[$z-1]="and";}और (-7) else$a[]=$a?Only:None;के बजाय elseif($z<1)$a[]=None;else$a[]=Only;(-14)। बारी if(1<$z=count($a))$a[$z-1]="and $a[$z-1]";else$a[]=$a?Only:None;में if($x=array_pop($a))$a[]=$a?"and $x":"$x Only";else$a[]=None;(-3) और उसके बाद में $a[]=($x=array_pop($a))?$a?"and $x":"$x Only":None;(-10)

— टाइटस

@ टिट्स गूंज str_pad ("$ u:", 8), $ एक [$ z-1] = "और $ एक [$ z-1]" ;, बाकी $ a [] = $ a? केवल: कोई नहीं हो गया $ i => अप्रचलित मैं नहीं कर सकता तो $ m = $ argv [1] [$ i] आवश्यक है। बाकी के लिए मैं पहले दूसरा तरीका आजमाऊंगा। इनपुट के लिए धन्यवाद

— जॉर्ग हल्सरमैन

अधिक विचार: (-3) के if(4&$m=$argv[1][$i])बजाय या एक लूप से प्रतिस्थापित करें: (-7)$m=$argv[1][$i];if(4&$m)$m=;if();if();if();foreach([Read,Write,Execute]as$k=>$s)if($argv[1][$i]&4>>$k)$a[]=$s;

— टाइटस

Answer 29

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

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

ungolfed

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

Comments

PPCG में आपका स्वागत है! अच्छी पहली पोस्ट!

— R

हम्म, मैं बहुत उत्सुक हूं कि जब मैं केवल 191 प्राप्त करता हूं तो मॉडरेटर को 151bytes कैसे मिले: क्या यह गलती है? चेक एडिट

— अलेक्सांद्रा स्मिरनोव

वो मैं थी, सॉरी। मैं संपादन में टाइप करता हूं। अब तय हो गया।

— R

Answer 30

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

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

---

उदाहरण:

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