Objectif:

Créez un programme pour trouver le plus petit fichier dans le dossier actuel.

• La taille du fichier peut être mesurée en octets ou en caractères.
• Si plusieurs fichiers ont la même taille, vous pouvez en choisir un ou les afficher tous.
• Vous pouvez supposer qu'il y aura au moins un fichier dans le dossier et qu'aucun fichier n'aura une taille de 0.

• Supposons que tous les fichiers du dossier peuvent être chargés dans la langue que vous utilisez.

• Supposons qu'il n'y ait aucun dossier dans le répertoire actuel.

Contribution:

Le programme ne doit recevoir aucune entrée de l'utilisateur, sauf si:

• Si votre langue n'a pas de "dossier actuel", il peut demander à l'utilisateur un nom / chemin d'accès au dossier.
• Si votre langue ne peut pas accéder directement aux fichiers sur votre ordinateur, cela peut permettre à l'utilisateur de télécharger des fichiers. (JavaScript, par exemple)

Production:

Le nom du plus petit fichier doit être affiché.

• Les symboles de début / fin sont autorisés, tant qu'il est clair quel fichier a été choisi.
• (L'impression d'une liste de tous les fichiers est contraire aux règles).

Remarques:

• Les échappatoires standard ne sont pas autorisées.
• Vous ne pouvez pas modifier / créer / supprimer des fichiers dans le dossier pour changer le résultat.
• C'est du golf de code ; la réponse la plus courte (en octets) l'emporte.

Vim 12 octets

!!ls -Sa
Gd{

Essayez-le en ligne!

Explication:

!!est la commande de filtrage . Il redirige le contenu de la ligne actuelle vers une commande système arbitraire et renvoie la sortie dans le tampon. Il est utile pour utiliser des outils externes pour des choses où bash est meilleur que vim, par exemple !!revpour inverser la ligne actuelle ou !Gxxdpour vider le tampon hexadécimal. Dans notre cas, le tampon est vide, il est donc équivalent à :r!ls, ce qui alimente simplement la sortie de la commande dans la ligne actuelle.

Maintenant, le curseur est sur la ligne 1, et nous voulons supprimer toutes les lignes sauf la dernière. L'approche naïve est

G       " Go to the last line
 k      " Go up one line
  d     " Delete:
   gg   "   Everything up to the first line

Mais nous pouvons faire mieux. Comme je l'ai expliqué dans cette astuce , le {peut généralement (mais pas toujours) être équivalent à gg. Ici, c'est encore mieux. Parce que le mouvement est basé sur des caractères , et non sur des lignes comme ggc'est le cas, nous n'avons pas besoin de remonter une ligne en premier, nous laissant avec

Gd{

Bash + coreutils, 13 octets

ls -Sar|sed q

Explication:

ls -Sar|sed q
ls            # list files
   -S         # sorted, biggest first
     a        # show hidden files
      r       # reversed (smallest first)
       |sed q # q is quit at first line that matches given regex, 
              # given regex is empty so guaranteed match.         

Python 2 3, 94 76 74 54 octets

-18 octets grâce à @orlp
-2 octets grâce à @Jonathan Allan
-20 octets grâce à une modification des spécifications du défi

from os import*
print(min(listdir(),key=path.getsize))

PowerShell , 30 24 21 octets

(ls|sort le*)[0].Name

Essayez-le en ligne!

lsest un alias pour Get-ChildItem. C'est lié à sort-objectl' lengthattribut, donc les fichiers sont triés par taille. Nous indexons cela avec le (...)[0]pour obtenir le premier (c'est-à-dire le plus petit), puis prenons .Namecelui - ci. La sortie via implicite Write-Outputse produit à la fin du programme.

6 octets enregistrés car nous sommes garantis que seuls les fichiers existent dans le répertoire. Enregistré 3 supplémentaires grâce à ConnorLSW.

Rubis, 61 40 38 37 octets

Merci GB et Value Ink

p Dir[?*,".*"].min_by{|x|File.size x}

Mathematica, 35 octets

FileNames[]~MinimalBy~FileByteCount

FileNames[]produit une liste de noms de tous les fichiers (et répertoires) du répertoire courant; ~MinimalBy~FileByteCountsélectionne le nom du fichier dont le nombre d'octets est le plus petit. FileByteCountjette un tas d'erreurs lorsqu'il est appliqué aux répertoires, mais les erreurs ne font pas dérailler le programme.

Java 7, 149 142 octets

String f(){String n="";long s=-1>>>1,p;for(java.io.File f:new java.io.File(".").listFiles())if((p=f.length())<s){n=f.getName();s=p;}return n;}

Essayez-le en ligne!

-7 octets grâce à CAD97

SH (Linux / Unix) 15 14 13 14 octets

ls -aS|tail -1

-S trie par taille (décroissant),

-rinverse ettail -1 sort le dernier fichier de la liste.

@ Dennis Merci d'avoir économisé 1 octet @Dani_l Merci d'avoir enregistré 1 octet.

MATLAB / Octave, 52 48 octets

d=dir;[~,n]=min([d.bytes]./~[d.isdir]);d(n).name

Explication

Cela obtient une liste de répertoires de tous les fichiers et dossiers du répertoire en cours à l'aide de dir. La sortie de direst un structcontenant le nom du fichier, que ce soit un répertoire ou non, la taille (en octets), etc.

Nous pouvons ensuite prendre un tableau des tailles de chacun en octets [d.bytes]et effectuer une division élément par élément avec un booléen indiquant s'il s'agit d'un répertoire ou non ~[d.isdir]qui donneraInf où il est un répertoire (division par zéro) et la taille en octets sinon (division par 1).

Nous trouvons l'index du minimum de ce tableau en utilisant la deuxième sortie de minet l'utilisons pour indexer dans la structure initiale et afficher le nom avecd(n).name

Scala, 52 octets

Ancienne version, 79 octets

new java.io.File(".").listFiles.map(a=>a.getName->a.length)sortBy(_._2)apply(0)

Ajusté selon les conseils de jaxad0127. Il ne fait plus que 52 octets maintenant.

new java.io.File(".").listFiles.sortBy(_.length)head

Lot, 43 39 35 octets

@dir/b/os|(set/pf=&call echo %%f%%)

Output includes a leading space for some reason, but fortunately that's allowed. Edit: Now assuming there are no directories to save 4 bytes.

Perl 6 ,  33 32 31  16 octets

'.'.IO.dir.grep(*.f).min(*.s).put

Essayez-le

put '.'.IO.dir.min:{try .s//Inf}

Essayez-le

put $*CWD.dir.min:{try .s//Inf}

Essayez-le

put dir.min: *.s

Essayez-le

Étendu:

put        # print with trailing newline
dir        # the list of files in the current directory
.min:      # find the minimum by
  *.s      # calling the `s` method (size) in a Whatever lambda

J , 21 20 bytes

>{.,(/:2&{"1)1!:0'*'

Un octet enregistré grâce à @Conor.

Explication

>{.,(/:2&{"1)1!:0'*'
                 '*' Glob all files in current directory
             1!:0    Table of file metadata in that directory
       2&{"1         Get the file size of each
     /:              Sort the files by that
   ,                 Flatten
 {.                  Get the first value
>                    Unbox

BATCH File, 77 72 63 bytes

@FOR /F "tokens=*" %%G IN ('dir/o-s/b') DO @SET F=%%G
@ECHO %F%

There's no direct equivalent of head or tail in BATCH, at least to my knowledge, so here's a kludgy work-around. (with much assistance from @Neil - thanks!)

The dir command, with /o-s to sort in descending file size, and /b to output only the file names. We loop through those with FOR /F, setting the variable F to the file name each time. Finally, we output just the last one with ECHO %F%.

Saved 9 more bytes thanks to Neil and thanks to guarantees that no directories are present.

PHP, 84 62 bytes

$t=array_map(filesize,$g=glob('*'));asort($t);echo$g[key($t)];

Since the question was updated with the assumption that there will be no folders in the current directory, I was able to remove the file check stuff and golf this down.

Here is my old answer:

$t=array_map(filesize,$g=array_filter(glob('*'),is_file));asort($t);echo$g[key($t)];

This is the best I could do. Maybe there is a better way I'm missing.

$t=array_map(              # visit each array element and...
    filesize,              # map each filename to its filesize...
    $g=array_filter(       # using an array of...
        glob('*'),         # all files and directories...
        is_file            # filtered by files...
    )                      # 
);                         # 
asort($t);                 # sort the array of filesizes, then...
echo$g[key($t)];           # print element from the array of files using the first key of the sorted array as an index

Node.js (using walk), 114 bytes

Ignore newline:

require('walk').walk(__dirname).on('file',(r,s,n)=>
(m=s.size>m.size?m:s,n()),m=0).on('end',_=>console.log(m.name))

This invokes a walker that traverses through the current directory (__dirname) and for each file calls a function with its stat s and a function next n() that must be invoked to continue the traversal. Then at the end, it prints a filename with the minimum size in bytes found. s.size>m.size returns false when m.size is undefined, so after the first callback, m is equal to the first file found, and continues from there normally.

R, 36 bytes

x=file.info(y<-dir())$s;y[x==min(x)]

Explained

file.info() returns a data.frame of "file information" when given a character or character vector of file/folder names which when used on the list of files/folders in the current directory (dir()), looks something like:

                                                               size isdir mode               mtime               ctime               atime exe
Polyspace_Workspace                                               0  TRUE  777 2014-11-28 17:29:25 2014-11-28 17:29:25 2014-11-28 17:29:25  no
Python Scripts                                                    0  TRUE  777 2016-03-21 23:59:41 2016-03-21 23:59:41 2016-03-21 23:59:41  no
R                                                                 0  TRUE  777 2015-12-23 20:11:02 2015-12-23 20:11:02 2015-12-23 20:11:02  no
Rockstar Games                                                    0  TRUE  777 2015-04-14 12:23:05 2015-04-14 12:23:03 2015-04-14 12:23:05  no
TrackmaniaTurbo                                                   0  TRUE  777 2016-03-24 17:15:05 2016-03-24 13:13:48 2016-03-24 17:15:05  no
ts3_clientui-win64-1394624943-2014-06-11 03_18_47.004772.dmp 314197 FALSE  666 2014-06-11 02:18:47 2014-06-11 02:18:47 2014-06-11 02:18:47  no

Subsequently we just have the find the name of the file for which the size column (abbreviated using $s) is the smallest. Consequently, if there are more than one file with the smallest size, all will be returned.

Bonus: if we also wanted to disregard folders in the current directory we could simply search for size when isdir == FALSE: x=file.info(y<-dir());y[x$s==min(x$s[!x$i])] which turns out to be 44 bytes.

Tcl, 88 bytes

set s Inf
lmap f [glob -ty f *] {if [set m [file si $f]]<$s {set n $f
set s $m}}
puts $n

Try it online!

SmileBASIC, 110 bytes

DIM F$[0]FILES"TXT:",F$FOR I=0TO LEN(F$)-1F$[I][0]="TXT:
S=LEN(LOAD(F$[I],0))IF!Z||S<Z THEN Z=S:B=I
NEXT?F$[B]

Only looks at TXT: files, since DAT: files cannot be loaded unless you already know their size, making it impossible to load a random one.

Groovy, 49 bytes

m={f->f.listFiles().sort{it.length()}[0].getName()}

Try it online!

Closure, usage: m(new File("location"))

C#, 277 bytes

Not the shortest, but what would you expect from C#?

Golfed

using System.Linq;using static System.IO.Directory;class P{static void Main(){var x=GetFiles(GetCurrentDirectory());var d=new long[]{}.ToList();foreach(var s in x){var b=new System.IO.FileInfo(s).Length;if(!d.Contains(b))d.Add(b);}System.Console.Write(x[d.IndexOf(d.Min())]);}}

Ungolfed

//Linq using for List.Min()
using System.Linq;
//Static using to save bytes on GetCurrentDirectory() and GetFiles()
using static System.IO.Directory;

class P
{
    static void Main()
    {
        //String array containing file paths
        var x = GetFiles(GetCurrentDirectory());
        //Creating a Long array and converting it to a list, less bytes than "new System.Collections.Generic.List<long>()"
        var d = new long[] { }.ToList();
        foreach (var s in x) //Loop through all file paths
        {
            //Getting file size in bytes
            var b = new System.IO.FileInfo(s).Length;
            if (!d.Contains(b))
                //If there isn't already a file with this size in our List, add the file path to list
                d.Add(b);

        }
        //Get index of the smallest Long in our List, which is also the index of the file path to the smallest file, then write that path
        System.Console.Write(x[d.IndexOf(d.Min())]);
    }
}

Röda, 32 31 bytes

{ls""|sort key=fileLength|pull}

It's an anonymous function that sorts the files in the current directory by file length and selects then the first file with pull.

Use it like this: main{ {ls""|sort key=fileLength|pull} }

SmileBASIC 3, 105 bytes (competing?)

Beats 12Me21's answer but still suffers from inability to load DAT files (which feels very cruel to be disqualifying considering the circumstances.)

DIM F$[0],T[0]FILES"TXT:",F$FOR I=0TO LEN(F$)-1F$[I][0]="TXT:
PUSH T,LEN(LOAD(F$[I]))NEXT
SORT T,F$?F$[0]

The shorter version above is annoying and prompts you on every file to load, but it does work. For two bytes more you can suppress the prompt; change line 2 to this:

PUSH T,LEN(LOAD(F$[I],0))NEXT

Batch File, 33 bytes

Batch files are moderately competitive this time, oddly enough.

@dir/os/b>..\q&set/pa=<..\q&"%a%.

Output

Find a way to stop the creation of q prior to dir/os/b being run and you'll save a maximum of 6 bytes by not needing to put the output file in a separate directory.

@dir/os/b>q&set/pa=<q&"%a%

Will always output q as the smallest file (unless tied for another 0 byte file) as it is created as an empty file before dir/b/os gathers a list of files.

C++17 (gcc), 180 bytes

#include<filesystem>
using namespace std::filesystem;auto f(){std::error_code e;path r;size_t m=-1,s;for(auto&p:directory_iterator(".")){s=file_size(p,e);if(s<m)m=s,r=p;}return r;}

Try it online!

Requires a recent standard library that implements std::filesystem.

Zsh, 18 14 bytes

echo *(DoL[1])

Try it online! Try it online!

• (D) globs dotfiles
• (oL) sorts by size
• [1] selects the first match