Trova il file più piccolo


19

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 è ; la risposta più breve (in byte) vince.

1
Possiamo supporre che i file possano avere una dimensione di 0?
Rɪᴋᴇʀ

Inoltre, cosa significa "presumere che sia possibile accedere a tutti i file nella cartella"? significa che non è necessario mostrare i file nascosti?
Rɪᴋᴇʀ

2
Posso presumere che non ci siano cartelle nella cartella corrente? Fa la differenza se hai una funzione di lingua che restituisce sia file che cartelle anziché solo file!
sergiol

1
Non necessariamente. Si può presumere che non ci siano directory all'interno della directory corrente che non siano ambigue e che non invalidi alcuna risposta.
Dennis,

1
(scusate se non ho risposto prima, la mia connessione a Internet è stata interrotta per alcuni giorni) Il problema che ho nel consentire di saltare i file nascosti è che sembra aprire molte lacune. Consentire di saltare i file "leggermente più difficili da accedere" significherebbe che le persone potrebbero fare qualcosa come controllare solo i primi 9 file perché consente di risparmiare pochi byte.
Me21

Risposte:


7

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{

16

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.         

Inserito questo come mia risposta, ma penso che sia troppo simile al tuo. ls -1Sa|tail -1è più corto di 3 byte e ha un output più pulito.
orlp,

@orlp grazie! ..
Rɪᴋᴇʀ

1
Non credo che sia necessario "-1", pipe inserisce automaticamente un file per riga.
GB

@EasterlyIrk Penso che GB abbia ragione. se lsrileva l'output sul terminale, formatterà l'output in più colonne. Ma se l'output è una pipe, farà solo 1 per riga. Confronta lsvsls|cat
Digital Trauma

Due byte più brevi:ls -Sar|sed q
Trauma digitale il

8

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

print min(filter(path.isfile,listdir(".")),key=path.getsize)è più pulito e sostanzialmente più corto.
orlp,

Salva due byte passando a Python 3 poiché "."è l'impostazione predefinita. print(min(filter(path.isfile,listdir()),key=path.getsize))
Jonathan Allan,

Anche io conto 76 non 77.
Jonathan Allan il

@JonathanAllan Ho misurato il conteggio dei byte con wccui mi ha dato 1 byte in più
ovs

Il byte estraneo sarebbe dovuto a una nuova riga finale, che non è richiesta per Python. Inoltre, poiché la sfida è stata aggiornata per affermare che non sono presenti sottodirectory, l'intera parte non filterè necessaria. Anche questo non funziona in Python 3, poiché printè una funzione. Quanto segue funzionerebbe e sarebbe sostanzialmente più breve:print(min(listdir(),key=path.getsize))
Mego

8

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.


2
Non riesci a sbarazzartene dal -filemomento che solo i file si trovano nella directory corrente?
Mutantoe,

@Mutantoe Sì: è stato modificato nella sfida dopo aver pubblicato questa risposta. Grazie!
AdmBorkBork,

puoi usare sort le*per radere alcuni byte poiché PowerShell lo accetterà.
domenica

@ConnorLSW Sì, certo. Grazie!
AdmBorkBork

7

Rubino, 61 40 38 37 byte

Grazie GB e Value Ink

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

Puoi usare ?. anziché Dir.pwd e min_by {} per ottenere il file più piccolo. Dir.foreach(?.).min_by{|x|File.size x}ottiene lo stesso risultato in 38 byte.
GB

@GB Grazie!
dkudriavtsev

È un peccato che debbano essere esaminati "tutti" i file a cui la lingua può accedere, perché Dir[?*]è molto più breve ma non include i file Unix nascosti come .bash_profile...
Value Ink

Forse Dir [? *, ".? *"] Potrebbe funzionare. Non ci ho provato Ed è più corto.
GB,

@GB In realtà sarebbe Dir[?*,".*"]. La stringa globale .?*non corrisponde al file .ase esiste.
Value Ink

6

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.


6

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


Penso che si desidera File :: lunghezza non sul file :: getTotalSpace
CAD97

Java 8 non testato: ()->java.utils.stream(new java.io.File(".").listFiles()).max((a,b)->a.length()-b.length).get().getName()per 104 byte
CAD97

@ CAD97 Hai ragione! Cosa stavo pensando ...
Colpisci il

6

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.


Che trova il file più grande , no?
Dennis,

Non importa, sono stanco. È possibile utilizzare tailinvece di invertire, ed -1è una scorciatoia per -n1.
Dennis,

@Dennis Aggiornato
Abel Tom il

@EasterlyIrk Ora dovrebbe :)
Abel Tom,

@AbelTom cool, grazie per il fissaggio.
Rɪᴋᴇʀ

4

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


Dovresti aggiungere disp(...)l'output per stamparlo correttamente. Altrimenti, se per esempio ci fosse un file chiamato ansche non è il più piccolo nella cartella, l'output non sarebbe chiaro su quale file sia il più piccolo per chiunque non abbia familiarità con MATLAB.
Tom Carpenter,

@TomCarpenter Hmmm Ho interpretato "Sono consentiti simboli iniziali / finali, purché sia ​​chiaro quale file è stato scelto" per indicare che ans = è ok
Suever,

Ho appena realizzato che MATLAB aggiunge l'implicito .(cartella corrente) e ..(cartella sopra), quindi non riesco a rimuovere il controllo della directory che sembra. Mi dispiace per quello.
Tom Carpenter,

4

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

L'uso di head invece di apply (0) è più breve. Inoltre, il metodo toString di File va bene, non è necessario chiamare get name.
jaxad0127,

4

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.


Oh, usando / p in quel modo, dang clever!
AdmBorkBork,

@AdmBorkBork Ah, non avevo notato che era permesso, grazie!
Neil,

Hai la garanzia che non esistono sottodirectory (la sfida è stata aggiornata) in modo da poter eliminare /a-d.
AdmBorkBork,

4

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

La forma della funzione di dirdefault è $*CWD, e la descrizione dell'attività dice che puoi presumere che non ci saranno cartelle, quindi penso che puoi accorciarlo dir.min(*.s).put.
smls

Quando ho scritto questo, ha detto che il programma deve ignorare le cartelle.
Brad Gilbert b2gills

4

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

@ConorO'Brien Grazie
miglia

3

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.


1
La tua FORvariabile ha bisogno di due %secondi per funzionare in uno script. Altrimenti, alcuni trucchi per giocare a golf: 1. Non usare @ECHO OFFsu script brevi, aggiungi a @a ciascuna riga e dopo DO. 2. Elimina lo spazio prima DO. 3. Gli spazi e gli :s non sono necessari nel dircomando.
Neil,

1
@Neil Ack, grazie. Scusa, abbastanza arrugginito da quando ho fatto PowerShell ... Grazie!
AdmBorkBork,

3

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

2

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.


2

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.


Un po 'in ritardo, ma file.sizeè più corto perché non devi fare $sdopo.
JAD,


2

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.


Come si carica un DAT: file? Potresti forzare brutalmente ogni nome / dimensione del file nella cartella?
Pavel,

Cercare di caricare un DAT:file tridimensionale in un array bidimensionale (ad esempio) provocherà un errore, quindi non è possibile forzarlo. Devi solo sapere in anticipo il numero di dimensioni, che normalmente faresti.
Me21,

Potresti caricare un DAT: file 2-d in un array 3-d? Quindi è possibile creare un array di dimensioni massime. E non riesci a rilevare gli errori in alcun modo?
Pavel,

No, ciò causerà un errore di mancata corrispondenza del tipo. E non c'è nemmeno modo di rilevare errori.
Me21,


1

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

1

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


Apparentemente ls""funziona altrettanto bene ls".". Penso che puoi salvare un byte da quello
Kritixi Lithos

@KritixiLithos Sembra. Grazie!
Fergusq

0

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

0

File batch, 33 byte

Questa volta i file batch sono moderatamente competitivi, stranamente.

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

Produzione

inserisci qui la descrizione dell'immagine


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.


0

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.


Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.