ในSalesforce CRMทุกอ็อบเจ็กต์มี ID ตัวอักษรผสมตัวเลข 15 ตัวซึ่งเป็นแบบตัวพิมพ์เล็กและตัวพิมพ์ใหญ่ ถ้าใครอยากรู้อยากเห็นจริง ๆ แล้วมันเป็นเลขฐาน 62จำนวน อย่างไรก็ตามเครื่องมือที่ใช้สำหรับการโยกย้ายข้อมูลและการรวมอาจสนับสนุนหรือไม่ก็ได้ เพื่อที่จะเอาชนะนั้น ID สามารถแปลงได้อย่างปลอดภัยเป็น 18 ตัวอักษรและตัวเลขตัวพิมพ์เล็ก - ใหญ่ ในการตรวจสอบตัวเลขและตัวอักษร 3 กระบวนการนั้นจะถูกผนวกเข้ากับ ID อัลกอริทึมการแปลงคือ:

ตัวอย่าง :

a0RE000000IJmcN

1. แยก ID ออกเป็นสามส่วนห้าตัวอักษร

   a0RE0  00000  IJmcN
   

2. ย้อนกลับแต่ละอัน

   0ER0a  00000  NcmJI
   

3. แทนที่อักขระแต่ละตัวในทุก ๆ อันด้วย1ถ้าเป็นตัวพิมพ์ใหญ่หรือเป็น0อย่างอื่น

   01100  00000  10011
   

4. สำหรับเลขฐานสอง 5 หลักแต่ละiตัวให้รับตัวอักษรที่ตำแหน่งพร้อมการiเรียงตัวอักษรตัวพิมพ์ใหญ่และตัวเลข 0-5 ( ABCDEFGHIJKLMNOPQRSTUVWXYZ012345)

   00000 -> A,
   00001 -> B,
   00010 -> C, ..., 
   11010 -> Z, 
   11011 -> 0, ...,
   11111 -> 5`
   

   ผลผลิต:

   M  A  T
   

5. ต่อท้ายอักขระเหล่านี้คือ checksum ให้กับ ID ดั้งเดิม

ผลผลิต :

a0RE000000IJmcNMAT

เขียนโปรแกรมหรือฟังก์ชั่นซึ่งใช้สตริงตัวอักษรผสมตัวเลข (ASCII) 15 ตัวเป็นอินพุตและส่งคืน ID 18 อักขระ

การตรวจสอบการป้อนข้อมูลอยู่นอกขอบเขตของคำถามนี้ โปรแกรมอาจคืนค่าหรือความผิดพลาดใด ๆ จากอินพุตที่ไม่ถูกต้อง

โปรดอย่าใช้คุณสมบัติของภาษาที่เป็นประโยชน์ของ Salesforce ซึ่งทำให้ความท้าทายนี้เป็นเรื่องเล็กน้อย (เช่นสูตรCASESAFEID()การแปลงIdเป็นStringAPEX & c)

กรณีทดสอบ

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

Ruby, 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]]

ปรากฎว่ามัน waaay นานเกินไปเมื่อเทียบกับ regex ง่าย ( x.chars.each_slice(5)เทียบกับx.scan(/.{5}/)) นี่ดูเหมือนจะเห็นได้ชัดในการเข้าใจถึงปัญหาย้อนหลัง แต่ฉันไม่เคยคิดถึงเรื่องนี้จริง ๆ ... บางทีฉันอาจปรับปรุงคำตอบทับทิมเก่าของฉันที่นี่

สิ่งที่ฉันภูมิใจที่สุดในคำตอบนี้คือรหัสชิ้นนี้:

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

เอาล่ะนี่คือพื้นหลังของผู้ที่ไม่ใช่รูบี้ Ruby แยก booleans ( TrueClass, FalseClass) ออกจากจำนวนเต็ม / จำนวนอย่างสมบูรณ์ (Numeric ) - นั่นหมายความว่าไม่มีการแปลงอัตโนมัติจาก true เป็น 1 และ false เป็น 0 เช่นกัน นี่เป็นเรื่องที่น่ารำคาญขณะเล่นกอล์ฟ (แต่เป็นสิ่งที่ดี ... สำหรับจุดประสงค์อื่นทั้งหมด)

วิธีการไร้เดียงสาเพื่อตรวจสอบว่าอักขระตัวเดียวเป็นตัวพิมพ์ใหญ่ (และส่งคืน 1 หรือ 0)

y.upcase==y?1:0

เราสามารถทำสิ่งนี้ได้อีกเล็กน้อย (อีกครั้งด้วย regex):

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

แต่แล้วฉันก็เริ่มคิด อืม ... =~ส่งคืนดัชนีของการจับคู่ (ดังนั้นสำหรับตัวละครเดียวของเราเสมอ0หากมีการแข่งขัน) หรือnilเมื่อล้มเหลวในการจับคู่ค่าเท็จ (ทุกสิ่งยกเว้นยกเว้นFalseClassเป็นความจริงในทับทิม) ||ผู้ประกอบการจะใช้เวลาดำเนินแรกของถ้ามัน truthy และถูกดำเนินการที่สองเป็นอย่างอื่น ดังนั้นเราสามารถตีกอล์ฟลงไปได้

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

เอาล่ะมาดูสิ่งที่เกิดขึ้นที่นี่ ถ้าyเป็นอักษรตัวพิมพ์ใหญ่ก็จะล้มเหลวเพื่อให้ตรงกับ[^A-Z]ดังนั้นส่วนหนึ่ง regex nilจะกลับ nil || 1คือเพื่อให้กลายเป็นตัวพิมพ์ใหญ่1 1หากyคืออะไร แต่อักษรตัวพิมพ์ใหญ่, ส่วน regex จะกลับมา0(เพราะมีการจับคู่ที่ดัชนี0) และตั้งแต่0เป็น truthy, คือ0 || 10

... และหลังจากเขียนสิ่งทั้งหมดนี้ออกไปฉันก็ตระหนักว่านี่เป็นความยาวเท่าy=~/[A-Z]/?1:0กันจริง ๆ ฮ่าฮ่าโอ

Pyth, 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

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

JavaScript (ES6), 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>

CJam, 27 ไบต์

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

เรียกใช้กรณีทดสอบทั้งหมด

การใช้งานสเปคที่ค่อนข้างตรงไปตรงมา ส่วนที่น่าสนใจที่สุดคือการแปลงอักขระเป็นเช็คซัม เราบวก 17 เข้ากับผลลัพธ์ของแต่ละอัน ใช้เวลาที่โมดูโล 43 '0และเพิ่มผลจากการที่ตัวละคร

Japt, 46 ไบต์

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

ไม่ค่อยมีความสุขกับความยาว แต่ฉันหาทางตีกอล์ฟไม่ได้ ลองออนไลน์!

JavaScript (ES6), 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 ไบต์ด้วย@ ՊՓԼՃՐՊՃՈԲՍԼ !

คำอธิบาย

ความท้าทายนี้ไม่เหมาะสำหรับ JavaScript เลย ไม่มีวิธีสั้น ๆ ในการย้อนกลับสตริงและดูเหมือนว่าวิธีที่สั้นที่สุดในการแปลงตัวเลขเป็นอักขระคือการกำหนดโค้ดที่ยากที่สุดสำหรับอักขระแต่ละตัว

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>

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 (คอลัมน์)
• พลิกลำดับแถว
• แปลงเมทริกซ์เพื่อเตรียมการสำหรับการอ่านในรูปแบบไบนารี
• จัดสรร ABC ... อาร์เรย์ XYZ012345
• เปรียบเทียบดัชนีอักขระของเมทริกซ์ที่ถูกเปลี่ยนเป็นเทียบเท่าตัวพิมพ์เล็กและแปลงบูลีนเป็นสตริงซึ่งจะถูกอ่านเป็นไบนารี่และแปลงเป็นทศนิยม
• ตีความทศนิยมเหล่านี้ (เพิ่มขึ้น 1) เป็นดัชนีของอาร์เรย์ที่จัดสรร
• แสดงอินพุตด้วยอักขระเพิ่มเติม 3 ตัว

ตอนนี้ต่ำกว่า 100 ไบต์ขอบคุณ Luis Mendo!

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;

ฉันเริ่มคิดว่าฉันสามารถทำให้สั้นกว่านี้มาก แต่ฉันหมดความคิดเพื่อทำให้สั้นลง

Python 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])

PowerShell ขนาด 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 ...)ทันที การเรียกใช้ฟังก์ชันแต่ละครั้งผ่านไปเป็นอาร์กิวเมนต์สตริงอินพุตที่ทำดัชนีในกลุ่มคำสั่งย้อนกลับเป็น char-array - ความหมายสำหรับอินพุตตัวอย่าง$a[4..0]จะเท่ากับ@('0','E','R','0','a')กับแต่ละรายการเป็น char ไม่ใช่สตริง

ตอนนี้ถึงฟังก์ชั่นโดยที่เนื้อสัตว์จริงของโปรแกรมอยู่ เราป้อนข้อมูลเป็น$f, แต่มันใช้วิธีไปยังจุดสิ้นสุดเท่านั้น, ดังนั้นเราจะมุ่งเน้นที่นั่นก่อน เนื่องจากมันถูกส่งผ่านเป็น char-array (ขอบคุณการทำดัชนีก่อนหน้านี้) เราจึงสามารถไพพ์มันเข้าไปในลูปด้วย$f|%{...}ได้ทันที ภายในลูปเราใช้อักขระแต่ละตัวและดำเนินการจับคู่ regex แบบตรง-cmatchตามตัวพิมพ์ใหญ่- เล็กซึ่งจะส่งผลให้เป็นจริง / เท็จหากเป็นตัวพิมพ์ใหญ่ / อย่างอื่น เราแคสต์ว่าเป็นจำนวนเต็มที่มีการห่อหุ้ม+()จากนั้นอาร์เรย์ของ 1 และ 0 นั้นจะถูก-joinสร้างเป็นสตริง นั่นถูกส่งผ่านไปแล้วเป็นพารามิเตอร์แรกในสุทธิ[convert]::ToInt32()เรียกร้องให้เปลี่ยนไบนารี (ฐาน2 ) ลงทศนิยม เราใช้เลขทศนิยมที่เป็นผลลัพธ์เพื่อทำดัชนีลงในสตริง (-join(...)[...]) สตริงจะถูกกำหนดเป็นช่วงแรก(65..90)ที่ใช้ในการโยนเป็น char-array จากนั้นก็ต่อเข้ากับช่วง(0..5)(เช่นสตริงคือ"ABCDEFGHIJKLMNOPQRSTUVWXYZ012345") ทั้งหมดนี้คือการส่งคืนอักขระที่เหมาะสมจากสตริง

Jolf 30 ไบต์

ในที่สุดอาจจะยังคง jolfable! ลองที่นี่!

+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"

Python 3, 201 174 138 ไบต์

ขอบคุณมากสำหรับตรังอูลที่ชี้ให้เห็นการประกาศฟังก์ชั่นที่ไม่จำเป็นต้องมีอยู่อีกต่อไป และผู้ประกอบการประกอบไปด้วยหลาม และเอาท์พุทที่ไม่ถูกต้อง เพียงแค่ ... ให้เขา upvotes

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)

J, 36 ไบต์

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

การใช้งาน:

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

ลองออนไลน์ได้ที่นี่

ค, 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);
    }
}

C #, 171 ไบต์

ฉันไม่ชำนาญในการเล่นกอล์ฟ C # จริงๆ แต่นี่เป็นช็อต

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;}

C # 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;}

หากมีการร้องขอฉันจะย้อนกลับรหัสของฉันกลับไปอ่านได้และโพสต์

Python 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))