एक निर्देशिका (जैसे कि C:/) को देखते हुए , स्टड से दी गई या किसी फ़ाइल से पढ़ी गई, एक निर्देशिका ट्री का उत्पादन करें, जिसकी गहराई के आधार पर प्रत्येक फ़ाइल / फ़ोल्डर को इंडेंट किया गया हो।

उदाहरण

मैं एक है, तो C:/ड्राइव जो केवल दो फ़ोल्डर हैं fooऔर bar, और barखाली है, जबकि fooहोता है baz.txt, तो चल इनपुट के साथ C:/पैदा करता है:

C:/
    bar/
    foo/
        baz.txt

इनपुट के साथ दौड़ते समय C:/foo/उत्पादन करना चाहिए

foo/
    baz.txt

जैसा कि यह कोडगोल्फ है, सबसे कम बाइट काउंट जीतता है। फ़ाइल एक्सटेंशन (जैसे baz.txt) वैकल्पिक हैं। अतिरिक्त नोट: छिपी हुई फ़ाइलों को अनदेखा किया जा सकता है, निर्देशिकाओं का वास्तव में अस्तित्व होना चाहिए, यह माना जा सकता है कि फ़ाइलों में अनपेक्षित वर्ण या नई लाइनें नहीं हैं लेकिन अन्य सभी मुद्रण योग्य ASCII वर्ण ठीक हैं (रिक्त स्थान वाले फ़ाइल नाम समर्थित होने चाहिए)। आउटपुट फ़ाइल या स्टडआउट को लिखा जा सकता है। इंडेंटेशन को एक टैब कैरेक्टर या 4 स्पेस से बनाया जा सकता है।

code-golf string file-system

— Mathime
स्रोत

1

अतिरिक्त ध्यान दें: यह प्रश्न खराब स्वरूपित है, इसलिए एक सुधार की सराहना की जाएगी।

— मैथ्यू जूल

क्या ऐसी भाषाएँ जिनके पास स्वचालित रूप से अयोग्य घोषित की गई फ़ाइलों तक पहुंच नहीं है?

— लीक नून

किन फिल्नामों का समर्थन किया जाना है? उनके नाम पर रिक्त स्थान वाली फाइलें? नई कहानियों के साथ? अनपेक्षित वर्णों के साथ? छिपी हुई फ़ाइलों के बारे में क्या (शुरुआत के साथ .)?

— दरवाज़े

1

@LeakyNun संदर्भ प्रश्न का आउटपुट सरणी का एक सरणी है। इस प्रश्न के लिए निर्देशिका ट्री के प्रतिनिधित्व को stdout में प्रिंट करने की आवश्यकता होती है।

— मैथ्यू जूल

1

क्या इनपुट किसी फ़ंक्शन के लिए एक स्ट्रिंग पैरामीटर हो सकता है?

— mbomb007

10

बैश, 61 58 54 बाइट्स

find "$1" -exec ls -Fd {} \;|perl -pe's|.*?/(?!$)|  |g'

कमांड लाइन तर्क के रूप में इनपुट लेता है, STDOUT पर आउटपुट।

ध्यान दें कि अंत से पहले रिक्त स्थान |gवास्तव में एक टैब वर्ण हैं (एसई उन्हें पोस्ट प्रदर्शित करते समय रिक्त स्थान में परिवर्तित करता है)।

find              crawl directory tree recursively
"$1"              starting at the input directory
-exec             and for each file found, execute...
ls -Fd {} \;      append a trailing slash if it's a directory (using -F of ls)
|perl -pe         pipe each line to perl
'
s|                replace...
.*?/              each parent directory in the file's path...
(?!$)             that doesn't occur at the end of the string...
|    |            with a tab character...
g                 globally
'

4 बाइट्स के लिए @ डेनिस को धन्यवाद !

— Doorknob
स्रोत

2

दिल्लोग एपीएल , 48 बाइट्स

(⊂∘⊃,1↓'[^\\]+\\'⎕R'    ')r[⍋↑r←⎕SH'dir/s/b ',⍞]

⍞ चरित्र इनपुट के लिए संकेत

'dir/s/b ', पाठ प्रस्तुत करना

⎕SH खोल में निष्पादित करें

r←आर में स्टोर करें

↑ चरित्र मैट्रिक्स में तार की सूची बनाओ

⍋ आरोही छँटाई के लिए सूचकांक

r[... ]पुन: आर [क्रमबद्ध]

(... )शेल कमांड के मानक पर, करें:

'[^\\]+\\'⎕R' ' रेगेक्स ने बैकस्लैश-टर्मिनेटेड रन ऑफ नॉन-बैकस्लैश को चार स्थानों से बदला

1↓ पहली पंक्ति छोड़ें

⊂∘⊃, संलग्न पहली [लाइन]

"\ Tmp" प्रॉम्प्ट पर इनपुट करने का परिणाम मेरे कंप्यूटर पर निम्नानुसार शुरू होता है:

C:\tmp\12u64
            keyboards64.msi
            netfx64.exe
            setup.exe
            setup_64_unicode.msi
            setup_dotnet_64.msi
        AdamsReg.reg
        AdamsReg.zip
        qa.dws
        ride-experimental
            win32
                d3dcompiler_47.dll
                icudtl.dat
                libEGL.dll

⋮

— एडम
स्रोत

क्या निर्देशिकाओं को अनुगामी \ वर्ण नहीं चाहिए?

— नील

@ उन्हें पसंद किया जाता है लेकिन अनिवार्य नहीं है

— 16

2

एसएमएल , 176 बाइट्स

open OS.FileSys;val! =chDir;fun&n w=(print("\n"^w^n);!n;print"/";c(openDir(getDir()))(w^"\t");!"..")and c$w=case readDir$of SOME i=>(&i w handle _=>();c$w)|x=>()fun%p=(&p"";!p)

घोषणा (दूसरों के बीच) एक फ़ंक्शन %जो तर्क के रूप में एक स्ट्रिंग लेता है। वर्तमान निर्देशिका के साथ % "C:/Some/Path";या उसके % (getDir());लिए कॉल करें ।

मैं सामान्य रूप से बल्कि कार्यात्मक रूप से इस्तेमाल की जाने वाली भाषा StandardML का उपयोग कर रहा हूं जिसका FileSys-Library मैंने इस चुनौती को पढ़ने के बाद खोजा।

विशेष वर्ण !, &, $और %खुद की भाषा में कोई विशेष अर्थ नहीं और बस पहचानकर्ता के रूप में इस्तेमाल कर रहे हैं; हालाँकि, उन्हें मानक अल्फ़ान्यूमेरिक पहचानकर्ताओं के साथ मिश्रित नहीं किया जा सकता है जो कि कुछ अन्यथा आवश्यक रिक्त स्थान से छुटकारा पाने की अनुमति देता है।

open OS.FileSys;
val ! = chDir;                       define ! as short cut for chDir

fun & n w = (                        & is the function name
                                     n is the current file or directory name
                                     w is a string containing the tabs
    print ("\n"^w^n);                ^ concatenates strings
    ! n;                             change in the directory, this throws an 
                                     exception if n is a file name
    print "/";                       if we are here, n is a directory so print a /
    c (openDir(getDir())) (w^"\t");  call c with new directory and add a tab to w
                                     to print the contents of the directory n
    ! ".."                           we're finished with n so go up again
)
and c $ w =                          'and' instead of 'fun' must be used 
                                     because '&' and 'c' are mutual recursive
                                     $ is a stream of the directory content
    case readDir $ of                case distinction whether any files are left
        SOME i => (                  yes, i is the file or directory name
            & i w handle _ => ();    call & to print i an check whether it's a 
                                     directory or not, handle the thrown exception 
            c $ w )                  recursively call c to check for more files in $
        | x    => ()                 no more files, we are finished

fun % p = (                          % is the function name, 
                                     p is a string containing the path
    & p "";                          call & to print the directory specified by p
                                     and recursively it's sub-directories
    ! p                              change back to path p due to the ! ".." in &
)

SML / NJ के साथ या मॉस्को एमएल * के साथ उपसर्ग द्वारा इस तरह संकलित किया जा सकता है load"OS";।

* देखें mosml.org, 2 से अधिक लिंक पोस्ट नहीं कर सकते।

— Laikoni
स्रोत

1

सी # (.NET कोर) , 222 बाइट्स

namespace System.IO{class P{static int n;static void Main(String[]a){Console.WriteLine(new string('\t',n++)+Path.GetFileName(a[0]));try{foreach(var f in Directory.GetFileSystemEntries(a[0])){a[0]=f;Main(a);}}catch{}n--;}}}

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

द अनगुल्फ:

using System.IO;
using System;

class P
{
    static int n=0;
    static void Main(String[] a)
    {
        for (int i=0;i<n;i++) Console.Write("\t");
        Console.WriteLine(Path.GetFileName(a[0]));
        n++;

        if(Directory.Exists(a[0]))
            foreach (String f in Directory.GetFileSystemEntries(a[0]))
                Main(new String[]{f});
        n--;
    }
}

पहली बार मैंने कभी किसी Mainसमारोह में शिरकत की !

मेरा मानना है कि एक व्यक्ति जिसे C # का ताज़ा ज्ञान है, वह इसे और अधिक बढ़ा सकता है, क्योंकि मैंने कुछ समय के लिए C # पर कार्यक्रम नहीं किया था!

— sergiol
स्रोत

0

PHP, 180 बाइट्स

पहला तर्क: पथ में एक अनुगामी स्लैश (या बैकस्लैश) होना चाहिए
दूसरा तर्क: स्तर की चूक NULLऔर इसके 0द्वारा व्याख्या की जाएगी str_repeat; प्रदान नहीं किए जाने पर चेतावनी फेंक देंगे

function d($p,$e){$s=opendir($p);echo$b=str_repeat("\t",$e++),$e?basename($p)."/":$p,"
";while($f=readdir($s))echo preg_match("#^\.#",$f)?"":is_dir($p.$f)?d("$p$f/",$e):"$b\t$f
";}

छिपी हुई फ़ाइलों और निर्देशिकाओं को प्रदर्शित करता है, लेकिन छिपी हुई निर्देशिकाओं की पुनरावृत्ति नहीं करता है, आउटपुट (+2) से छिपी हुई प्रविष्टियों को हटाने के
लिए कोष्ठक जोड़ते हैं, is_dir(...)?d(...):"..."छिपी हुई प्रविष्टियों को प्रदर्शित करने / पुन: दर्ज करने के लिए
प्रतिस्थापित "#^\.#"करते #^\.+$#हैं, लेकिन डॉट प्रविष्टियों (+2) को छोड़ देते हैं
जब निर्देशिकाएँ बहुत गहरी हों, तो त्रुटियां फेंक सकते हैं। तय करने closedir($s);से पहले डालें }(+13)
यदि कोई निर्देशिका बिना नाम वाली प्रविष्टि में विफल रहती है, तो false!==ठीक करने के लिए शर्त पर प्रीपेन्ड करें (+8)

ग्लोब के साथ, 182 बाइट्स (शायद भविष्य के php में 163)

function g($p,$e){echo$b=str_repeat("\t",$e),$e++?basename($p)."/":$p,"
";foreach(glob(preg_replace("#[*?[]#","[$1]",$p)."*",2)as$f)echo is_dir($f)?g($f,$e):"$b\t".basename($f)."
";}

छिपी हुई फ़ाइलों / निर्देशिकाओं को प्रदर्शित या पुनर्जीवित नहीं करता है
2के लिए खड़ा है GLOB_MARK, सभी निर्देशिका नामों के लिए एक स्लैश जोड़ देगा, जैसा कि करता हैls -F
इस preg_replaceविशेष ग्लोब के लिए
मैं preg_quote(-19) के साथ दुर्व्यवहार कर सकता था ; लेकिन यह विंडोज सिस्टम पर विफल होगा, क्योंकि बैकस्लैश वहां निर्देशिका विभाजक है।
php में जल्द ही एक फंक्शन glob_quote शामिल हो सकता है , जो समान गोल्फिंग की अनुमति देगा और सभी प्रणालियों पर काम करेगा।preg_quote

iterators के साथ, 183 बाइट्स
(अच्छी तरह से, नहीं विशुद्ध रूप से Iterators: मैं अंतर्निहित इस्तेमाल किया SplFileInfo::__toString()गोल्फ के लिए $f->getBaseName()और $f->isDir()पुराने PHP 4 कार्यों के लिए।)

function i($p){echo"$p
";foreach($i=new RecursiveIteratorIterator(new RecursiveDirectoryIterator($p),1)as$f)echo str_repeat("\t",1+$i->getDepth()),basename($f),is_dir($f)?"/":"","
";}

कोई अनुगामी स्लैश की आवश्यकता नहीं है
छिपी हुई प्रविष्टियों को प्रदर्शित करता है और उनकी पुनरावृत्ति करता है ( ls -a)
सम्मिलित करें ,4096या ,FilesystemIterator::SKIP_DOTSपहले ),1डॉट प्रविष्टियाँ छोड़ें (+5) ( ls -A)
झंडा लिए 1खड़ा हैRecursiveIteratorIterator::SELF_FIRST

— टाइटस
स्रोत

0

पॉवरशेल, 147 बाइट्स

param($a)function z{param($n,$d)ls $n.fullname|%{$f=$_.mode[0]-ne"d";Write-Host(" "*$d*4)"$($_.name)$(("\")[$f])";If(!$f){z $_($d+1)}}}$a;z(gi $a)1

यार, मुझे ऐसा लगता है कि PS को bash उत्तर जैसा कुछ करने में सक्षम होना चाहिए, लेकिन मैं यहां जो कुछ भी कर रहा हूं उससे कम के साथ नहीं आ रहा हूं।

स्पष्टीकरण:

param($a)                     # assign first passed parameter to $a
function z{param($n,$d) ... } # declare function z with $n and $d as parameters
ls $n.fullname                # list out contents of directory
|%{ ... }                     # foreach
$f=$_.namde[0]-ne"d"          # if current item is a file, $f=true
Write-Host                    # writes output to the console
(" "*$d*4)                    # multiplies a space by the depth ($d) and 4
"$($_.name)$(("\")[$f])"      # item name + the trailing slash if it is a directory
;if(!$f){z $_($d+1)}          # if it is a directory, recursively call z
$a                            # write first directory to console
z(gi $a)1                     # call z with $a as a directoryinfo object and 1 as the starting depth

— ThePoShWolf
स्रोत

0

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

इस एसओ उत्तर से संशोधित । वे इंडेंटेशन के लिए टैब हैं, स्पेस नहीं। इनपुट की तरह ले जाया जाएगा "C:/"।

import os
p=input()
for r,d,f in os.walk(p):
    t=r.replace(p,'').count('/');print' '*t+os.path.basename(r)
    for i in f:print'   '*-~t+i

इसे ऑनलाइन आज़माएं - यह बहुत दिलचस्प है कि मुझे Ideone पर निर्देशिका ब्राउज़ करने की अनुमति है ...

एक ही लंबाई:

from os import*
p=input()
for r,d,f in walk(p):
    t=r.replace(p,'').count(sep);print' '*t+path.basename(r)
    for i in f:print'   '*-~t+i

— mbomb007
स्रोत

0

बैच, 237 बाइट्स

@echo off
echo %~1\
for /f %%d in ('dir/s/b %1')do call:f %1 %%~ad "%%d"
exit/b
:f
set f=%~3
call set f=%%f:~1=%%
set i=
:l
set i=\t%i%
set f=%f:*\=%
if not %f%==%f:*\=% goto l
set a=%2
if %a:~0,1%==d set f=%f%\
echo %i%%f%

जहाँ \ t शाब्दिक टैब वर्ण का प्रतिनिधित्व करता है। इस संस्करण में \निर्देशिकाओं में अनुगामी एस शामिल हैं लेकिन यदि आवश्यक नहीं है तो 41 बाइट्स बचाए जा सकते हैं।

— नील
स्रोत

अनुगामी `\ _ की आवश्यकता नहीं है

— केवल

0

पर्ल, 89 बाइट्स

जब मुख्य वितरण में एक खोज मॉड्यूल होता है तो यह उपयोगी होता है। पर्ल की फ़ाइल :: ढूँढें मॉड्यूल अक्षरांकीय क्रम में पेड़ को पार नहीं करता है, लेकिन कल्पना ने उसके लिए नहीं पूछा।

/usr/bin/perl -MFile::Find -nE 'chop;find{postprocess,sub{--$d},wanted,sub{say" "x$d.$_,-d$_&&++$d&&"/"}},$_'

स्क्रिप्ट उचित 76 बाइट्स है, मैंने कमांड-लाइन विकल्पों के लिए 13 बाइट्स गिना।

— डैनियल
स्रोत

0

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

proc L f {puts [string repe \t [expr [incr ::n]-1]][file ta $f];lmap c [glob -n -d $f *] {L $c};incr ::n -1}
L $argv