À travers l'alphabet

Dans ce défi, vous avez du mal à vous souvenir des lettres de l'alphabet. Pour contourner cela, vous montez et descendez l'alphabet jusqu'à ce que vous arriviez à la lettre.

Parce que vous voulez que votre code soit portable, vous l'écrirez avec des blocs de lettres. Vous avez un nombre limité de blocs de lettres car la plupart d'entre eux ont été volés, vous devez donc vous assurer que votre code est aussi court que possible.

Exemples

Les paires d'entrée / sortie sont séparées par une ligne vierge:

Ac
ABc

Ad
ABcd

fA
fedCBA

adB
abcdcB


Hello, World!
HGfefghijkllmno, WVUTSrqpopqrqponmlkjihgfed!

Défi

Votre objectif est de chaîner les lettres adjacentes avec toutes les lettres intermédiaires de l'alphabet ( A-Za-z) entre elles. Si la capitalisation diffère, la capitalisation doit être transformée au milieu. Si la capitalisation ne peut pas être transformée de manière égale au milieu, elle se décompose après le milieu. Si un caractère n'est pas un caractère alphabétique, aucune transformation ne doit être effectuée.

Gagnant

C'est le code-golf donc le code le plus court en octets gagne!

-10% de bonus: si vos chaînes de code sont des chiffres

Pyth, 40 octets

+sm?-rdZGhd+hdsrVc2jktr.*rdZm!}kGd.:z2ez

Essayez-le en ligne.

Python 2, 303 291 288 282 276 261 253 octets

Il s'agit d'un algorithme complètement différent de celui de Hannes Karppila, et après beaucoup de golf, j'ai réussi à améliorer considérablement la longueur. Je pense que cet algorithme pourrait également permettre l'un des codes les plus courts dans d'autres langues, en particulier les langues avec des boucles do-while et des fonctions de signalisation intégrées. Des suggestions pour de nouvelles améliorations sont les bienvenues. (Quelque chose me dit que toute la boucle intérieure devrait être réécrite comme une compréhension de liste.)

l=map(ord,list(raw_input()));f=q=1
while q:
 q=0;m=~-f/2;c=m
 while abs(c)<len(l)-1:
  u=c+f;d=(l[u]-96)%32-(l[c]-96)%32
  if chr(l[c]).isalpha()*chr(l[u]).isalpha()*(d*d>1):l[:u-m]+=[l[c]+d/abs(d)];u+=f;q=1
  c=u
 f=-f
print "".join(map(chr,l))

JavaScript (ES6), 198 197 194 octets

f=s=>(o="",a=u=0,[...s].map(c=>{j=c.toUpperCase();p=j==c;b=j<"A"|j>"Z"?0:j.charCodeAt();for(i=0,m=a<b?b-a:a-b;a&&b&&++i<m;)o+=String.fromCharCode(i*(a<b||-1)+a+32*!(i>m/2?p:u));a=b;u=p;o+=c}),o)

Usage

f("Hello, World!")
=> "HGfefghijkllmno, WVUTSrqpopqrqponmlkjihgfed!"

Explication

f=s=>(
  o="",                                   // o = output string
  a=                                      // a = previous character code (or 0 if symbol)
    u=0,                                  // u = 1 if previous character was upper-case
  [...s].map(c=>{                         // iterate through each letter of input

    // Get information about the current character
    j=c.toUpperCase();                    // j = current character in upper-case
    p=j==c;                               // p = current character is upper-case
    b=j<"A"|j>"Z"?0:j.charCodeAt();       // b = current character code (or 0 if symbol)

    // Interpolate characters (unless A or B is a symbol)
    for(i=0,m=a<b?b-a:a-b;a&&b&&++i<m;)   // loop for each character between A and B
      o+=String.fromCharCode(             // add interpolated character to output
        i*(a<b||-1)+a+                    // interpolate character code
          32*!(i>m/2?p:u)                 // apply case of the nearest character
      );

    // Set character A values to B for the next character
    a=b;
    u=p;
    o+=c                                  // add B itself to the output

  }),
  o                                       // return the output
)

JavaScript ES6, 168 (186-10%) 176 193

Modifier modifié pour obtenir le bonus de 10%

Testez l'exécution de l'extrait ci-dessous à l'aide d'un navigateur compatible EcmaScript 6 (j'utilise FireFox)

f=s=>[...s].map(c=>{a=parseInt(c,36),m=(a-q)/(d=a>q?1:-1);for(n=1;m&&(a>9)==(q>9)&&(q+=d)!=a;n+=2)r=q.toString(36),o+=n<m&p<'a'|n>=m&c<'a'?r.toUpperCase():r;p=c,q=a,o+=c},o='',p=q=-f)&&o

// Explained
U=s=>(
  o = '', // initialize output
  p = '', // provious char, initialize to none
  q = NaN, // previous char code, initialize to none
  [...s].map( c => { // for each char 
    a = parseInt(c,36), // convert digit/letter to numeric code, case invariant, NaN if invalid
    d = a > q ? 1 : -1, // sign of difference (if not equal)
    m = (a - q) / d; // absolute value of difference or NaN 
    if (m && (a>9)==(q>9)) // if current and prev are different and both alpha or both digits  
      for( n = 1; 
          (q += d) != a; // loop from prev char (not included) to current (not included)
           n += 2)
        r=q.toString(36),
        // add intermediate char to output
        // upcase if: left side & prev is upcase or right side and current is upcase
        o+= n<m&p<'a'|n>=m&c<'a'?r.toUpperCase():r;
    p = c, // copy current to previous
    q = a, // copy current to previous
    o += c // add current char to ouput
  }),
  o
)  

// test
console.log=(...x)=>O.innerHTML+=x+'\n'

;['Ac','Ad','fA','adB','04aQ27','Hello World!'].
forEach(x=>console.log(x + ' -> ' + f(x)))

<pre id=O></pre>

Python 2, 349 octets

C'est beaucoup trop long, mais au moins c'est le premier.

f=lambda p:ord(p.lower())
u=lambda p:"".join(p).upper()
s=raw_input()
w=s[0]
r=w
for q in s[1:]:
 o=q+w
 if q==w:o=""
 if o.isalpha():
  m=(f(w)<f(q))*2-1
  e=map(chr,range(f(w)+m,f(q)+m,m))
  if o==u(o):e=u(e)
  elif q==u(q):e[len(e)/2:]=u(e[len(e)/2:])
  elif -o.islower()+1:e[:len(e)/2]=u(e[:len(e)/2])
  r+="".join(e)
 else:
  r+=q
 w=q
print r