Obbiettivo:

Crea un programma per trovare il file più piccolo nella cartella corrente.

• La dimensione del file può essere misurata in byte o caratteri.
• Se più file hanno le stesse dimensioni, puoi sceglierne uno o visualizzarli tutti.
• Puoi presumere che ci sarà almeno un file nella cartella e nessun file avrà una dimensione di 0.

• Supponiamo che tutti i file nella cartella possano essere caricati nella lingua che stai usando.

• Supponiamo che non ci siano cartelle nella directory corrente.

Ingresso:

Il programma non dovrebbe ricevere alcun input dall'utente, a meno che:

• Se la tua lingua non ha una "cartella corrente", potrebbe chiedere all'utente un nome / percorso della cartella.
• Se la tua lingua non può accedere direttamente ai file sul tuo computer, potrebbe consentire all'utente di caricare file. (JavaScript, ad esempio)

Produzione:

Dovrebbe essere visualizzato il nome del file più piccolo.

• Sono consentiti simboli iniziali / finali, purché sia ​​chiaro quale file è stato scelto.
• (La stampa di un elenco di tutti i file è contraria alle regole).

Appunti:

• Non sono ammesse scappatoie standard .
• Non è possibile modificare / creare / eliminare i file nella cartella per cambiare il risultato.
• Questo è code-golf ; la risposta più breve (in byte) vince.

Vim 12 byte

!!ls -Sa
Gd{

Provalo online!

Spiegazione:

!!è il comando filtro . Inoltra il contenuto della riga corrente a un comando di sistema arbitrario e restituisce l'output nel buffer. È utile per usare strumenti esterni per cose che bash è meglio di vim, ad esempio !!revper invertire la linea corrente o !Gxxdper eseguire il dump del buffer. Nel nostro caso, il buffer è vuoto, quindi è equivalente a :r!ls, che alimenta semplicemente l'output del comando nella riga corrente.

Ora il cursore si trova sulla riga 1 e vogliamo eliminare ogni riga tranne l'ultima. L'approccio ingenuo è

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

Ma possiamo fare di meglio. Come ho spiegato in questo suggerimento , il {grado di solito (ma non sempre) essere equivalente a gg. Qui è ancora meglio. Poiché il movimento è basato sul personaggio , non su una linea come ggè, non dobbiamo prima andare su una linea, lasciandoci con

Gd{

Bash + coreutils, 13 byte

ls -Sar|sed q

Spiegazione:

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 byte

-18 byte grazie a @orlp
-2 byte grazie a @Jonathan Allan
-20 byte grazie a un cambiamento nelle specifiche della sfida

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

PowerShell , 30 24 21 byte

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

Provalo online!

lsè un alias per Get-ChildItem. Viene convogliato sort-objectcon l' lengthattributo, quindi i file sono ordinati per dimensione. Ci indicizziamo con quello (...)[0]per ottenere il primo (cioè il più piccolo), e quindi prendere il .Namesuo. L'output tramite implicito Write-Outputavviene al completamento del programma.

6 byte salvati poiché garantiamo che nella directory esistono solo file. Ne ho salvati altri 3 grazie a ConnorLSW.

Rubino, 61 40 38 37 byte

Grazie GB e Value Ink

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

Mathematica, 35 byte

FileNames[]~MinimalBy~FileByteCount

FileNames[]produce un elenco di nomi di tutti i file (e directory) nella directory corrente; ~MinimalBy~FileByteCountseleziona il nome del file il cui conteggio dei byte è il più piccolo. FileByteCountgenera un sacco di errori quando viene applicato alle directory, ma gli errori non fanno deragliare il programma.

Java 7, 149 142 byte

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

Provalo online!

-7 byte grazie a CAD97

SH (Linux / Unix) 15 14 13 14 byte

ls -aS|tail -1

-S ordina per dimensione (decrescente),

-rinverte e tail -1restituisce l'ultimo file nell'elenco.

@ Dennis Grazie per aver salvato 1 byte @Dani_l Grazie per aver salvato 1 byte.

MATLAB / Octave, 52 48 byte

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

Spiegazione

Questo ottiene un elenco di directory di tutti i file e le cartelle nella directory corrente utilizzando dir. L'output di dirè un structcontenente il nome del file, che sia una directory o meno, la dimensione (in byte), ecc.

Possiamo quindi prendere una matrice delle dimensioni di ciascuno in byte [d.bytes]ed eseguire una divisione in termini di elementi con un valore booleano che indica se si tratta di una directory o meno ~[d.isdir]che produrrà Infdove è una directory (divisione per zero) e la dimensione in byte altrimenti (divisione per 1).

Troviamo l'indice del minimo di questo array usando il secondo output di mine usiamo quello per indicizzare nella struttura iniziale e visualizzare il nome cond(n).name

Scala, 52 byte

Vecchia versione, 79 byte

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

Modificato secondo il consiglio di jaxad0127. Adesso sono solo 52 byte.

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

Lotto, 43 39 35 byte

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

L'output include uno spazio iniziale per qualche motivo, ma per fortuna è permesso. Modifica: ora supponiamo che non ci siano directory per salvare 4 byte.

Perl 6 ,  33 32 31  16 byte

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

Provalo

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

Provalo

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

Provalo

put dir.min: *.s

Provalo

Allargato:

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 byte

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

Salvataggio di un byte grazie a @ Conor .

Spiegazione

>{.,(/: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

File BATCH, 77 72 63 byte

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

Non esiste un equivalente diretto di heado tailin LOTTO, almeno per quanto ne so, quindi ecco un agghiacciante soluzione. (con molta assistenza da @Neil - grazie!)

Il dircomando, con /o-sl'ordinamento in ordine decrescente, e /bl'output dei soli nomi di file. Esaminiamo quelli con FOR /F, impostando Fogni volta la variabile sul nome del file. Infine, abbiamo prodotto solo l'ultimo con ECHO %F%.

Risparmio di 9 byte in più grazie a Neil e grazie alle garanzie che non sono presenti directory.

PHP, 84 62 byte

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

Dato che la domanda è stata aggiornata partendo dal presupposto che non ci saranno cartelle nella directory corrente, sono stato in grado di rimuovere le cose di controllo dei file e di golf giù.

Ecco la mia vecchia risposta:

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

Questo è il massimo che potrei fare. Forse c'è un modo migliore che mi manca.

$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 (usando walk), 114 byte

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

Questo invoca un walker che attraversa la directory corrente ( __dirname) e per ogni file chiama una funzione con la sua stat se una funzione successiva n()che deve essere invocata per continuare l'attraversamento. Quindi a end, stampa un nome file con il minimo sizein byte trovato. s.size>m.sizeritorna falsequando m.sizeè undefined, quindi dopo il primo callback, mè uguale al primo file trovato e continua da lì normalmente.

R, 36 byte

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

spiegato

file.info()restituisce una data.frame"informazione sul file" quando viene assegnato un carattere o un vettore di caratteri di nomi di file / cartelle che, se utilizzati nell'elenco di file / cartelle nella directory corrente ( dir()), assomigliano a:

                                                               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

Successivamente abbiamo solo trovato il nome del file per il quale la sizecolonna (abbreviata usando $s) è la più piccola. Di conseguenza, se sono presenti più file con dimensioni minime, verrà restituito tutto.

Bonus: se volessimo anche ignorare le cartelle nella directory corrente potremmo semplicemente cercare la dimensione quando isdir == FALSE: x=file.info(y<-dir());y[x$s==min(x$s[!x$i])]che risulta essere di 44 byte.

Tcl , 88 byte

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

Provalo online!

SmileBASIC, 110 byte

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]

Guarda solo i TXT:file, poiché i DAT:file non possono essere caricati se non si conosce già la loro dimensione, rendendo impossibile caricarne uno casuale.

Groovy , 49 byte

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

Provalo online!

Chiusura, utilizzo: m(new File("location"))

C #, 277 byte

Non il più breve, ma cosa ti aspetteresti da 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 byte

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

È una funzione anonima che ordina i file nella directory corrente in base alla lunghezza del file e seleziona quindi il primo file con pull.

Usalo in questo modo: main{ {ls""|sort key=fileLength|pull} }

SmileBASIC 3, 105 byte (in competizione?)

Batte la risposta di 12Me21 ma soffre ancora dell'incapacità di caricare i file DAT (che sembra molto crudele essere squalificante considerando le circostanze).

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]

La versione più breve sopra è fastidiosa e richiede di caricare tutti i file, ma funziona. Per altri due byte è possibile sopprimere il prompt; cambia la riga 2 in questo:

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

File batch, 33 byte

Questa volta i file batch sono moderatamente competitivi, stranamente.

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

Produzione

Trova un modo per interrompere la creazione di qprima di dir/os/bessere eseguito e risparmierai un massimo di 6 byte non avendo bisogno di mettere il file di output in una directory separata.

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

Verrà sempre visualizzato qcome il file più piccolo (a meno che non sia associato per un altro file da 0 byte) in quanto viene creato come file vuoto prima di dir/b/osraccogliere un elenco di file.

C ++ 17 (gcc) , 180 byte

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

Provalo online!

Richiede una libreria standard recente che implementa std::filesystem.

Zsh , 18 14 byte

echo *(DoL[1])

Provalo online! Provalo online!

• (D) Globs dotfiles
• (oL) ordina per dimensione
• [1] seleziona la prima partita