20

में Salesforce सीआरएम , हर वस्तु 15-चरित्र अक्षरांकीय आईडी है, जो केस-संवेदी है है। अगर किसी के लिए उत्सुक है, वास्तव में यह आधार -62 नंबर है । हालाँकि, डेटा माइग्रेशन और एकीकरण के लिए उपयोग किए जाने वाले उपकरण केस सेंसिटिविटी का समर्थन कर सकते हैं या नहीं भी कर सकते हैं। उस पर काबू पाने के लिए, आईडी को सुरक्षित रूप से 18-वर्ण केस-असंवेदनशील अल्फ़ान्यूमेरिक आईडी में परिवर्तित किया जा सकता है। उस प्रक्रिया में 3-वर्ण अल्फ़ान्यूमेरिक चेकसम को ID से जोड़ा जाता है। रूपांतरण एल्गोरिथ्म है:

उदाहरण :

a0RE000000IJmcN

स्प्लिट आईडी को तीन 5-वर्ण वाले विखंडू में।
```
a0RE0  00000  IJmcN
```
प्रत्येक चंक को उल्टा कर दें।
```
0ER0a  00000  NcmJI
```
1यदि यह अपरकेस है या 0यदि अन्यथा, तो प्रत्येक वर्ण को प्रत्येक वर्ण में बदलें ।
```
01100  00000  10011
```
प्रत्येक 5-अंकीय बाइनरी संख्या के लिए i, iअपरकेस वर्णमाला और अंक 0-5 ( ABCDEFGHIJKLMNOPQRSTUVWXYZ012345) के स्थान पर चरित्र प्राप्त करें ।
```
00000 -> A,
00001 -> B,
00010 -> C, ..., 
11010 -> Z, 
11011 -> 0, ...,
11111 -> 5`
```
उपज:
```
M  A  T
```
मूल आईडी पर इन वर्णों, चेकसम को जोड़ें।

आउटपुट :

a0RE000000IJmcNMAT

प्रोग्राम या फ़ंक्शन लिखें जो इनपुट के रूप में 15-वर्ण अल्फ़ान्यूमेरिक (ASCII) स्ट्रिंग लेता है और 18-वर्ण आईडी देता है।

इनपुट सत्यापन इस प्रश्न के दायरे से बाहर है। प्रोग्राम अमान्य इनपुट पर कोई मान या क्रैश लौटा सकते हैं।

कृपया, सेल्सफोर्स के प्रॉपराइटर लैंग्वेज के फीचर्स का इस्तेमाल न करें, जो इस चैलेंज को तुच्छ बनाते हैं (जैसे कि फॉर्मूला CASESAFEID(), APEX और में कनवर्ट Idकरना String)।

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

a01M00000062mPg    -> a01M00000062mPgIAI
001M000000qfPyS    -> 001M000000qfPySIAU
a0FE000000D6r3F    -> a0FE000000D6r3FMAR
0F9E000000092w2    -> 0F9E000000092w2KAA
aaaaaaaaaaaaaaa    -> aaaaaaaaaaaaaaaAAA
AbCdEfGhIjKlMnO    -> AbCdEfGhIjKlMnOVKV
aBcDEfgHIJKLMNO    -> aBcDEfgHIJKLMNO025

code-golf string

— त्रंग ऊल
स्रोत

3

अफसोस की बात है, एपेक्स कोड में एक स्ट्रिंग को एक आईडी में बदलना अभी भी यहां दिए गए कुछ उत्तरों से कम नहीं होगा, खासकर अगर कोड स्वयं-युक्त होना चाहिए। एपेक्स कोड गोल्फिंग के लिए अच्छी तरह से अनुकूल नहीं है।

— फेयरफॉक्स

2

एक पूर्व सेल्सफोर्स देव के रूप में @phyrfox। एपेक्स ज्यादा के लिए अनुकूल नहीं है ...

— माइक मैकमोहन

2

अपेक्स, 56 बाइट्स public class X{public X(Id i){System.debug((String)i);}}:। केवल वैध सेल्सफोर्स आईडी के साथ काम करता है, हालांकि।

— त्रंग ऊल

मैं वास्तव में काम के लिए ऐसा करने के लिए देख रहा था ( सफलता। jitterbit.com/display/DOC/… ) , गोल्फ नहीं, लेकिन मैं एल्गोरिथ्म के विवरण से थोड़ा भ्रमित हूं। आप कहते हैं कि चरण 4 में प्रत्येक उलट और साफ-सुथरा हिस्सा एक "बाइनरी नंबर" होगा, लेकिन आप अंकों को 2-8 और 0 के 1 के साथ कभी नहीं बदलते हैं। वास्तव में मुझे चरण 4 के लिए क्या करना चाहिए जब "62mPg" जैसे एक चंक पर 1-3 कदमों के परिणामस्वरूप "01026" जैसी संख्या होती है?

— k .. 18

6

रूबी, 97 बाइट्स

->s{s+s.scan(/.{5}/).map{|x|[*?A..?Z,*?0..?5][x.reverse.gsub(/./){|y|y=~/[^A-Z]/||1}.to_i 2]}*''}

->s{               # define an anonymous lambda
s+                 # the original string plus...
s.scan(/.{5}/)     # get every group of 5 chars
.map{|x|           # map over each group of 5 chars...
[*?A..?Z,*?0..?5]  # build the array of A-Z0-5
[                  # index over it with...
x.reverse          # the 5-char group, reversed...
.gsub(/./){|y|     # ... with each character replaced with...
y=~/[^A-Z]/||1     # ... whether it's uppercase (0/1)...
}.to_i 2           # ... converted to binary
]                  # (end index)
}*''               # end map, join into a string
}                  # end lambda

यह किसी को वास्तव में स्वच्छ चाल है।

5 वर्णों के समूहों में स्ट्रिंग को विभाजित करने के लिए मेरी मूल प्रवृत्ति थी each_slice:

irb(main):001:0> [*1..20].each_slice(5).to_a
=> [[1, 2, 3, 4, 5], [6, 7, 8, 9, 10], [11, 12, 13, 14, 15], [16, 17, 18, 19, 20]]

एक साधारण रेगेक्स ( x.chars.each_slice(5)बनाम x.scan(/.{5}/)) की तुलना में यह बहुत लंबा है । यह स्पष्ट रूप से स्पष्ट लगता है, लेकिन मैंने वास्तव में इसके बारे में कभी नहीं सोचा था ... शायद मैं अपने पुराने रूबी उत्तरों में से कुछ का यहाँ अनुकूलन कर सकता हूँ।

हालाँकि मुझे इस उत्तर पर सबसे अधिक गर्व है, हालाँकि यह कोड है:

y=~/[^A-Z]/||1

ठीक है, इसलिए यहां गैर-रूबिस्टों के लिए कुछ पृष्ठभूमि है। रूबी पूर्णांक / संख्या () से बूलियन्स ( ) को पूरी तरह से अलग करती है TrueClass, इसका मतलब यह है कि सच से 1 तक कोई स्वचालित रूपांतरण नहीं है और 0 से गलत है। गोल्फ करते समय यह कष्टप्रद होता है (लेकिन अन्य सभी उद्देश्यों के लिए एक अच्छी बात ...)।FalseClassNumeric

एक एकल चरित्र अपरकेस (और 1 या 0 लौट रहा है) की जाँच करने के लिए भोली दृष्टिकोण है

y.upcase==y?1:0

हम इसे थोड़ा और नीचे ला सकते हैं (फिर से, एक रेगेक्स के साथ):

y=~/[A-Z]/?1:0

लेकिन फिर मैं वास्तव में सोचने लगा। हम्म ... =~एक मैच का इंडेक्स लौटाता है (इसलिए, हमारे एकल चरित्र के लिए, हमेशा 0अगर कोई मैच होता है) या nilमैच में असफल होने पर, एक मिथ्या मूल्य ( FalseClassरूबी में सच्चाई को छोड़कर बाकी सब कुछ )। ||अगर यह truthy है, और अपने दूसरे संकार्य अन्यथा ऑपरेटर अपनी पहली संकार्य लेता है। इसलिए, हम इसे नीचे कर सकते हैं

y=~/[^A-Z]/||1

ठीक है, चलो देखते हैं कि यहां क्या हो रहा है। यदि yएक अपरकेस अक्षर है, तो यह मिलान करने में विफल रहेगा [^A-Z], इसलिए रेगेक्स भाग वापस आ जाएगा nil। nil || 1है 1, इसलिए बड़े अक्षर बन जाते हैं 1। यदि yकुछ भी है लेकिन एक बड़े अक्षर के रूप में, रेगेक्स भाग वापस आ जाएगा 0(क्योंकि सूचकांक में एक मैच है 0), और चूंकि 0सत्य है, 0 || 1है 0।

... और यह सब लिखने के बाद ही मुझे एहसास होता है कि यह वास्तव में उसी तरह की लंबाई है y=~/[A-Z]/?1:0। हाहा, ओह वेल।

— Doorknob
स्रोत

6

पायथ, 23 22 बाइट्स

1 बाइट FryAmTheEggman द्वारा सहेजा गया ।

sm@s+JrG1U6i}RJ_d2c3pz

इसे ऑनलाइन आज़माएं। परीक्षण सूट।

यह पहली बार हो सकता है जब मैंने pगोल्फ में रेंट अनुदेश का उपयोग किया हो ।

व्याख्या

     JrG1                   save uppercase alphabet in J
                     z      input string
                    p       print it without newline
                  c3        split into 3 parts
 m              d           for each part:
               _              reverse
            }R                map characters to being in
              J                 uppercase alphabet (saved in J)
           i     2            parse list of bools as binary
  @                           get correct item of
     J                          uppercase alphabet (saved in J)
   s+    U6                     add nums 0-5 to it
s                           concatenate and print

— PurkkaKoodari
स्रोत

4

MATL , 24 बाइट्स

j1Y24Y2hG5IePtk=~!XB1+)h

भाषा / संकलक के वर्तमान संस्करण (9.1.0) का उपयोग करता है ।

उदाहरण

>> matl
 > j1Y24Y2hG5IePtk=~!XB1+)h
 >
> a0RE000000IJmcN
a0RE000000IJmcNMAT

>> matl
 > j1Y24Y2hG5IePtk=~!XB1+)h
 >
> a01M00000062mPg
a01M00000062mPgIAI

व्याख्या

j            % input string
1Y2          % predefined literal: 'ABC...Z'
4Y2          % predefined literal; '012...9'
h            % concatenate into string 'ABC...Z012...9'
G            % push input string
5Ie          % reshape into 5x3 matrix, column-major order
P            % flip vertically
tk=~         % 1 if uppercase, 0 if lowercase
!XB1+        % convert each column to binary number and add 1
)            % index 'ABC...Z012...9' with resulting numbers
h            % concatenate result with original string

— लुइस मेंडो
स्रोत

3

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

x=>x.replace(/[A-Z]/g,(x,i)=>t|=1<<i,t=0)+[0,5,10].map(n=>x+='ABCDEFGHIJKLMNOPQRSTUVWXYZ012345'[t>>n&31])&&x

परीक्षा

f=x=>x.replace(/[A-Z]/g,(x,i)=>t|=1<<i,t=0)+[0,5,10].map(n=>x+='ABCDEFGHIJKLMNOPQRSTUVWXYZ012345'[t>>n&31])&&x

// Less golfed

U=x=>{
  x.replace(/[A-Z]/g,(x,i)=>t|=1<<i,t=0); // build a 15 bit number (no need to explicit reverse)
  // convert 't' to 3 number of 5 bits each, then to the right char A..Z 0..5
  [0,5,10].forEach(n=> // 3 value for shifting
    x += 'ABCDEFGHIJKLMNOPQRSTUVWXYZ012345' // to convert value to char
     [ t>>n&31 ] // shift and mask
  );
  return x
}

console.log=x=>O.innerHTML+=x+'\n';

;[
  ['a01M00000062mPg','a01M00000062mPgIAI']
, ['001M000000qfPyS','001M000000qfPySIAU']
, ['a0FE000000D6r3F','a0FE000000D6r3FMAR']
, ['0F9E000000092w2','0F9E000000092w2KAA']
, ['aaaaaaaaaaaaaaa','aaaaaaaaaaaaaaaAAA']
, ['AbCdEfGhIjKlMnO','AbCdEfGhIjKlMnOVKV']
, ['aBcDEfgHIJKLMNO','aBcDEfgHIJKLMNO025']
].forEach(t=>{
  var i=t[0],x=t[1],r=f(i);
  console.log(i+'->'+r+(r==x?' OK':' Fail (expected '+x+')'));
})

<pre id=O></pre>

स्निपेट का विस्तार करें

— edc65
स्रोत

2

सीजेएम, 27 बाइट्स

l_5/{W%{_el=!}%2bH+43%'0+}%

सभी परीक्षण मामलों को चलाएं।

कल्पना का एक बिल्कुल सीधा कार्यान्वयन। सबसे दिलचस्प हिस्सा चेकसम में पात्रों का रूपांतरण है। हम प्रत्येक चंक के परिणाम में 17 जोड़ते हैं। उस मोडुलो 43 को लें और उस के परिणाम को चरित्र में जोड़ें '0।

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

2

जाप, 46 बाइट्स

U+U®f"[A-Z]" ?1:0} f'.p5)®w n2 +A %36 s36 u} q

लंबाई के साथ बहुत खुश नहीं है, लेकिन मैं इसे नीचे गोल्फ के लिए एक रास्ता नहीं मिल सकता है। इसे ऑनलाइन आज़माएं!

— ETHproductions
स्रोत

2

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

s=>s+s.replace(/./g,c=>c>"9"&c<"a").match(/.{5}/g).map(n=>"ABCDEFGHIJKLMNOPQRSTUVWXYZ012345"[0|"0b"+[...n].reverse().join``]).join``

4 बाइट्स @ @ के लिए धन्यवाद सहेजे गए !

व्याख्या

यह चुनौती जावास्क्रिप्ट के लिए बिल्कुल भी अनुकूल नहीं है। स्ट्रिंग को रिवर्स करने का कोई छोटा तरीका नहीं है और यह नंबर को एक चरित्र में बदलने के लिए सबसे छोटा तरीका है, प्रत्येक संभावित चरित्र को हार्ड-कोड करना है।

s=>
  s+                                   // prepend the original ID
  s.replace(/./g,c=>c>"9"&c<"a")       // convert each upper-case character to 1
  .match(/.{5}/g).map(n=>              // for each group of 5 digits
    "ABCDEFGHIJKLMNOPQRSTUVWXYZ012345"
    [0|"0b"+                            // convert from binary
      [...n].reverse().join``]          // reverse the string
  ).join``

यदि चेकसम में अंकों को निम्न-केस होने दिया जाता है, तो इसे 124 बाइट्स में इस तरह किया जा सकता है:

s=>s+s.replace(/./g,c=>c>"9"&c<"a").match(/.{5}/g).map(n=>((parseInt([...n].reverse().join``,2)+10)%36).toString(36)).join``

परीक्षा

कोड स्निपेट दिखाएं

var solution = s=>s+s.replace(/./g,c=>c>"9"&c<"a").match(/.{5}/g).map(n=>"ABCDEFGHIJKLMNOPQRSTUVWXYZ012345"[0|"0b"+[...n].reverse().join``]).join``

<input type="text" id="input" value="AbCdEfGhIjKlMnO" />
<button onclick="result.textContent=solution(input.value)">Go</button>
<pre id="result"></pre>

स्निपेट का विस्तार करें

— user81655
स्रोत

अगर मैं गलत नहीं हूं, parseInt([...n].reverse().join``,2)तो इसे बदला जा सकता है +`0b${[...n].reverse().join``}`।

— मामा फन रोल

@ Are सही है आप! मैंने उस के ऊपर एक और बाइट भी बचाई, धन्यवाद।

— user81655

उपयोग करके 10 पूरे बाइट्स बचाएं .replace(/.{5}/g,n=>/*stuff*/)।

— नील

2

MATLAB, 100 98 बाइट्स

s=input('');a=flip(reshape(s,5,3))';e=['A':'Z',48:53];disp([s,e(bin2dec(num2str(a~=lower(a)))+1)])

एक स्ट्रिंग इनपुट के रूप में अनुरोध किया जाएगा और आउटपुट स्क्रीन पर प्रदर्शित किया जाएगा।

व्याख्या

मैं शायद यहां सबसे सीधे-अग्रगामी दृष्टिकोण का उपयोग कर रहा हूं:

इनपुट का अनुरोध करें
5 (पंक्तियों) x 3 (स्तंभों) पर रीसेट करें
पंक्ति क्रम को पलटें
मैट्रिक्स को बाइनरी के रूप में पढ़ने के लिए तैयार करने के लिए स्थानांतरित करें
एबीसी आवंटित करें ... XYZ012345 सरणी
ट्रांसपोज़्ड मैट्रिक्स के चरित्र सूचकांकों की तुलना उसके निचले-मामले के समकक्ष करें और बूलियंस को स्ट्रिंग्स में परिवर्तित करें, जिसे तब बाइनरी के रूप में पढ़ा जाता है और दशमलव में परिवर्तित किया जाता है।
आवंटित सरणी के सूचक के रूप में इन दशमलव (1 से बढ़े हुए) की व्याख्या करें।
अतिरिक्त 3 वर्णों के साथ इनपुट प्रदर्शित करें

लुइस मेंडो के लिए अब 100 बाइट्स के नीचे धन्यवाद!

— slvrbld
स्रोत

1

आप थोड़ा सा उपयोग करके बचा सकते हैंe=['A':'Z',48:53]

— लुइस मेंडो

मैं देख रहा हूं कि मेरा दृष्टिकोण लगभग आपकी तरह ही है :-)

— लुइस मेंडो

2

PHP, 186 181 बाइट्स

<?$z=$argv[1];$x=str_split($z,5);$l="ABCDEFGHIJKLMNOPQRSTUVWXYZ012345";foreach($x as$y){foreach(str_split(strrev($y))as$a=>$w)$y[$a]=ctype_upper($w)?1:0;$z.=$l[bindec($y)];}echo $z;

Unglofed

<?php
$z = $argv[1];
$x = str_split($z,5);
$l = "ABCDEFGHIJKLMNOPQRSTUVWXYZ012345";
foreach($x as $y) {
    foreach( str_split( strrev($y) ) as $a => $w) {
        $y[$a] = ctype_upper($w) ? 1 : 0;
    }
    $z .= $l[bindec($y)];
}
echo $z;

मैंने यह सोचना शुरू कर दिया कि मैं इसे इससे बहुत छोटा बना सकता हूं, लेकिन मैं इसे छोटा बनाने के लिए विचारों से बाहर भाग गया।

— Samsquanch
स्रोत

1

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

lambda i:i+''.join(chr(48+(17+sum((2**j)*i[x+j].isupper()for j in range(5)))%43)for x in[0,5,10])

— TFeld
स्रोत

1

पावरशेल, 162 बाइट्स

function f{param($f)-join([char[]](65..90)+(0..5))[[convert]::ToInt32(-join($f|%{+($_-cmatch'[A-Z]')}),2)]}
($a=$args[0])+(f $a[4..0])+(f $a[9..5])+(f $a[14..10])

ठीक है, इस एक में बहुत सारे स्वच्छ सामान हो रहे हैं। मैं दूसरी पंक्ति से शुरू करता हूँ।

हम इनपुट को स्ट्रिंग के रूप में लेते हैं $args[0]और इसे $aबाद में उपयोग के लिए सेट करते हैं । यह इनकैप्सुलेटेड है, ()इसलिए इसे निष्पादित किया गया है और परिणाम (यानी, $a) लौटाया गया है, इसलिए हम तुरंत तीन फ़ंक्शन कॉल के परिणामों के साथ इसे स्ट्रिंग-कॉन्सेटनेट कर सकते हैं (f ...)। प्रत्येक फ़ंक्शन कॉल एक तर्क के रूप में उत्तीर्ण होता है इनपुट इनपुट स्ट्रिंग को एक चार-सरणी के रूप में रिवर्स ऑर्डर चंक्स में अनुक्रमित किया जाता है - उदाहरण के इनपुट के लिए, प्रत्येक प्रविष्टि के साथ एक चार के रूप में $a[4..0]बराबर होगा @('0','E','R','0','a'), न कि एक स्ट्रिंग के रूप में।

अब फ़ंक्शन के लिए, जहां कार्यक्रम का वास्तविक मांस है। हम इनपुट के रूप में लेते हैं $f, लेकिन इसका उपयोग केवल समाप्ति की ओर किया जाता है, इसलिए चलो वहां ध्यान दें, पहले। चूंकि यह एक चार-सरणी (हमारे पिछले अनुक्रमण के लिए धन्यवाद) के रूप में पारित हो गया है, हम तुरंत इसे एक लूप में पाइप कर सकते हैं $f|%{...}। लूप के अंदर, हम प्रत्येक चरित्र को लेते हैं और एक केस-सेंसिटिव रेगेक्स मैच करते हैं, -cmatchजिसके परिणामस्वरूप यदि यह अपरकेस है तो यह सच / गलत होगा। हमने उसे एनकैप्सुलेटिंग के साथ पूर्णांक के रूप में कास्ट किया +(), फिर 1 और 0 के उस ऐरे को -joinएक स्ट्रिंग बनाने के लिए एड किया। यही कारण है कि तब .NET में पहले पैरामीटर के रूप पारित हो जाता है [convert]::ToInt32()कॉल बाइनरी (आधार बदलने के लिए 2दशमलव में)। हम उस परिणामी दशमलव संख्या को एक स्ट्रिंग में अनुक्रमित करने के लिए उपयोग करते हैं (-join(...)[...])। स्ट्रिंग को पहली बार एक रेंज के रूप में तैयार किया (65..90)गया है जो चार-सरणी के रूप में डाली गई है, फिर सीमा (0..5)(यानी, स्ट्रिंग है "ABCDEFGHIJKLMNOPQRSTUVWXYZ012345") के साथ संक्षिप्त किया गया है । वह सब स्ट्रिंग से उपयुक्त चरित्र को वापस करना है।

— AdmBorkBork
स्रोत

1

जोल्फ, 30 बाइट्स

अंत में, एक शायद अभी भी घिनौना! यहाँ कोशिश करो!

+i mZci5d.p1CρA_Hpu1"[^1]'0"2
    Zci5                      split input into groups of 5
  _m                          map it
        d                      with this function
               _H              reverse H
              A  pu1            and replace in it all uppercase letters with 1
             ρ      "[^1]'0"    replace all non-ones with zeroes
            C               2   parse as binary integer
         .p1                    get the (^)th member of "A...Z0...9"

— कोनोर ओ ब्रायन
स्रोत

1

पायथन 3, 201 174 138 बाइट्स

एक फ़ंक्शन घोषणा की ओर इशारा करने के लिए ट्रेंग ओउल को बड़ा धन्यवाद, जिसे अब मौजूद होने की आवश्यकता नहीं थी। और पायथन टर्नरी ऑपरेटर। और कुछ गलत आउटपुट। बस ... बस उसे उत्थान दें।

i=input();n='';c=l=15;
while c:c-=1;n+=('0','1')[i[c].isupper()]
while l:v=int(n[l-5:l],2);l-=5;i+=(chr(v+65),str(v-26))[v>25]
print(i)

— स्टीव एकर्ट
स्रोत

आप z()एक बार फ़ंक्शन का उपयोग करते हैं , आप इसकी कॉल को बदल सकते हैं और 25 बाइट्स बचा सकते हैं। इसके अलावा, आपका कोड इसके [बजाय गलत तरीके से असाइन करता है 0।

— ट्रांग ओउल

खैर, यह मेरी ओर से एक शर्मनाक निरीक्षण था। धन्यवाद।

— स्टीव एकर्ट

1

आप इस निर्माण केif else साथ पहले की जगह और टर्नरी ऑपरेटर के साथ दूसरा भी बचा सकते हैं ।

— तुरंग ऊल

1

जे, 36 बाइट्स

,_5(u:@+22+43*<&26)@#.@|.\]~:tolower

उपयोग:

   (,_5(u:@+22+43*<&26)@#.@|.\]~:tolower) 'a0RE000000IJmcN'
a0RE000000IJmcNMAT

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

— randomra
स्रोत

1

सी, 120 118 बाइट्स

n,j;main(c,v,s)char**v,*s;{for(printf(s=v[1]);*s;s+=5){for(n=0,j=5;j--;)n=n*2+!!isupper(s[j]);putchar(n+65-n/26*17);}}

किसी भी इनपुट के लिए काम करता है जिसकी लंबाई 5 से अधिक है :)

Ungolfed

n,j;

main(c,v,s) char **v, *s;
{
    for(printf(s = v[1]); *s; s+=5)
    {
        for(n=0, j=5; j--;)
            n=n*2+!!isupper(s[j]);

        putchar(n+65-n/26*17);
    }
}

— कोल कैमरून
स्रोत

यदि आप अन्यथा argc का उपयोग नहीं कर रहे हैं, तो कुछ बाइट्स को बचाने के लिए आप वैश्विक नेमस्पेस से n, हटा सकते हैं यदि आप अपने हस्ताक्षर के लिए मुख्य (n, v, s) का उपयोग करते हैं।

— क्लेब्लांक

इसके अलावा 26 * 17 को सादे पुराने 442 से बदल दें, एक और बाइट बचाता है

— क्लेब्लांक

कुछ और संपादन के साथ मुझे आपका संस्करण 110 बाइट्स में मिला। मुझे समझ नहीं आता कि आपके पास क्यों था (isupprer () जब isupper () मेरे लिए ठीक काम करता है। इसके अलावा, मैंने आपके लूप के लिए कुछ अनावश्यक हटा दिया{} j;main(n,v,s)char**v,*s;{for(printf(s=v[1]);*s;s+=5,putchar(n+65-n/442))for(n=0,j=5;j--;n=n*2+isupper(s[j]));}

— क्लेब्लैंक

@cleblanc उत्कृष्ट सुझाव, बहुत बहुत धन्यवाद। ऑपरेशन का क्रम n/26*17अभिव्यक्ति पर बहुत महत्वपूर्ण है इसलिए 442 के साथ प्रतिस्थापित करना एक विकल्प नहीं है। जहाँ तक !!isupper, वह फ़ंक्शन मेरे सिस्टम पर सही के लिए 1 नहीं लौटाता है, यह 256 रिटर्न करता है। !!इसे 0/1 रिटर्न वैल्यू में परिवर्तित करने का एक छोटा तरीका है, इससे कोई फर्क नहीं पड़ता। YMMV।

— कोल कैमरून

1

सी #, 171 बाइट्स

मैं सी # गोल्फिंग में वास्तव में अच्छी तरह से अभ्यास नहीं कर रहा हूं, लेकिन यहां एक शॉट है।

s=>{for(var u=s;u.Length>0;u=u.Substring(5)){int p=0,n=u.Substring(0,5).Select(t=>char.IsUpper(t)?1:0).Sum(i=>(int)(i*Math.Pow(2,p++)));s+=(char)(n+65-n/26*17);}return s;}

— कोल कैमरून
स्रोत

सुझाव: के char.IsUpper(t)साथ प्रतिस्थापित किया जा सकता है t>=65&t<=90( &सी # में बूल पर मूल रूप से &&शॉर्ट-सर्किटिंग के बिना एक गोल्फ-छोटा है )। 447से छोटा है 26*17। आपको एक अलग करने की आवश्यकता नहीं है Select: आप सीधे भीतर टर्नरी को शामिल कर सकते हैं Sum। इसके बजाय, Substringलूप के साथ उन सभी उपयोगों को बदलने पर विचार करें Take, जैसे for(int i=0;i<3;i++)s.Skip(i*5).Take(5)। भविष्य के संदर्भ के लिए, u!=""इससे छोटा होगा u.Length>0(लेकिन यदि आप उपयोग कर रहे हैं तो यह आवश्यक नहीं है Take)।

— बॉब

अभिव्यक्ति के n/26*17बराबर नहीं है n/442, लेकिन इसके अलावा, सुझाव के लिए धन्यवाद। जैसा कि कहा गया है, मैं सी # में गोल्फ खेलने में बहुत अनुभवी नहीं हूं इसलिए भविष्य में इस पर विचार करने के लिए यह सब बहुत अच्छा है।

— कोल कैमरून

आह, क्षमा करें - मैंने इसे गलत समझा।

— बॉब

1

सी # 334

string g(string c){string[]b=new string[]{c.Substring(0,5),c.Substring(5, 5),c.Substring(10)};string o="",w="";for(int i=0,j=0;i<3;i++){char[]t=b[i].ToCharArray();Array.Reverse(t);b[i]=new string(t);o="";for(j=0;j<5;j++){o+=Char.IsUpper(b[i][j])?1:0;}int R=Convert.ToInt32(o,2);char U=R>26?(char)(R+22):(char)(R+65);w+=U;}return c+w;}

यदि अनुरोध किया गया है, तो मैं अपने कोड को वापस पठनीय में बदल दूंगा और इसे पोस्ट करूंगा।

— Yytsi
स्रोत

1

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

lambda s:s+bytes(48+(17+sum((~s[i+j]&32)>>(5-i)for i in range(5)))%43 for j in(0,5,10))

— अलेक्सी तोरामो
स्रोत

सेल्सफोर्स को 15-कैरेक्टर आईडी से 18-कैरेक्टर में कन्वर्ट करें

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

रूबी, 97 बाइट्स

पायथ, 23 22 बाइट्स

व्याख्या

MATL , 24 बाइट्स

उदाहरण

व्याख्या

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

सीजेएम, 27 बाइट्स

जाप, 46 बाइट्स

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

व्याख्या

परीक्षा

MATLAB, 100 98 बाइट्स

व्याख्या

PHP, 186 181 बाइट्स

Unglofed

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

पावरशेल, 162 बाइट्स

जोल्फ, 30 बाइट्स

पायथन 3, 201 174 138 बाइट्स

जे, 36 बाइट्स

सी, 120 118 बाइट्स

Ungolfed

सी #, 171 बाइट्स

सी # 334

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