Schreiben Sie ein Programm, das ein einzelnes Wort in Kleinbuchstaben als Eingabe akzeptiert und die Anzahl der Buchstabenpaare ausgibt, zwischen denen sich im Wort die gleiche Anzahl von Buchstaben befindet wie im Alphabet.

Zum Beispiel haben wir im Wort 'Natur' 4 Paare:

• nr: da drei Buchstaben im Wort (a, t, u) und drei Buchstaben im Alphabet (o, p, q) dazwischen stehen
• ae: da drei Buchstaben im Wort (t, u, r) und drei Buchstaben im Alphabet (b, c, d) dazwischen stehen
• tu: da im wort keine buchstaben dazwischen und im alphabet keine buchstaben dazwischen sind
• tr: da es einen Buchstaben zwischen ihnen im Wort (u) und einen Buchstaben zwischen ihnen im Alphabet (s) gibt

Da es vier Paare gibt, sollte der Ausgang in diesem Fall 4 sein.

Pyth, 19 Bytes

lfqF-MSMCT.cCUBCMz2

Probieren Sie es online aus: Demonstration

Erläuterung:

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 Bytes

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}

Entgolfet:

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

Oktave, 41 Bytes

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

CJam, 36 Bytes

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

Probieren Sie es online.

J, 27 Bytes

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

Verwendung:

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

Erläuterung:

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

Probieren Sie es hier online aus.

CJam, 25 Bytes

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

Probieren Sie es online aus

Erläuterung:

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)

Verwendung

f("nature")
=> 4

Erläuterung

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 Zeichen

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 Bytes

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

Diese Zeile fordert eine Zeichenfolge als Eingabe an. Anschließend werden alle möglichen Buchstabenpaare erstellt und für die entsprechenden Indizes die gleichen Schritte ausgeführt. Dann bestimmen wir, ob die (absolute) Differenz der Werte übereinstimmt, um schließlich alle Fälle zu summieren, in denen dies der Fall ist. Das Ergebnis wird im Befehlsfenster angezeigt.

JavaScript ES7, 93

Mit Array Verständnis . ES6 mit.map.map.map ist 2 Byte länger.

Testen Sie das folgende Snippet mit 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

Ziemlich unkompliziert, benutzt aber ein paar Tricks.

• param(..) Nimmt unsere Eingabe, speichert es auf $a .
• Wir setzen eine temporäre Variable $bals .lengthEingabe. Dadurch wird ein Byte später gespeichert.
• 0..($b-1)|%{..} ist das Äquivalent von a for($i=0;$i-le($b-1);$i++){..} Schleife, aber viel kürzer.
• Wir müssen jedoch eine Variable $isetzen, damit das so bleibt ...
• ($_+1)..$b|%{..}die nächste forSchleife seit$_ nur positionell zur inneren Schleife.
• Wir verwenden dann einen längeren .NET-Aufruf, um zu überprüfen, ob der absolute Wert zwischen unseren beiden Zeichen (hier verwenden wir implizites Casting mit vorangestelltem Zeichen +, um eine Reihe von Bytes zu speichern) -eqdem Positionsunterschied im Array entspricht. Da explizit Kleinbuchstaben eingegeben werden, ist keine Konvertierung der Groß- und Kleinschreibung erforderlich. Diese Anweisung gibt entweder Trueoder zurück False.
• Wir missbrauchen offen implizites Casting erneut, um dieses Ergebnis zu akkumulieren $o, also Trueaddieren wir 1, während wir False0 addieren.
• Sobald die Schleifen beendet sind, geben wir aus $o. Beachten Sie, dass wir das gleiche trickreiche Cast-to-Int ausführen müssen, um +zu vermeiden, dass gedruckt wird, Falsewenn keine Übereinstimmungen vorhanden sind.

Rubin, 74

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

Nichts super interessantes hier. Am liebsten hätte ich verwendet, eval("s[i].#{["succ"]*(j-i)*?.}")aber ... schien zu lang.

Matlab(94)(80)

Bearbeiten: Ich habe nicht in umgekehrter alphabetischer Reihenfolge, wie (t, r) in "Natur", so mehr Bytes zu upweight genommen :(

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

• Die Binomialfunktion löst eine dumme Ausnahme aus, wenn k größer als n ist und ich Ausnahmen in der arraycellFunktion nicht fangen kann, da ich sonst mehr Golf spielen könnte. Wer braucht eine eingebaute Funktion?

  Jetzt könnte ich es einfach von Hand tun und das Binom (n, 2) = n / (2 (n-2)!) = N (n-1) / 2 vereinfachen. Beachten Sie, dass dieser letzte Wert die Summe der ganzen Zahlen von 1 bis n-1 darstellt. Dies macht in Matlab keine Ausnahme. Gott segne Mathe.

• Ps: Diese Methode ist anders als die von slvrbld

Ausführung

  >> ans('abef')

  ans =

       2

  >> ans('abcd')

  ans =

       6

  >> ans('nature')

  ans =

       4