Harf olarak tek küçük harfli bir sözcük kabul eden ve alfabetik harflerle aynı kelimelerde aynı sayıda harf içeren harf çiftlerinin çıktısını alan bir program yazın.

Örneğin, 'doğa' kelimesinde 4 çiftimiz var:

• nr: çünkü aralarında üç harf (a, t, u) ve aralarında üç harf olduğundan (o, p, q)
• ae: kelimelerin içinde üç harf (t, u, r) ve aralarında üç harf olduğundan (b, c, d)
• tu: çünkü kelimenin içinde aralarında hiçbir harf yoktur ve aralarında harf yoktur.
• tr: Çünkü (u) kelimesi içinde aralarında bir harf ve aralarında alfabede bir harf var.

Dört çift olduğundan, bu durumda çıktı 4 olmalıdır.

Pyth, 19 bayt

lfqF-MSMCT.cCUBCMz2

Çevrimiçi deneyin: Gösteri

Açıklama:

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 bayt

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

Octave, 41 bayt

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

CJam, 36 bayt

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

Çevrimiçi deneyin.

J, 27 bayt

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

Kullanımı:

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

Açıklama:

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

Burada çevrimiçi deneyin.

CJam, 25 bayt

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

Çevrimiçi deneyin

Açıklama:

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 bayt

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)

kullanım

f("nature")
=> 4

açıklama

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 bayt

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

Bu satır girdi olarak bir dize ister. Daha sonra olası tüm harf çiftlerini yaratır ve karşılık gelen endeksleri için aynısını yapar. Daha sonra değerlerin (mutlak) farkının nihayet gerçekleştiği tüm vakaları toplaması için eşleşip eşleşmediğini tespit ederiz. Sonuç, komut penceresinde görüntülenir.

JavaScript ES7, 93

Kullanılması dizi anlama . ES6 ile .map.map.map2 bayt daha uzun.

Aşağıdaki pasajı Firefox ile çalıştırmayı test edin

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 Bayt

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

Oldukça yalındır, ancak birkaç püf noktası kullanır.

• param(..)girdilerimizi alır, kaydeder $a.
• Girdilerimizin $bolduğu bir sıcaklık değişkeni belirledik .length. Bu daha sonra bir bayt kazandırır.
• 0..($b-1)|%{..}bir for($i=0;$i-le($b-1);$i++){..}döngünün eşdeğeri , ancak çok daha kısa.
• Ancak, bunun $idevam etmesini sağlamak için değişken ayarlamamız gerekir ...
• ($_+1)..$b|%{..}sonraki fordöngü, çünkü $_sadece iç döngü için konumsaldır.
• Daha sonra iki karakterimiz arasındaki mutlak değerin (burada bir kaç +bayt tasarruf etmeye hazır olan örtük döküm kullanıyoruz ) -eqdizideki konumsal farkla aynı olup olmadığını kontrol etmek için uzun bir .NET çağrısı kullanırız . Açıkça küçük harf girişi yapıldığından, büyük / küçük harf dönüşümü yapmamıza gerek kalmaz. Bu ifade Trueveya geri dönecektir False.
• İçine Biz pervasızca bu sonuca toplamaya tekrar örtük casting kötüye $oböylece, True1 katacak olurken, False0 ekleyecektir.
• Döngüler bittikten sonra, çıktık $o. Not Eğer eşleşme yoksa +yazdırmayı önlemek için aynı hileli oyuncu kadrosu ile aynı şeyi yapmamız gerektiğini unutmayın False.

Ruby, 74

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

Burada ilginç hiçbir şey yok. Kullanmayı çok isterdim eval("s[i].#{["succ"]*(j-i)*?.}")ama ... çok uzun görünüyordu.

Matlab(94)(80)

Düzenleme: 't' r 'de olduğu gibi (t, r) gibi alfabetik sıraya ters olarak bakmadım, bu yüzden fazla kilo için bayt :(

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

• binom fonksiyonu, k n'den büyük olduğunda aptalca bir istisna atar ve arraycellfonksiyonun içindeki istisnaları yakalayamadım , aksi takdirde daha çok golf oynayabilirim. Kim yerleşik bir işleve ihtiyaç duyar?

  Şimdi el ile yapabilirdim, binom (n, 2) = n / (2 (n-2)!) = N (n-1) / 2'yi basitleştirerek. Bu son değerin 1'den n-1'e kadar olan tamsayıları telafi ettiğini, bunun matematikte herhangi bir istisna yaratmadığına dikkat edin, Tanrı matematiği korusun.

• Ps: Bu yöntem slvrbld'den daha farklı

infaz

  >> ans('abef')

  ans =

       2

  >> ans('abcd')

  ans =

       6

  >> ans('nature')

  ans =

       4