int main(void){
int number;
int length;
int first;
int power;
int body;
int i;
int length_copy;
char num;
number = 98;
length_copy = number_length(number);
/*do this for the lenght of the number*/
for(i = 0 ; i < length_copy; i++)
{
length = number_length(number);
first = first_digit(number, length);
/*converting an integer to a char*/
num = first +48;
write(1, &num, 1);
power = power_of(length);
body = num_body(number, power, first);
number = body;
}
return 0;
}
int main() {
char *line = NULL; // answers will be read here
size_t len = 0; // answers len
ssize_t read = 0; // answer line length
char default_answer[6] = "12345"; //default answer
char *pname = NULL;
char *guessed_number = NULL;
get_name(&pname);
get_number(&guessed_number, pname);
FILE *fp = fopen("answers.txt", "r");
if (fp == NULL) assert(fp != NULL);
bool match = false;
while ((read = getline(&line, &len, fp)) != -1) {
assert(read);
int name_ends_at = name_length(line, read);
line[name_ends_at] = 0;
if (strcmp(pname, line) == 0) {
int number_ends_at = number_length(line, name_ends_at + 1, read);
line[number_ends_at] = 0;
int cmp = strcmp(guessed_number, line + name_ends_at + 1);
cmp_and_print(cmp);
match = true;
break;
}
free(line);
line = NULL;
}
//Name not found in the answers.txt -> compare to default value
if (!match) {
int cmp = strcmp(guessed_number, default_answer);
cmp_and_print(cmp);
}
fclose(fp);
if (line != NULL) free(line);
if (pname != NULL) free(pname);
if (guessed_number != NULL) free(guessed_number);
return 0;
}
void print_number(int n){
/* Function prints a number one digit at a time */
int l;
int ll;
int d;
char p;
l = number_length(n);
ll = l;
d = 1;
while (ll - 1 > 0){
d = d * 10;
ll--;
}
while (l > 0){
p = '0' + (n / d);
print_char(p);
l--;
n = n % d;
d = d / 10;
}
}
/* callback to handle display of transaction progress */
void cb_progress(alpm_progress_t event, const char *pkgname, int percent,
size_t howmany, size_t current)
{
static int prevpercent;
static size_t prevcurrent;
/* size of line to allocate for text printing (e.g. not progressbar) */
int infolen;
int digits, textlen;
char *opr = NULL;
/* used for wide character width determination and printing */
int len, wclen, wcwid, padwid;
wchar_t *wcstr;
const unsigned short cols = getcols();
if(config->noprogressbar || cols == 0) {
return;
}
if(percent == 0) {
get_update_timediff(1);
} else if(percent == 100) {
/* no need for timediff update, but unconditionally continue unless we
* already completed on a previous call */
if(prevpercent == 100) {
return;
}
} else {
if(current != prevcurrent) {
/* update always */
} else if(!pkgname || percent == prevpercent ||
get_update_timediff(0) < UPDATE_SPEED_MS) {
/* only update the progress bar when we have a package name, the
* percentage has changed, and it has been long enough. */
return;
}
}
prevpercent = percent;
prevcurrent = current;
/* set text of message to display */
switch(event) {
case ALPM_PROGRESS_ADD_START:
opr = _("installing");
break;
case ALPM_PROGRESS_UPGRADE_START:
opr = _("upgrading");
break;
case ALPM_PROGRESS_DOWNGRADE_START:
opr = _("downgrading");
break;
case ALPM_PROGRESS_REINSTALL_START:
opr = _("reinstalling");
break;
case ALPM_PROGRESS_REMOVE_START:
opr = _("removing");
break;
case ALPM_PROGRESS_CONFLICTS_START:
opr = _("checking for file conflicts");
break;
case ALPM_PROGRESS_DISKSPACE_START:
opr = _("checking available disk space");
break;
case ALPM_PROGRESS_INTEGRITY_START:
opr = _("checking package integrity");
break;
case ALPM_PROGRESS_KEYRING_START:
opr = _("checking keys in keyring");
break;
case ALPM_PROGRESS_LOAD_START:
opr = _("loading package files");
break;
default:
return;
}
infolen = cols * 6 / 10;
if(infolen < 50) {
infolen = 50;
}
/* find # of digits in package counts to scale output */
digits = number_length(howmany);
/* determine room left for non-digits text [not ( 1/12) part] */
textlen = infolen - 3 /* (/) */ - (2 * digits) - 1 /* space */;
/* In order to deal with characters from all locales, we have to worry
* about wide characters and their column widths. A lot of stuff is
* done here to figure out the actual number of screen columns used
* by the output, and then pad it accordingly so we fill the terminal.
*/
/* len = opr len + pkgname len (if available) + space + null */
len = strlen(opr) + ((pkgname) ? strlen(pkgname) : 0) + 2;
wcstr = calloc(len, sizeof(wchar_t));
/* print our strings to the alloc'ed memory */
#if defined(HAVE_SWPRINTF)
wclen = swprintf(wcstr, len, L"%s %s", opr, pkgname);
#else
/* because the format string was simple, we can easily do this without
* using swprintf, although it is probably not as safe/fast. The max
* chars we can copy is decremented each time by subtracting the length
* of the already printed/copied wide char string. */
wclen = mbstowcs(wcstr, opr, len);
wclen += mbstowcs(wcstr + wclen, " ", len - wclen);
wclen += mbstowcs(wcstr + wclen, pkgname, len - wclen);
#endif
wcwid = wcswidth(wcstr, wclen);
padwid = textlen - wcwid;
/* if padwid is < 0, we need to trim the string so padwid = 0 */
if(padwid < 0) {
int i = textlen - 3;
wchar_t *p = wcstr;
/* grab the max number of char columns we can fill */
while(i - wcwidth(*p) > 0) {
i -= wcwidth(*p);
p++;
}
/* then add the ellipsis and fill out any extra padding */
wcscpy(p, L"...");
padwid = i;
}
printf("(%*zu/%*zu) %ls%-*s", digits, current,
digits, howmany, wcstr, padwid, "");
free(wcstr);
/* call refactored fill progress function */
fill_progress(percent, percent, cols - infolen);
if(percent == 100) {
alpm_list_t *i = NULL;
on_progress = 0;
fflush(stdout);
for(i = output; i; i = i->next) {
fputs((const char *)i->data, stderr);
}
fflush(stderr);
FREELIST(output);
} else {
on_progress = 1;
}
}
/* callback to handle messages/notifications from libalpm transactions */
void cb_event(alpm_event_t *event)
{
if(config->print) {
return;
}
switch(event->type) {
case ALPM_EVENT_HOOK_START:
if(event->hook.when == ALPM_HOOK_PRE_TRANSACTION) {
colon_printf(_("Running pre-transaction hooks...\n"));
} else {
colon_printf(_("Running post-transaction hooks...\n"));
}
break;
case ALPM_EVENT_HOOK_RUN_START:
{
alpm_event_hook_run_t *e = &event->hook_run;
int digits = number_length(e->total);
printf("(%*zu/%*zu) %s\n", digits, e->position,
digits, e->total,
e->desc ? e->desc : e->name);
}
break;
case ALPM_EVENT_CHECKDEPS_START:
printf(_("checking dependencies...\n"));
break;
case ALPM_EVENT_FILECONFLICTS_START:
if(config->noprogressbar) {
printf(_("checking for file conflicts...\n"));
}
break;
case ALPM_EVENT_RESOLVEDEPS_START:
printf(_("resolving dependencies...\n"));
break;
case ALPM_EVENT_INTERCONFLICTS_START:
printf(_("looking for conflicting packages...\n"));
break;
case ALPM_EVENT_TRANSACTION_START:
colon_printf(_("Processing package changes...\n"));
break;
case ALPM_EVENT_PACKAGE_OPERATION_START:
if(config->noprogressbar) {
alpm_event_package_operation_t *e = &event->package_operation;
switch(e->operation) {
case ALPM_PACKAGE_INSTALL:
printf(_("installing %s...\n"), alpm_pkg_get_name(e->newpkg));
break;
case ALPM_PACKAGE_UPGRADE:
printf(_("upgrading %s...\n"), alpm_pkg_get_name(e->newpkg));
break;
case ALPM_PACKAGE_REINSTALL:
printf(_("reinstalling %s...\n"), alpm_pkg_get_name(e->newpkg));
break;
case ALPM_PACKAGE_DOWNGRADE:
printf(_("downgrading %s...\n"), alpm_pkg_get_name(e->newpkg));
break;
case ALPM_PACKAGE_REMOVE:
printf(_("removing %s...\n"), alpm_pkg_get_name(e->oldpkg));
break;
}
}
break;
case ALPM_EVENT_PACKAGE_OPERATION_DONE:
{
alpm_event_package_operation_t *e = &event->package_operation;
switch(e->operation) {
case ALPM_PACKAGE_INSTALL:
display_optdepends(e->newpkg);
break;
case ALPM_PACKAGE_UPGRADE:
case ALPM_PACKAGE_DOWNGRADE:
display_new_optdepends(e->oldpkg, e->newpkg);
break;
case ALPM_PACKAGE_REINSTALL:
case ALPM_PACKAGE_REMOVE:
break;
}
}
break;
case ALPM_EVENT_INTEGRITY_START:
if(config->noprogressbar) {
printf(_("checking package integrity...\n"));
}
break;
case ALPM_EVENT_KEYRING_START:
if(config->noprogressbar) {
printf(_("checking keyring...\n"));
}
break;
case ALPM_EVENT_KEY_DOWNLOAD_START:
printf(_("downloading required keys...\n"));
break;
case ALPM_EVENT_LOAD_START:
if(config->noprogressbar) {
printf(_("loading package files...\n"));
}
break;
case ALPM_EVENT_DELTA_INTEGRITY_START:
printf(_("checking delta integrity...\n"));
break;
case ALPM_EVENT_DELTA_PATCHES_START:
printf(_("applying deltas...\n"));
break;
case ALPM_EVENT_DELTA_PATCH_START:
printf(_("generating %s with %s... "),
event->delta_patch.delta->to,
event->delta_patch.delta->delta);
break;
case ALPM_EVENT_DELTA_PATCH_DONE:
printf(_("success!\n"));
break;
case ALPM_EVENT_DELTA_PATCH_FAILED:
printf(_("failed.\n"));
break;
case ALPM_EVENT_SCRIPTLET_INFO:
fputs(event->scriptlet_info.line, stdout);
break;
case ALPM_EVENT_RETRIEVE_START:
colon_printf(_("Retrieving packages ...\n"));
break;
case ALPM_EVENT_DISKSPACE_START:
if(config->noprogressbar) {
printf(_("checking available disk space...\n"));
}
break;
case ALPM_EVENT_OPTDEP_REMOVAL:
{
alpm_event_optdep_removal_t *e = &event->optdep_removal;
char *dep_string = alpm_dep_compute_string(e->optdep);
colon_printf(_("%s optionally requires %s\n"),
alpm_pkg_get_name(e->pkg),
dep_string);
free(dep_string);
}
break;
case ALPM_EVENT_DATABASE_MISSING:
if(!config->op_s_sync) {
pm_printf(ALPM_LOG_WARNING,
"database file for '%s' does not exist\n",
event->database_missing.dbname);
}
break;
case ALPM_EVENT_PACNEW_CREATED:
{
alpm_event_pacnew_created_t *e = &event->pacnew_created;
if(on_progress) {
char *string = NULL;
pm_sprintf(&string, ALPM_LOG_WARNING, _("%s installed as %s.pacnew\n"),
e->file, e->file);
if(string != NULL) {
output = alpm_list_add(output, string);
}
} else {
pm_printf(ALPM_LOG_WARNING, _("%s installed as %s.pacnew\n"),
e->file, e->file);
}
}
break;
case ALPM_EVENT_PACSAVE_CREATED:
{
alpm_event_pacsave_created_t *e = &event->pacsave_created;
if(on_progress) {
char *string = NULL;
pm_sprintf(&string, ALPM_LOG_WARNING, _("%s saved as %s.pacsave\n"),
e->file, e->file);
if(string != NULL) {
output = alpm_list_add(output, string);
}
} else {
pm_printf(ALPM_LOG_WARNING, _("%s saved as %s.pacsave\n"),
e->file, e->file);
}
}
break;
/* all the simple done events, with fallthrough for each */
case ALPM_EVENT_FILECONFLICTS_DONE:
case ALPM_EVENT_CHECKDEPS_DONE:
case ALPM_EVENT_RESOLVEDEPS_DONE:
case ALPM_EVENT_INTERCONFLICTS_DONE:
case ALPM_EVENT_TRANSACTION_DONE:
case ALPM_EVENT_INTEGRITY_DONE:
case ALPM_EVENT_KEYRING_DONE:
case ALPM_EVENT_KEY_DOWNLOAD_DONE:
case ALPM_EVENT_LOAD_DONE:
case ALPM_EVENT_DELTA_INTEGRITY_DONE:
case ALPM_EVENT_DELTA_PATCHES_DONE:
case ALPM_EVENT_DISKSPACE_DONE:
case ALPM_EVENT_RETRIEVE_DONE:
case ALPM_EVENT_RETRIEVE_FAILED:
case ALPM_EVENT_HOOK_DONE:
case ALPM_EVENT_HOOK_RUN_DONE:
/* we can safely ignore those as well */
case ALPM_EVENT_PKGDOWNLOAD_START:
case ALPM_EVENT_PKGDOWNLOAD_DONE:
case ALPM_EVENT_PKGDOWNLOAD_FAILED:
/* nothing */
break;
}
fflush(stdout);
}
