RFC 2550 टाइमस्टैम्प की गणना करें


26

RFC 2550 एक व्यंग्यपूर्ण प्रस्ताव है (1 अप्रैल, 1999 को प्रकाशित) एक अंतरिक्ष-कुशल ASCII के लिए टाइमस्टैम्प का प्रतिनिधित्व जो किसी भी तारीख (ब्रह्मांड की शुरुआत से पहले और ब्रह्मांड के अनुमानित अंत से पहले वाले) का समर्थन कर सकता है। एक RFC 2550-संगत टाइमस्टैम्प की गणना करने के लिए एल्गोरिथ्म इस प्रकार है (ध्यान दें: सभी श्रेणियों में प्रारंभ शामिल है लेकिन अंत को शामिल करें - 0 से 10,000 का अर्थ है सभी nजहाँ 0 <= n < 10000):

  • वर्ष प्रारूप
    • साल 0 से 10,000: एक 4-अंकीय दशमलव संख्या, शून्य-बाएँ।
    • वर्ष 10,000 से 100,000: एक 5 अंकों की दशमलव संख्या, वर्ण ए के साथ उपसर्ग।
    • १००,००,००० से १० ३० : वर्ष के लिए दशमलव संख्या, अपरकेस ASCII अक्षर के साथ उपसर्ग जिसका अंग्रेजी वर्णमाला में सूचकांक दशमलव वर्ष में अंकों की संख्या के बराबर है, शून्य से ५ (६ अंकों के वर्षों के लिए बी, C के लिए C) -digit वर्ष, आदि)।
    • वर्ष 10 30 से 10 56 : एक ही प्रारूप 10,000 से 10 30 , ए के साथ अक्षरों को शुरू करना, और इसके अलावा ^स्ट्रिंग के लिए एक कैरेट ( ) को उपसर्ग करना (इसलिए वर्ष 10 30 का प्रतिनिधित्व किया जाता है ^A1000000000000000000000000000000, और वर्ष 10 31 का प्रतिनिधित्व किया जाता है द्वारा ^B10000000000000000000000000000000)।
    • वर्ष 10 56 56 से 10 732 : वर्ष दो देखभाल और दो ASCII अपरकेस अक्षरों द्वारा उपसर्ग है। अपरकेस अक्षर वर्ष में अंकों की संख्या का प्रतिनिधित्व करते हुए एक आधार -26 संख्या बनाते हैं, माइनस 57।
    • वर्ष 10 732 बाद में: 10 56 से 10 732 के लिए एक ही प्रारूप का उपयोग किया जाता है, जब आवश्यक हो तो एक अतिरिक्त कैरेट और अपरकेस पत्र जोड़कर इसे विस्तारित किया जाता है।
    • BCE वर्ष (वर्ष 0 से पहले): वर्ष के निरपेक्ष मान के वर्ष स्ट्रिंग की गणना करें। फिर, सभी अक्षरों को उनके आधार -26 पूरक (A <-> Z, B <-> Y, आदि) द्वारा प्रतिस्थापित करें, सभी अंकों को उनके आधार -10 पूरक (0 <-> 9, 1 <-> 8) से बदलें आदि), और विस्मयादिबोधक चिह्न ( !) के साथ कैरेट्स को बदलें । यदि वर्ष स्ट्रिंग 4 अंक या उससे कम (यानी -1 से -10,000) है, तो आगे की स्लैश ( /) को रोकें । यदि वर्ष स्ट्रिंग को आगे स्लैश या विस्मयादिबोधक चिह्न द्वारा उपसर्ग नहीं किया जाता है, तो तारांकन चिह्न ( *) को पूर्वस्थापित करें ।
  • महीने, दिन, घंटे, मिनट और सेकंड : चूंकि ये मान केवल 2 अंकों में सबसे अधिक होते हैं, वे बस वर्ष स्ट्रिंग के दाईं ओर जोड़ दिए जाते हैं, महत्व के घटते क्रम में, यदि आवश्यक हो तो शून्य के साथ बाएं-पैडेड 2-अंकीय तार।
  • अतिरिक्त परिशुद्धता : यदि अतिरिक्त परिशुद्धता (मिलीसेकंड, माइक्रोसेकंड, नैनोसेकंड, आदि के रूप में) की जरूरत है, तो उन मानों को शून्य से 3 अंकों के साथ छोड़ दिया जाता है (क्योंकि प्रत्येक मान 1/1000पिछले मूल्य का है, और इस तरह सबसे अधिक है 999) और महत्व के घटते क्रम में टाइमस्टैम्प के अंत में संलग्न है।

इस प्रारूप में लेक्सिकल छँटाई का लाभ संबंधित टाइमस्टैम्प के संख्यात्मक छँटाई के बराबर है - यदि समय बी से पहले आता है, तो लेक्सिकल छँटाई लागू होने पर ए के लिए टाइमस्टैम्प बी के लिए टाइमस्टैम्प से पहले आएगा।

चुनौती

अंकीय मूल्यों की एक लंबी-लंबी सूची (महत्व के घटते क्रम में समय मान के अनुसार, उदाहरण के लिए [year, month, day, hour, minute, second, millisecond]) को देखते हुए, संबंधित RFC 2550 टाइमस्टैम्प का उत्पादन करता है।

नियम

  • समाधान किसी भी दिए गए इनपुट के लिए काम करना चाहिए। केवल सीमाएं समय और उपलब्ध स्मृति होनी चाहिए।
  • इनपुट को किसी भी उचित, सुविधाजनक प्रारूप में लिया जा सकता है (जैसे संख्यात्मक की एक सूची, तार की एक सूची, एक एकल गैर-अंक चरित्र द्वारा सीमांकित स्ट्रिंग)।
  • इनपुट में हमेशा कम से कम एक मान (वर्ष) होगा। अतिरिक्त मूल्य हमेशा महत्व के घटते क्रम में होते हैं (जैसे इनपुट में एक महीने के मूल्य के बिना एक दिन का मूल्य या महीने के मूल्य के बाद दूसरा मूल्य नहीं होगा)।
  • इनपुट हमेशा एक वैध समय होगा (जैसे कि 30 फरवरी के लिए कोई टाइमस्टैम्प नहीं होगा)।
  • आरएफसी 2550 टाइमस्टैम्प की गणना करने वाले बिल्डरों को मना किया जाता है।

उदाहरण

ये उदाहरण इनपुट को एक स्ट्रिंग के रूप में उपयोग करते हैं, जिसमें अलग-अलग मूल्य अवधि ( .) से अलग होते हैं ।

1000.12.31.13.45.16.8 -> 10001231134516008
12.1.5.1 -> 0012010501
45941 -> A45941
8675309.11.16 -> C86753091116
47883552573911529811831375872990.1.1.2.3.5.8.13 -> ^B478835525739115298118313758729900101020305008013
4052107100422150625478207675901330514555829957419806023121389455865117429470888094459661251.2.3.5.7.11 -> ^^BI40521071004221506254782076759013305145558299574198060231213894558651174294708880944596612510203050711
-696443266.1.3.6.10.15.21.28 -> *V3035567330103061015021028
-5342 -> /4657
-4458159579886412234725624633605648497202 -> !Q5541840420113587765274375366394351502797

संदर्भ कार्यान्वयन

#!/usr/bin/env python

import string

# thanks to Leaky Nun for help with this
def base26(n):
    if n == 0:
        return ''
    digits = []
    while n:
        n -= 1
        n, digit = divmod(n, 26)
        digit += 1
        if digit < 0:
            n += 1
            digit -= 26
        digits.append(digit)
    return ''.join(string.ascii_uppercase[x-1] for x in digits[::-1])

year, *vals = input().split('.')

res = ""
negative = False

if year[0] == '-':
    negative = True
    year = year[1:]

if len(year) < 5:
    y = "{0:0>4}".format(year)
elif len(year) <= 30:
    y = "{0}{1}".format(string.ascii_uppercase[len(year)-5], year)
else:
    b26len = base26(len(year)-30)
    y = "{0}{1}{2}".format('^'*len(b26len), b26len, year)

if negative:
    y = y.translate(str.maketrans(string.ascii_uppercase+string.digits+'^', string.ascii_uppercase[::-1]+string.digits[::-1]+'!'))
    if len(year) == 4:
        y = '/' + y
    if y[0] not in ['/', '!']:
        y = '*' + y

res += y
for val in vals[:5]: #month, day, hour, minute, second
    res += '{0:0>2}'.format(val)

for val in vals[5:]: #fractional seconds
    res += '{0:0>3}'.format(val)

print(res)

निश्चित रूप से -696443266.1.3.6.10.15.21.28होना चाहिए *V3035567339896938984978971?
नील

11
@ जब तक हम नकारात्मक महीनों का आविष्कार नहीं करते हैं। Negember।
मेगो

1
@TaylorScott अतिरिक्त परिशुद्धता : यदि अतिरिक्त परिशुद्धता (मिलीसेकंड, माइक्रोसेकंड, नैनोसेकंड, आदि के रूप में) की आवश्यकता है, तो उन मानों को शून्य से 3 अंकों के साथ छोड़ दिया जाता है।
मेघो

2
यह मुझे ऐसा लगता है जैसे प्रश्न में दिए गए युक्ति वास्तव में RFC2550 से मेल नहीं खाते हैं। जैसा कि मैं इसे समझता हूं, एक बार जब आप पिछले तीन कैरेट प्राप्त कर लेते हैं, तो अक्षरों की संख्या तेजी से बढ़नी चाहिए, क्योंकि यह फाइबोनैचि श्रृंखला से ली गई है (4 कैरेट का अर्थ है 5 अक्षर, 5 कैरेट का अर्थ है 8 अक्षर, आदि) क्या यह सुरक्षित है मान लें कि हमें RFC के उस पहलू को अनदेखा करना चाहिए?
जेम्स होल्डरनेस

1
@JamesHolderness आप सही हैं, मैंने कल्पना को गड़बड़ कर दिया। हालाँकि, इसे ठीक करने में बहुत देर हो चुकी है, क्योंकि पहले से ही ऐसे उत्तर हैं जो अमान्य होंगे।
मेगो

जवाबों:


5

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

f=
s=>s.split`.`.map((n,i)=>i?`00${n}`.slice(i>5?-3:-2):n<'0'?g(n.slice(1),'!','*','/').replace(/\w/g,c=>c>'9'?(45-parseInt(c,36)).toString(36):9-c):g(n),g=(n,c='^',d='',e='',l=n.length)=>l<5?e+`000${n}`.slice(-4):l<31?d+(l+5).toString(36)+n:h(l-30,c)+n,h=(n,c)=>n?c+h(--n/26|0,c)+(n%26+10).toString(36):'').join``.toUpperCase()
;
<input oninput=o.value=f(this.value);><input id=o>

चौंककर लंबा।


क्या आप आसान परीक्षण के लिए स्टैक स्निपेट जोड़ना पसंद करेंगे?
मेगो

@ मेगो डन। कुछ टाइपो को भी तय किया गया है जो (मैंने गलती से कॉपी और पेस्ट करते समय कोड में से कुछ हटा दिया है क्योंकि लाइन मुझे भ्रमित करती है। उफ़।)
नील

3

Befunge, 418 384 बाइट्स

अग्रिम में यह बताना मुश्किल है कि एक बेफुंज कार्यक्रम कितने बड़े पैमाने पर समाप्त होने की संभावना है, और जब मैंने इस पर काम करना शुरू किया तो मुझे लगा कि यह वास्तव में प्रतिस्पर्धा का कुछ मौका हो सकता है। नतीजा मेरा गलत होना निकला।

~:59*-!:00p:2*1\-10p:9*68*+20p>0>#~$_v
68*-:0\`30p\>>:"P"%\"P"/9+p30g#v_1+:~>
0\`v`\0:\p04<<:+1g04-$<_\49+2*v>0>+#1:#\4#g\#0`#2_130p040p5-::01-`\49+2*-:
v:$_\50p\$:130g:1+30p:!^!:-1\*<>g*"A"++\49+2*/50g1-:
_$1+7g00g40g!**:!>_40g:!v!:\g8<^00*55*g01%*2+94:p05
|#9/"P"\%"P":<:_,#!>#:<$_1-00g^v3$\_\#`\0:>#g+
>10g*20g+,1+:^v\&\0+2`4:_@#`<0+<
/*v*86%+55:p00<_$$>:#,_$1+~0^
^!>+\55+/00g1-:^

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


3

पर्ल 5 , 328 322 317 301 + 1 ( -a) = 302 बाइट्स

$_=shift@F;if(($l=y/-//c)<5){s/^/0 x(4-$l)/e}elsif($l<57){s/^/'^'x($l>30).chr 65+($l-5)%26/e}else{$l-=57;do{s/\^*\K/'^'.chr 65+$l%26/e}while$l=int$l/26;s/^\^\K\D-?\d/^A$&/}if(s/-//){s%^....$%/$&%;eval join'',reverse'!/',0..9,A..Z,"y/A-Z0-9^/";s%^[^!/]%*$&%}printf$_.'%02d'x(@F>5?5:@F).'%03d'x(@F-5),@F

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

Ungolfed

$_=shift@F; # Store the year in the default variable for easier regex

if(($l=y/-//c)<5){      # if the length of the year is less than 5
    s/^/0 x(4-$l)/e         # pad with leading zeros to 4 digits
}elsif($l<57){          # if the length is less than 57
    s/^/'^'x($l>30).chr 65+($l-5)%26/e  # put a carat at the front if there are more than 30 characters
                        # and map the length minus 5 to A-Z
}else{
    $l-=57;         # offset the length by 57
    do{         
        s/\^*\K/'^'.chr 65+$l%26/e # put a carat at the front and map the length to base 26 (A-Z)
    }while$l=int$l/26;  # until the length is down to 0
    s/^\^\K\D-?\d/^A$&/ # insert an extra '^A' to pad the result to at least 2 characters if there was only 1
}
if(s/-//){          # if the year is negative
    s%^....$%/$&%;          # put a '/' in front of a 4 digit year
    eval join'',reverse'!/',0..9,A..Z,"y/A-Z0-9^/"; # map A-Z,0-9, and ^ to Z-A,9-0, and ! respectively
    s%^[^!/]%*$&%           # add a * at the front if there are no other indicators
}
printf$_.           # output the year
'%02d'x(@F>5?5:@F).             # followed by the month, day, hour, and minutes, padded to 2 digits
'%03d'x(@F-5),@F                # followed by fractional seconds, padded to three digits

3

जावा 8, 653 640 637 623 बाइट्स

s->{String r="",q="ABCDEFGHIJKLMNOP",z=q+"QRSTUVWXYZ",y="0123456789",x;int i=0,f=0,t,u;for(String p:s){if(p.charAt(0)<46){p=p.substring(1);f=1;}t=p.length();if(i++<1){r+=(t<5?"000".substring(t-1):t<32?(char)(t+60):t<58?"^"+(char)(t+34):"");if(t>57){for(r+="^^",u=675;u<t-57;u*=26)r+="^";x="";for(String c:Long.toString(t-57,26).toUpperCase().split(""))x+=z.charAt((y+q).indexOf(c));r+=x;}r+=p;if(f>0){x=t<5?"/":t<32?"*":r.replace("^","!").replaceAll("[^!]","");for(char c:r.toCharArray())x+=c>93?"":"ZYXWVUTSRQPONMLKJIHGFEDCBA9876543210".charAt((z+y).indexOf(c));r=x;}}else r+=i>6?t<2?"00"+p:t<3?0+p:p:t<2?0+p:p;}return r;}

इनपुट के रूप में String-अरे और रिटर्न-टाइप के रूप में String

निकला काफी लंबा (उम्मीद के मुताबिक), लेकिन निश्चित रूप से कुछ और गोल्फ हो सकता है। मुझे खुशी है कि यह काफी समय के लिए इसके साथ काम करने के बाद काम करता है ..

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

स्पष्टीकरण:

  • for(String p:s){: भागों पर लूप
    • if(p.charAt(0)<46){p=p.substring(1);f=1;}: निर्धारित करें कि क्या यह नकारात्मक है, और यदि यह है, तो माइनस साइन को हटा दें और बाइट को कम करने के लिए एक ध्वज सेट करें
    • t=p.length();: अंकों की राशि प्राप्त करें
    • if(i++<1){: यदि यह पहली संख्या है (वर्ष):
      • t<5?"000".substring(t-1): यदि यह 0-100,000 (अनन्य) है: यदि आवश्यक हो तो अग्रणी शून्य जोड़ें
      • t<32?(char)(t+60): यदि यह 100,000-10 30 है (अनन्य): एक प्रमुख पत्र जोड़ें
      • t<58?"^"+(char)(t+34): यदि यह 10 30 -10 732 (अनन्य) है: एक शाब्दिक "^"+ अग्रणी पत्र जोड़ें
      • if(t>57)for(r+="^^",u=675;u<t-57;u*=26)r+="^";: शाब्दिक "^"+ की उचित राशि जोड़ें x="";for(String c:Long.toString(t-57,26).toUpperCase().split(""))x+=z.charAt((y+q).indexOf(c));r+=x;: प्रमुख अक्षर (वर्णमाला रूपांतरण के लिए बेस -26)
      • r+=p;: रिजल्ट-स्ट्रिंग के लिए ही वर्ष जोड़ें
      • if(f>0){: यदि वर्ष नकारात्मक था:
        • x=t<5?"/":t<32?"*":r.replace("^","!").replaceAll("[^!]","");: xसही /, *या एक या कई के साथ एक अस्थायी स्ट्रिंग बनाएँ!
        • for(char c c:r.toCharArray())x+=c>93?"":"ZYXWVUTSRQPONMLKJIHGFEDCBA9876543210".charAt((z+y).indexOf(c));: रूपांतरण करें (A↔Z, B↔Y, 0 ,9, 1 ,8, आदि)
        • r=x;: और फिर इस अस्थायी स्ट्रिंग का परिणाम निर्धारित करें x
    • else: यदि यह महीना, दिन, घंटे, मिनट, सेकंड, मिलीसेकंड, माइक्रोसेकंड, नैनोसेकंड, या है:
      • i>6?t<2?"00"+p:t<3?0+p:p: यदि यह मिलीसेकंड या छोटा है: यदि आवश्यक हो तो अग्रणी शून्य जोड़ें
      • :t<2?0+p:p;: एल्से (महीने, दिन, घंटे, मिनट, सेकंड): यदि आवश्यक हो तो एकल अग्रणी शून्य जोड़ें
  • return r: परिणाम लौटाओ

Input may be taken in any reasonable, convenient format (such as a list of numerics, a list of strings, a string delimited by a single non-digit character, etc.).- आप इनपुट को न्यूमेरिक्स की सूची के रूप में ले सकते हैं, और महंगा विभाजन और रूपांतरण को छोड़ सकते हैं।
मेघो

1
@Mego दुर्भाग्य से डिफॉल्ट न्यूमेरिक्स ( long64 बिट्स सबसे बड़ा होने के साथ) कुछ इनपुट्स के लिए जावा में बहुत छोटा है, इसलिए इससे Stringछोटा है java.math.BigInteger। मैंने इसे एक Stringऐरे में बदल दिया , हालांकि, मुझे डॉट्स द्वारा विभाजन करने की आवश्यकता नहीं है, जिससे कुछ बाइट्स बच गए, इसलिए धन्यवाद।
केविन क्रूज़सेन

2

एक्सेल VBA, 500 486 485 470 बाइट्स

अनाम VBE तत्काल विंडो फ़ंक्शन

बेनामी VBE तत्काल विंडो फ़ंक्शन जो इनपुट से वर्ष के रूप में लेता है [A1], महीने से [B1], दिनों से [C1], घंटों से [D1]मिनट [E1], सेकंड से [F1]और एक अतिरिक्त अतिरिक्त सटीक सरणी [G1:Z1], RFC2550 टाइमस्टैम्प की गणना करता है और VBE तत्काल विंडो को आउटपुट करता है। नीचे घोषित सहायक समारोह का उपयोग करता है।

n=Left([A1],1)="-":y=Mid([A1],1-n):l=Len(y):o=IIf(l<5,Right("000"&y,4),IIf(l<31,"",String(Len(b(l-30)),94))&B(l-IIf(l<31,4,30))&y):For Each c In[B1:Z1]:j=j+1:p=p+IIf(c,Format(c,IIf(j>5,"000","00")),""):Next:If n Then For i=1To Len(o):c=Asc(Mid(o,i,1)):Mid$(o,i,1)=Chr(IIf(c<60,105,155)-c):Next:?IIf(l<5,"/",IIf(InStr(1,o,"="),"","*"))Replace(o,"=","!")p:Else?o;p

हेल्पर फंक्शन

घोषित हेल्पर फ़ंक्शन जो इनपुट नंबर लेता है और उस नंबर को बेस -26 में लौटाता है जैसे 1->Aऔर26->Z

एक सार्वजनिक मॉड्यूल में रखा जाना चाहिए।

Function b(n)
While n
n=n-1
d=n Mod 26+1
n=Int(n/26)
d=d+26*(d<0):n=n-(d<0)
b=Chr(64+d)+b
Wend
End Function

प्रयोग

एक स्पष्ट मॉड्यूल में उपयोग किया जाना चाहिए, या मॉड्यूल को वेरिएस के रूप में निष्पादन से पहले साफ किया जाना चाहिए j, oऔर pकोड के निष्पादन की शुरुआत में उनके डिफ़ॉल्ट, असंबद्ध राज्य में होना माना जाता है। के लिए j, जो एक Variant\Integerचर है, यह डिफ़ॉल्ट मान है 0और इसके लिए oऔर p, जो Variant\Stringचर हैं, यह डिफ़ॉल्ट मान खाली स्ट्रिंग ( "") है।

इनपुट, स्ट्रिंग्स की एक सरणी, 1:1ActiveSheet से ली गई है और आउटपुट VBE तत्काल विंडो पर है।

नमूना I / O

[A1:F1]=Split("4052107100422150625478207675901330514555829957419806023121389455865117429470888094459661251.2.3.5.7.11",".")
n=Left([A1],1)="-":y=Mid([A1],1-n):l=Len(y):o=IIf(l<5,Right("000"&y,4),IIf(l<31,"",String(Len(b(l-30)),94))&B(l-IIf(l<31,4,30))&y):For Each c In[B1:ZZ1]:j=j+1:p=p+IIf(c,Format(c,IIf(j>5,"000","00")),""):Next:If n Then For i=1To Len(o):c=Asc(Mid(o,i,1)):Mid$(o,i,1)=Chr(IIf(c<60,105,155)-c):Next:?IIf(l<5,"/",IIf(InStr(1,o,"="),"","*"))Replace(o,"=","!")p:Else?o;p
^^BI40521071004221506254782076759013305145558299574198060231213894558651174294708880944596612510203050711021028

Cells.Clear:j=0:o="":p="" '' clear the worksheet and vars
[A1:H1]=Array("-696443266","1","3","6","10","15","21","28")
n=Left([A1],1)="-":y=Mid([A1],1-n):l=Len(y):o=IIf(l<5,Right("000"&y,4),IIf(l<31,"",String(Len(b(l-30)),94))&B(l-IIf(l<31,4,30))&y):For Each c In[B1:ZZ1]:j=j+1:p=p+IIf(c,Format(c,IIf(j>5,"000","00")),""):Next:If n Then For i=1To Len(o):c=Asc(Mid(o,i,1)):Mid$(o,i,1)=Chr(IIf(c<60,105,155)-c):Next:?IIf(l<5,"/",IIf(InStr(1,o,"="),"","*"))Replace(o,"=","!")p:Else?o;p
*V3035567330103061015021028

Cells.Clear:j=0:o="":p="" '' clear the worksheet and vars
[A1]="45941"
n=Left([A1],1)="-":y=Mid([A1],1-n):l=Len(y):o=IIf(l<5,Right("000"&y,4),IIf(l<31,"",String(Len(b(l-30)),94))&B(l-IIf(l<31,4,30))&y):For Each c In[B1:ZZ1]:j=j+1:p=p+IIf(c,Format(c,IIf(j>5,"000","00")),""):Next:If n Then For i=1To Len(o):c=Asc(Mid(o,i,1)):Mid$(o,i,1)=Chr(IIf(c<60,105,155)-c):Next:?IIf(l<5,"/",IIf(InStr(1,o,"="),"","*"))Replace(o,"=","!")p:Else?o;p
A45941

Cells.Clear:j=0:o="":p="" '' clear the worksheet and vars
[A1:F1]=Split("4052107100422150625478207675901330514555829957419806023121389455865117429470888094459661251.2.3.5.7.11",".")
n=Left([A1],1)="-":y=Mid([A1],1-n):l=Len(y):o=IIf(l<5,Right("000"&y,4),IIf(l<31,"",String(Len(b(l-30)),94))&B(l-IIf(l<31,4,30))&y):For Each c In[B1:ZZ1]:j=j+1:p=p+IIf(c,Format(c,IIf(j>5,"000","00")),""):Next:If n Then For i=1To Len(o):c=Asc(Mid(o,i,1)):Mid$(o,i,1)=Chr(IIf(c<60,105,155)-c):Next:?IIf(l<5,"/",IIf(InStr(1,o,"="),"","*"))Replace(o,"=","!")p:Else?o;p
^^BI40521071004221506254782076759013305145558299574198060231213894558651174294708880944596612510203050711

Subनियमित संस्करण

घोषित सबरूटीन जो इनपुट के रूप में वर्ष से [A1], महीने से [B1], दिन से [C1], घंटों से [D1], मिनट से [E1]सेकंड [F1]और एक अतिरिक्त अतिरिक्त सटीक सरणी से [G1:Z1]लेता है, RFC2550 टाइमस्टैम्प की गणना करता है और VBE तत्काल विंडो को आउटपुट करता है।

Sub R(x)
a=x(0)
n=Left(a,1)="-"'<- that `"` is only there to make sure highlighting is correct
y=Mid(a,1-n)
l=Len(y)
o=IIf(l<5,Right("000"&y,4),IIf(l<31,"",String(Len(b(l-30)),94))&B(l-IIf(l<31,4,30))&y)
If n Then For i=1To Len(o):c=Asc(Mid(o,i,1)):Mid$(o,i,1)=Chr(IIf(c<60,105,155)-c):Next:o=IIf(l<5,"/",IIf(InStr(1,o,"="),"","*"))&Replace(o,"=","!")
For j=1To UBound(x)
o=o+IIf(x(j),Format(x(j),IIf(j>5,"000","00")),"")
Next
[A2]=o
End Sub
Function b(n)
While n
n=n-1
d=n Mod 26+1
n=Int(n/26)
d=d+26*(d<0):n=n-(d<0)
b=Chr(64+d)+b
Wend
End Function

प्रयोग

रेंज में इनपुट [A1:ZZ1]या तो मैन्युअल रूप से किया जा सकता है, कोशिकाओं में टाइप करके, सबसे बाईं ओर से दाईं ओर, आवश्यकतानुसार या VBE तत्काल विंडो से असाइन करके।

ध्यान से, एक्सेल ऑटो-कन्वर्टिंग नंबरों को वैज्ञानिक संकेतन के कारण, ऐसी कोई भी संख्या जिनकी आधार-संख्या लंबाई के बराबर या 12 अंकों से अधिक हो, को स्पष्ट रूप से सेल में टेक्स्ट सेल के रूप में सेट करके या तो सेल में सम्मिलित किया जाना चाहिए या 'सेल के मूल्य की शुरुआत के लिए शाब्दिक को तैयार करने से

नमूना I / O

r Split("4052107100422150625478207675901330514555829957419806023121389455865117429470888094459661251.2.3.5.7.11",".")
?[A2]  '' <- print output to VBE console
^^BI40521071004221506254782076759013305145558299574198060231213894558651174294708880944596612510203050711 ''  <- Output

r Array("47883552573911529811831375872990","1","1","2","3","5","8","13")
?[A2]
^B478835525739115298118313758729900101020305008013

r Array("-696443266","1","3","6","10","15","21","28")
?[A2]
*V3035567330103061015021028

r Array("45941")
?[A2]
A45941

अनगढ़ और समझाया हुआ

''  Returns RFC2550 timestamp corresponding to passed vars
Public Function RFC2550(ByVal pYear As String, ParamArray Extra() As Variant) As String

    ''  Declare Vars
    Dim Negative As Boolean, _
        leny As Long, _
        i As Long, _
        c As Byte, _
        s As Variant, _
        out As String

    ''  Check if year is negative and store the absolute value of the year
    Let Negative = Left(pYear, 1) = "-"
    Let pYear = Mid(pYear, 1 - Negative)

    ''  Take the length of the year
    Let leny = Len(pYear)
    If leny < 5 Then
        ''  If the length is less than 5, pad the year left to 4 characters 
        ''  using zeros
        Let out = Format("0000", pYear)
    Else
        ''  If the length of the year is greater than 30, then set out to be 
        ''  as string comprised of length-30 instances of `^`
        Let out = IIf(leny < 31, "", String(Len(Base26(leny - 30)), 94)) 
        ''  append the Base26 representation of the length of the year,
        ''  minus 30, if the length is greater than 30
        Let out = out & Base26(leny - IIf(leny < 31, 4, 30)) 
        ''  append the year to out
        Let out = out & pYear
    End If


    If Negative Then
        ''  iterate across out
        For i = 1 To Len(out)
            ''  store the char code for the current char
            Let c = Asc(Mid(out, i, 1))
            ''  swap letter/number with its inverse (0->9,A->Z)
            Mid$(out, i, 1) = Chr(IIf(c < 60, 105, 155) - c)
        Next i

        ''  replace `=` (the inverse of `^`) with `!`
        Let out = Replace(out, "=", "!")
        ''  Prepend either `/`, `*`, or nothing depending on length and 
        ''  start of out
        Let out = IIf(leny < 5, "/", IIf(InStr(1, out, "!"), "", "*")) & out
    End If

    Let i = 1
    For Each s In Extra
        ''  append all of the extra precision data - padding to 2 chars for 
        ''  the first 5 elements in the array (month, day, hour, minute and 
        ''  second) and to 3 chars for all following elements (milli, micro, 
        ''  nano, pico, femto, atto, zepto, yocto - seconds) with the char 0
        Let out = out & IIf(s, Format(s, IIf(i > 5, "000", "00")), "")
        Let i = i + 1
    Next

    ''  return out
    Let RFC2550 = out 

End Function


''  returns non-standard base26 version of input number 
''  1->A, 2->B,... 26->Z
Function Base26(ByVal n As Long) As String

    ''  declare vars
    Dim out As String, _
        digit As Integer

    ''  init out, digit
    Let out = ""
    Let digit = 0

    ''  iterate through n 
    While n
        ''  Decrement, hold the value of the digit
        Let n = n - 1
        Let digit = n Mod 26 + 1

        ''  divide by 26
        Let n = Int(n / 26)

        ''  correct for negative numbers
        If digit < 0 Then Let n = n + 1: Let digit = digit - 26

        ''  prepend char corresponding to the digit to out
        Let out = Chr(64 + digit) & out
    Wend

    ''  return out
    Let Base26 = out
End Function

2

जैली , 165 126 बाइट्स

ḣ5ṫ€3
ØD,“^ /*!”,ØA
_µ‘l26Ċṗ@€ØAẎị@
Lµç30;€”^UZFµç4⁶;µ®L>30¤?µḟ®L>4¤?;®AṾ€¤µL=4”/x2£FiЀị€2£UF¤µ®S<0¤¡
4R¬+DU$UµḢ©Ç;Ñ;ṫ6ṫ€2$$F

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

रेखा 4 वर्ष 2 और 3 की मदद से प्रारूपण करता है। पहली और आखिरी पंक्ति शून्य इनपुट के तत्वों को उनकी उचित लंबाई तक पहुंचाती है और फिर उन्हें स्वरूपित वर्ष के साथ समेटती है।

  • _µ‘l26Ċṗ@€ØAẎị@आधार 26 उपसर्ग पाता है। यह ØA1 और छत के बीच प्रत्येक संख्या के लिए वर्णमाला ( ) की कार्टेशियन शक्ति लेता है (लॉग 26 (मंजिल (लॉग 10 (वर्ष) - n + 1))) (जहां n या तो 30 या 4 है) तो इस सूची में अनुक्रमित हो जाता है मंजिल के साथ (लॉग 10 (वर्ष)) - एन ( ị@)।
  • ç30;€”^UZF प्रारूप वर्ष> = 10 30 ( ®L>30¤?)
  • ç4⁶;प्रारूप वर्ष <10 30 । ( संपादित करें : ⁶;इसके बजाय का उपयोग करके एक बाइट को बचाया ;@⁶)
  • 1RḊ वर्षों के लिए एक खाली उपसर्ग देता है <10 5 ( ®L>4¤?)। यह अंकों की सूची लेता है फिर अपने आप में प्रत्येक तत्व को फ़िल्टर करता है। सिर्फ पैदावार के लिए इसका उपयोग करना []क्योंकि यहाँ काम नहीं करता है। यह सिर्फ मूल्यांकन करता है []और []यहां काम नहीं करते हैं और मुझे एक और 2 बाइट्स नहीं मिली हैं जो एक खाली सूची लौटाती हैं।
  • ;®AṾ€¤ वर्ष को उपसर्ग में जोड़ता है और फिर इसे समतल करता है।
  • L=4”/xउपसर्ग /यदि एक वर्ष की लंबाई 4 के कथन में है ®S<0¤¡
  • 2£FiЀ¹ị€2£UF¤का पूरक लेता है A .. Z, 0 .. 9और ^ /*!यदि वर्ष नकारात्मक है ( ®S<0¤¡)। दूसरी कड़ी को संदर्भित करता है, ØD,“^ *!”,ØAजो सूची है [['0' .. '9'], ['^',' ','/','*','!'], ['A' .. 'Z']]^C125...इस लिंक की तरह एक स्वरूपित वर्ष के साथ तब के चपटे संस्करण में प्रत्येक वर्ण के सूचकांक को पाता है, उन सूचकांकों का उपयोग करता है जहां चपटा संस्करण से एक नया स्ट्रिंग का निर्माण होता है, जहां प्रत्येक सबलिस्ट उलटा होता है, यानी ['9' .. '0','!','*','/',' ','^','Z' .. 'A']उपज !X874.../खुद के लिए नक्शे क्योंकि यह सब कुछ से पहले इसके पूरक लिया है उपसर्ग है।
  • L=4a®S<0x@”/;/में नकारात्मक वर्षों की शुरुआत के लिए एक जोड़ता है [-9999 .. -0001]। मेरा अनुमान है कि इसे छोटा किया जा सकता है। मैंने पिछले do स्टेटमेंट ( ¡) में इसे शामिल किया और 7 बाइट्स बचाए क्योंकि तब मुझे दो बार नकारात्मक वर्षों के लिए परीक्षण करने की आवश्यकता नहीं थी।

¡लाइन 4 में बहुत सारे उपयोग हैं और मुझे लगता है कि वे ?इसके बजाय का उपयोग करके संकुचित हो सकते हैं लेकिन मुझे यकीन नहीं है कि उन लोगों को कैसे काम करना है। मैंने ?काम किया और कुछ बाइट्स बचाए।

जेम्स होल्डरनेस ने बताया कि मेरा पहला सबमिशन 30 अंकों के साथ सही नहीं था। यह पता चला कि बग किसी भी वर्ष के लिए था Zजिसे आधार 26 उपसर्ग में आवश्यक था । यह पता चलता है कि मैं उपयोग नहीं कर सकता क्योंकि जब आप 26 को बेस 26 में बदलते हैं तो यह आपको (डुह) के [1,0]बजाय देता है 26। इसके बजाय मैंने प्रतिस्थापन के साथ जोड़े का आदेश दिया। मुझे नहीं लगता कि इसके लिए एक परमाणु है, लेकिन अगर वहाँ है तो मैं कुछ बाइट्स बचा सकता हूं। इसे ठीक करने से मेरी लागत ~ 40 बाइट्स समाप्त हो गई। निश्चित रूप से मेरा सबसे लंबा जेली कार्यक्रम अभी तक। संपादित करें : कार्टेशियन उत्पाद करने के लिए एक छोटा तरीका मिला। मुझे एहसास हुआ कि मुझे यकीन नहीं था कि पिछले एक ने दो से अधिक अक्षरों के साथ उपसर्गों के लिए काम किया था, लेकिन नया तरीका काम नहीं करता है।

क्षमा करें कई बार मैंने इस पोस्ट को संपादित किया है, मैं इसे छोटा करने के तरीके खोज रहा हूं।

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