कोड गोल्फ: डायरेक्टरी ट्री -> ट्री

Question

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

नियम:

• आपको पुनरावृत्ति का उपयोग करना चाहिए
• नियम देखें

नोट: मान लें कि कोई पुनरावृत्ति गहराई सीमा नहीं है। दूसरे शब्दों में, आपके कोड को पर्याप्त रूप से छोटे निर्देशिका पेड़ों के लिए काम करने की आवश्यकता है, और सिद्धांत रूप में बड़े लोगों के लिए।

उदाहरण के लिए:

डायरेक्टरी ट्री है

dir1
├── dir11
│   ├── file111
│   └── file112
├── dir12
│   ├── file121
│   ├── file122
│   └── file123
├── file11
├── file12
└── file13

आउटपुट ट्री है

[[[],[]],[[],[],[]],[],[],[]]

यहाँ पहले कोड गोल्फ तो lemme पता है कि मैं कुछ गलत कर रहा हूँ।

मज़े करो :)

Comments

"नियम: 1. आपको पुनरावृत्ति का उपयोग करना चाहिए। नियम देखें" आह !! मैं एक इन्फिनिटी लूप में स्टाक हूँ!

— जस्टिन

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

— जस्टिन

यह कितना गहरा होगा?

— इट्नोटली।

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

— जस्टिन

मैं अंधा हो रहा हूं, आपके आउटपुट प्रारूप को पार्स कर रहा हूं। यह, किसी ऐसे व्यक्ति से जो लिस्प का आनंद लेता है।

— डैरेन स्टोन

Answer 1

गणितज्ञ 120 21 20

स्पष्ट पुनरावृत्ति (धन्यवाद एक चार को बचाने के लिए alephalpha):

f=f/@__~FileNames~#&

f["~/StackExchange/dir1"]

{{{}, {}}, {{}, {}, {}}, {}, {}, {}}

TreeForm[%]

पिछला अधूरा समाधान:

d="~/StackExchange/dir1"

f@{x___,Longest@s:{y_,___}..,z___}:=f@{x,f@Drop[{s},1,1],z}
f[FileNameSplit/@FileNames[__,SetDirectory@d;"",∞]]/.f->(#&)

Comments

f=f/@__~FileNames~#&

— एलेफाल्फा

Answer 2

रूबी, 38 वर्ण

यदि आपको आउटपुट में कुछ अतिरिक्त व्हाट्सएप का मन नहीं है:

f=->n{Dir[n+'/*'].map{|c|f[c]}}
p f[D]

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

D='C:/work/dir1'
f=->n{Dir[n+'/*'].map{|c|f[c]}}
p f[D]

आउटपुट:

[[[], []], [[], [], []], [], [], []]

अगर मेरे पास व्हाट्सएप नहीं है, तो दूसरी पंक्ति के लिए कुछ इस तरह से होगा:

puts"#{f[D]}".tr' ',''

Answer 3

पायथन 2.7, 111 चर

स्टड से लक्ष्य पथ लेता है।

import os
def R(d):return[R(f)for f in[d+'/'+e for e in os.listdir(d)]if os.path.isdir(f)]
print R(raw_input())

Answer 4

पॉवर्सशेल - 182 चार

function A([string]$b){write-host -NoNewline '['; ls -path $b|foreach{if($_.PSIsContainer){A($_.FullName)}ELSE{write-host -NoNewline $f'[]';$f=', '}};write-host -NoNewline ']'};A($D)

काफी सरल। यदि अल्पविराम आवश्यक नहीं थे, तो 10 वर्णों से कम किया जा सकता है। $ D से इनपुट लेता है (जैसा कि प्रश्न में कहा गया है), STD-Out पर आउटपुट देता है क्योंकि प्रश्न में उदाहरण दिया गया है।

वास्तव में इच्छुक उपनाम विकल्प का उपयोग कर सकते हैं! मुझे 'राइट-होस्ट-नोवनलाइन' द्वारा मारा जा रहा है!

Comments

मुझे लगता है कि यह थोड़ा बेहतर किया जा सकता है। एक अधिक अनुभवी गोल्फर इसे एक दरार देना चाहते हैं?

— lochok

मुझे नहीं पता कि क्या आपने वास्तव में लक्ष्य को मारा है जो चुनौती के लिए लक्ष्य कर रहा है ... लेकिन यह कोई बड़ी बात नहीं है क्योंकि जवाब देने वाले हर व्यक्ति ने अपनी व्याख्या को चुना है।

— HRRambler

{DOH! दुर्घटना से मारा। } कहा जा रहा है कि मैं आपकी फॉर्च्यूनर को छूने नहीं जा रहा हूं {} इंटरप्रिटेशन, मैं सिर्फ एक सुधार की ओर इशारा करने जा रहा हूं जो आप कर सकते हैं। आपके द्वारा याद की जा रही पहली पॉवरशेल ट्रिक यह है कि राइट-होस्ट अनावश्यक है, यदि आप अपना कोड पाइप में डेटा के साथ समाप्त करते हैं जो होस्ट को लिखा गया है। दूसरी चाल स्वचालित दुःखद विस्तार और सुरीली है जो दोहरे कोट्स के भीतर होती है। अंत में%-foreach जैसे ट्रिक को पहचानने के लिए get-alias का उपयोग करें। अगली बार एक रणनीति का उपयोग करें जो एक चर के भीतर आपके परिणामों को संलग्न करता है फिर उस चर को कॉल करके समाप्त होता है: $ a = gi $ d | ls | % {}; "[$ a]"

— HRRambler

Answer 5

सी # 200 चार्ट

एक स्ट्रिंग का आउटपुट, वास्तविक सरणी नहीं। पहले तर्क के रूप में एक रास्ता लेता है।

using D=System.IO.DirectoryInfo;class P{static string R(D d){var r="[";foreach(D e in d.GetDirectories())r+=R(e);return r+"]";}static void Main(string[] a) {System.Console.WriteLine(R(new D(a[0])));}}

Ungolfed:

using D = System.IO.DirectoryInfo;

class P
{
    static string R(D d)
    {
        var r = "[";
        foreach (D e in d.GetDirectories())
            r += R(e);
        return r + "]";
    }

    static void Main(string[] a)
    {
        System.Console.WriteLine(R(new D(a[0])));
    }
}

Comments

मेरा पहला गोल्फ प्रयास, और C # एक क्रियात्मक भाषा है। किसी भी सलाह की सराहना की जाएगी।

— बॉब

Answer 6

सी ++, 318 बाइट्स

#include <cstdio>
#include <dirent.h>
#include <string>
#define s std::string
#define n e->d_name
s l(s p){s r;dirent*e;DIR*d;if(d=opendir(p.c_str())){int c=0;while(e=readdir(d))if(s("..")!=n&s(".")!=n)r+=&",["[!c++]+(e->d_type==DT_DIR?l(p+'/'+n):"")+"]";closedir(d);}return r;}main(){puts((s("[")+l(D)+"]").c_str());}

यहाँ एक थोड़ा ungolfed संस्करण है:

#include <cstdio>
#include <dirent.h>
#include <string>

#define s std::string
#define n e->d_name

s l(s p) {
    s r;
    dirent*e;
    DIR*d;
    if (d=opendir(p.c_str())) {
        int c=0;
        while (e=readdir(d))
            if (s("..")!=n&s(".")!=n)
                r+=&",["[!c++]+(e->d_type==DT_DIR?l(p+'/'+n):"")+"]";
        closedir(d);
    }
    return r;
}

main() {
    puts((s("[")+l(D)+"]").c_str());
}

कृपया ध्यान दें कि चूंकि - निर्देशों के अनुसार - डी को एक पूर्वनिर्धारित चर माना जाता है, कोड किसी तरह डी की आपूर्ति किए बिना निर्माण नहीं करता है। यहां निर्माण का एक तरीका है:

g++ -Dmain="s D=\".\";main" -o tree golfed.cpp

Answer 7

बैच स्क्रिप्ट - 146, 157, 152 127 बाइट्स

set x=
:a
set x=%x%,[
cd %1
goto %errorlevel%
:0
for /f %%a in ('dir/b') do call:a %%a
cd..
:1
set x=%x:[,=[%]
cls
@echo %x:~1%

साथ दौड़ो:

scriptfile.cmd folderroot

Comments

इस स्क्रिप्ट के हर रन पर आउटपुट बड़ा मिलता है।

— चाचा

हाँ, यह बहुत सत्र के अनुकूल नहीं था, लेकिन अब बेहतर होना चाहिए

— रॉबर्ट सोरली