Tulis program yang menerima satu huruf kecil sebagai input dan menampilkan jumlah pasangan huruf yang memiliki jumlah huruf yang sama di antara mereka dalam kata seperti dalam alfabet.

Misalnya, dalam kata 'alam', kami memiliki 4 pasangan:

• nr: karena ada tiga huruf di antara mereka di dalam kata (a, t, u) dan tiga huruf di antara mereka dalam alfabet (o, p, q)
• ae: karena ada tiga huruf di antara mereka di dalam kata (t, u, r) dan tiga huruf di antara mereka dalam alfabet (b, c, d)
• tu: karena tidak ada huruf di antara mereka di dalam kata dan tidak ada huruf di antara mereka dalam alfabet
• tr: karena ada satu huruf di antara mereka di dalam kata (u) dan satu huruf di antara mereka dalam alfabet

Karena ada empat pasangan, output dalam kasus ini harus 4.

Pyth, 19 byte

lfqF-MSMCT.cCUBCMz2

Cobalah online: Demonstrasi

Penjelasan:

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}

Diturunkan:

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

Oktaf, 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_:+

Cobalah secara Online.

J, 27 byte

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

Pemakaian:

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

Penjelasan:

#-:@-~#\+/@,@:=&(|@-/~)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)

Cobalah online di sini.

CJam, 25 byte

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

Cobalah online

Penjelasan:

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)

Pemakaian

f("nature")
=> 4

Penjelasan

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 karakter

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

Baris ini meminta string sebagai input. Itu kemudian menciptakan semua pasangan surat yang mungkin dan melakukan hal yang sama untuk indeks yang sesuai. Lalu kami menentukan apakah perbedaan (absolut) dari nilai cocok untuk akhirnya menjumlahkan semua kasus di mana itu terjadi. Hasilnya ditampilkan di jendela perintah.

JavaScript ES7, 93

Menggunakan pemahaman array . ES6 dengan .map.map.maplebih lama 2 byte.

Tes menjalankan cuplikan di bawah ini dengan 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 Bytes

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

Cukup mudah, tetapi menggunakan beberapa trik.

• param(..)mengambil input kami, menyimpannya $a.
• Kami menetapkan variabel temp $bmenjadi .lengthinput kami. Ini menghemat satu byte nanti.
• 0..($b-1)|%{..}adalah setara dengan for($i=0;$i-le($b-1);$i++){..}loop, tetapi jauh lebih pendek.
• Namun, kita perlu mengatur variabel $iuntuk menjaga agar ...
• ($_+1)..$b|%{..} selanjutnya forloop , karena $_hanya posisional ke loop dalam.
• Kami kemudian menggunakan panggilan .NET yang panjang untuk memeriksa apakah nilai absolut antara dua karakter kami (di sini kami menggunakan casting implisit dengan prepending +untuk menyimpan banyak byte) -eqsesuai dengan perbedaan posisi dalam array. Karena kami secara eksplisit diberi input huruf kecil, kami tidak perlu melakukan konversi huruf besar-kecil. Pernyataan ini akan mengembalikan salah satu TrueatauFalse .
• Kami secara terang-terangan menyalahgunakan casting implisit lagi untuk mengakumulasikan hasil itu $o, jadi Trueakan menambahkan 1, sementaraFalse akan menambahkan 0.
• Setelah loop selesai, kami output $o. Perhatikan bahwa kita perlu melakukan trik-cor-ke-int yang sama dengan +untuk menghindari pencetakan Falsejika tidak ada kecocokan.

Ruby, 74

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

Tidak ada yang super menarik di sini. Saya ingin sekali menggunakannya eval("s[i].#{["succ"]*(j-i)*?.}")tetapi ... sepertinya terlalu lama.

Matlab(94)(80)

Sunting: Saya tidak mengambil kalau-kalau urutan alfabet terbalik, seperti (t, r) di 'nature', jadi lebih banyak byte ke berat :(

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

• fungsi binomial melempar pengecualian bodoh ketika k lebih besar dari n dan saya tidak bisa menangkap pengecualian di dalam arraycellfungsi, kalau tidak saya bisa golf lebih. Siapa yang butuh fungsi bawaan ??

  Sekarang saya bisa melakukannya dengan tangan, menyederhanakan binomial (n, 2) = n / (2 (n-2)!) = N (n-1) / 2. menyatakan bahwa nilai terakhir ini merepresentasikan jumlah bilangan bulat dari 1 ke n-1, ini tidak membuang pengecualian dalam matlab, Tuhan memberkati matematika.

• Ps: metode ini berbeda dari slvrbld

Eksekusi

  >> ans('abef')

  ans =

       2

  >> ans('abcd')

  ans =

       6

  >> ans('nature')

  ans =

       4