Dadas duas seqüências, uma sequência pai e uma sequência de consulta, respectivamente, sua tarefa é determinar quantas vezes a sequência de consultas ou um anagrama da sequência de consultas ; aparece na sequência pai, em uma pesquisa que diferencia maiúsculas de minúsculas.

Exemplos de comportamento

Entrada 1

AdnBndAndBdaBn
dAn

Saída 1

4

Explicação As substrings estão destacadas em negrito abaixo:

Adn BndAndBdaBn

AdnB ndA ndBdaBn

AdnBn e dBdaBn

AdnBnd And BdaBn

Observe que a pesquisa DEVE fazer distinção entre maiúsculas e minúsculas para todas as pesquisas.

Entrada 2

AbrAcadAbRa
cAda

Saída 2

2

Isso deve funcionar apenas para ASCII padrão. Isso é código-golfe, portanto, o menor número de caracteres receberá o visto de aprovação. Publique também uma versão sem código do seu código junto com a versão com código.

Pitão, 11 10 bytes

lfqSzST.:w

1 byte de golfe graças a @Jakube.

Demonstração.

Leva a string de consulta, seguida pela string pai em uma nova linha.

Ungolfed:

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

CJam, 13 bytes

le!lf{\/,(}:+

(12 bytes, se a sobreposição for permitida)

l$_,lew:$\e=

A entrada é como:

dAn
AdnBndAndBdaBn

ie

<query string>
<parent string>

Agradecimentos a Dennis por salvar 3 bytes no cenário sobreposto

Experimente online aqui

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 é uma função que aceita dois argumentos como este: f(parent,query) .

Ele percorre todas as substrings da string pai do comprimento da string de consulta e as classifica. Se forem iguais à sequência de consulta classificada, ela será incrementada n. A classificação da sequência é irritante porque deve ser convertida em uma matriz, classificada e convertida novamente em uma sequência. Código não testado e testável abaixo.

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

Como funciona: a string pai é p, a string de consulta é s.

tailscria uma lista de seus parâmetros com a remoção sucessiva do primeiro elemento, por exemplo tails "abcd" -> ["abcd","bcd","cd","d",""]. Para cada elemento xdesta lista, faça um 1se os primeiros nelementos classificados (onde nestá o comprimento de s) forem iguais aos classificadoss . Soma os 1s.

Editar: em tailsvez de recursão explícita

Python, 61 bytes

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

Este é um algoritmo recursivo. Ele verifica se os caracteres iniciais da sequência pai, uma vez ordenados, são os mesmos que a sequência de consultas ordenada. Em seguida, recursiva na cadeia pai com seu primeiro caractere removido. Ele termina quando a sequência pai está vazia.

Python 2, 76 70 bytes

Essa função lambda compara iterativamente cada substring classificada com a substring de destino. As correspondências são contadas e retornadas.

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

O código não destruído:

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)

e a saída de teste:

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

Python 2, 124 118 bytes

Experimente aqui

Esta é uma função lambda anônima. Provavelmente ainda pode ser ainda mais jogado.

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

Ungolfed:

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