Gelen Salesforce CRM , her nesne harf duyarlı 15 karakterli alfanumerik numarası vardır. Merak eden biri varsa, aslında taban 62 sayısı . Ancak, veri taşıma ve entegrasyon için kullanılan araçlar büyük / küçük harf duyarlılığını destekleyebilir veya desteklemeyebilir. Bunun üstesinden gelmek için kimlikler güvenle 18 karakterlik büyük / küçük harfe duyarlı olmayan alfasayısal kimliklere dönüştürülebilir. Bu işlemde kimliğe 3 karakterlik alfasayısal sağlama toplamı eklenir. Dönüşüm algoritması:

Örnek :

a0RE000000IJmcN

1. Kimliği 5 karakterlik üç parçaya ayırın.

   a0RE0  00000  IJmcN
   

2. Her parçayı ters çevirin.

   0ER0a  00000  NcmJI
   

3. Her öbekteki her bir karakteri 1büyük harfle veya 0başka bir şekilde değiştirir.

   01100  00000  10011
   

4. Her 5 basamaklı ikili sayı için i, ibüyük harfli alfabe ve 0-5 ( ABCDEFGHIJKLMNOPQRSTUVWXYZ012345) arasındaki rakamların birleşimindeki konumunda karakter alın .

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

   Verim:

   M  A  T
   

5. Bu karakterleri, sağlama toplamını, orijinal kimliğe ekleyin.

Çıktı :

a0RE000000IJmcNMAT

15 karakterli alfasayısal (ASCII) dizgiyi girdi olarak alan ve 18 karakterli kimliği döndüren program veya işlev yazın.

Giriş doğrulaması bu sorunun kapsamı dışındadır. Programlar geçersiz girdiye herhangi bir değer döndürebilir veya çökebilir.

(Örneğin formülü olarak bu meydan önemsiz hale Salesforce propretiary dilde özelliklerini kullanmak etmeyin CASESAFEID(), dönüştürme Idiçin StringAPEX & c).

Test Durumları

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

Ruby, 97 bayt

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

Bunun gerçekten düzgün hileleri var.

Dizeyi 5 karakterlik gruplara bölmek için orijinal içgüdüm şuydu 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]]

Bu basit bir normal ifadeye kıyasla çok uzun sürüyor ( x.chars.each_slice(5)vs. x.scan(/.{5}/)). Bu gezide açık gibi görünüyor, ama bunu hiç düşünmemiştim ... belki de bazı eski Ruby cevaplarımı burada optimize edebilirim.

Bu cevapta en çok gurur duyduğum şey bu kod parçası:

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

Pekala, işte Ruby olmayanlar için bir arka plan. Ruby TrueClass, booleans ( , FalseClass) Numericdeğerini tamsayılardan / sayılardan ( ) tamamen ayırır; bu, true'dan 1'e ve false'dan 0'a otomatik dönüşüm olmadığı anlamına gelir. Bu golf sırasında can sıkıcı (ama iyi bir şey ... tüm diğer amaçlar için).

Tek bir karakterin büyük harf olup olmadığını kontrol etmek için naif yaklaşım (ve 1 veya 0 döndürme)

y.upcase==y?1:0

Bunu biraz daha aşağı indirebiliriz (yine, bir regex ile):

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

Ama sonra gerçekten düşünmeye başladım. Hmm ... =~bir maçın dizinini döndürür (yani, tek karakterimiz için, her zaman 0bir eşleşme varsa) veya nileşleşme başarısızlığında, bir falsy değeri ( FalseClassRuby dışındaki diğer her şey doğrudur). ||O truthy, ve ikinci işlenen aksi takdirde operatör ilk işlenen alır. Bu nedenle, bunu

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

Pekala, burada neler olduğuna bakalım. Eğer ybüyük harf olduğunda, bu maç için başarısız olur [^A-Z]regex bölüm dönecektir yüzden nil. nil || 1yani 1, büyük harfler olur 1. Eğer ybir şey ama büyük harf olduğunda, normal ifade bölüm dönecektir 0(indeksinde bir maç var, çünkü 0), ve o zamandan beri 0truthy olduğunu 0 || 1olduğunu 0.

... ve tüm bunları yazdıktan sonra bunun aslında aynı uzunlukta olduğunun farkındayım y=~/[A-Z]/?1:0. Haha, oh güzel.

Pyth, 23 22 bayt

1 bayt FryAmTheEggman tarafından kaydedildi .

sm@s+JrG1U6i}RJ_d2c3pz

Çevrimiçi deneyin. Test odası.

pGolfte rint talimatını ilk kez kullanmış olabilirim .

açıklama

     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 bayt

j1Y24Y2hG5IePtk=~!XB1+)h

Dilin / derleyicinin geçerli sürümünü (9.1.0) kullanır .

Örnekler

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

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

açıklama

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

Ölçek

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 bayt

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

Tüm test senaryolarını çalıştırın.

Spesifikasyonun oldukça basit bir uygulaması. En ilginç kısım, sağlama toplamındaki karakterlere dönüşümdür. Her yığının sonucuna 17 ekliyoruz. Bu modulo 43'ü alın ve bunun sonucunu karaktere ekleyin '0.

Japt, 46 bayt

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

Uzunluğu ile çok mutlu değil, ama onu golf bir yol bulamıyorum. Çevrimiçi deneyin!

JavaScript (ES6), 137 132 bayt

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

@ Thanks sayesinde 4 bayt kurtarıldı !

açıklama

Bu sorun JavaScript için hiç uygun değildir. Bir dizgeyi tersine çevirmenin kısa bir yolu yoktur ve sayıyı bir karaktere dönüştürmenin en kısa yolu, olası her karakteri sabit kodlamaktır.

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``

Sağlama toplamındaki rakamların küçük harf olmasına izin verildiyse, bu 124 baytta yapılabilir:

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``

Ölçek

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 bayt

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

Giriş olarak bir dize istenecek ve çıkış ekranda görüntülenecektir.

açıklama

Muhtemelen burada en basit yaklaşımı kullanıyorum:

• Giriş iste
• 5 (satır) x 3 (sütun) şeklinde yeniden şekillendirme
• Satır sırasını ters çevirin
• İkili olarak okunmak üzere hazırlamak için matrisi çevirin
• ABC ... XYZ012345 dizisini ayırın
• Aktarılan matrisin karakter indekslerini küçük harf eşdeğeriyle karşılaştırın ve boolean'ları dizelere dönüştürün, daha sonra ikili olarak okunur ve ondalığa dönüştürülür.
• Bu ondalık sayıları (1 ile artırılır), ayrılmış dizinin dizinleri olarak yorumlar.
• Girdiyi ek 3 karakterle görüntüleyin

Şimdi Luis Mendo sayesinde 100 baytın altında!

PHP, 186 181 bayt

<?$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;

Bundan daha kısa yapabileceğimi düşünmeye başladım, ama kısaltmak için fikirlerim bitti.

Python 2, 97 bayt

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 bayt

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

Tamam, bunda çok düzgün şeyler oluyor. İkinci satırdan başlayacağım.

Girişi dize olarak alıyoruz $args[0]ve $adaha sonra kullanmak üzere ayarlıyoruz . Bu, içinde ()yürütülür ve sonuç döndürülür (yani, $a), böylece hemen üç işlev çağrısının sonuçlarıyla dizeyi birleştirebiliriz (f ...). Her işlev çağrısı, ters sıralı yığınlar halinde dizine alınan giriş dizesinin bir char-array olarak argüman olarak geçer - yani, örnek girdi için, her girişe dize olarak değil char olarak $a[4..0]eşit @('0','E','R','0','a')olur.

Şimdi programın gerçek etinin olduğu fonksiyona. Girdiyi şu şekilde alıyoruz $f, ama bu yalnızca sonuna doğru kullanıldı, bu yüzden önce oraya odaklanalım. Bir char-array olarak geçtiğinden (önceki dizinlememiz sayesinde), hemen bir döngüye bağlayabiliriz $f|%{...}. Döngünün içinde, her karakteri alırız ve -cmatchbüyük / küçükse doğru / false ile sonuçlanacak büyük / küçük harfe duyarlı bir normal ifade eşleşmesi gerçekleştiririz . Bunu kapsülleme ile bir tamsayı olarak yayınladık +(), daha sonra 1 ve -join0'ların dizisi bir dize oluşturmak üzere düzenlenir. Bu[convert]::ToInt32() ikili (temel 2) ondalık olarak değiştirmek için .NET çağrısında ilk parametre olarak geçirilir . Sonuçta elde edilen ondalık sayıyı bir dizeye dizine eklemek için kullanırız (-join(...)[...]). Dize önce (65..90)char-array olarak dökülen bir aralık olarak formüle edilir , daha sonra aralıkla birleştirilir (0..5)(yani dize "ABCDEFGHIJKLMNOPQRSTUVWXYZ012345"). Tüm bunlar dizeden uygun karakteri döndürmektir.

Jolf, 30 bayt

Sonunda, muhtemelen hala sallanabilir! Burada deneyin!

+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, 201173138 bayt

Trang Oul'a artık var olması gerekmeyen bir işlev bildirgesine işaret ettiği için çok teşekkürler. Ve Python üçlü operatörleri. Ve bazı yanlış çıktılar. Sadece ... ona upvotes verin.

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 bayt

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

Kullanımı:

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

Burada çevrimiçi deneyin.

C 120 118 bayt

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

Uzunluğu 5'in katı olan herhangi bir giriş için çalışır :)

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 bayt

Ben C # golf gerçekten iyi uygulanmış değilim, ama burada bir atış.

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

İstenirse, kodumu okunabilir hale geri döndürür ve gönderirim.

Python 3, 87 bayt

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