Viết chương trình chấp nhận một từ viết thường duy nhất làm đầu vào và xuất ra số lượng các cặp chữ cái có cùng số lượng chữ cái giữa chúng trong từ như trong bảng chữ cái.

Ví dụ: trong từ 'tự nhiên', chúng tôi có 4 cặp:

• nr: vì có ba chữ cái giữa chúng trong từ (a, t, u) và ba chữ cái giữa chúng trong bảng chữ cái (o, p, q)
• ae: vì có ba chữ cái giữa chúng bên trong từ (t, u, r) và ba chữ cái giữa chúng trong bảng chữ cái (b, c, d)
• tu: vì không có chữ cái nào giữa chúng trong từ và không có chữ cái nào giữa chúng trong bảng chữ cái
• tr: vì có một chữ cái giữa chúng bên trong từ (u) và một chữ cái giữa chúng trong bảng chữ cái

Vì có bốn cặp, đầu ra trong trường hợp này phải là 4.

Bình thường, 19 byte

lfqF-MSMCT.cCUBCMz2

Dùng thử trực tuyến: Trình diễn

Giải trình:

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}

Bị thoái hóa:

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

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

Hãy thử trực tuyến.

J, 27 byte

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

Sử dụng:

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

Giải trình:

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

Hãy thử trực tuyến tại đây.

CJam, 25 byte

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

Dùng thử trực tuyến

Giải trình:

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)

Sử dụng

f("nature")
=> 4

Giải trình

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 ký tự

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

Dòng này yêu cầu một chuỗi làm đầu vào. Sau đó, nó tạo ra tất cả các cặp chữ cái có thể và thực hiện tương tự cho các chỉ số tương ứng của chúng. Sau đó, chúng tôi xác định xem sự khác biệt (tuyệt đối) của các giá trị có khớp với cuối cùng để tổng hợp tất cả các trường hợp không. Kết quả được hiển thị trong cửa sổ lệnh.

JavaScript ES7, 93

Sử dụng mảng hiểu . ES6 .map.map.mapdài hơn 2 byte.

Kiểm tra chạy đoạn mã dưới đây với 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

Khá đơn giản, nhưng sử dụng một vài thủ thuật.

• param(..)mất đầu vào của chúng tôi, lưu nó vào $a.
• Chúng tôi đặt một biến tạm thời $blà .lengthđầu vào của chúng tôi. Điều này tiết kiệm một byte sau.
• 0..($b-1)|%{..}là tương đương với một for($i=0;$i-le($b-1);$i++){..}vòng lặp, nhưng ngắn hơn khá nhiều.
• Tuy nhiên, chúng ta cần đặt biến $iđể duy trì điều đó ...
• ($_+1)..$b|%{..}forvòng lặp tiếp theo , vì $_chỉ có vị trí cho vòng lặp bên trong.
• Sau đó, chúng tôi sử dụng một cuộc gọi .NET dài để kiểm tra xem giá trị tuyệt đối giữa hai ký tự của chúng tôi (ở đây chúng tôi sử dụng truyền ẩn với việc chuẩn bị +để lưu một bó byte) có -eqphải là sự khác biệt về vị trí trong mảng hay không. Vì chúng tôi rõ ràng được cung cấp đầu vào chữ thường, chúng tôi không cần phải thực hiện chuyển đổi trường hợp. Tuyên bố này sẽ trở lại Truehoặc False.
• Chúng tôi ngang nhiên lạm dụng việc đúc ngầm một lần nữa để tích lũy kết quả đó vào $o, vì vậy Truesẽ thêm 1, trong khi Falsesẽ thêm 0.
• Khi các vòng lặp kết thúc, chúng tôi xuất ra $o. Lưu ý rằng chúng ta cần thực hiện cùng một thủ thuật +để tránh in Falsenếu không có kết quả khớp.

Ruby, 74

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

Không có gì siêu thú vị ở đây. Tôi rất thích sử dụng eval("s[i].#{["succ"]*(j-i)*?.}")nhưng ... dường như quá lâu.

Matlab(94)(80)

Chỉnh sửa: Tôi đã không thực hiện trong trường hợp đảo ngược thứ tự chữ cái, vì (t, r) trong 'tự nhiên', do đó, nhiều byte hơn để tăng cân :(

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

• Hàm nhị thức đưa ra một ngoại lệ ngu ngốc khi k lớn hơn n và tôi không thể bắt ngoại lệ bên trong arraycellhàm, nếu không tôi có thể đánh gôn nhiều hơn. Ai cần một chức năng tích hợp ??

  Bây giờ tôi chỉ có thể làm điều đó bằng tay, đơn giản hóa nhị thức (n, 2) = n / (2 (n-2)!) = N (n-1) / 2. nhận xét rằng giá trị cuối cùng này đại diện cho các số nguyên từ 1 đến n-1, điều này không ném bất kỳ ngoại lệ nào trong matlab, Chúa phù hộ toán học.

• Ps: phương pháp này khác với slvrbld

Chấp hành

  >> ans('abef')

  ans =

       2

  >> ans('abcd')

  ans =

       6

  >> ans('nature')

  ans =

       4