int patterncalculated(char *pattern, extmanager MyManager, int loc) {
int i;
if (pattern == NULL) return 0;
for (i = loc - 1; i > -1; i--)
if (patternmatch(pattern, MyManager.varmap.vars[i])) return 1;
return 0;
}
int main()
{
int i,j,k,n,tc;
scanf("%d",&tc);
/*char *p="na";
char *t="banananobano";*/
while(tc--)
{
scanf("%d %d",&n,&k);
t[0]='\0';
for(i=1;i<=n;i++)
{
itoa(i,temp,10);
strcat(t,temp);
temp[0]='\0';
}
itoa(k,p,10);
//puts(t);
//puts(p);
patternmatch(p,t);
}
// pref=(malloc(strlen(p)*sizeof(int)));
//prefix(p);
/*for(i=1;i<=strlen(p);i++)
{
printf("%d\n",pref[i]);
}*/
return 0;
}
void
finish(const struct teelib* tlibs, const char* ptrn)
{
for(size_t i=0; i < MAX_FREEPROCS && tlibs[i].pattern; ++i) {
const struct teelib* tl = &tlibs[i];
if(patternmatch(tl, ptrn) && tl->finish) {
tl->finish(ptrn);
}
}
}
void
stream(const struct teelib* tlibs, const char* ptrn, const void* buf,
const size_t n)
{
for(size_t i=0; i < MAX_FREEPROCS && tlibs[i].pattern; ++i) {
if(patternmatch(&tlibs[i], ptrn)) {
tlibs[i].transfer(ptrn, buf, n);
}
}
}
bool
matches(const struct teelib* tlibs, const char* ptrn)
{
for(size_t i=0; i < MAX_FREEPROCS && tlibs[i].pattern; ++i) {
if(patternmatch(&tlibs[i], ptrn)) {
return true;
}
}
return false;
}
void
file(const struct teelib* tlibs, const char* ptrn)
{
for(size_t i=0; i < MAX_FREEPROCS && tlibs[i].pattern; ++i) {
if(patternmatch(&tlibs[i], ptrn) && tlibs[i].file) {
/* since our file *is* the pattern to match against, it's also the file
* we want to give to the 'file' function. */
tlibs[i].file(ptrn);
}
}
}
gradientpair CalcGradient(extmanager MyManager, DdNode *Current, int TargetVar,
char *TargetPattern) {
DdNode *h, *l;
hisnode *Found;
char *curnode;
gradientpair lvalue, hvalue, tvalue;
double this_probability;
double *gradient;
if (params.debug) {
curnode = GetNodeVarNameDisp(MyManager.manager, MyManager.varmap, Current);
fprintf(stderr, "%s\n", curnode);
}
if (Current == MyManager.t) {
tvalue.probability = 1.0;
tvalue.gradient = 0.0;
return tvalue;
}
if (Current == MyManager.f) {
tvalue.probability = 0.0;
tvalue.gradient = 0.0;
return tvalue;
}
if ((Found = GetNode(MyManager.his, MyManager.varmap.varstart, Current)) !=
NULL) {
tvalue.probability = Found->dvalue;
tvalue.gradient = *((double *)Found->dynvalue);
return tvalue;
}
l = LowNodeOf(MyManager.manager, Current);
h = HighNodeOf(MyManager.manager, Current);
if (params.debug)
fprintf(stderr, "l(%s)->", curnode);
lvalue = CalcGradient(MyManager, l, TargetVar, TargetPattern);
if (params.debug)
fprintf(stderr, "h(%s)->", curnode);
hvalue = CalcGradient(MyManager, h, TargetVar, TargetPattern);
this_probability = sigmoid(
MyManager.varmap.dvalue[GetIndex(Current) - MyManager.varmap.varstart],
params.sigmoid_slope);
tvalue.probability = this_probability * hvalue.probability +
(1 - this_probability) * lvalue.probability;
tvalue.gradient = this_probability * hvalue.gradient +
(1 - this_probability) * lvalue.gradient;
if ((GetIndex(Current) == TargetVar) ||
((TargetPattern != NULL) &&
patternmatch(TargetPattern, MyManager.varmap.vars[GetIndex(Current)]))) {
tvalue.gradient += hvalue.probability - lvalue.probability;
}
gradient = (double *)malloc(sizeof(double));
*gradient = tvalue.gradient;
AddNode(MyManager.his, MyManager.varmap.varstart, Current, tvalue.probability,
0, gradient);
return tvalue;
}
void
metadata(const struct teelib* tlibs, const char* ptrn, const size_t dims[3],
enum FPDataType type)
{
for(size_t i=0; i < MAX_FREEPROCS && tlibs[i].pattern; ++i) {
if(patternmatch(&tlibs[i], ptrn)) {
if(tlibs[i].metadata) {
tlibs[i].metadata(ptrn, dims, type);
}
}
}
}
static int
match(char *pat, char *string)
{
return patternmatch(pat, dashcount(pat), string, dashcount(string));
}
static int
patternmatch(char *pat, int patdashes, char *string, int stringdashes)
{
int c, t;
if (stringdashes < patdashes)
return 0;
for (;;) {
switch (c = *pat++) {
case '*':
if (!(c = *pat++))
return 1;
if (c == '-') {
patdashes--;
for (;;) {
while ((t = *string++) != '-')
if (!t)
return 0;
stringdashes--;
if (patternmatch(pat, patdashes, string, stringdashes))
return 1;
if (stringdashes == patdashes)
return 0;
}
} else {
for (;;) {
while ((t = *string++) != c) {
if (!t)
return 0;
if (t == '-') {
if (stringdashes-- < patdashes)
return 0;
}
}
if (patternmatch(pat, patdashes, string, stringdashes))
return 1;
}
}
break;
case '?':
if (*string++ == '-')
stringdashes--;
break;
case '\0':
return (*string == '\0');
case '-':
if (*string++ == '-') {
patdashes--;
stringdashes--;
break;
}
return 0;
default:
if (c == *string++)
break;
return 0;
}
}
}
