सबसे छोटी फ़ाइल ढूँढें

19

लक्ष्य:

वर्तमान फ़ोल्डर में सबसे छोटी फ़ाइल खोजने के लिए एक प्रोग्राम बनाएं।

  • फ़ाइल का आकार बाइट्स या वर्णों में मापा जा सकता है।
  • यदि एकाधिक फ़ाइलों का आकार समान है, तो आप या तो उनमें से किसी एक को चुन सकते हैं या प्रदर्शित कर सकते हैं।
  • आप मान सकते हैं कि फ़ोल्डर में कम से कम एक फ़ाइल होगी, और किसी भी फ़ाइल का आकार 0 नहीं होगा।

  • मान लें कि फ़ोल्डर की सभी फाइलें आपके द्वारा उपयोग की जा रही भाषा द्वारा लोड की जा सकती हैं।

  • मान लें कि वर्तमान निर्देशिका में कोई फ़ोल्डर नहीं हैं।

इनपुट:

कार्यक्रम को उपयोगकर्ता से कोई इनपुट नहीं लेना चाहिए, जब तक कि:

  • यदि आपकी भाषा में "वर्तमान फ़ोल्डर" नहीं है, तो यह उपयोगकर्ता से एक फ़ोल्डर नाम / पथ पूछ सकता है।
  • यदि आपकी भाषा सीधे आपके कंप्यूटर पर फ़ाइलों तक नहीं पहुंच सकती है, तो यह उपयोगकर्ता को फाइलें अपलोड करने की अनुमति दे सकती है। (उदाहरण के लिए जावास्क्रिप्ट)

आउटपुट:

सबसे छोटी फ़ाइल का नाम प्रदर्शित किया जाना चाहिए।

  • प्रमुख / अनुगामी प्रतीकों को अनुमति दी जाती है, जब तक कि यह स्पष्ट नहीं हो जाता है कि किस फ़ाइल को चुना गया है।
  • (सभी फाइलों की सूची छापना नियमों के खिलाफ है)।

टिप्पणियाँ:

  • मानक Loopholes की अनुमति नहीं है।
  • आप परिणाम बदलने के लिए फ़ोल्डर में फ़ाइलों को संशोधित / बना / हटा नहीं सकते हैं।
  • यह कोड-गोल्फ है ; सबसे छोटा जवाब (बाइट्स में) जीतता है।
code-golf  file-system 
— 12Me21
स्रोत
1
हम फ़ाइलों मान सकते हैं कर सकते हैं 0 से आकार है?
— 21
इसके अलावा, "फ़ोल्डर में सभी फ़ाइलों तक पहुँचा जा सकता है" क्या मतलब है? इसका मतलब यह है कि छिपी हुई फ़ाइलों को दिखाने की आवश्यकता नहीं है?
— R
2
क्या मैं मान सकता हूं कि वर्तमान फ़ोल्डर में कोई फ़ोल्डर नहीं हैं? यदि आपके पास एक भाषा फ़ंक्शन है जो केवल फ़ाइलों के बजाय फ़ाइलों और फ़ोल्डरों दोनों को लौटाता है तो यह सभी अंतर बनाता है!
— सेरगिओल
1
जरुरी नहीं। आप मान सकते हैं कि वर्तमान निर्देशिका के अंदर कोई निर्देशिका नहीं है और यह अस्पष्ट है और किसी भी उत्तर को अमान्य नहीं करता है।
— डेनिस
1
(क्षमा करें, मैंने जल्द ही उत्तर नहीं दिया है, मेरा इंटरनेट कनेक्शन कुछ दिनों के लिए डाउन हो गया था) मुझे आपके द्वारा छिपी हुई फाइलों को छोड़ने की अनुमति देने में समस्या यह है कि यह बहुत अधिक खामियों को खोलती है। आपको उन फ़ाइलों को छोड़ देने की अनुमति है जो "एक्सेस करने के लिए थोड़ा कठिन हैं" का मतलब होगा कि लोग कुछ ऐसा कर सकते हैं जैसे कि पहले 9 फाइलों को चेक करना क्योंकि यह कुछ बाइट्स को बचाता है।
— 12Me21

जवाबों:

7

विम 12 बाइट्स

!!ls -Sa
Gd{

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

स्पष्टीकरण:

!!है फिल्टर आदेश। यह वर्तमान लाइन की सामग्री को एक मनमाना सिस्टम कमांड पर पाइप करता है, और आउटपुट को वापस बफर में भेजता है। यह उन चीजों के लिए बाहरी साधनों का उपयोग करने के लिए उपयोगी है जो बैश विम से बेहतर है, उदाहरण के !!revलिए वर्तमान लाइन को उल्टा करने के लिए , या !Gxxdबफर को हेक्सडंप करने के लिए। हमारे मामले में, बफर खाली है, इसलिए यह उसके बराबर है :r!ls, जो कि कमांड के आउटपुट को वर्तमान लाइन में फीड करता है।

अब कर्सर पंक्ति 1 पर है, और हम हर पंक्ति को हटाना चाहते हैं लेकिन अंतिम है। भोला दृष्टिकोण है

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

लेकिन हम बेहतर कर सकते हैं। जैसे कि मैंने में विस्तार से बताया इस टिप , {कर सकते हैं आमतौर पर (लेकिन हमेशा नहीं) के बराबर हो gg। यहाँ, यह और भी बेहतर है। क्योंकि गति है चरित्र आधारित , नहीं लाइन पर आधारित की तरह ggहै, हम, पहले एक लाइन तक जाने के लिए नहीं है हमारे साथ छोड़ने

Gd{
— DJMcMayhem
स्रोत
16

बैश + कोरुटिल्स, 13 बाइट्स

ls -Sar|sed q

स्पष्टीकरण:

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.
— Rɪᴋᴇʀ
स्रोत
इसे मेरे स्वयं के उत्तर के रूप में पोस्ट किया गया है, लेकिन मुझे लगता है कि यह आपके समान है। ls -1Sa|tail -13 बाइट्स छोटा होता है और इसमें क्लीनर आउटपुट होता है।
— orlp
@orlp धन्यवाद! ..
— Rɪᴋᴇʀ
1
मुझे नहीं लगता कि आपको '-1' की आवश्यकता है, पाइप स्वचालित रूप से प्रति पंक्ति एक फ़ाइल डालता है।
— जीबी
@EasterlyIrk मुझे लगता है कि GB सही है। यदि lsआउटपुट टर्मिनल का पता लगाता है तो यह आउटपुट को कई कॉलम में फॉर्मेट कर देगा। लेकिन अगर आउटपुट एक पाइप है तो यह सिर्फ 1 प्रति पंक्ति करेगा। तुलना lsबनामls|cat
— डिजिटल ट्रॉमा
दो बाइट्स छोटी:ls -Sar|sed q
— डिजिटल ट्रॉमा
8

पायथन 2 3, 94 76 74 54 बाइट्स

-18 बाइट्स धन्यवाद @orlp
-2 बाइट्स के लिए धन्यवाद @ जोनाथन एलन
-20 बाइट्स चुनौती में बदलाव के लिए धन्यवाद

from os import*
print(min(listdir(),key=path.getsize))
— OVS
स्रोत
print min(filter(path.isfile,listdir(".")),key=path.getsize)क्लीनर है और काफी छोटा है।
— orlp
"."डिफ़ॉल्ट के बाद से पायथन 3 पर जाने वाले दो बाइट्स सहेजें । print(min(filter(path.isfile,listdir()),key=path.getsize))
— जोनाथन एलन
इसके अलावा, मैं 76 नहीं 77 की गिनती करता हूं।
— जोनाथन एलन
@JonathanAllan मैंने बाइट काउंट की गणना की wcजिसके साथ मुझे 1 बाइट दिया गया
— ovs
विलुप्त बाइट एक अनुगामी न्यूलाइन के कारण होगा, जो कि पायथन के लिए आवश्यक नहीं है। इसके अतिरिक्त, चूंकि चुनौती को filterयह बताने के लिए अद्यतन किया गया था कि कोई उपनिर्देशिका मौजूद नहीं है, इसलिए पूरी बिट अनावश्यक है। यह भी पायथन 3 में काम नहीं करता है, क्योंकि printएक फ़ंक्शन है। निम्नलिखित काम करेगा, और काफी कम होगा:print(min(listdir(),key=path.getsize))
— मेगो
8

पॉवरशेल , 30 24 21 बाइट्स

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

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

lsके लिए एक उपनाम है Get-ChildItem। यह विशेषता के sort-objectसाथ पाइप किया गया lengthहै, इसलिए फ़ाइलें आकार द्वारा क्रमबद्ध हैं। हम (...)[0]पहले (यानी, सबसे छोटा) प्राप्त करने के लिए उस में अनुक्रमित करते हैं , और फिर उसके बाद लेते .Nameहैं। निहितार्थ के माध्यम से आउटपुट Write-Outputकार्यक्रम पूरा होने पर होता है।

6 बाइट्स सहेजे जाने के बाद से हम गारंटी देते हैं कि केवल फाइलें निर्देशिका में मौजूद हैं। ConorLSW के लिए एक अतिरिक्त 3 धन्यवाद बचाता है।

— AdmBorkBork
स्रोत
2
क्या आप से छुटकारा नहीं मिल सकता है -fileक्योंकि वर्तमान निर्देशिका में केवल फाइलें हैं?
— म्यूटेंटो
@Mutantoe हाँ - इस चुनौती को संपादित करने के बाद मुझे यह उत्तर दिया गया। धन्यवाद!
— AdmBorkBork
आप sort le*कुछ बाइट्स दाढ़ी बनाने के लिए उपयोग कर सकते हैं क्योंकि पावरशेल इसे स्वीकार करेंगे।
— कोल्स
@ConnorLSW हाँ, बिल्कुल। धन्यवाद!
— AdmBorkBork
7

रूबी, 61 40 38 37 बाइट्स

धन्यवाद GB और मूल्य स्याही

p Dir[?*,".*"].min_by{|x|File.size x}
— dkudriavtsev
स्रोत
आप उपयोग कर सकते हैं ?। इसके बजाय Dir.pwd, और min_by {} सबसे छोटी फ़ाइल प्राप्त करने के लिए। Dir.foreach(?.).min_by{|x|File.size x}38 बाइट्स में एक ही परिणाम मिलता है।
— GB
@GB धन्यवाद!
— dkudriavtsev
यह शर्म की बात है कि "सभी" फाइलें जिस भाषा तक पहुंच सकती हैं, उस पर गौर किया जाना चाहिए, क्योंकि Dir[?*]बहुत छोटी है लेकिन इसमें छिपी हुई यूनिक्स फाइलें शामिल नहीं हैं .bash_profile...
— मूल्य इंक
शायद डर [? *, "। *?"] काम कर सकता था। मैंने कोशिश नहीं की है। और यह छोटा है।
— जीबी
@GB यह वास्तव में होगा Dir[?*,".*"]। ग्लोब स्ट्रिंग मौजूद .?*होने पर फ़ाइल से मेल नहीं खाएगा .a।
— मूल्य इंक
6

मैथेमेटिका, 35 बाइट्स

FileNames[]~MinimalBy~FileByteCount

FileNames[]वर्तमान निर्देशिका में सभी फाइलों (और निर्देशिकाओं) के नामों की एक सूची तैयार करता है; ~MinimalBy~FileByteCountउस फ़ाइल का नाम चुनता है जिसकी बाइट गिनती सबसे छोटी है। FileByteCountजब यह निर्देशिकाओं पर लागू होता है, तो त्रुटियों का एक गुच्छा फेंकता है, लेकिन त्रुटियाँ कार्यक्रम को पटरी से नहीं उतारती हैं।

— ग्रेग मार्टिन
स्रोत
6

जावा 7, 149 142 बाइट्स

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

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

CAD97 के लिए -7 बाइट्स धन्यवाद

— प्रहार
स्रोत
मुझे लगता है कि आप फ़ाइल चाहते हैं: लंबाई नहीं फ़ाइल :: getTotalSpace
— CAD97
अछूता जावा 8: ()->java.utils.stream(new java.io.File(".").listFiles()).max((a,b)->a.length()-b.length).get().getName()104 बाइट्स के लिए
— कैड 97
@ CAD97 तुम सही हो! मैं क्या सोच रहा था ...
— प्रहार
6

एसएच (लिनक्स / यूनिक्स) 15 14 13 14 बाइट्स

ls -aS|tail -1

-S आकार के आधार पर (अवरोही),

-rtail -1सूची में अंतिम फ़ाइल को उलट और आउटपुट करता है।

@ डेनिस 1 बाइट बचाने के लिए धन्यवाद @ डानी_एल 1 बाइट बचाने के लिए धन्यवाद।

— हाबिल टॉम
स्रोत
यह सबसे बड़ी फ़ाइल पाता है , नहीं?
— डेनिस
कोई बात नहीं, मैं थक गया हूं। आप tailउलटने के बजाय उपयोग कर सकते हैं , और इसके -1लिए एक आशुलिपि है -n1।
— डेनिस
@ डेनिस अपडेट किया गया
— हाबिल टॉम
@ तेजी से अब यह चाहिए :)
— एबेल टॉम
@AbelTom कूल, फिक्सिंग के लिए धन्यवाद।
— Rɪᴋᴇʀ
4

MATLAB / ऑक्टेव, 52 48 बाइट्स

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

व्याख्या

इसका उपयोग करके वर्तमान निर्देशिका में सभी फ़ाइलों और फ़ोल्डरों की डायरेक्टरी लिस्टिंग मिलती है dir। आउटपुट dirएक structफ़ाइल नाम है, चाहे वह एक निर्देशिका हो या न हो, आकार (बाइट्स में), आदि।

हम तब बाइट्स में प्रत्येक के आकार का एक सरणी ले सकते हैं [d.bytes]और एक बूलियन के साथ तत्व-वार डिवीजन का प्रदर्शन कर सकते हैं, यह दर्शाता है कि यह एक निर्देशिका है या नहीं ~[d.isdir], Infजहां यह एक निर्देशिका (शून्य से विभाजन) और बाइट में आकार का उत्पादन करेगा अन्यथा 1)।

हम दूसरे आउटपुट के उपयोग से इस एरे के न्यूनतम के minइंडेक्स को खोजते हैं और इसका उपयोग प्रारंभिक संरचना में इंडेक्स करने और नाम को प्रदर्शित करने के लिए करते हैंd(n).name

— Suever
स्रोत
आपको disp(...)इसे ठीक से प्रिंट करने के लिए आउटपुट के चारों ओर जोड़ना चाहिए । अन्यथा अगर उदाहरण के लिए एक फाइल थी जिसे ansफोल्डर में सबसे छोटा नहीं है, तो आउटपुट स्पष्ट नहीं होगा कि कौन सी फाइल MATLAB से अपरिचित किसी के लिए सबसे छोटी है।
— टॉम कारपेंटर
@TomCarpenter हम्म ने व्याख्या की "लीडिंग / ट्रेलिंग प्रतीकों को अनुमति दी जाती है, जब तक यह स्पष्ट है कि कौन सी फाइल चुनी गई है" का अर्थ है कि ans = यह ठीक है
— स्वेवर
मुझे अभी पता चला है कि MATLAB अंतर्निहित .(वर्तमान फ़ोल्डर) और ..(ऊपर फ़ोल्डर) को जोड़ता है , इसलिए ऐसा लगता है कि निर्देशिका को हटा दें। उसके लिए माफ़ करना।
— टॉम कारपेंटर
4

स्काला, 52 बाइट्स

पुराना संस्करण, 79 बाइट्स

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

Jaxad0127 की सलाह के अनुसार समायोजित किया गया। यह अब केवल 52 बाइट्स है।

new java.io.File(".").listFiles.sortBy(_.length)head
— आरिया ऐक्स
स्रोत
लागू करने के बजाय सिर का उपयोग करना (0) छोटा है। इसके अलावा, फ़ाइल की स्ट्रीस्टिंग विधि ठीक है, नाम प्राप्त करने के लिए कॉल करने की आवश्यकता नहीं है।
— jaxad0127
4

बैच, 43 39 35 बाइट्स

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

आउटपुट में किसी कारण से एक अग्रणी स्थान शामिल है, लेकिन सौभाग्य से इसकी अनुमति है। संपादित करें: अब मान लें कि 4 बाइट्स को बचाने के लिए कोई निर्देशिका नहीं है।

— नील
स्रोत
ओह, का उपयोग / पी की तरह है कि, खतरे चतुर!
— AdmBorkBork
@AdmBorkBork आह, मैंने ध्यान नहीं दिया कि अनुमति थी, धन्यवाद!
— नील
आपको गारंटी है कि कोई उप-निर्देशिका मौजूद नहीं है (चुनौती अपडेट की गई थी) ताकि आप इसे समाप्त कर सकें /a-d।
— AdmBorkBork
4

पर्ल 6 ,  33 32 31  16 बाइट्स

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

कोशिश करो

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

कोशिश करो

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

कोशिश करो

put dir.min: *.s

कोशिश करो

विस्तारित:

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
— ब्रैड गिल्बर्ट b2gills
स्रोत
फ़ंक्शन का dirडिफ़ॉल्ट रूप $*CWD, और कार्य विवरण कहता है कि आप मान सकते हैं कि कोई फ़ोल्डर नहीं होगा, इसलिए मुझे लगता है कि आप इसे छोटा कर सकते हैं dir.min(*.s).put।
— SMLS
जब मैंने यह लिखा, तो उसने कहा कि प्रोग्राम को फ़ोल्डरों को नजरअंदाज करना चाहिए।
— ब्रैड गिल्बर्ट 21
4

जे , 21 20 बाइट्स

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

@ कॉनर को एक बाइट धन्यवाद दिया ।

व्याख्या

>{.,(/: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 धन्यवाद
— मील
3

बैच फ़ाइल, 77 72 63 बाइट्स

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

BATCH में headया tailमेरे ज्ञान के लिए कम से कम कोई प्रत्यक्ष समकक्ष नहीं है , इसलिए यहां एक काम-काज है। (@ निल से बहुत सहायता के साथ - धन्यवाद!)

dirआदेश, साथ /o-sउतरते फ़ाइल आकार में तरह है, और /bउत्पादन के लिए केवल फ़ाइल नाम। हम उन लोगों के माध्यम से लूप करते हैं FOR /F, जो Fहर बार चर को फ़ाइल नाम पर सेट करते हैं। अंत में, हम केवल पिछले एक के साथ आउटपुट करते हैं ECHO %F%।

नील को 9 और बाइट्स के लिए धन्यवाद दिया और गारंटी दी कि कोई निर्देशिका मौजूद नहीं है।

— AdmBorkBork
स्रोत
1
आपके FORचर को %स्क्रिप्ट में काम करने के लिए दो एस की आवश्यकता होती है । अन्यथा, कुछ गोल्फिंग ट्रिक्स: 1. @ECHO OFFछोटी स्क्रिप्ट पर उपयोग न करें , @प्रत्येक पंक्ति में और बाद में जोड़ें DO। 2. पहले अंतरिक्ष को हटा दें DO। 3. रिक्त स्थान और कमांड :में आवश्यक नहीं हैं dir।
— नील २
1
@ नील आकाश, धन्यवाद। क्षमा करें, जब से मैं PowerShell कर रहा हूँ, सुंदर जंग लगा ... धन्यवाद!
— AdmBorkBork
3

पीएचपी, 84 62 बाइट्स

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

चूंकि यह प्रश्न इस धारणा के साथ अपडेट किया गया था कि वर्तमान निर्देशिका में कोई फ़ोल्डर नहीं होगा, इसलिए मैं फ़ाइल चेक सामान और गोल्फ को नीचे हटाने में सक्षम था।

यहाँ मेरा पुराना जवाब है:

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

यह सबसे अच्छा मैं कर सकता था। शायद एक बेहतर तरीका है जो मुझे याद आ रहा है।

$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 (उपयोग करना walk), 114 बाइट्स

ध्यान न दें:

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

यह एक वॉकर को आमंत्रित करता है जो वर्तमान निर्देशिका ( __dirname) के माध्यम से ट्रैवर्स करता है और प्रत्येक फ़ाइल के लिए अपनी स्टेट के साथ एक फ़ंक्शन कहता है sऔर इसके बाद एक फ़ंक्शन होता है n()जिसे ट्रैवर्सल जारी रखने के लिए आमंत्रित किया जाना चाहिए। फिर end, यह कम से कम sizeपाया गया बाइट्स के साथ एक फ़ाइल नाम प्रिंट करता है। जब s.size>m.sizeरिटर्न falseहोता m.sizeहै undefined, तो पहली कॉलबैक के बाद, पहले mमिली फ़ाइल के बराबर होता है, और वहां से सामान्य रूप से जारी रहता है।

— पैट्रिक रॉबर्ट्स
स्रोत
2

आर, 36 बाइट्स

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

व्याख्या की

file.info()एक data.frameफ़ाइल या फ़ोल्डर नामों के एक चरित्र या चरित्र वेक्टर दिए जाने पर "फ़ाइल जानकारी" का रिटर्न देता है , जो वर्तमान निर्देशिका में फ़ाइलों / फ़ोल्डरों की सूची में उपयोग होने पर ( dir()), कुछ इस तरह दिखता है:

                                                               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

इसके बाद हमारे पास केवल उस फ़ाइल का नाम है जिसके लिए sizeकॉलम (संक्षिप्त रूप से उपयोग किया गया $s) सबसे छोटा है। नतीजतन, यदि सबसे छोटे आकार के साथ एक से अधिक फ़ाइल हैं, तो सभी को वापस कर दिया जाएगा।

बोनस: यदि हम वर्तमान निर्देशिका में फ़ोल्डरों की अवहेलना करना चाहते हैं, तो हम केवल आकार की खोज कर सकते हैं isdir == FALSE:x=file.info(y<-dir());y[x$s==min(x$s[!x$i])] जो 44 बाइट्स की हो।

— Billywob
स्रोत
थोड़ा देर से, लेकिन file.sizeकम है क्योंकि आपको $sबाद में करने की ज़रूरत नहीं है ।
— JAD
2

स्माइलबासिक, 110 बाइट्स

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]

केवल TXT:फ़ाइलों को देखता है , क्योंकि DAT:फ़ाइलों को तब तक लोड नहीं किया जा सकता है जब तक कि आप पहले से ही उनके आकार को नहीं जानते हैं, जिससे एक यादृच्छिक लोड करना असंभव है।

— 12Me21
स्रोत
आप किसी DAT: फ़ाइल को कैसे लोड करते हैं ? क्या आप फ़ोल्डर में प्रत्येक नाम / फ़ाइल का आकार पा सकते हैं?
— पावेल
3-आयामी DAT:फ़ाइल को 2-आयामी सरणी (उदाहरण के लिए) में लोड करने का प्रयास करने से त्रुटि होगी, इसलिए आप इसे बाध्य नहीं कर सकते। आपको बस पहले से कई आयामों को जानना होगा, जो आप सामान्य रूप से करेंगे।
— 12M2121
क्या आप 2-डी DAT: फ़ाइल को 3-डी सरणी में लोड कर सकते हैं ? तब आप एक अधिकतम आकार सरणी बना सकते हैं। और आप किसी भी तरह से त्रुटियों को पकड़ नहीं सकते हैं?
— पावेल
नहीं, यह एक प्रकार की बेमेल त्रुटि का कारण होगा। और त्रुटियों को पकड़ने का कोई तरीका नहीं है।
— 12M2121
1

सी #, 277 बाइट्स

सबसे छोटा नहीं है, लेकिन आप 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())]);
    }
}
— Metoniem
स्रोत
1

रोड़ा , 32 31 बाइट्स

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

यह एक अनाम फ़ंक्शन है जो फ़ाइल की लंबाई से वर्तमान निर्देशिका में फ़ाइलों को क्रमबद्ध करता है और फिर पहली फ़ाइल के साथ चयन करता है pull ।

इसे इस तरह उपयोग करें: main{ {ls""|sort key=fileLength|pull} }

— fergusq
स्रोत
जाहिरा तौर पर भी ls""काम करता है ls"."। मुझे लगता है कि आप उस से एक बाइट बचा सकते हैं
— क्रिति लिथोस
@KritiiLithos ऐसा लगता है। धन्यवाद!
— fergusq
0

SmileBASIC 3, 105 बाइट्स (प्रतिस्पर्धा?)

12Me21 के उत्तर को धड़कता है लेकिन अभी भी DAT फ़ाइलों को लोड करने में असमर्थता से ग्रस्त है (जो परिस्थितियों को देखते हुए अयोग्य होना बहुत क्रूर लगता है।)

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]

ऊपर का छोटा संस्करण कष्टप्रद है और आपको लोड करने के लिए हर फ़ाइल पर संकेत देता है, लेकिन यह काम नहीं करता है। दो बाइट्स के लिए आप शीघ्र दबा सकते हैं; लाइन 2 को इसमें बदलें:

PUSH T,LEN(LOAD(F$[I],0))NEXT
— snail_
स्रोत
0

बैच फ़ाइल, 33 बाइट्स

इस बार बैच फ़ाइलें मामूली रूप से प्रतिस्पर्धी हैं, अजीब तरह से पर्याप्त हैं।

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

उत्पादन

यहाँ छवि विवरण दर्ज करें

चलाने से qपहले निर्माण को रोकने का तरीका खोजें dir/os/bऔर आउटपुट फ़ाइल को एक अलग निर्देशिका में रखने की आवश्यकता नहीं होने से आप अधिकतम 6 बाइट बचाएंगे।

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

हमेशा qछोटी फ़ाइल के रूप में आउटपुट करेगा (जब तक कि किसी अन्य 0 बाइट फ़ाइल के लिए बंधा हुआ न हो) क्योंकि यह dir/b/osफ़ाइलों की सूची को इकट्ठा करने से पहले एक खाली फ़ाइल के रूप में बनाई जाती है ।

— BDM
स्रोत
0

सी ++ 17 (जीसीसी) , 180 बाइट्स

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

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

एक हालिया मानक पुस्तकालय की आवश्यकता है जो लागू करता है std::filesystem।

— जी। स्लीपेन
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.