Attraverso l'alfabeto

In questa sfida, hai difficoltà a ricordare le lettere dell'alfabeto. Per aggirare questo, vai su e giù nell'alfabeto, fino ad arrivare alla lettera.

Poiché vuoi che il tuo codice sia portatile, lo scriverai con blocchi di lettere. Hai un numero limitato di blocchi di lettere perché molti di loro sono stati rubati, quindi devi assicurarti che il tuo codice sia il più corto possibile.

Esempi

Le coppie di input / output sono separate da una riga vuota:

Ac
ABc

Ad
ABcd

fA
fedCBA

adB
abcdcB


Hello, World!
HGfefghijkllmno, WVUTSrqpopqrqponmlkjihgfed!

Sfida

Il tuo obiettivo è quello di concatenare le lettere adiacenti con tutte le lettere intermedie dell'alfabeto ( A-Za-z) tra di loro. Se la capitalizzazione differisce, la capitalizzazione dovrebbe essere trasformata nel mezzo. Se la capitalizzazione non può essere uniformemente trasformata nel mezzo, si spezza dopo il centro. Se un personaggio non è un carattere alfabetico, non è necessario eseguire alcuna trasformazione.

vincente

Questo è code-golf quindi vince il codice più breve in byte!

-10% di bonus: se il tuo codice digita le cifre

Pyth, 40 byte

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

Provalo online.

Python 2, 303 291 288 282 276 261 253 byte

Questo è un algoritmo completamente diverso da quello di Hannes Karppila, e dopo un sacco di golf, sono riuscito a migliorare sostanzialmente la lunghezza. Penso che questo algoritmo potrebbe consentire anche uno dei codici più brevi in ​​altre lingue, in particolare le lingue con loop do-while e funzioni signum integrate. Suggerimenti per ulteriori miglioramenti sono benvenuti. (Qualcosa mi dice che l'intero ciclo interno dovrebbe essere riscritto come una comprensione della lista.)

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 byte

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)

uso

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

Spiegazione

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

Modifica Modificata per ottenere il bonus del 10%

Prova a eseguire lo snippet di seguito utilizzando un browser compatibile con EcmaScript 6 (utilizzo 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 byte

È troppo lungo, ma almeno è il primo.

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