int istrunc(int d, char *n) { int i; if (!is_prime(mknum(d, n))) return 0; for (i = 1; i < d; i++) if (!is_prime(mknum(d-i, n)) || !is_prime(mknum(d-i, n+i))) return 0; return 1; }
int main(int argc, char **argv) { int n = 0, m = 0, s = 0; int i, j, aa, a, b, c; char first[] = {2, 3, 5, 7}; char last[] = {3, 7}; char middle[] = {1, 3, 7, 9}; char num[10] = {0}; while (n < 11) { for (aa = 1, i = 0; i < m; i++) aa *= sizeof(middle); for (a = 0; a < aa; a++) { for (i = 0, j = a; i < m; i++, j /= sizeof(middle)) num[i+1] = middle[j % sizeof(middle)]; for (b = 0; b < sizeof(first); b++) { num[m+1] = first[b]; for (c = 0; c < sizeof(last); c++) { num[0] = last[c]; if (istrunc(m+2, num)) { n++; s += mknum(m+2, num); } } } } m++; } printf("%d\n", s); return 0; }
static cstring_t printf_doformat(cstring_t start, int32_t* rval) { static const char skip1[] = "#'-+ 0"; static const char skip2[] = "0123456789"; cstring_t fmt; int32_t fieldwidth; int32_t haveprec, havewidth; int32_t mod_ldbl, precision; char32_t convch; char32_t nextch; fmt = start + 1; /* skip to field width */ fmt += strspn(fmt, skip1); if (*fmt == '*') { if (getint(&fieldwidth)) return (NULL); havewidth = 1; ++fmt; } else { havewidth = 0; /* skip to possible '.', get following precision */ fmt += strspn(fmt, skip2); } if (*fmt == '.') { /* precision present? */ ++fmt; if (*fmt == '*') { if (getint(&precision)) return (NULL); haveprec = 1; ++fmt; } else { haveprec = 0; /* skip to conversion char */ fmt += strspn(fmt, skip2); } } else haveprec = 0; if (!*fmt) { warnx("missing format character"); return (NULL); } /* * Look for a length modifier. POSIX doesn't have these, so * we only support them for floating-point conversions, which * are extensions. This is useful because the L modifier can * be used to gain extra range and precision, while omitting * it is more likely to produce consistent results on different * architectures. This is not so important for integers * because overflow is the only bad thing that can happen to * them, but consider the command printf %a 1.1 */ if (*fmt == 'L') { mod_ldbl = 1; fmt++; if (!strchr("aAeEfFgG", *fmt)) { warnx("bad modifier L for %%%c", *fmt); return (NULL); } } else { mod_ldbl = 0; } convch = *fmt; nextch = *++fmt; *fmt = '\0'; switch (convch) { case 'b': { size_t len; cstring_t p; int32_t getout; p = strdup(getstr()); if (p == NULL) { warnx("%s", strerror(ENOMEM)); return (NULL); } getout = escape(p, 0, &len); *(fmt - 1) = 's'; PF(start, p, havewidth, haveprec, fieldwidth, precision); *(fmt - 1) = 'b'; free(p); if (getout) return (fmt); break; } case 'c': { // create a nullterminated char32_t character uint64_t ch; ch = getchr(); PF(start, (cstring_t)&ch, havewidth, haveprec, fieldwidth, precision); break; } case 's': { const_cstring_t p; p = getstr(); PF(start, (cstring_t)p, havewidth, haveprec, fieldwidth, precision); break; } case 'd': case 'i': case 'o': case 'u': case 'x': case 'X': { cstring_t f; intmax_t val; uintmax_t uval; int32_t signedconv; signedconv = (convch == 'd' || convch == 'i'); if ((f = mknum(start, convch)) == NULL) return (NULL); if (getnum(&val, &uval, signedconv)) *rval = 1; if (signedconv) PF(f, val, havewidth, haveprec, fieldwidth, precision); else PF(f, uval, havewidth, haveprec, fieldwidth, precision); break; } case 'e': case 'E': case 'f': case 'F': case 'g': case 'G': case 'a': case 'A': { long double p; if (getfloating(&p, mod_ldbl)) *rval = 1; if (mod_ldbl) PF(start, p, havewidth, haveprec, fieldwidth, precision); else PF(start, (double)p, havewidth, haveprec, fieldwidth, precision); break; } default: warnx("illegal format character %c", convch); return (NULL); } *fmt = nextch; return (fmt); }
static char * printf_doformat(char *fmt, int *rval) { static const char skip1[] = "#'-+ 0"; int fieldwidth, haveprec, havewidth, mod_ldbl, precision; char convch, nextch; char start[strlen(fmt) + 1]; char **fargv; char *dptr; int l; dptr = start; *dptr++ = '%'; *dptr = 0; fmt++; /* look for "n$" field index specifier */ l = strspn(fmt, digits); if ((l > 0) && (fmt[l] == '$')) { int idx = atoi(fmt); if (idx <= myargc) { gargv = &myargv[idx - 1]; } else { gargv = &myargv[myargc]; } if (gargv > maxargv) maxargv = gargv; fmt += l + 1; /* save format argument */ fargv = gargv; } else { fargv = NULL; } /* skip to field width */ while (*fmt && strchr(skip1, *fmt) != NULL) { *dptr++ = *fmt++; *dptr = 0; } if (*fmt == '*') { fmt++; l = strspn(fmt, digits); if ((l > 0) && (fmt[l] == '$')) { int idx = atoi(fmt); if (fargv == NULL) { warnx("incomplete use of n$"); return (NULL); } if (idx <= myargc) { gargv = &myargv[idx - 1]; } else { gargv = &myargv[myargc]; } fmt += l + 1; } else if (fargv != NULL) { warnx("incomplete use of n$"); return (NULL); } if (getint(&fieldwidth)) return (NULL); if (gargv > maxargv) maxargv = gargv; havewidth = 1; *dptr++ = '*'; *dptr = 0; } else { havewidth = 0; /* skip to possible '.', get following precision */ while (isdigit(*fmt)) { *dptr++ = *fmt++; *dptr = 0; } } if (*fmt == '.') { /* precision present? */ fmt++; *dptr++ = '.'; if (*fmt == '*') { fmt++; l = strspn(fmt, digits); if ((l > 0) && (fmt[l] == '$')) { int idx = atoi(fmt); if (fargv == NULL) { warnx("incomplete use of n$"); return (NULL); } if (idx <= myargc) { gargv = &myargv[idx - 1]; } else { gargv = &myargv[myargc]; } fmt += l + 1; } else if (fargv != NULL) { warnx("incomplete use of n$"); return (NULL); } if (getint(&precision)) return (NULL); if (gargv > maxargv) maxargv = gargv; haveprec = 1; *dptr++ = '*'; *dptr = 0; } else { haveprec = 0; /* skip to conversion char */ while (isdigit(*fmt)) { *dptr++ = *fmt++; *dptr = 0; } } } else haveprec = 0; if (!*fmt) { warnx("missing format character"); return (NULL); } *dptr++ = *fmt; *dptr = 0; /* * Look for a length modifier. POSIX doesn't have these, so * we only support them for floating-point conversions, which * are extensions. This is useful because the L modifier can * be used to gain extra range and precision, while omitting * it is more likely to produce consistent results on different * architectures. This is not so important for integers * because overflow is the only bad thing that can happen to * them, but consider the command printf %a 1.1 */ if (*fmt == 'L') { mod_ldbl = 1; fmt++; if (!strchr("aAeEfFgG", *fmt)) { warnx("bad modifier L for %%%c", *fmt); return (NULL); } } else { mod_ldbl = 0; } /* save the current arg offset, and set to the format arg */ if (fargv != NULL) { gargv = fargv; } convch = *fmt; nextch = *++fmt; *fmt = '\0'; switch (convch) { case 'b': { size_t len; char *p; int getout; p = strdup(getstr()); if (p == NULL) { warnx("%s", strerror(ENOMEM)); return (NULL); } getout = escape(p, 0, &len); fputs(p, stdout); free(p); if (getout) return (end_fmt); break; } case 'c': { char p; p = getchr(); PF(start, p); break; } case 's': { const char *p; p = getstr(); PF(start, p); break; } case 'd': case 'i': case 'o': case 'u': case 'x': case 'X': { char *f; intmax_t val; uintmax_t uval; int signedconv; signedconv = (convch == 'd' || convch == 'i'); if ((f = mknum(start, convch)) == NULL) return (NULL); if (getnum(&val, &uval, signedconv)) *rval = 1; if (signedconv) PF(f, val); else PF(f, uval); break; } case 'e': case 'E': case 'f': case 'F': case 'g': case 'G': case 'a': case 'A': { long double p; if (getfloating(&p, mod_ldbl)) *rval = 1; if (mod_ldbl) PF(start, p); else PF(start, (double)p); break; } default: warnx("illegal format character %c", convch); return (NULL); } *fmt = nextch; /* return the gargv to the next element */ return (fmt); }