माइक्रोसेकंड को घंटे: मिनट: सेकंड, आदि के रूप में प्रारूपित करें

28

निम्नलिखित एक प्रश्न से प्रेरित है जो आज स्टैक ओवरफ्लो पर आया था ।

कई microseconds, 0 <= n <= 86400000000(जैसे 12345678900) को देखते हुए , एक स्वरूपित स्ट्रिंग hh:mm:ss:000:000, उदा 03:25:45:678:900।

          0 -> '00:00:00:000:000'
12345678900 -> '03:25:45:678:900'
86400000000 -> '24:00:00:000:000'

मेरे पास 209 बाइट्स में पायथन में एक समाधान है, लेकिन क्या यह कम हो सकता है?

code-golf  date 
— सैम
स्रोत
1
मुझे अब एहसास हुआ कि यह वास्तव में लिखने के समय के लिए एक मानक प्रारूप नहीं है, और hh:mm:ss.000000शायद बेहतर (और आसान) होगा। फिर भी, अब इसे बदलने नहीं जा सकता।
— सैम
1
जिज्ञासा से बाहर, एसओ पद क्या था?
— डिजिटल ट्रॉमा
अपेक्षाकृत नए उपयोगकर्ता द्वारा @DigitalTrauma stackoverflow.com/questions/31251377 । एक सही उत्तर पहले ही चुना जा चुका था, मैं सिर्फ IDLE में इधर-उधर खेल रहा था और एक अचंभे-से-दिखने वाले शब्दकोश की समझ के साथ आया, जो इस प्रश्न का विशेष रूप से अच्छा उत्तर नहीं था। किसी ने इसे देखा और एक टिप्पणी में इस साइट को इंगित किया। मैं यहां आया था, एक प्रश्न (एसओ पद से थोड़ा अलग) लिखा था, और मेरे उत्तर का एक बेहतर संस्करण भी लिखा था (जो मैंने पोस्ट नहीं किया है, और जो अब नीचे सभी बहुत अधिक कॉम्पैक्ट और कल्पनाशील उत्तर के लिए बेमानी है) ।
— सैम
क्या इनपुट में घंटे की संख्या पर कोई सीमा है?
— फ़ूजएक्सएक्सएल
हां, मनमाने ढंग से मैंने इसे <= 86400000000 माइक्रोसेक बना दिया, इसलिए <= 24 घंटे।
— सैम

जवाबों:

15

पायथन 2, 82 79 बाइट्स

n=input()
o=""
for k in[1000]*2+[60]*3:o=":%0*d"%(k%7/2,n%k)+o;n/=k
print o[1:]

Divmods की एक श्रृंखला के माध्यम से पुनरावृत्ति करते हुए, स्ट्रिंग बनाता है। केवल फैंसी बिट है %7/2, जो नक्शे 1000 -> 3और 60 -> 2।

— Sp3000
स्रोत
6

पायथ, 31 बाइट्स

j\:_m>l`td+"00"%~/QddCM"ϨϨ<<<

इसे ऑनलाइन आज़माएँ: प्रदर्शन

स्पष्टीकरण:

                                 implicit: Q = input number
                       "ϨϨ<<<   string "ϨϨ<<<" (5 chars but 7 bytes)
                     CM          convert each to number => [1000, 1000, 60, 60, 60]
    m                            map each number d to:
                 /Qd                divide Q by d
                ~                   and update Q with the new value
               %~ Q d               but use the old value to calculate Q mod d
          +"00"                     add the result to the string "00"
     >                              but only take the last 
      l`td                          len(str(d-1)) chars
   _                             revert order
j\:                              join the strings with ":"s
— Jakube
स्रोत
5

बैश + कोरुटिल्स, 61

अब तक की सबसे छोटी "मुख्यधारा" भाषा ...

a=%02d:
printf $a$a$a%03d:%03d `dc -e$1\ A00~rA00~r60~r60~rf`

परीक्षण उत्पादन:

$ for t in 0 12345678900 86400000000; do ./usec.sh $t; echo; done
00:00:00:000:000
03:25:45:678:900
24:00:00:000:000
$
— डिजिटल आघात
स्रोत
4

सी, 97 बाइट्स

q=1000,s=60;
#define f(n)printf("%02d:%02d:%02d:%03d:%03d",n/s/s/q/q,n/s/q/q%s,n/q/q%s,n/q%q,n%q)

टेस्ट कोड:

int main(int intc, char **argv)
{
    long long n = atoll(argv[1]);
    f(n);
}
— कुछ उपयोगकर्ता
स्रोत
1
सी में उत्तर एक पूर्ण, कार्यक्रम माना जाता है; स्निपेट नहीं।
— नोनाडा - मोनिका जूल
प्रश्न में इसका उल्लेख नहीं है। क्या वैश्विक आवश्यकताओं का कुछ प्रकार है?
— कुछ उपयोगकर्ता
— NobodyNada - को पुनः स्थापित मोनिका
यदि आप उत्तर पढ़ते हैं, तो यह केवल उदाहरण के रूप में C का उपयोग कर रहा है। नियम हर भाषा पर लागू होता। इसके अलावा, उत्तर गर्म विवादित है - उच्चतम रेटेड टिप्पणी देखें। लब्बोलुआब यह है कि प्रश्न को स्पष्ट रूप से बताने की आवश्यकता है यदि एक पूर्ण कार्यक्रम की आवश्यकता है।
— कुछ उपयोगकर्ता
3
इस साइट पर बहुत सारे उत्तर पूर्ण कार्यक्रमों के बजाय फ़ंक्शंस का उपयोग करते हैं - उदाहरण के लिए, मुझे नहीं लगता कि मैंने कभी एक जावा उत्तर देखा है जो एक संपूर्ण कार्यक्रम था ...
— जेरी जेरेमिया
4

क्यू (34)

मुझे यकीन है कि यह छोटा हो सकता है

":"sv 0 8 11__[;8]15$2_($)16h$1e3*

जैसे

q)f:":"sv 0 8 11__[;8]15$2_($)16h$1e3*
q)f 12345678900
"03:25:45:678:900"
— skeevey
स्रोत
4
किसी भी ऑनलाइन संकलक? दूसरे शब्दों में - मैं इसे एक आलसी व्यक्ति के रूप में कैसे चलाऊं?
— ऑप्टिमाइज़र
32 बिट संस्करण kx.com
— skeevey
अच्छी जगह। दुर्भाग्य से फिक्स कुछ पात्रों को जोड़ता है
— कंकाल
1
आप यहां अधिक बाइट्स काट सकते हैं":"sv 0 8 11__[;8]15$2_($)"n"$1e3*
— वूइकेंट ली जूल
3

जूलिया, 110 96 95 बाइट्स

t->(o="";for i=int([36e8,6e7,1e6,1e3,1]) x,t=t÷i,t%i;o*=lpad(x,i>1e3?2:3,0)*":"end;o[1:end-1])

यह एक अनाम फ़ंक्शन बनाता है जो एक पूर्णांक को इनपुट के रूप में स्वीकार करता है और एक स्ट्रिंग लौटाता है। इसे कॉल करने के लिए, इसे एक नाम दें, उदा f=t->...।

असंगठित + स्पष्टीकरण:

function f(t)
    # Initialize an output string
    o = ""

    # Loop over an array consisting of the number of microseconds in
    # an hour, minute, second, millisecond, and microsecond
    for i = int([36e8, 6e7, 1e6, 1e3, 1])

        # Get the quotient and remainder for microseconds into t,
        # setting t to be the remainder
        x, t = t ÷ i, t % i

        # Left-pad x with zeroes and append it to the output
        o *= lpad(x, i > 1e3 ? 2 : 3, 0) * ":"
    end

    # o has a trailing :, so return everything but the last character
    o[1:end-1]
end

उदाहरण:

julia> f(12345678900)
"03:25:45:678:900"

julia> f(0)
"00:00:00:000:000"

julia> f(86400000000)
"24:00:00:000:000"
— एलेक्स ए।
स्रोत
अच्छा है। आप मेरा वोट प्राप्त करें क्योंकि आपने मेरे मतलबी उत्तर को प्रेरित किया :-)
— होकी
3

सी #, 179 175 बाइट्स

जब आपके पास अपने निपटान में भवन हैं, तो उन्हें क्यों नहीं उपयोग करें?

static void Main(string[]a){var t=TimeSpan.FromTicks(long.Parse(Console.ReadLine())*10);Console.Write(t.ToString((t.Days<1?"hh":@"\2\4")+@"\:mm\:ss\:ffffff").Insert(12,":"));}

बेहतर स्वरूपण के साथ:

static void Main(string[]a){
    var t = TimeSpan.FromTicks(long.Parse(Console.ReadLine())*10);
    Console.Write(t.ToString((t.Days<1?"hh":@"\2\4")+@"\:mm\:ss\:ffffff").Insert(12,":"));
    Console.Read();
}
— Kade
स्रोत
3

एक्सेल, 65 63 अक्षर

मान लें कि आपका माइक्रोसेकंड A1 में है :

=TEXT(A1/50/1200^3,"[HH]:mm:ss:")&RIGHT(TEXT(A1,"000\:000"),7)

आउटपुट:

        A              B
1            0  00:00:00:000:000
2  12345678900  03:25:46:678:900
3  86400000000  24:00:00:000:000
— हाथ-ए-खाना
स्रोत
2

पर्ल, 141 78 बाइट्स

printf"%02d"x3.%03d:%03d",$_/36e8,$_/6e7%60,$_/1e6%60,$_/1e3%1e3,$_‌​%1e3

-nध्वज के लिए कोड के 77 बाइट्स, +1 । साथ दौड़ो:

echo 12345678900 | perl -ne'printf"%02d"x3.%03d:%03d",$_/36e8,$_/6e7%60,$_/1e6%60,$_/1e3%1e3,$_‌​%1e3'

लगभग आधे में मेरे कोड के आकार को काटने के लिए थॉमस क्वा और चिलामेजिक का धन्यवाद।

— ASCIIThenANSI
स्रोत
मुझे लगता है कि 3600000000हो सकता है 36e8।
— lirtosiast
इसके बजाय chomp($n=<STDIN>);आप इसे -nध्वज के साथ वन-लाइनर के रूप में चला सकते हैं (जो 1 वर्ण के रूप में गिना जाता है)। आप भी int(..)प्रत्येक के आसपास की जरूरत नहीं है $_। थॉमस की टिप को लागू करने से हम इसे नीचे ला सकते हैं echo 12345678900 | perl -ne'printf"%02d:%02d:%02d:%03d:%03d\n",$_/36e8,$_/6e7%60,$_/1e6%60,$_/1e3%1e3,$_%1e3'और यहां तक ​​कि एक छोटा रास्ता भी हो सकता है!
— hmatt1
आपको \nआउटपुट स्ट्रिंग में भी आवश्यकता नहीं है । आप स्ट्रिंग को प्रतिस्थापित भी कर सकते हैं"%02d:"x3 ."%03d:%03d"
— hmatt1
@chilemagic बाइट्स में वृद्धि के रूप में "इको" गणना का उपयोग करता है?
— ASCIIThenANSI
@ASCIIThenANSI ऐसा नहीं करता क्योंकि यह आपके कार्यक्रम का हिस्सा नहीं है। आपके द्वारा गिने जाने वाले वर्ण एकल उद्धरणों के बीच वाले होते हैं, printf"%02d:%02d:%02d:%03d:%03d\n",$_/36e8,$_/6e7%60,$_/1e6%60,$_/1e3%1e3,$_‌​%1e3और फिर आप -nध्वज के लिए एक अतिरिक्त बाइट जोड़ते हैं । यदि आप -nleउदाहरण के लिए उपयोग करते हैं, तो वह अतिरिक्त 2 ( nऔर l) के लिए गिना जाएगा । आपको मुफ्त -में e(और Eयदि आपको उपयोग करने की आवश्यकता है say)।
— hmatt1
1

मतलाब - 88 89 बाइट्स

निर्मित फ़ंक्शन का उपयोग किए बिना एक बाइट के साथ एक बाइट दिया:

n=[36e8,6e7,1e6,1e3];f=@(t)sprintf('%02d:%02d:%02d:%03d:%03d',fix([t mod(t,n)]./[n 1]))

एक इनलाइन फ़ंक्शन बनाएं जो एक संख्यात्मक इनपुट तर्क लेता है tऔर एक स्ट्रिंग लौटाता है।

यह समय तत्वों को अलग करने fixऔर modफिर प्रदर्शित करने के लिए एक वेक्टरकृत संयोजन का उपयोग करता है ।

यह थोड़ा निराशा की बात है कि आउटपुट स्ट्रिंग का प्रारूपण इतना अधिक हो जाता है, स्वयं गणना से अधिक ...

परीक्षा:

for t=[0 12345678900 86400000000]
    f(t)
end

ans =
00:00:00:000:000
ans =
03:25:45:678:900
ans =
24:00:00:000:000

89 बाइट्स संस्करण:

f=@(t)sprintf('%s:%03d:%03d',datestr(fix(t/1e6)/86400,13),fix(mod(t,1e6)/1e3),mod(t,1e3))

यह संख्या को विभाजित करता है, एचएच के लिए एक अंतर्निहित फ़ंक्शन का उपयोग करता है: मिमी: एसएस हिस्सा, जो माइक्रोसेकंड से निपट नहीं सकता है, इसलिए स्ट्रिंग को fixऔर modसंचालन के संयोजन के साथ पूरा किया गया है

— Hoki
स्रोत
1

जावास्क्रिप्ट (ईएस 6), 128 118 116 111 बाइट्स

इसमें शायद कुछ गोल्फ की क्षमता है।

f=t=>(t<864e8?new Date(t/1e3).toJSON().slice(11,-1):`24:00:00:000`).replace(`.`,`:`)+':'+('00'+t%1e3).slice(-3)

डेमो

यह ES6 है, इसलिए केवल फ़ायरफ़ॉक्स, अब के लिए वैसे भी:

f=t=>(t<864e8?new Date(t/1e3).toJSON().slice(11,-1):`24:00:00:000`).replace(`.`,`:`)+':'+('00'+t%1e3).slice(-3)

// DEMO
document.body.innerHTML += '<br>' + f(0);
document.body.innerHTML += '<br>' + f(12345678020);
document.body.innerHTML += '<br>' + f(86400000000);
स्निपेट का विस्तार करें

— rink.attendant.6
स्रोत
पहली जाँच की आवश्यकता नहीं है, क्योंकि यह प्रश्न स्पष्ट है: 0 <= n <= 86400000000
— edc65
@ edc65 पहली जांच के बिना मैं केवल 0 8 n <86400000000 की सीमा प्राप्त कर सकता हूं, क्योंकि अगले दिन 8.64e10 रोल करेगा।
— रिंक.टेंटेंड ।6
ओह ठीक है, मैं चूक गया। toJSON () के बजाय toISOString ()?
— edc65
1

सी, 113 103 105 बाइट्स

संपादित करें: बंद कुछ और बाइट्स

FIX: लंबे प्रकार को हटा दिया, कुछ उपयोगकर्ता के लिए धन्यवाद

कम से कम सी जवाब नहीं है, लेकिन मुझे गाड़ी के रिटर्न के साथ कुछ मज़ा आया तो मुझे लगा कि किसी को यह पसंद आ सकता है।

i,k,p=16;
#define f(n)for(;i<5;p-=i++<2?4:3)k=i<2?1000:60,printf("%0*d%c\r",p,n%k,i?58:13),n/=k;puts("");

इसे कॉल करें जैसे:

int main() {
    long long n = 12345678900;
    f(n);

    return 0;
}
— एंड्रिया बियोन्डो
स्रोत
प्लेटफ़ॉर्म पर निर्भर करता है, "लंबा" सिर्फ 32-बिट हो सकता है। (देखें en.wikipedia.org/wiki/64-bit_computing#64-bit_data_models )। मैंने फ़ंक्शन के बजाय "f" को मैक्रो घोषित करके समस्या को टाल दिया।
— कुछ उपयोगकर्ता
मैंने गौर किया। मैंने x64 पर GCC ग्रहण किया, कल इसे ठीक कर रहा हूं।
— एंड्रिया बियोनडो
0

कॉफ़ीस्क्रिप्ट, 127 बाइट्स

ASCIIThenANSI के उत्तर में दृष्टिकोण लिया । यह बहुत बुरा है कि जावास्क्रिप्ट कंसोल एपीआई में पैडिंग नंबर के लिए प्रारूप प्लेसहोल्डर नहीं है।

p=(a,b)->('00'+~~a).slice -b||-2
f=(t)->console.log '%s:%s:%s:%s:%s',p(t/36e8),p(t/6e7%60),p(t/1e6%60),p(t/1e3%1e3,3),p t%1e3,3
— rink.attendant.6
स्रोत
0

Powershell, 153

$t=[timespan]::FromTicks(($a=$args[0]));"{0:D2}:{1:D2}:{2:D2}:{3:D3}:{4:000}"-f
[int]($t.TotalHours),$t.Minutes,$t.Seconds,$t.Milliseconds,(($a%1e4)/10)

प्रयोग

powershell -nologo .\modprintsec.ps1 123456789000    
03:25:45:678:900   
powershell -nologo .\modprintsec.ps1 864000000000   
24:00:00:000:000   
powershell -nologo .\modprintsec.ps1 0   
00:00:00:000:000
— blabb
स्रोत
0

एफ #, 111 92 102 बाइट्स

पहला पुनरावृत्ति: आधार विचार।

दूसरा पुनरावृत्ति: छोटे स्थिरांक

तीसरा पुनरावृत्ति: एकल अंक भागों के लिए सही स्वरूपण।

ध्यान दें कि इस फ़ंक्शन को काम करने के लिए एक int64 दिया जाना चाहिए।

let s,t=60L,1000L
let f n=sprintf"%02d:%02d:%02d:%03d:%03d"(n/s/s/t/t)(n/s/t/t%s)(n/t/t%s)(n/t%t)(n%t)

उदाहरण आउटपुट:

f 0L           -> "00:00:00:000:000"
f 12345678900L -> "03:25:45:678:900"
f 86400000000L -> "24:00:00:000:000"
— हाथ-ए-खाना
स्रोत
0

PHP - 115 102 बाइट्स

155 बाइट्स में एक समाधान (पठनीयता के लिए 3 लाइनों पर लिपटा हुआ):

$a=$argv[1];
$h=($a-($m=($a=($a-($s=($a=($a-($t=($a=($a-($u=$a%1000))/1000)%1000))/1000)%60))/60)%60))/60;
printf("%02d:%02d:%02d:%03d:%03d",$h,$m,$s,$t,$u);

दूसरी पंक्ति कंप्यूटर्स के साथ शुरू होने वाले घटकों के सटीक मानों की गणना (अंदर से बाहर तक) करती है।

छोटे संस्करण (115 बाइट्स, पठनीयता के लिए दो लाइनों पर लिपटे हुए):

$u=$argv[1];$h=($m=($s=($t=$u/1000)/1000)/60)/60;
printf("%02d:%02d:%02d:%03d:%03d",$h,$m%60,$s%60,$t%1000,$u%1000);

यह फ्लोटिंग पॉइंट नंबरों का उपयोग करके मिलीसेकंड, सेकंड, मिनट और घंटों में माइक्रोसेकंड की इनपुट संख्या को बदलने के लिए एम्बेडेड असाइनमेंट का उपयोग करता है। मापांक ऑपरेटर ( %) और दशमलव संख्या प्रारूप ( %d) का printf()उपयोग तब उन्हें पूर्णांक संख्याओं के लिए मजबूर करने के लिए किया जाता है (भिन्नात्मक भाग अनदेखा किया जाता है)।

एक अन्य समाधान जो दिनांक कार्यों (102 बाइट्स) का उपयोग करता है

$u=$argv[1];
echo gmdate("H:i:s",strtotime("@".substr($u,0,-6))),":",substr($u,-6,3),":",substr($u,-3);

घंटे: मिनट: सेकंड का हिस्सा PHP तारीख के कार्यों द्वारा नियंत्रित किया जाता है gmdate()और strtotime(), इनपुट मूल्य से मिलों और माइक्रो-सेकंड को तार के रूप में निकाला जाता है।

उपयोग:

$ php -r '$u=$argv[1];echo gmdate("H:i:s",strtotime("@".substr($u,0,-6))),":",substr($u,-6,3),":",substr($u,-3);' 7198898787; echo
01:59:58:898:787
— axiac
स्रोत
0

जावा, 215 बाइट्स

String f(long n){return p(n/3600000000l,2)+":"+p(n/60000000%60,2)+":"+p(n/1000000%60,2)+":"+p(n/1000%1000,3)+":"+p(n%1000,3);}String p(long n,int i){String s=String.valueOf(n);while(s.length()<i){s="0"+s;}return s;}

विधि fकुछ गणनाओं को nघंटों, मिनटों आदि के आधार पर करने के लिए करती है और pप्रत्येक मूल्य को सही ढंग से प्रारूपित करने के लिए विधि को सौंपती है।

प्रारूपित:

String f(long n) {
    return p(n / 3600000000l, 2) + ":" + p(n / 60000000 % 60, 2) + ":" 
            + p(n / 1000000 % 60, 2) + ":" + p(n / 1000 % 1000, 3) + ":" + p(n % 1000, 3);
}

String p(long n, int i) {
    String s = String.valueOf(n);
    while (s.length() < i) {
        s = "0" + s;
    }
    return s;
}

उपयोग:

public void demo() {
    long n = 12345678900l;
    System.out.println(f(n));
}
— आरसीबी
स्रोत
-1

रूबी - 82 बाइट्स

puts (t=Time.at(0,gets.to_i)).strftime("%2H:%2M:%2S:%3L:#{(t.usec%1000).to_s.rjust(3,?0)}")
— Xenotoad
स्रोत
2
लेकिन मैंने 91 बाइट्स गिना। यह केवल यूटीसी टाइमज़ोन में भी काम करता है।
— jimmy23013
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.