चुनौती

अपने काम के लिए समय (12 घंटे के समय में) के रूप में है।

उपयोग किए जाने वाले सभी वर्ण निम्नानुसार हैं:

  ___    __   ___    ____    _  _     _____     __    ______ 
 / _ \  /_ | |__ \  |___ \  | || |   | ____|   / /   |____  |
| | | |  | |    ) |   __) | | || |_  | |__    / /_       / / 
| | | |  | |   / /   |__ <  |__   _| |___ \  | '_ \     / /  
| |_| |  | |  / /_   ___) |    | |    ___) | | (_) |   / /   
 \___/   |_| |____| |____/     |_|   |____/   \___/   /_/    

   ___     ___  
  / _ \   / _ \                                _
 | (_) | | (_) |   __ _ _ __    _ __ _ __     (_)
  > _ <   \__, |  / _` | '  \  | '_ \ '  \     _ 
 | (_) |    / /   \__,_|_|_|_| | .__/_|_|_|   (_)
  \___/    /_/                 |_|

(प्रत्येक संख्या / प्रतीक के लिए व्यक्तिगत रूप से, इस सलाह से परामर्श करें )।

आपको प्रपत्र की एक सरणी में इनपुट प्राप्त होगा:

[hours, minutes, 'am/pm']। उदाहरण के लिए, [4, 57, 'am']एकल उद्धरण के साथ, केवल am / pm के लिए उपयोग किया जाता है
या "hours-minutes-am/pm"। उदाहरण के लिए,"4-56-am"
या [hours, 'minutes', 'am/pm']उन भाषाओं के लिए जो संख्याओं पर अग्रणी शून्य को संभाल नहीं सकती हैं। उदाहरण के लिए,[4, '07', 'am']

आप इनपुट विधि का उपयोग कर सकते हैं।

आउटपुट फॉर्म में होगा 1 2 : 5 9 am, जहां एक प्रारंभिक स्थान होता है, प्रत्येक संख्या के बीच दो स्थान (जिस्ट में, प्रत्येक संख्या में पहले से ही एक तरफ प्रत्येक स्थान होता है), एक स्थान के बीच: (कोलन) और पड़ोसी संख्या और एक स्थान अंतिम संख्या के बीच और am/pm, एक वैकल्पिक अग्रणी और / या अनुगामी न्यूलाइन के साथ। सभी रिक्त स्थान बाईं ओर के प्रतीक के दाईं ओर-सबसे बिंदु के बीच और दाईं ओर प्रतीक के बाएं-सबसे बिंदु के बीच हैं।

अंतर्निहित उत्पादन की अनुमति है।

सबसे कम बाइट आकार जीतता है।

am/pmऐसी है कि के नीचे गठबंधन किया जाना है pमें pmउत्पादन, यह है कि, undercore के शीर्ष दर्शाने के बाकी के नीचे के साथ गठबंधन किया है am/pmतीसरी पंक्ति नीचे पर शुरू होता है (एक अग्रणी न्यू लाइन गिनती नहीं)।

बृहदान्त्र को इस तरह संरेखित किया जाना है कि यह पहला चरित्र है (एक अंडरस्कोर) दूसरी पंक्ति नीचे (एक अग्रणी नई रेखा की गिनती नहीं) पर शुरू होता है।

इसके लिए minutes < 10, मिनटों को एक अग्रणी के साथ आउटपुट करें 0(आपको इसे इनपुट में प्राप्त करना चाहिए)। उदाहरण के लिए, [8, 04, 'pm']-> 8 : 0 4 pm।

आपको लाइब्रेरी या बाहरी संसाधन से संख्याओं के लिए डेटा प्राप्त नहीं करना चाहिए। सभी डेटा कार्यक्रम के भीतर निहित होना चाहिए।

उदाहरण के लिए, इनपुट के लिए [12, 47, 'am'], आउटपुट निम्नानुसार होगा:

  __    ___          _  _      ______  
 /_ |  |__ \    _   | || |    |____  | 
  | |     ) |  (_)  | || |_       / /   __ _ _ __ 
  | |    / /    _   |__   _|     / /   / _` | '  \
  | |   / /_   (_)     | |      / /    \__,_|_|_|_|
  |_|  |____|          |_|     /_/

(यदि आपको कोई बढ़त के मामले दिखाई देते हैं जो आप तय नहीं कर सकते कि क्या करना है, तो कृपया टिप्पणियों में पोस्ट करें और मैं उन्हें उदाहरणों में जोड़ दूंगा)।

code-golf ascii-art kolmogorov-complexity

2

के संभावित डुप्लिकेट रेंडर करें "डिजिटल घड़ी शैली" नंबर

— Mego

@ क्या आप पर भरोसा है? यह सवाल बस (बहुत) बुनियादी ascii कला के रूप में (किसी भी) संख्या प्रस्तुत करना कहते हैं। यह प्रश्न एससीआई कला से ऊपर उठता है, am / pm और कॉलन जोड़ता है, और एक प्रकार के मिश्रण के साथ एक सरणी के साथ इनपुट निर्दिष्ट करता है।

विशेष रूप से: यह सवाल घड़ी-शैली की संख्या है। यह प्रश्न वास्तविक समय है, सभी सही प्रारूपण के साथ।

संख्याओं के अलग-अलग प्रारूप और बृहदान्त्र के जोड़ और am / pm चुनौतियों को कम करने के लिए बहुत कम करते हैं। चुनौती का मुख्य हिस्सा अभी भी पूर्णांकों को आस्की कला में परिवर्तित कर रहा है।

— मेगो

9

@ मुझे लगता है कि यह एक डुप्लिकेट नहीं है। दूसरी चुनौती में अल्ट्रा सरल प्रारूपण (यहां तक कि द्विआधारी के रूप में संपीड़ित) है। यह शायद अधिक kolmogorov-complexity- जैसे उत्तर प्राप्त करेगा।

— पुरकाकूदरी

5

पर्ल, 592 579 540 522 510 बाइट्स

एक सेक्टर के तहत!

($L,$C,$b)=unpack"W/aW/aB*",q!12346677889999 _|/\)(
'<,>.` PP¨ 
¨@T @ôäð˜SÀ§€fÌU`à¨Àäð'€GÖf`3 X½`fÍ5 s Î|½`gËÖ— $¡))õ™˜À8Sô BÁªx~O àÔýåËþÏÃÆ~O‡ŸY¬Àf s 
½`À*õŸ/X8|½`p>^€<¯åkgúºÖ·ÓÊ¸°ªÀj® kª¸•p¸å\×   ô!;@c=map{$i<<=$_-$P if$_>$P;$P=$_;sprintf"%${l}b",$i++}$L=~/./g;while($b){$b=~s/^$c[$_]// and$g.=($C=~/./sg)[$_]for 0..$#c}$_=pop;s/-/:/;y/apm-/;</d;for$a(0..5){map{$o.=substr((split$/,$g)[$a],($x=-48+ord)*12,('6356766766099'=~/./g)[$x]+3)}/./g;$o.=$/}print$o

यह कार्यक्रम 2 के प्रारूप ( "12-34-am" ) में एक कमांडलाइन तर्क के रूप में समय की अपेक्षा करता है।

टिप्पणी की:

($L,$C,$b) = unpack "W/aW/aB*",             # extract code lengths, chars, and bitstream
    q!12346677889999 _|/\)(
'<,>.` PP¨ 
¨@T @ôäð˜SÀ§€fÌU`à¨Àäð'€GÖf`3 X½`fÍ5 s Î|½`gËÖ— $¡))õ™˜À8Sô BÁªx~O àÔýåËþÏÃÆ~O‡ŸY¬Àf s 
½`À*õŸ/X8|½`p>^€<¯åkgúºÖ·ÓÊ¸°ªÀj® kª¸•p¸å\×   ô!;
@c = map {                                  # reconstruct huffman prefix codes
    $i <<= $_-$P if $_ > $P;                # increase code size
    $P = $_;                                # keep track of previous code
    sprintf "%${l}b", $i++                  # append code as bitstring
}
$L=~/./g;                                   # canonical huffman prefix lengths
while ( $b ) {                              # decompress font
        $b =~ s/^$c[$_]//                   # match and strip prefix code
        and $g .= ($C=~/./sg)[$_]           # append char for prefix code
    for 0..$#c                              # iterate prefix codes in order
}                                           # luckily we can omit checking trailing bytes    

$_ = pop;                                   # get cmdline arg "12-34-am"    
s/-/:/;                                     # ord(':')-ord('0')=10
y/apm-/;</d;                                # 'a'-> chr(11), 'p' -> chr(12), strip -,m
for $a (0..5) {                             # iterate 6 output lines
    map {                                   # iterate each char in input
        $o .= substr(
            ( split $/, $g )[$a],           # grab line $a
            ( $x=-48+ord ) * 12,            # $x=glyph index, 12=glyph width
            ('6356766766099'=~/./g)[$x]+3   # glyph display width
        )
    } /./g;
    $o .= $/                                # append newline
}
print $o                                    # output

ध्यान दें कि वर्ण एन्कोडिंग समस्याओं के कारण, जब आप उपरोक्त कोड को किसी फ़ाइल में पेस्ट करते हैं, तो आउटपुट कुछ विकृत हो सकता है। तो यहाँ गोल्फ संस्करण, बेस -64 इनकोडिंग है। इसे कॉपी करें, और इसमें पेस्ट करें base64 -d > 510.pl:

KCRMLCRDLCRiKT11bnBhY2siVy9hVy9hQioiLHEhDjEyMzQ2Njc3ODg5OTk5DiBffC9cKSgKJzws
Pi5gFQBQAVACqAIgCqgBQBVUAqAFQAH05PAOmANTwBqngGbMBlVgHOAaqMDk8AcngEfWZmAzAA9Y
Ar1gZs0DNQBzoAHOBny9YGfL1g+XoAUkoSkp9ZmYDMAHOANT9A1Cwap4Bn5PABzgH9T9AeV/GBAB
y/7Pw8Z+Tx+Hn1mswGYAc6AKvWAMwCr1gZ8vWAc4Bny9YA5wPl6APK/lrWtn+rrWt9PKuAawBqrA
aq4AawGquAeVcA64AeVcAdcAAAABrfQhO0BjPW1hcHskaTw8PSRfLSRQIGlmJF8+JFA7JFA9JF87
c3ByaW50ZiIlJHtsfWIiLCRpKyt9JEw9fi8uL2c7d2hpbGUoJGIpeyRiPX5zL14kY1skX10vLyBh
bmQkZy49KCRDPX4vLi9zZylbJF9dZm9yIDAuLiQjY30kXz1wb3A7cy8tLzovO3kvYXBtLS87PC9k
O2ZvciRhKDAuLjUpe21hcHskby49c3Vic3RyKChzcGxpdCQvLCRnKVskYV0sKCR4PS00OCtvcmQp
KjEyLCgnNjM1Njc2Njc2NjA5OSc9fi8uL2cpWyR4XSszKX0vLi9nOyRvLj0kL31wcmludCRv

यहां वह फॉन्ट है जिसका मैं उपयोग कर रहा हूं। मैंने आसानी से अनुक्रमण के लिए ग्लिफ़्स 12 वर्णों को अलग कर दिया है (am / pm का आकार)।

   ___        __          ___         ____        _  _        _____         __        ______       ___         ___            
  / _ \      /_ |        |__ \       |___ \      | || |      | ____|       / /       |____  |     / _ \       / _ \      _  
 | | | |      | |           ) |        __) |     | || |_     | |__        / /_           / /     | (_) |     | (_) |    (_)          __ _ _ __   _ __ _ __ 
 | | | |      | |          / /        |__ <      |__   _|    |___ \      | '_ \         / /       > _ <       \__, |     _          / _` | '  \ | '_ \ '  \
 | |_| |      | |         / /_        ___) |        | |       ___) |     | (_) |       / /       | (_) |        / /     (_)         \__,_|_|_|_|| .__/_|_|_|
  \___/       |_|        |____|      |____/         |_|      |____/       \___/       /_/         \___/        /_/                              |_|

यह फॉन्ट 592 बाइट्स है।
पिछले दृष्टिकोण ने RLE कम्प्रेशन पर कुछ बदलावों का उपयोग करते हुए इसे कम करके 783 बाइट्स के अपघटन कोड की कीमत पर 353 बाइट्स तक घटा दिया।
हफ़मैन कोडिंग विघटन एल्गोरिथ्म के लिए 154 बाइट्स की कीमत पर फ़ॉन्ट को 221 बाइट्स तक संपीड़ित करता है।

— केनी
स्रोत

इसे रफू करें! मैं वास्तव में हैक्सेल के लिए स्ट्रिंग संपीड़न चाहता हूं ..

— जे एटकिन

2

बैश + जीएनयू उपयोगिताओं + अंजीर , 134

सुनिश्चित नहीं है कि अंजीर की अनुमति है या नहीं, लेकिन यह सही फोंट प्रदान करने के लिए लगता है - bigअंकों smallके लिए :और निम्नलिखित के लिए {a,p}m:

f=figlet\ -f
b()(date +%$1|sed 's/./& /g'|$f big)
b -I|paste - <(echo "    ";$f small ": ") <(b M) <(echo;date +%P|$f small)|tr \\t \

बाकी बस सही जानकारी प्राप्त कर रहा है dateऔर चारों ओर से फेरबदल कर रहा है ताकि यह सही लगे:

  ___          _____    ___    
 / _ \    _   | ____|  / _ \               
| (_) |  (_)  | |__   | | | |   __ _ _ __  
 > _ <    _   |___ \  | | | |  / _` | '  \ 
| (_) |  (_)   ___) | | |_| |  \__,_|_|_|_|
 \___/        |____/   \___/

आंकड़े को उबंटू के साथ स्थापित किया जा सकता है sudo apt-get install figlet।

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

ऊह ने इस खामोशी के बारे में नहीं सोचा। मैं यह सुनिश्चित करने के लिए प्रश्न को संपादित करूंगा कि कार्यक्रम में चरित्र डेटा शामिल है, लेकिन अपना सबमिशन रखें और इसे निष्क्रिय करें - यह अभी भी एक अच्छा है।

2

हालाँकि मैंने अंको के लिए डेटा प्राप्त करने के लिए अंजीर का उपयोग किया था, इसलिए यह पता लगाने के लिए +1 :)

बस इसे स्पष्ट करने के लिए: फ़ॉन्ट बाहरी स्रोतों से या पुस्तकालयों से लोड नहीं किए जा सकते।

2

सी ++, 938 बाइट्स

इनपुट डेटा के कुछ बुनियादी संपीड़न के साथ संशोधित संस्करण: यहां परीक्षण करें

#include <stdio.h>
#include <time.h>
int main(){char e[]="!1`2!3`1!2`1!4`2!4`!1`!4`4!4`1!3`5!4`2!4`2!35^!`!]!1^`!}!}`1!]!1}`2!]!1}!}1!}!2}!`3}!2^!^!2}`3!1}!2^!`!]!2^!`!]!31`!}!}!}!}!1}!}!3*!}!2`1*!}!}!}1!}`!1}!}`1!3^!^`!6^!^!2}!)`*!}!}!)`*!}!2`1!`!`!`1!3`!`1!`!`1!4)`*}!}!}!}!1}!}!2^!^!2}`1!=!1}`1!2`}!}`2!]!1}!(`!]!4^!^!4?!`!=!2]`1-!}!1^!`a!}!(!1]!1}!(`!]!(!1]!4`!}!}`}!}!1}!}!1^!^`!2`2*!}!3}!}!3`2*!}!}!)`*!}!2^!^!4}!)`*!}!3^!^!2]`1-`}`}`}`}!}!/`1^`}`}`}!2)`*!]`2^!2}`}!}`3}!}`3^!4}`}!2}`3^!2]`2^!2^`^!6]`2^!3^`^!16}`}!14",l[]="8578988998>?3",f[666],*q=f,*p=e,c,r;time_t z;time(&z);tm*u=localtime(&z);while(*p){if(*p>47&&*p<58){r=*p++-48;if(*p>47&&*p<58)r=r*10+*p++-48;while(r--)*q++=c;}else{*q++=c=*p++==94?48:p[-1];}}c=u->tm_hour;sprintf(e,"%02d<%02d%c",c%12,u->tm_min,':'+c/12);for(int s,n,o,r=0;r<6;r++){for(q=e;*q;q++){o=r*111;for(n=0; n<*q-48;n++)o+=l[n]-48;s=l[n]-48;for(n=o;n<o+s;n++)putchar(f[n]-1);}putchar('\n');}return 0;}

— जोहान डू टिट
स्रोत

आवश्यक डेटा की तुलना में इस सबमिशन के हेडर के पास बाइट के आकार पर इतना अधिक प्रभाव नहीं होता है, इसलिए यह वास्तव में जीतने का उचित मौका हो सकता है।

2

हास्केल, 932 699 बाइट्स

700 बाइट्स के तहत याय !!

t=transpose
i=intercalate
l=lines
u=unlines
s=show
c(h,m,a)=u$t$l(i(r"!!\n!!\n")(map d(s h++':':(if m<10 then '0':s m else s m)))++r"!!"++(d$a!!0))
e s z n=i s$splitOn z n
r=e"   ""!"
d 'a'=b 10
d 'p'=b 11
d ':'=b 12
d n=b$read[n]
b n=splitOn(r"!!")(u$t$l$r$e" |""@"$e"___""$"$e"_|""~"$e"!!""*"$e"_ ""#""  $! __!$! $_! # _!  $__!  __! $$! $!  $*****  \n / #\\  /_@@_#\\ @$ \\ @@|@!| $~!/ /!|$#@  / #\\!/ #\\****!  #\n|@@@ @@! )@!__)@@@|@#@@__! / /_* / / @ (_)@@ (_)@  _###__! #_##__!(_)\n|@@@ @@!/ /!|_#< @__!~@$ \\ @ '#\\!  / /! > #<!\\__,@ / _`@ '  \\ @ '#\\ '  \\!#\n|@~@ @@  / /_!$)@!@@! $)@@ (_)@!/ /!@ (_)@! / /  \\__,~~~~@ .__/~~~ (_)\n \\$/!|~@$~@$_/! @~!|$_/!\\$/!/_/*\\$/! /_/**!@~** ")!!n

थोड़े अनगढ़

module Clock where
import Data.Lists

main :: IO ()
main = putStr $ clock (5,05,"am")

clock :: (Int, Int, String) -> String
clock (h,m,a) | m <- if m < 10 then '0':show m else show m
              , hm <- intercalate "      \n      \n" (map digit (show h ++ ':' :m))
              =  unlines $ transpose $ lines (hm ++ "      "++(digit$a!!0))

digit :: Char -> String
digit 'a' = numbers 10
digit 'p' = numbers 11
digit ':' = numbers 12
digit n = numbers (read [n])


numbers :: Int -> String
numbers n = splitOn "      " (unlines $ transpose $ lines "  ___    __   ___    ____    _  _     _____     __    ______    ___     ___                                \n / _ \\  /_ | |__ \\  |___ \\  | || |   | ____|   / /   |____  |  / _ \\   / _ \\                             _ \n| | | |  | |    ) |   __) | | || |_  | |__    / /_       / /  | (_) | | (_) |  __ _ _ __    _ __ _ __   (_)\n| | | |  | |   / /   |__ <  |__   _| |___ \\  | '_ \\     / /    > _ <   \\__, | / _` | '  \\  | '_ \\ '  \\   _ \n| |_| |  | |  / /_   ___) |    | |    ___) | | (_) |   / /    | (_) |    / /  \\__,_|_|_|_| | .__/_|_|_| (_)\n \\___/   |_| |____| |____/     |_|   |____/   \\___/   /_/      \\___/    /_/                |_|             ") !! n

यह काम किस प्रकार करता है

(यह ज्यादातर कैसे ungolfed कार्यक्रम काम करता है)

clock :: (Int, Int, String) -> String
clock (h,m,a) | m <- if m < 10 then '0':show m else show m
              , hm <- intercalate "      \n      \n" (map digit (show h ++ ':' :m))
              =  unlines $ transpose $ lines (hm ++ "      "++(digit$a!!0))

clockसमय का एक हिस्सा लेता है और एक स्ट्रिंग लौटाता है। mअग्रणी 0जोड़ के साथ वर्तमान मिनट है अगर यह है <10। hmघंटे और मिनट एक के साथ शामिल हो गया है :। आखिरी चीज जो आउटपुट करती है, वह है ट्रांसपोर्ट ।

digit :: Char -> String
digit 'a' = numbers 10
digit 'p' = numbers 11
digit ':' = numbers 12
digit n = numbers (read [n])

यहाँ बहुत सरल है। digitएक फ़ंक्शन है जो संग्रहीत स्ट्रिंग में स्थानों के लिए चार्ट मैप करता है।

numbers :: Int -> String
numbers n = splitOn "      " (unlines $ transpose $ lines  replace" |""@"$replace"___""$"$replace"_|""~"$replace"!!""*"$replace"_ ""#""  $! __!$! $_! # _!  $__!  __! $$! $!  $*****  \n / #\\  /_@@_#\\ @$ \\ @@|@!| $~!/ /!|$#@  / #\\!/ #\\****!  #\n|@@@ @@! )@!__)@@@|@#@@__! / /_* / / @ (_)@@ (_)@  _###__! #_##__!(_)\n|@@@ @@!/ /!|_#< @__!~@$ \\ @ '#\\!  / /! > #<!\\__,@ / _`@ '  \\ @ '#\\ '  \\!#\n|@~@ @@  / /_!$)@!@@! $)@@ (_)@!/ /!@ (_)@! / /  \\__,~~~~@ .__/~~~ (_)\n \\$/!|~@$~@$_/! @~!|$_/!\\$/!/_/*\\$/! /_/**!@~** ")!!n

यह जादू संग्रहीत स्ट्रिंग है।

गोल्फ और अनलॉफल्ड कार्यक्रमों के बीच एकमात्र वास्तविक बदलाव यह है कि गोल्फ प्रोग्राम कुछ सामान्य चार पैटर्न को बदलकर कुछ स्ट्रिंग संपीड़न जोड़ता है !@$। मूल डेटा स्ट्रिंग 667बाइट्स था , प्रतिस्थापन संपीड़न के बाद यह 390बाइट्स के नीचे है

— जे एटकिन
स्रोत

1

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

कच्चे डेटा के साथ भयानक प्रयास सभी में संकुचित नहीं होते हैं, और आउटपुट के लिए एक बहुत ही कठिन तरीका है।

लेकिन हे ... यह केवल मेरा दूसरा कोडगोल्फ जवाब है!

d="   ___   !  / _ \\  ! | | | | ! | | | | ! | |_| | !  \\___/  0  __  ! /_ | !  | | !  | | !  | | !  |_| 0  ___   ! |__ \\  !    ) | !   / /  !  / /_  ! |____| 0  ____   ! |___ \\  !   __) | !  |__ <  !  ___) | ! |____/  0  _  _    ! | || |   ! | || |_  ! |__   _| !    | |   !    |_|   0  _____  ! | ____| ! | |__   ! |___ \\  !  ___) | ! |____/  0    __   !   / /   !  / /_   ! |  _ \\  ! | (_) | !  \\___/  0  ______  ! |____  | !     / /  !    / /   !   / /    !  /_/     0   ___   !  / _ \\  ! | (_) | !  > _ <  ! | (_) | !  \\___/  0   ___   !  / _ \\  ! | (_) | !  \\__, | !    / /  !   /_/   0   ! _ !(_)! _ !(_)!   0!! __ _ _ __ !/ _` | '  \\!\\__,_|_|_|_|!0!! _ __ _ __ !| '_ \\ '  \\!| .__/_|_|_|!|_|".split(0);
f=a=>{t="toString",s="split",h=a[0][t]()[s](""),m=a[1][s](""),p=a[2]=='am'?11:12,g=h.length>1?1:0,r="";for(i=0;i<6;i++){r+=d[h[0]][s]('!')[i];r+=(g&&1)?d[h[1]][s]('!')[i]:"";r+=d[10][s]('!')[i]+d[m[0]][s]('!')[i]+d[m[1]][s]('!')[i]+d[p][s]('!')[i]+"\n"}return r}

पुरानी सबमिशन (994 बाइट्स) :

d=["   ___   !  / _ \\  ! | | | | ! | | | | ! | |_| | !  \\___/  ","  __  ! /_ | !  | | !  | | !  | | !  |_| ","  ___   ! |__ \\  !    ) | !   / /  !  / /_  ! |____| ","  ____   ! |___ \\  !   __) | !  |__ <  !  ___) | ! |____/  ","  _  _    ! | || |   ! | || |_  ! |__   _| !    | |   !    |_|   ","  _____  ! | ____| ! | |__   ! |___ \\  !  ___) | ! |____/  ","    __   !   / /   !  / /_   ! |  _ \\  ! | (_) | !  \\___/  ","  ______  ! |____  | !     / /  !    / /   !   / /    !  /_/     ","   ___   !  / _ \\  ! | (_) | !  > _ <  ! | (_) | !  \\___/  ","   ___   !  / _ \\  ! | (_) | !  \\__, | !    / /  !   /_/   ","   ! _ !(_)! _ !(_)!   ","!! __ _ _ __ !/ _` | '  \\!\\__,_|_|_|_|!","!! _ __ _ __ !| '_ \\ '  \\!| .__/_|_|_|!|_|"];
f=a=>{
    t="toString",s="split",h=a[0][t]()[s](""),m=a[1][s],p=(a[2]=='am')?11:12,g=(h.length>1)?1:0,r="";
    for(i=0;i<6;i++){
        r+=d[h[0]].s('!')[i];
        r+=g&&1?d[h[1]].s('!')[i]:"";
        r+=d[10].s('!')[i]+d[m[0]].s('!')[i]+d[m[1]].s('!')[i]+d[p].s('!')[i]+"\n"
    }
return r
}

पढ़ने में आसान बनाने के लिए लाइनों में विभाजित करें।

मूल रूप से:

var f = function (a) {
  hours = a[0].toString().split(""), // convert hours to a string then array to
                                    // handle single and and double numbers
  minutes = a[1].split(""), // ditto with minutes
  period = a[2] == "am" ? 11 : 12, // if it is am, get data[11], if pm, get data[12]
  g = hours.length > 1 ? 1 : 0, // if hours > 9, then g is true
  r = ""; // the string that will be returned
for (i = 0; i < 6; i++) {
    r += data[hours[0]].split("!")[i]; // add the first digit of hours to r
    r += g && 1 ? data[hours[1]].split("!")[i] : ""; // if g is true, add the second 
                                                    //digit of hours to r
    r += data[10].split("!")[i] + // colon
    data[minutes[0]].split("!")[i] + // first digit of minutes
    data[minutes[1]].split("!")[i] + // second digit of minutes
    data[period].split("!")[i] + // am/pm
    "\n"; // and finally linebreak.
  } // entire loop repeated six times, each iteration adds one line to the string
return r; // return the string
};

0

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

golfed

def f(h,c="",n=["   ___   @  / _ \  @ | | | | @ | | | | @ | |_| | @  \___/  ","  __  @ /_ | @  | | @  | | @  | | @  |_| ","  ___   @ |__ \  @    ) | @   / /  @  / /_  @ |____| ","  ____   @ |___ \  @   __) | @  |__ <  @  ___) | @ |____/  ","  _  _    @ | || |   @ | || |_  @ |__   _| @    | |   @    |_|   ","  _____  @ | ____| @ | |__   @ |___ \  @  ___) | @ |____/  ","    __   @   / /   @  / /_   @ |  _ \  @ | (_) | @  \___/  ","  ______  @ |____  | @     / /  @    / /   @   / /    @  /_/     ","   ___   @  / _ \  @ | (_) | @  > _ <  @ | (_) | @  \___/  ","   ___   @  / _ \  @ | (_) | @  \__, | @    / /  @   /_/   ","   @ _ @(_)@ _ @(_)@   ","            @            @ __ _ _ __ @/ _` | '  \@\__,_|_|_|_|@            ","            @            @ _ __ _ __ @| '_ \ '  \@| .__/_|_|_|@|_|"]):
 for i in range(6):
  for j in range(3):
   if j<2:
    x=int(h[j]);d=x//10;u=x%10
    if d>0 or j>0:c+=n[d].split("@")[i]
    c+=n[u].split("@")[i]
    if j==0:c+=" "+n[10].split("@")[i]+" "
   else:y=11 if h[j]=="am" else 12;c+=" "+n[y].split("@")[i]
  c+="\n"
 return c

Ungolfed

import os
from time import ctime

def asciiClock(hour):
    num = ["   ___   @  / _ \  @ | | | | @ | | | | @ | |_| | @  \___/  @","  __  @ /_ | @  | | @  | | @  | | @  |_| @",
   "  ___   @ |__ \  @    ) | @   / /  @  / /_  @ |____| @","  ____   @ |___ \  @   __) | @  |__ <  @  ___) | @ |____/  @",
   "  _  _    @ | || |   @ | || |_  @ |__   _| @    | |   @    |_|   @","  _____  @ | ____| @ | |__   @ |___ \  @  ___) | @ |____/  @",
   "    __   @   / /   @  / /_   @ |  _ \  @ | (_) | @  \___/  @","  ______  @ |____  | @     / /  @    / /   @   / /    @  /_/     @",
   "   ___   @  / _ \  @ | (_) | @  > _ <  @ | (_) | @  \___/  @","   ___   @  / _ \  @ | (_) | @  \__, | @    / /  @   /_/   @",
   "   @ _ @(_)@ _ @(_)@   @","            @            @ __ _ _ __ @/ _` | '  \@\__,_|_|_|_|@            @",
   "            @            @ _ __ _ __ @| '_ \ '  \@| .__/_|_|_|@|_|@"]
    clock = ""
    for i in range(6):
        for j in range(3):
            if j < 2:
                x = int(hour[j])
                d = x // 10
                u = x % 10
                if d > 0 or j > 0:
                    clock += num[d].split("@")[i]
                clock += num[u].split("@")[i]
                if j == 0:
                    clock += " " + num[10].split("@")[i] + " "
            else:
                y = 11 if hour[j] == "am" else 12
                clock += " " + num[y].split("@")[i]
        clock += "\n"
    return clock

previousMinute = -1
while True:
    hour = ctime().split()[3].split(":")
    h = int(hour[0])
    m = hour[1]
    x = "am" if h < 12 else "pm"
    if h > 12:
        h -= 12
    if  previousMinute != m:
        os.system("clear") # if using Windows change to "cls"
        print(asciiClock([h, m, x]))
    previousMinute = m

— आर्गेनिस गार्सिया
स्रोत

Ascii कला में वर्तमान समय का उत्पादन