Scrivi un programma che accetta una singola parola minuscola come input e genera il numero di coppie di lettere che hanno lo stesso numero di lettere tra loro nella parola e nell'alfabeto.

Ad esempio, nella parola "natura", abbiamo 4 coppie:

• nr: poiché ci sono tre lettere tra loro all'interno della parola (a, t, u) e tre lettere tra loro nell'alfabeto (o, p, q)
• ae: poiché ci sono tre lettere tra loro all'interno della parola (t, u, r) e tre lettere tra loro nell'alfabeto (b, c, d)
• tu: poiché non ci sono lettere tra loro all'interno della parola e nessuna lettera tra loro nell'alfabeto
• tr: poiché c'è una lettera tra loro all'interno della parola (u) e una lettera tra loro nell'alfabeto (i)

Poiché ci sono quattro coppie, l'output in questo caso dovrebbe essere 4.

Pyth, 19 byte

lfqF-MSMCT.cCUBCMz2

Provalo online: dimostrazione

Spiegazione:

lfqF-MSMCT.cCUBCMz2
                 z   read a string from input
               CM    convert into list of ascii-values
            CUB      create a list of pairs (ascii-value, index in string)
          .c      2  all combinations of length 2
 f                   filter for combinations T, which satisfy:
        CT              transpose T ((ascii1, ascii2), (index1, index2)
      SM                sort each list
    -M                  create the the difference for each
  qF                    check if they are equal
l                    print the number of remaining combinations

R, 110 byte

function(s){w=strsplit(s,"")[[1]]
O=outer
n=nchar(s)
sum(abs(O(r<-match(w,letters),r,"-"))==O(1:n,1:n,"-"))-n}

Degolfed:

F = function(s){
   chars = strsplit(s,"")[[1]]
   num_chars = nchar(s)
   letter_rank = match(chars, letters)
   rank_dist = abs(outer(letter_rank, letter_rank, "-"))
   position_dist = outer(1:num_chars, 1:num_chars, "-")
   return(sum(rank_dist == position_dist) - num_chars)
}

F("nature")
# [1] 4
F("supercalifragilisticexpialidocious")
# [1] 25

Ottava, 41 byte

@(s)nnz(abs(s-s')==(t=1:(u=nnz(s)))-t')-u

CJam, 36 byte

r:A,{)Aew}%1>{{:B,B0=BW=-z)=}%}%e_:+

Provalo online.

J, 27 byte

#-:@-~#\+/@,@:=&(|@-/~)3&u:

Uso:

   (#-:@-~#\+/@,@:=&(|@-/~)3&u:) 'nature'
4

Spiegazione:

#-:@-~#\+/@,@:=&(|@-/~)3&u:
      #\                    lengths of input prefixes (1,2,...,length)
                       3&u: codepoints of input
               &(     )     with the last two do parallel:
                 |@-/~      create difference table with itself and take absolute values
              =             compare the elements of the two difference tables
        +/@,@:              sum the table              
#   -~                      subtract the length of the input (self-similar letters)
 -:@                        half the result (each pair was accounted twice)

Provalo online qui.

CJam, 25 byte

l:T,_2m*{_:-\Tf=:-z=},,\-

Provalo online

Spiegazione:

l     Get input.
:T    Store in variable T for later use.
,     Calculate length.
_     Copy for use at the very end.
2m*   Use Cartesian power to calculate all possible position pairs.
{     Start filter.
  _     Create copy of index pair.
  :-    Calculate difference between indices.
  \     Swap copy of index pair to top.
  T     Get input string stored in variable T.
  f=    Extract the letters for the index pair.
  :-    Calculate difference of the two letters.
  z     Take the absolute value.
  =     Compare index difference and letter difference.
},    End filter.
,\
-     Pairs of identical indices passed the filter. Eliminate them from the
      count by subtracting the length of the input.

JavaScript (ES6), 98 byte

f=w=>(p=0,q="charCodeAt",[...w].map((c,a)=>{for(b=a;w[++b];)p+=Math.abs(w[q](a)-w[q](b))==b-a}),p)

uso

f("nature")
=> 4

Spiegazione

f=w=>(
  p=0,                                 // p = number of pairs
  q="charCodeAt",
  [...w].map((c,a)=>{                  // iterate through each character of input
                                       // a = character A index
    for(b=a;w[++b];)                   // iterate through the remaining input characters
                                       // b = character B index
      p+=                              // add 1 to p if true or 0 if false
        Math.abs(w[q](a)-w[q](b))==b-a // compare absolute difference of character codes
                                       //     to difference of indices
  }),
  p                                    // return p
)

Python 2, 91 caratteri

lambda i:sum(y-x==abs(ord(i[y])-ord(i[x]))for x in range(len(i))for y in range(x+1,len(i)))

MATLAB, 84 byte

s=input('');disp(sum(diff(nchoosek(find(s),2),[],2)==abs(diff(nchoosek(s,2),[],2))))

Questa riga richiede una stringa come input. Crea quindi tutte le possibili coppie di lettere e fa lo stesso per i loro indici corrispondenti. Quindi determiniamo se la differenza (assoluta) dei valori corrisponde per sommare finalmente tutti i casi in cui lo fa. Il risultato viene visualizzato nella finestra di comando.

JavaScript ES7, 93

Usando la comprensione dell'array . ES6 con .map.map.mapè di 2 byte più lungo.

Prova a eseguire lo snippet di seguito con Firefox

f=s=>[for(x of s)x.charCodeAt()].map((a,i,s)=>s.map((b,j)=>t+=j>i&(b>a?b-a:a-b)==j-i),t=0)&&t

document.write('nature'+'\n'+f('nature'))

PowerShell, 114 100 byte

param($a)$b=$a.length;0..($b-1)|%{$i=$_;($_+1)..$b|%{$o+=[math]::Abs(+$a[$_]-$a[$i])-eq($_-$i)}};+$o

Abbastanza diretto, ma usa un paio di trucchi.

• param(..)prende il nostro input, lo salva $a.
• Impostiamo una variabile temp $bin modo che sia il .lengthnostro input. Questo salva un byte dopo.
• 0..($b-1)|%{..}è l'equivalente di un for($i=0;$i-le($b-1);$i++){..}loop, ma molto più breve.
• Tuttavia, abbiamo bisogno di impostare la variabile $iper continuare a andare in ...
• ($_+1)..$b|%{..}il forciclo successivo , poiché $_è solo posizionale al ciclo interno.
• Quindi utilizziamo una lunga chiamata .NET per verificare se il valore assoluto tra i nostri due caratteri (qui utilizziamo il cast implicito con prepending +per salvare un mucchio di byte) è -eqidentico alla differenza di posizione nell'array. Poiché ci viene esplicitamente fornito un input in minuscolo, non è necessario eseguire la conversione del caso. Questa dichiarazione restituirà Trueo False.
• Usiamo palesemente di nuovo il cast implicito per accumulare quel risultato $o, quindi Trueaggiungeremo 1, mentre Falseaggiungeremo 0.
• Una volta terminati i loop, eseguiamo l'output $o. Nota che dobbiamo fare lo stesso tricksy-cast-to-int con +per evitare di stampare Falsese non ci sono corrispondenze.

Ruby, 74

 ->s{[*0...s.size].permutation(2).count{|i,j|(s[i].ord-s[j].ord).abs==j-i}}

Niente di molto interessante qui. Mi sarebbe piaciuto usare eval("s[i].#{["succ"]*(j-i)*?.}")ma ... sembrava troppo lungo.

Matlab(94)(80)

Modifica: non ho preso nel caso in ordine alfabetico inverso, come (t, r) in 'natura', quindi più byte per sovrappeso :(

@(a)sum(arrayfun(@(x)sum(1:nnz(find(a==fix(x/2)+(-1)^x*(1:1:nnz(a))))-1),2:244))

• la funzione binomiale genera una stupida eccezione quando k è più grande di n e non riesco a rilevare eccezioni all'interno arraycell funzione, altrimenti potrei golf di più. Chi ha bisogno di una funzione integrata ??

  Ora potrei farlo a mano, semplificando il binomio (n, 2) = n / (2 (n-2)!) = N (n-1) / 2. osserva che quest'ultimo valore rappresenta la somma di numeri interi da 1 a n-1, ciò non genera alcuna eccezione in MATLAB, che Dio benedica la matematica.

• Ps: questo metodo è diverso da quello di slvrbld

Esecuzione

  >> ans('abef')

  ans =

       2

  >> ans('abcd')

  ans =

       6

  >> ans('nature')

  ans =

       4