Dadas dos cadenas, una cadena principal y una cadena de consulta, respectivamente, su tarea es determinar cuántas veces la cadena de consulta o un anagrama de la cadena de consulta ; aparece en la cadena principal, en una búsqueda que distingue entre mayúsculas y minúsculas.

Ejemplos de comportamiento

Entrada 1

AdnBndAndBdaBn
dAn

Salida 1

4

Explicación Las subcadenas se resaltan en negrita a continuación:

Adn BndAndBdaBn

AdnB ndA ndBdaBn

AdnBn dAn dBdaBn

AdnBnd y BdaBn

Tenga en cuenta que la búsqueda DEBE ser sensible a mayúsculas y minúsculas para todas las búsquedas.

Entrada 2

AbrAcadAbRa
cAda

Salida 2

2

Esto debe funcionar solo para ASCII estándar. Este es el código de golf, por lo que el menor número de caracteres obtendrá la aprobación. También publique una versión de su código que no sea de golf junto con la versión de golf.

Pyth, 11 10 bytes

lfqSzST.:w

1 byte de golf gracias a @Jakube.

Demostración.

Toma la cadena de consulta, seguida de la cadena principal en una nueva línea.

Sin golf:

z = input()
len(filter(lambda T: sorted(z) == sorted(T), substrings(input())

CJam, 13 bytes

le!lf{\/,(}:+

(12 bytes, si se permite la superposición)

l$_,lew:$\e=

La entrada es como:

dAn
AdnBndAndBdaBn

es decir

<query string>
<parent string>

Gracias a Dennis por guardar 3 bytes en el escenario superpuesto

Pruébalo en línea aquí

JavaScript ES6, 95 bytes

f=(p,q,n=0,s=a=>[...a].sort().join(''))=>[...p].map((_,i)=>n+=s(p.substr(i,q.length))==s(q))&&n

Esta es una función que toma dos argumentos como este: f(parent,query).

Atraviesa todas las subcadenas de la cadena principal de la longitud de la cadena de consulta y las ordena. Si son iguales a la cadena de consulta ordenada, se incrementa n. La cadena de clasificación es molesta porque debe convertirse en una matriz, ordenarse y volverse a convertir en una cadena. Código sin golf y comprobable a continuación.

var f = function(p, q) {
  var n = 0
  var s = function(a) {
    return a.split('').sort().join('')
  }
  
  p.split('').map(function(_, i) {
    n += s(p.substr(i, q.length)) == s(q)
  })
  return n
}

// testing code below
document.getElementById('go').onclick = function() {
  var parent = document.getElementById('parent').value,
    query = document.getElementById('query').value;
  document.getElementById('output').innerHTML = f(parent, query);
}

<label>Parent: <input id="parent" value="AdnBndAndBdaBn"/></label><br />
<label>Query:  <input id="query" value="dAn"/></label><br />
<button id="go">Go</button><br />
<samp id="output">&mdash;</samp> anagrams found

Haskell, 77 68 bytes

import Data.List
p#s=sum[1|x<-tails p,sort s==sort(take(length s)x)]

Uso:

*Main> "AdnBndAndBdaBn" # "dAn"
4
*Main> "AbrAcadAbRa" # "cAda"
2
*Main> "abacacaba"# "aac"
2

Cómo funciona: la cadena principal es p, la cadena de consulta es s.

tailscrea una lista de sus parámetros con la eliminación sucesiva del primer elemento, por ejemplo tails "abcd" -> ["abcd","bcd","cd","d",""]. Para cada elemento xde esta lista, tome un 1si los primeros nelementos ordenados (donde nes la longitud de s) son iguales a los ordenados s. Suma el 1s.

Editar: en tailslugar de recurrencia explícita

Python, 61 bytes

s=sorted
f=lambda a,b:a>''and(s(b)==s(a[:len(b)]))+f(a[1:],b)

Este es un algoritmo recursivo. Comprueba si los caracteres iniciales de la cadena principal, una vez ordenados, son los mismos que los de la cadena de consulta, ordenados. Luego, es recursivo en la cadena principal con su primer carácter eliminado. Termina cuando la cadena principal está vacía.

Python 2, 76 70 bytes

Esta función lambda compara iterativamente cada subcadena ordenada con la subcadena de destino. Los partidos se cuentan y se devuelven.

lambda a,d:sum(sorted(d[n:n+len(a)])==sorted(a)for n in range(len(d)))

El código sin golf:

f = lambda substr, text: sum(
    sorted(text[n:n+len(substr)]) == sorted(substr)
    for n in range(len(text))
    )

def test(tests):
    for t in tests.split():
        substr, text  = t.split(',')
        print t, f(substr, text)

tests = '''ba,abcba dAn,AdnBndAndBdaBn aac,abacacaba'''
test(tests)

y la salida de prueba:

ba,abcba 2
dAn,AdnBndAndBdaBn 4
aac,abacacaba 2

Python 2, 124 118 bytes

Pruébalo aquí

Esta es una función lambda anónima. Probablemente todavía se pueda jugar más al golf.

import re,itertools as i
lambda p,q:sum(len(re.findall('(?='+''.join(i)+')',p))for i in set(i.permutations(q,len(q))))

Sin golf:

from itertools import*
import re
def f(p,q):
    c=0
    for i in set(permutations(q,len(q))):
        c+=len(re.findall('(?='+''.join(i)+')',p))
    print c