하나의 소문자 단어를 입력으로 받아들이고 알파벳과 같이 단어에서 같은 수의 문자를 가진 문자 쌍의 수를 출력하는 프로그램을 작성하십시오.

예를 들어 '자연'이라는 단어에는 4 쌍이 있습니다.

• nr : 단어 (a, t, u) 내부에 3 개의 문자가 있고 알파벳 (o, p, q)에 3 개의 문자가 있기 때문에
• ae : 단어 (t, u, r) 안에는 세 글자가 있고 알파벳 (b, c, d)에는 세 글자가 있기 때문에
• tu : 단어 안에는 글자가없고 알파벳에는 글자가 없기 때문에
• tr : 단어 (u) 안에 그들 사이에 하나의 문자가 있고 알파벳 (들) 안에 그들 사이에 하나의 문자가 있기 때문에

4 쌍이 있으므로이 경우 출력은 4가되어야합니다.

Pyth, 19 바이트

lfqF-MSMCT.cCUBCMz2

온라인으로 사용해보십시오 : 데모

설명:

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 바이트

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}

디고 프드 :

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

옥타브, 41 바이트

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

CJam, 36 바이트

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

온라인으로 사용해보십시오.

J, 27 바이트

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

용법:

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

설명:

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

여기에서 온라인으로 사용해보십시오.

CJam, 25 바이트

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

온라인으로 사용해보십시오

설명:

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 바이트

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)

용법

f("nature")
=> 4

설명

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
)

파이썬 2, 91 자

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 바이트

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

이 줄은 문자열을 입력으로 요청합니다. 그런 다음 가능한 모든 문자 쌍을 만들고 해당 인덱스에 대해 동일한 작업을 수행합니다. 그런 다음 값의 (절대) 차이가 일치하는지 확인하여 모든 경우를 합산합니다. 결과는 명령 창에 표시됩니다.

자바 스크립트 ES7, 93

배열 이해 사용 . ES6의 .map.map.map길이는 2 바이트입니다.

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, 114100 바이트

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

매우 간단하지만 몇 가지 트릭을 사용합니다.

• param(..)입력을 받아 저장합니다 $a.
• 우리는 입력 변수 $b를 임시 변수 로 설정했습니다 .length. 이것은 바이트를 나중에 저장합니다.
• 0..($b-1)|%{..}for($i=0;$i-le($b-1);$i++){..}루프 와 동일 하지만 훨씬 짧습니다.
• 그러나 우리는 $i계속해서 변수를 설정해야합니다 ...
• ($_+1)..$b|%{..}다음 for루프 $_는 내부 루프에만 위치하므로
• 그런 다음 긴 .NET 호출을 사용하여 두 문자 사이의 절대 값 (여기 +에서 바이트를 절약하기 위해 앞에 암시 적 캐스팅을 사용 )이 -eq배열의 위치 차이 와 일치하는지 확인합니다 . 명시 적으로 소문자 입력이 주어 졌으므로 대소 문자 변환이 필요하지 않습니다. 이 문장은 True또는 을 반환합니다 False.
• 우리는 묵시적 캐스팅을 다시 악용하여 결과를에 누적 $o하므로 True1 False을 추가하고 0을 추가합니다.
• 루프가 완료되면를 출력 $o합니다. 일치하는 것이 없으면 +인쇄를 피하기 위해 동일한 트릭 캐스팅 캐스트를 수행해야합니다 False.

루비, 74

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

여기서 흥미로운 것은 없습니다. 나는 사용하고 eval("s[i].#{["succ"]*(j-i)*?.}")싶었지만 너무 길어 보였다.

MATLAB(94)(80)

편집 : 나는 '자연'에서 (t, r)과 같이 알파벳 순서를 거꾸로하지 않았으므로 더 많은 바이트를 업 웨이트 :(

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

• 이항 함수는 k가 n보다 클 때 바보 같은 예외를 던지고 함수 내에서 예외를 잡을 arraycell수 없습니다. 그렇지 않으면 더 많이 골프를 탈 수 있습니다. 누가 내장 함수가 필요합니까 ??

  이제 이항식 (n, 2) = n / (2 (n-2)!) = n (n-1) / 2를 단순화하여 손으로 할 수 있습니다. 이 마지막 값은 1에서 n-1까지의 정수의 합계를 나타내며, 이것은 matlab에서 예외를 던지지 않습니다.

• 추신 :이 방법은 slvrbld와 다릅니다

실행

  >> ans('abef')

  ans =

       2

  >> ans('abcd')

  ans =

       6

  >> ans('nature')

  ans =

       4