Concours (!): Dans la langue de votre choix, écrivez un programme qui traversera l'arborescence d'un répertoire donné et produira une arborescence (c'est-à-dire un tableau de tableaux) qui lui correspond. Supposons que le répertoire soit une variable prédéfinie D. Le plus petit nombre de caractères gagne.

Règles:

• Vous devez utiliser la récursivité
• Voir les règles

Remarque: Supposons qu'il n'y a pas de limites de profondeur de récursivité. En d'autres termes, votre code doit simplement fonctionner pour des arborescences de répertoires suffisamment petites, et en principe pour les plus grandes.

Par exemple:

L'arborescence des répertoires est

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

L'arbre de sortie est

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

Commencez par jouer au golf ici afin que je sache si je fais quelque chose de mal.

S'amuser :)

Mathematica 120 21 20

Récursivité explicite (merci alephalpha d'avoir enregistré un caractère):

f=f/@__~FileNames~#&

f["~/StackExchange/dir1"]

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

TreeForm[%]

Solution précédente trop compliquée:

d="~/StackExchange/dir1"

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

Rubis, 38 caractères

Si cela ne vous dérange pas certains espaces supplémentaires dans la sortie:

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

Exemple d'utilisation:

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

Production:

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

Si je ne peux pas avoir d'espace, quelque chose comme ça pour la deuxième ligne:

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

Python 2.7, 111 caractères

Prend le chemin cible depuis stdin.

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

Powershell - 182 car.

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)

Assez simple. Peut être réduit de 10 caractères si les virgules n'étaient pas nécessaires. Prend l'entrée de $ D (comme indiqué dans la question), retourne la sortie sur STD-Out comme l'exemple de la question est allé.

Souhaitant vraiment que les alias puissent utiliser des options! Je suis tué par le 'write-host -NoNewline's!

Caractères C # 200

Sortie d'une chaîne, pas d'un tableau réel. Prend un chemin comme premier argument.

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

Non golfé:

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

C ++, 318 octets

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

Voici une version légèrement non golfée:

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

Veuillez noter que puisque - selon les instructions - D est supposé être une variable prédéfinie, le code ne se construit pas sans fournir en quelque sorte D. Voici une façon de construire:

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

Script batch - 146, 157, 152 127 octets

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%

Courir avec:

scriptfile.cmd folderroot