2019
November
Standard

last word

By • On • In C, level2 • 1 min read
Assignment name  : last_word
Expected files   : last_word.c
Allowed functions: write
--------------------------------------------------------------------------------
 
Write a program that takes a string and displays its last word followed by a \n.
 
A word is a section of string delimited by spaces/tabs or by the start/end of
the string.
 
If the number of parameters is not 1, or there are no words, display a newline.
 
Example:
 
$> ./last_word "FOR PONIES" | cat -e
PONIES$
$> ./last_word "this        ...       is sparta, then again, maybe    not" | cat -e
not$
$> ./last_word "   " | cat -e
$
$> ./last_word "a" "b" | cat -e
$
$> ./last_word "  lorem,ipsum  " | cat -e
lorem,ipsum$
$>
 
-------------------------------------------------------------------------------
 
void    last_word(char *str)
{
    int i = 0;
 
    while (str[i] != '\0')
        ++i;
    while (i >= 0 && (str[i] == ' ' || str[i] == '\t' || str[i] == '\0'))
        --i;
    while (i >= 0 && str[i] != ' ' && str[i] != '\t')
        --i;
    ++i;
    while (str[i] != '\0' && str[i] != ' ' && str[i] != '\t')
    {
        write(1, str + i, 1);
        ++i;
    }
}
 
int     main(int argc, char **argv)
{
    if (argc == 2)
        last_word(argv[1]);
 
    write(1, "\n", 1);
    return (0);
}
The end
Standard

reverse_bits

By • On • In C, level2 • 1 min read
Assignment name  : reverse_bits
Expected files   : reverse_bits.c
Allowed functions:
--------------------------------------------------------------------------------
 
Write a function that takes a byte, reverses it, bit by bit (like the
example) and returns the result.
 
Your function must be declared as follows:
 
unsigned char   reverse_bits(unsigned char octet);
 
Example:
 
  1 byte
_____________
 0100  0001
     ||
     \/
 1000  0010
 
------------------------------------------------------------------------------
 
unsigned char   reverse_bits(unsigned char octet)
{
    unsigned char out = 0;
 
    out = out | ((octet & 128) >> 7);
    out = out | ((octet & 64) >> 5);
    out = out | ((octet & 32) >> 3);
    out = out | ((octet & 16) >> 1);
    out = out | ((octet & 8) << 1);
    out = out | ((octet & 4) << 3);
    out = out | ((octet & 2) << 5);
    out = out | ((octet & 1) << 7);
    return (out);
}
The end
Standard

Inter

By • On • In level2 • 1 min read
Assignment name  : inter
Expected files   : inter.c
Allowed functions: write
--------------------------------------------------------------------------------
 
Write a program that takes two strings and displays, without doubles, the
characters that appear in both strings, in the order they appear in the first
one.
 
The display will be followed by a \n.
 
If the number of arguments is not 2, the program displays \n.
 
Examples:
 
$>./inter "padinton" "paqefwtdjetyiytjneytjoeyjnejeyj" | cat -e
padinto$
$>./inter ddf6vewg64f gtwthgdwthdwfteewhrtag6h4ffdhsd | cat -e
df6ewg4$
$>./inter "nothing" "This sentence hides nothing" | cat -e
nothig$
$>./inter | cat -e
$
--------------------------------------------------------------------------------
 
#include <unistd.h>
 
int     find_char_n(char c, char *str, int max)
{
    int i = 0;
    while (str[i] != '\0')
    {
        if (max != -1 && i == max)
            return (0);
        if (c == str[i])
            return (1);
        ++i;
    }
    return (0);
}
 
void    inter(char *a, char *b)
{
    int i = 0;
    while (a[i] != '\0')
    {
        if (find_char_n(a[i], b, -1) == 1 && find_char_n(a[i], a, i) == 0)
            write(1, a + i, 1);
        ++i;
    }
}
 
int     main(int argc, char **argv)
{
    if (argc == 3)
        inter(argv[1], argv[2]);
 
    write(1, "\n", 1);
    return (0);
}
The end
Standard

do_op

By • On • In C, level2 • 1 min read
Assignment name  : do_op
Expected files   : *.c, *.h
Allowed functions: atoi, printf, write
--------------------------------------------------------------------------------
 
Write a program that takes three strings:
- The first and the third one are representations of base-10 signed integers
  that fit in an int.
- The second one is an arithmetic operator chosen from: + - * / %
 
The program must display the result of the requested arithmetic operation,
followed by a newline. If the number of parameters is not 3, the program
just displays a newline.
 
You can assume the string have no mistakes or extraneous characters. Negative
numbers, in input or output, will have one and only one leading '-'. The
result of the operation fits in an int.
 
Examples:
 
$> ./do_op "123" "*" 456 | cat -e
56088$
$> ./do_op "9828" "/" 234 | cat -e
42$
$> ./do_op "1" "+" "-43" | cat -e
-42$
$> ./do_op | cat -e
$
-------------------------------------------------------------------------------
 
#include <stdio.h>
#include <stdlib.h>
 
int main(int argc, char **argv)
{
    if (argc == 4)
    {
        int a = atoi(argv[1]);
        int b = atoi(argv[3]);
        char operator = *argv[2];
 
        if (operator == '+')
            printf("%d", a + b);
        else if (operator == '-')
            printf("%d", a - b);
        else if (operator == '*')
            printf("%d", a * b);
        else if (b == 0)
            printf("UNDEFINED");
        else if (operator == '/')
            printf("%d", a / b);
        else if (operator == '%')
            printf("%d", a % b);
    }
    printf("\n");
    return (0);
}
The end
Standard

camel to snake

By • On • In C, level2 • 1 min read
Assignment name  : camel_to_snake
Expected files   : camel_to_snake.c
Allowed functions: malloc, free, realloc, write
--------------------------------------------------------------------------------
 
Write a program that takes a single string in lowerCamelCase format
and converts it into a string in snake_case format.
 
A lowerCamelCase string is a string where each word begins with a capital letter
except for the first one.
 
A snake_case string is a string where each word is in lower case, separated by
an underscore "_".
 
Examples:
$>./camel_to_snake "hereIsACamelCaseWord"
here_is_a_camel_case_word
$>./camel_to_snake "helloWorld" | cat -e
hello_world$
$>./camel_to_snake | cat -e
$
#include <unistd.h>
 
void    camel_to_snake(char *str)
{
    while (*str != '\0')
    {
        if (*str >= 'A' && *str <= 'Z')
        {
            write(1, "_", 1);
            *str = *str + ('a' - 'A');
        }
        write(1, str, 1);
        ++str;
    }
}
 
int     main(int argc, char **argv)
{
    if (argc == 2)
        camel_to_snake(argv[1]);
 
    write(1, "\n", 1);
    return (0);
}
The end
Standard

alpha_mirror

By • On • In C, level2 • 1 min read
Assignment name  : alpha_mirror
Expected files   : alpha_mirror.c
Allowed functions: write
--------------------------------------------------------------------------------
 
Write a program called alpha_mirror that takes a string and displays this string
after replacing each alphabetical character by the opposite alphabetical
character, followed by a newline.
 
'a' becomes 'z', 'Z' becomes 'A'
'd' becomes 'w', 'M' becomes 'N'
 
and so on.
 
Case is not changed.
 
If the number of arguments is not 1, display only a newline.
 
Examples:
 
$>./alpha_mirror "abc"
zyx
$>./alpha_mirror "My horse is Amazing." | cat -e
Nb slihv rh Znzarmt.$
$>./alpha_mirror | cat -e
$
$>
#include <unistd.h>
 
void    alpha_mirror(char *str)
{
    while (*str != '\0')
    {
        if (*str >= 'A' && *str <= 'M')
            *str = 'Z' - (*str - 'A');
        else if (*str >= 'a' && *str <= 'm')
            *str = 'z' - (*str - 'a');
        else if (*str >= 'N' && *str <= 'Z')
            *str = 'A' + ('Z' - *str);
        else if (*str >= 'n' && *str <= 'z')
            *str = 'a' + ('z' - *str);
 
        write(1, str, 1);
        ++str;
    }
}
 
int     main(int argc, char **argv)
{
    if (argc == 2)
        alpha_mirror(argv[1]);
 
    write(1, "\n", 1);
    return (0);
}
The end