परिचय

कल्पना कीजिए कि वर्णों की रेखा वास्तव में दो पंक्तियाँ हैं। ऊपरी पंक्ति - बिंदु - घंटे (24 घंटे प्रणाली) का प्रतिनिधित्व करती है , जबकि निचला - अल्पविराम - मिनट का प्रतिनिधित्व करता है । एक चरित्र घंटे, मिनट या दोनों का प्रतिनिधित्व कर सकता है - जब भी संभव हो।

पहले शायद आपको आधी रात से लेकर घंटों और मिनटों में मिनटों को बदलना होगा ।

परिणाम "डॉट प्रारूप" में वर्तमान समय दिखा रहा स्ट्रिंग है। डॉट काउंट ( एपोस्ट्रोपे यहां एक डॉट के रूप में गिना जाता है और इसे बुलाया जाएगा! ) आधी रात के बाद से घंटे की गिनती है और कॉमा गिनती मिनट की गिनती है। मैं इसे स्पष्ट करने के लिए कुछ उदाहरण दिखाता हूँ।

(टिप्पणी) hh: मिमी - result
(केवल घंटे) 05:00 - '''''
(केवल मिनट) 00:08 - ,,,,,,,,
(घंटे <मिनट) 03:07 - ;;;,,,,
(घंटे> मिनट) 08:02 - ;;''''''
(घंटे = मिनट) 07:07 - ;;;;;;;
(दिन की शुरुआत) 00:00 - ( खाली परिणाम )

ध्यान दें कि "दोनों" वर्ण का उपयोग अधिकतम 23 बार किया जा सकता है - 23 के लिए: xx, जहां xx 23 या अधिक है।

प्रतीक

यदि चरित्र को (नियम 5 देखें) अपनी भाषा में बच जाना है, तो आप इसे किसी एक विकल्प में बदल सकते हैं। यदि कहा गया कि विकल्प पर्याप्त नहीं हैं, तो आप अन्य प्रतीकों का उपयोग कर सकते हैं - लेकिन इसे उचित रखें। मैं सिर्फ एक बाधा बनने से बचना नहीं चाहता।

;(अर्धविराम) - मार्कर दोनों घंटे और मिनट के लिए (आल्ट: :)
'(अपॉस्ट्रफ़ी) - मार्कर घंटे के लिए (आल्ट: '``°)
,(अल्पविराम) - मार्कर मिनट के लिए (आल्ट: .)

अतिरिक्त नियम

कम से कम बाइट्स जीत के साथ कोड!
जब भी संभव हो आपको दोनों प्रतीक का उपयोग करना होगा। 02:04 के लिए, परिणाम नहीं हो सकता है '',,,,, न ही ;',,,। यह होना ही है;;,,
इनपुट - कोड
3.1 के अंदर स्क्रिप्ट / ऐप पैरामीटर, उपयोगकर्ता इनपुट (रीडलाइन की तरह) या चर हो सकता है । यदि कोड के अंदर चर का उपयोग किया जाता है, तो इसका लंबन सबसे लंबे समय तक संभव है। यह 1439(23:59) है, इसलिए ऐसा लगेगाt=1439
सामान्य भाग जो "दोनों" वर्ण का प्रतीक है (12 में 12:05, 03:10 में 3) स्ट्रिंग की शुरुआत में रखा जाना चाहिए
प्रतीकों को विकल्पों में तब ही बदला जा सकता है, जब उन्हें आपके कोड में बचना होगा।
00:00 के बाद मिनटों में इनपुट दिया जाता है । आप मान सकते हैं कि यह एक गैर-नकारात्मक पूर्णांक है।

परीक्षण के मामलों

Input: 300
Output: '''''

Input: 8
Output: ,,,,,,,,

Input: 187
Output: ;;;,,,,

Input: 482
Output: ;;''''''

Input: 427
Output: ;;;;;;;

Input: 0
Output:  (empty)

— Krzysiu
स्रोत

धन्यवाद, मेरी पोस्ट को संपादित करने के लिए अदनान! इस तरह मैं अपनी तुलना, नौसिखिया गोल्फ से आपकी तुलना करूँगा :)

— क्रिज़िउ

3

कोई बात नहीं! यह एक बहुत अच्छी पहली पोस्ट है और एक अच्छी चुनौती है :)

— अदनान

1

यह सिर्फ अर्धविराम और अल्पविराम के साथ बहुत अच्छा लगता है, लेकिन

— प्रेरितों ने

वास्तव में 1439है 23:59और नहीं 1339। (२३ x ६० + ५ ९)।

— इन्सर्टसर्नमीयर

अच्छे शब्दों के लिए आप सभी का धन्यवाद! :) @ शेअर, हाँ, यह बुरी बात है :( क्या आपको पता है कि इसे कैसे बदला जा सकता है? सम्मिलित रूप से, निश्चित रूप से यह सही है! फिक्स्ड :)

— Krzysiu

10

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

:.iF*V.DQ60J"',"J\;

परीक्षण सूट

:.iF*V.DQ60J"',"J\;
      .DQ60            Divmod the input by 60, giving [hours, minutes].
           J"',"       Set J equal to the string "',".
    *V                 Perform vectorized multiplication, giving H "'" and M ','.
 .iF                   Interleave the two lists into a single string.
:               J\;    Perform a substitution, replacing J with ';'.

— isaacg
स्रोत

8

CJam, 22 20 19 बाइट्स

STDIN से इनपुट लेता है:

ri60md]',`.*:.{;K+}

इसका परीक्षण यहां करें।

व्याख्या

ri     e# Read input and convert to integer.
60md   e# Divmod 60, pushes hours H and minutes M on the stack.
]      e# Wrap in an array.
',`    e# Push the string representation of the comma character which is "',".
.*     e# Repeat apostrophe H times and comma M times.
:.{    e# Apply this block between every pair of characters. This will only applied to
       e# first N characters where N = min(hours,minutes). The others will remain
       e# untouched. So we want the block to turn that pair into a semicolon...
  ;    e#   Discard the comma.
  K+   e#   Add 20 to the apostrophe to turn it into a semicolon.
}

यह वास्तव में भाग्यशाली था कि चीजों ने यहां कितनी अच्छी तरह से एक साथ काम किया, विशेष रूप से घंटों से लेकर 'मिनटों तक का काम ,ऐसा है कि स्टैक पर घंटों और मिनटों का क्रम चरित्र के स्ट्रिंग प्रतिनिधित्व के साथ मेल खाता है।

यह केवल 3-बाइट ब्लॉक है जो मैंने अब तक पाया है। हालांकि 4-वर्ण समाधान के टन थे:

{;;';}
{';\?}
{^'0+}
{^'F-}
{-'@+}
{-'6-}
...

— मार्टिन एंडर
स्रोत

6

जीएनयू सैड, 37

स्कोर में -Esed के विकल्प के लिए +1 शामिल है ।

मैं अपने बैश जवाब की गंभीरता से प्रभावित नहीं था , इसलिए मैंने सोचा कि मैं मज़े के लिए सेड के साथ कोशिश करूँगा।

इस मेटा-उत्तर के अनुसार इनपुट अनियंत्रित है ।

y/1/,/          # Convert unary 1's to commas (minutes)
s/,{60}/'/g     # divmod by 60.  "'" are hours
:               # unnamed label
s/(.*)',/;\1/   # replace an apostrophe and comma with a semicolon
t               # jump back to unnamed label until no more replacements

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

— डिजिटल आघात
स्रोत

अनाम लेबल ??

— mikeserv

@mikeserv, देख डिजिटल ट्रामा के संबंधित टिप में sed में गोल्फ के लिए सुझाव ।

— मैनटवर्क

@manatwork - मुझे लगता है कि यह एक GNU बग होना चाहिए।

— 15

@ mikeserv - लेकिन बग का उपयोग करना ठीक है, ठीक है? मैं आपसे मज़ाक करने के लिए नहीं कह रहा हूँ, मुझे अभी पता नहीं है :)

— Krzysiu

@Kzysiu - ठीक है? हम्म। पर इस साइट मुझे लगता है कि यह उत्कृष्टता का एक निशान होगा। अन्यथा, लगभग निश्चित रूप से नहीं। जब प्रोग्रामर एपीआई से भटक जाते हैं और कार्यान्वयन विवरण का उपयोग करते हैं, तो प्रोग्राम संस्करण / कार्यान्वयन पर निर्भर हो जाते हैं - जो एक बुरी बात है।

— 15

6

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

def g(t):d=t%60-t/60;print(t/60*";")[:t%60]+","*d+"'"*-d

एक फ़ंक्शन जो प्रिंट करता है (एक चार से छोटा t=input();)।

विधि Loovjo के समान है । ,0. की अनुमानित न्यूनतम के साथ मिनटों और घंटों के बीच की संख्या अलग-अलग है ', यह निषेध है। के रूप में ;, के minरूप में कई ;घंटे लेने के द्वारा अनुमानित गणना करता है , तो मिनट की संख्या के लिए truncating।

यह बचाने के लिए वर्णों को सहेजता है d, लेकिन यहां घंटों और मिनटों की संख्या नहीं। लैम्ब्डा के साथ एनालॉग दो वर्ण लंबा (58) था, इसलिए चर असाइनमेंट इसके लायक हैं।

lambda t:(t%60*";")[:t/60]+","*(t%60-t/60)+"'"*(t/60-t%60)

इनपुट को सीधे संसाधित करना या तो चार्ट को नहीं बचाता है (58):

h,m=divmod(input(),60);d=m-h;print(";"*m)[:h]+","*d+"'"*-d

स्लाइसिंग के साथ एक और रणनीति, बहुत लंबा (64):

def g(t):m=t%60;h=t/60;return(";"*m)[:h]+(","*m)[h:]+("'"*h)[m:]

— XNOR
स्रोत

3

रेटिना , २४

मेरे sed जवाब का तुच्छ बंदरगाह ।

इस मेटा-उत्तर के अनुसार इनपुट अनियंत्रित है ।

1
,
,{60}
'
+`(.*)',
;$1

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

— डिजिटल आघात
स्रोत

3

शुद्ध बैश (कोई बाहरी उपयोगिताओं), 103

p()(printf -vt %$2s;printf "${t// /$1}")
p \; $[h=$1/60,m=$1%60,m>h?c=m-h,h:m]
p , $c
p \' $[m<h?h-m:0]

2 बाइट बचाने के लिए @ F.Hauri को धन्यवाद।

— डिजिटल आघात
स्रोत

अच्छा! लेकिन आप को स्वैप करके 2 वर्ण को बचा सकता है $1और $2में p()और लिखने p , $cलाइन 3. पर

— एफ HAURI

हां, लेकिन जैसा कि यह केवल एक में उपयोग किया जाता है printf "%s", cखाली होने से ठीक काम होगा (पुन: उपयोग नहीं किया गया)

— F. Hauri

@ F.Hauri अब मैं इसे प्राप्त करता हूं - धन्यवाद!

— डिजिटल ट्रामा

3

सी, 119 बाइट्स

#define p(a,b) while(a--)putchar(b);
main(h,m,n){scanf("%d",&m);h=m/60;m%=60;n=h<m?h:m;h-=n;m-=n;p(n,59)p(h,39)p(m,44)}

विस्तृत

// macro: print b, a times
#define p(a,b) while(a--)putchar(b)

int main(void)
{
    int h,m,n;
    scanf("%d",&m);  // read input

    h=m/60;m%=60;    // get hours:minutes
    n=h<m?h:m;       // get common count
    h-=n;m-=n;       // get remaining hours:minutes

    p(n,59);        // print common
    p(h,39);        // print remaining hours
    p(m,44);        // print remaining minutes

    return 0;
}

— Khaled.K
स्रोत

1

putcharवर्णों के रूप में पूर्णांक शाब्दिक का उपयोग करना , एक बाइट को बचाता है, मैक्रो के अंदर अर्धविराम को खींचता है दो और बचाता है :)

— क्वेंटिन

@ क्वेंटिन नोट लिया, 5 बाइट्स बचाए गए

— खालिद.के

आप whileअपने #define मैक्रो में अपने से पहले स्थान खो सकते हैं । -1 बाइट

— अल्बर्ट रेनशॉ

1

आप केवल मैक्रो के बजाय p (a, b) फ़ंक्शन करके कुछ और बाइट्स बचा सकते हैं। (और अपने मुख्य कार्य के लिए कुछ और अर्द्ध कोलन छिड़काव)

— अल्बर्ट रेंशाव

3

हास्केल, 68 66 बाइट्स

g(h,m)=id=<<zipWith replicate[min h m,h-m,m-h]";',"
g.(`divMod`60)

उपयोग उदाहरण:

(g.(`divMod`60)) 482

यहां चतुर बिट यह है कि replicateखाली स्ट्रिंग वापस आ जाएगी यदि दी गई लंबाई नकारात्मक या शून्य है तो मैं इसे दोनों अंतरों पर लागू कर सकता हूं और केवल सकारात्मक दिखाई देगा। पहला भाग आसान है, क्योंकि अर्धविरामों की संख्या दो में से न्यूनतम है। फिर zipWithफ़ंक्शन को संबंधित आइटम पर लागू करता है।

संपादित करें: एहसास हुआ कि मैं मिनटों के लिए गलत चार का उपयोग कर रहा था

संपादित 2: @ लिकोनी के लिए धन्यवाद 2 बाइट्स सहेजे गए

— user1472751
स्रोत

आप की जगह दो बाइट्स बचा सकता है concat$के साथ id=<<।

— लैकोनी

2

जावास्क्रिप्ट (ईएस 6) 69

m=>";".repeat((h=m/60|0)>(m%=60)?m:h)+",'"[h>m|0].repeat(h>m?h-m:m-h)

— edc65
स्रोत

2

पॉवरशेल, 99 85 बाइट्स

param($n)";"*(($m=$n%60),($h=$n/60))[($b=$m-gt$h)]+"'"*(($h-$m)*!$b)+","*(($m-$h)*$b)

Loovjo की विधि का उपयोग करना , यह मेरा शक्तियां कार्यान्वयन है।

ungolfed

param($n) 
# set the number of minutes and hours, and a boolean which one is bigger
# and also output the correct number of ;s
";"*(($m=$n%60),($h=$n/60))[($b=$m-gt$h)]+ 
# add the difference between h and m as 's but only if h > m
"'"*(($h-$m)*!$b)+
# add the difference between m and h as ,s but only if m > h
","*(($m-$h)*$b)

AdmBorkBork के लिए धन्यवाद 14 बाइट्स सहेजे गए

— ब्योर्न मोलेनमेकर
स्रोत

आप पहले एक के लिए छद्म-त्रिशूल का उपयोग करके, उसमें $mऔर $hघोषणाओं को स्थानांतरित करके और फिर बूलियन गुणा का उपयोग करके बचा सकते हैं । जैसे -param($n)';'*(($m=$n%60),($h=$n/60))[($b=$m-gt$h)]+'°'*(($h-$m)*!$b)+','*(($m-$h)*$b)

— AdmBorkBork

1

पायथन 3, 98 बाइट्स

d=int(input());m=d%60;h=int((d-m)/60)
if m>=h:print(";"*h+","*(m-h))
else:print(";"*(m)+"'"*(h-m))

शायद सबसे अच्छा जवाब नहीं है, लेकिन यह बहुत मजेदार था!

— अदनान
स्रोत

1

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

t=input();m,h=t%60,t/60
print";"*min(h,m)+","*(m-h)+"'"*(h-m)

explaination:

t=input();              # Read input
          m,  t%60,     # Do a divmod, h = div, m = mod
            h=     t/60

print";"*min(h,m)+                    # Print the minimum of the h and m, but in ";"s
                  ","*(m-h)+          # Print (m-h) ","s (if m-h is negative, print nothing)
                            "'"*(h-m) # Print (h-m) "'"s (if h-m is negative, print nothing)

— Loovjo
स्रोत

1

PHP, 81 बाइट्स

मैं चर इनपुट के लिए गया क्योंकि यह STDINकमांड लाइन के तर्कों को पढ़ने या लेने से कम है ।

for($_=1439;$i<max($h=0|$_/60,$m=$_%60);++$i)echo$i<$h?$i<min($h,$m)?';':"'":",";

— insertusernamehere
स्रोत

मैंने सोचा था कि मैं PHP को अच्छी तरह से जानता हूं, लेकिन मैं देखता हूं | पहली बार। मुझे लगता है कि मैं इसे थोड़ा व्यायाम करने के लिए उपयोग करूँगा - मैं इसका विश्लेषण करूँगा :)

— क्रिज़िसी

के लिए विफल रहता है 240। प्रयास करें $i>=min($h,$m)?$h<$m?",":"'":";"(+1 बाइट)। या उपयोग for($_=1439;$i<max($h=0|$_/60,$m=$_%60);)echo"',;"[$i++<min($h,$m)?2:$h<$m];(76 बाइट्स)। Btw: एकल उद्धरण -rअसंभव प्रदान करता है ; तो अगर आप एक तार या °स्वसंपूर्ण में घंटों के लिए बैकटिक का उपयोग करना चाहिए (कोई उद्धरण की जरूरत है -> -1 बाइट)।

— टाइटस

1

जावास्क्रिप्ट (ईएस 6), 77 71 बाइट्स

x=>';'[r='repeat'](y=Math.min(h=x/60|0,m=x%60))+"'"[r](h-y)+','[r](m-y)

— Mwr247
स्रोत

विशेषता पहुंच / फ़ंक्शन तर्कों में असाइनमेंट का महान उपयोग। +1

— साइओस

1

पर्ल 6, 103 101 98 97 69 बाइट्स

$_=get;say ";"x min($!=($_-$_%60)/60,$_=$_%60)~"'"x $!-$_~","x $_-$!;

~~कई सरणियों का उत्पादन करता है, लेकिन इसे बकवास करें,~~ आनंद लें। हमेशा की तरह, किसी भी गोल्फिंग oppertunities पर जोर दिया जाता है।

संपादित करें: -2 बाइट्स: बहादुर मिले और कुछ जातियों को हटाया।

एडिट 2: -3 बाइट्स को हटाकर।

Edit3: -1 बाइट को सही फॉर्मेट में प्रिंट करने के लिए, "लैम्ब्डा" का उपयोग करके और परांठे को हटाकर।

Edit4: (क्षमा करें दोस्तों) उस घंटे का दुरुपयोग करते हुए - मिनट 0 और विपरीत लौटना चाहिए। अगर बयान दिए तो हटा दिए। फिर कोष्ठक को हटाते हुए, फिर मुझे पता चला कि लैम्ब्डा की आवश्यकता नहीं है। -28 बाइट्स :)

इस पर वाह बेहतर हो रही है।

— हेवार्ड न्यागार्ड
स्रोत

0

सी, 141 बाइट्स

main(h,m){scanf("%d",&m);h=(m/60)%24;m%=60;while(h||m){if(h&&m){printf(";");h--;m--;}else if(h&&!m){printf("'");h--;}else{printf(",");m--;}}}

— user2064000
स्रोत

मुझे लगता है कि आप उपयोग करके कुछ बाइट्स बचा सकते हैं h>0||m>0। तब आपको h--;m--;प्रत्येक पुनरावृत्ति में केवल एक बार की आवश्यकता होती है और इसके {}लिए if/elseअप्रचलित होना चाहिए।

— इन्सर्टसर्नमीयर

तुम भी अपने दूसरे सशर्त पर कुछ बाइट्स बचा सकते हैं: else if(h&&!m)आप के बजाय बस हो सकता हैelse if(h)

— नर्क में

और अंत में टर्नरी ऑपरेटर का उपयोग करने का प्रयास करें, यह आपको "लंबे" शब्दों जैसे ifऔर का उपयोग करने से बचाएगा else।

— insertusernamehere

एक फ़ंक्शन के रूप में रीफैक्टरिंग पर विचार करें जो इनपुट को एक अंतर पैरामीटर के रूप में लेता है - जो आपको कम से कम बचाने चाहिए scanf()।

— डिजिटल ट्रॉमा

मुझे नहीं लगता कि %24यह आवश्यक है - अधिकतम इनपुट 23:59 है।

— डिजिटल ट्रामा

0

गीमा, 119 वर्ण

<D>=@set{h;@div{$0;60}}@set{m;@mod{$0;60}}@repeat{@cmpn{$h;$m;$h;$h;$m};\;}@repeat{@sub{$h;$m};'}@repeat{@sub{$m;$h};,}

नमूना रन:

bash-4.3$ gema '<D>=@set{h;@div{$0;60}}@set{m;@mod{$0;60}}@repeat{@cmpn{$h;$m;$h;$h;$m};\;}@repeat{@sub{$h;$m};`}@repeat{@sub{$m;$h};,}' <<< '252'
;;;;,,,,,,,,

— आदमी काम पर है
स्रोत

0

मतलाब: 89 बाइट्स

i=input('');m=mod(i,60);h=(i-m)/60;[repmat(';',1,min(h,m)),repmat(39+5*(m>h),1,abs(h-m))]

परीक्षा:

310
ans =
;;;;;,,,,,

— brainkz
स्रोत

0

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

INPUT M
H%=M/60M=M-H%*60?";"*MIN(H%,M);",'"[M<H%]*ABS(H%-M)

व्याख्या की:

INPUT MINUTES 'input
HOURS=MINUTES DIV 60 'separate the hours and minutes
MINUTES=MINUTES MOD 60
PRINT ";"*MIN(HOURS,MINUTES); 'print ;s for all positions with both
PRINT ",'"[MINUTES<HOURS]*ABS(HOURS-MINUTES) 'print extra ' or ,

यह बहुत भयानक लग रहा है, क्योंकि नीचे का हिस्सा स्माइलबासिक के फॉन्ट में ;भी नहीं है,

— 12Me21
स्रोत

0

PHP, 81 बाइट्स

कुछ और उपाय:

echo($r=str_repeat)(";",min($h=$argn/60,$m=$argn%60)),$r(",`"[$h>$m],abs($h-$m));
// or
echo($p=str_pad)($p("",min($h=$argn/60,$m=$argn%60),";"),max($h,$m),",`"[$h>$m]);

के साथ भागो echo <time> | php -R '<code>'।

<?=($r=str_repeat)(";",min($h=($_=1439)/60,$m=$_%60)),$r(",`"[$h>$m],abs($h-$m));
// or
<?=($r=str_repeat)(";",min($h=.1/6*$_=1439,$m=$_%60)),$r(",`"[$h>$m],abs($h-$m));
// or
<?=str_pad(str_pad("",min($h=($_=1439)/60,$m=$_%60),";"),max($h,$m),",`"[$h>$m]);

1439इनपुट के साथ बदलें , फ़ाइल को सहेजें, चलाएं।

— टाइटस
स्रोत

0

रूबी, 50 अक्षर

->t{(?;*h=t/60)[0,m=t%60]+",',"[0<=>m-=h]*m.abs}

करने के लिए धन्यवाद:

जीबी के लिए
- मुझे याद दिलाते हुए कि मैं एक स्ट्रिंग से अधिक वर्ण नहीं ले सकता, जिसमें (-1 वर्ण) है
- मेरी गणना को पुनर्गठित करना (-1 वर्ण)

उपयोग करने के लिए इतना लंबा इंतजार किया Numeric.divmod, बस यह महसूस करने के लिए कि इसकी बहुत लंबी है।

नमूना रन:

2.1.5 :001 > puts ->t{(?;*h=t/60)[0,m=t%60]+",',"[0<=>m-=h]*m.abs}[252]
;;;;,,,,,,,,

— आदमी काम पर है
स्रोत

1

मिनट का उपयोग करने के बजाय स्ट्रिंग को काटकर 1 वर्ण सहेजें:(?;*h=t/60)[0,m=t%60]

— जीबी 23

1

और m से h को घटाकर एक और बाइट:",',"[0<=>m-=h]*m.abs

— GB

0

05AB1E , 25 बाइट्स

60‰vy„'.Nè×}‚.BøJ„'.';:ðK

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

60‰vy„'.Nè×}निश्चित रूप से छोटा किया जा सकता है, मैं अभी इसका पता नहीं लगा सका हूं, और संदेह है कि मैं इस दृष्टिकोण के साथ जीतने के लिए 7 बाइट्स से दाढ़ी बनाने में सक्षम होऊंगा जब तक कि इसका कोई वेटेड संस्करण न हो ×।

उदाहरण (इनपुट 63 के बराबर):

60‰                       # Divmod by 60.
                          # STACK: [[1,3]]
   vy      }              # For each element (probably don't need the loop)...
                          # STACK: []
     „'.Nè×               # Push n apostrophe's for hours, periods for minutes.
                          # STACK: ["'","..."]
            ‚             # Group a and b.
                          # STACK: [["'","..."]]
             .B           # Boxify.
                          # STACK: [["'  ","..."]]
               ø          # Zip it (Transpose).
                          # STACK: [["'."," ."," ."]
                J         # Join stack.
                          # STACK: ["'. . ."]
                 „'.';:   # Replace runs of "'." with ";".
                          # STACK: ["; . ."]
                       ðK # Remove all spaces.
                          # OUTPUT: ;..

D60÷''×s60%'.×‚.BøJ„'.';:ðK मेरा मूल संस्करण था, लेकिन यह भी divmod से अधिक महंगा है।

60‰WDµ';ˆ¼}-¬0Qi'.ë''}Z×¯ìJ अभी तक एक और विधि मैंने कोशिश की ...

— जादू ऑक्टोपस Urn
स्रोत

0

डीसी , 95 बाइट्स

[60~sdsp39sj]sd[60~spsd44sj]se?ddd60~<d60~!<e[59Plp1-spld1-dsd0<y]syld0<y[ljPlp1-dsp0<y]sylp0<y

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

— आर। कप
स्रोत

0

जावा 8, 101 99 86 बाइट्स

n->{String r="";for(int m=n%60,h=n/60;h>0|m>0;r+=h--*m-->0?";":h<0?",":"'");return r;}

स्पष्टीकरण:

इसे यहाँ आज़माएँ।

n->{                      // Method with integer parameter and String return-type
  String r="";            //  Result-String (starting empty)
  for(int m=n%60,h=n/60;  //   Get the minutes and hours from the input integer
      h>0|m>0;            //   Loop as long as either the hours or minutes is above 0
    r+=                   //   Append the result-String with:
       h--*m-->0?         //    If both hours and minutes are above 0
                          //    (and decrease both after this check):
        ";"               //     Use ";"
       :h<0?              //    Else-if only minutes is above 0 (hours is below 0)
        ","               //     Use ","
       :                  //    Else:
        "'"               //     Use "'"
  );                      //  End loop
  return r;               //  Return the result
}                         // End of method

— केविन क्रूज़सेन
स्रोत

एएससीआईआई घड़ी डॉट और कॉमा समय मार्करों के साथ

परिचय

प्रतीक

अतिरिक्त नियम

परीक्षण के मामलों

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

CJam, 22 20 19 बाइट्स

व्याख्या

जीएनयू सैड, 37

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

रेटिना , २४

शुद्ध बैश (कोई बाहरी उपयोगिताओं), 103

सी, 119 बाइट्स

हास्केल, 68 66 बाइट्स

जावास्क्रिप्ट (ईएस 6) 69

पॉवरशेल, 99 85 बाइट्स

पायथन 3, 98 बाइट्स

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

PHP, 81 बाइट्स

जावास्क्रिप्ट (ईएस 6), 77 71 बाइट्स

पर्ल 6, 103 101 98 97 69 बाइट्स

सी, 141 बाइट्स

गीमा, 119 वर्ण

मतलाब: 89 बाइट्स

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

PHP, 81 बाइट्स

रूबी, 50 अक्षर

05AB1E , 25 बाइट्स

डीसी , 95 बाइट्स

जावा 8, 101 99 86 बाइट्स