DEV Community: Monsif

Utilizing ASCII in C Programming for Symbol Identification in Passwords

Monsif — Tue, 14 Nov 2023 17:09:10 +0000

In the realm of password security, robust validation criteria are essential. One critical aspect is ensuring the inclusion of symbols to enhance password strength. Here, we'll delve into the utilization of ASCII values in C programming to precisely identify symbols within passwords, significantly contributing to comprehensive password validation.

Consider the following C program snippet:

include

// Global boolean variables for criteria
bool lower = false, upper = false, digit = false, symbol = false;

bool valid(string password);

int main(void)
{
string password = get_string("Enter your password: ");
if (valid(password))
{
printf("Your password is valid!\n");
}
else
{
printf("Your password needs at least one uppercase letter, lowercase letter, number, and symbol\n");
}
}

bool valid(string password)
{
for (int i = 0; password[i] != '\0'; i++)
{
// Check for lowercase, uppercase, and digits (not shown for brevity)

    // Check for symbols using ASCII values
    if ((password[i] >= 33 && password[i] <= 47) ||
        (password[i] >= 58 && password[i] <= 64) ||
        (password[i] >= 91 && password[i] <= 96))
    {
        symbol = true;
    }
    else
    {
        return false;
    }
}

// Ensure all criteria are met before considering the password valid
if (lower && upper && digit && symbol)
{
    return true;
}
else
{
    return false;
}

}

This code snippet showcases the use of ASCII values in C programming to identify symbols within passwords. ASCII, the American Standard Code for Information Interchange, assigns numerical values to characters, including symbols.

Key points highlighted in the code snippet:

Understanding ASCII Ranges:

    ASCII values for symbols occupy specific ranges. For instance, the exclamation mark '!' falls within the range of ASCII values 33 to 47, while other symbols like '@', '[', ']', etc., are situated in different ranges.

Symbol Identification Logic:

    By employing logical conditions (>= and <=), the code checks each character in the password against defined ASCII ranges representing symbols. If a character falls within these ranges, it is recognized as a symbol.

Ensuring Comprehensive Password Validation:

    The program aims to ensure the password contains at least one lowercase letter, uppercase letter, number, and symbol. The ASCII-based symbol check adds another layer of security to password validation.

Augmenting Password Security:

    Incorporating symbols in passwords strengthens their resilience against potential attacks. The utilization of ASCII values aids in efficiently identifying symbols, fortifying the overall security of passwords.

In conclusion, leveraging ASCII values in C programming to identify symbols within passwords is a crucial step in enhancing password security. By employing these techniques, password systems can reinforce their defenses against security threats.

The Art of Series Summation in C: Navigating Data Types, Casting Magic, and the Dance of Incrementation

Monsif — Fri, 10 Nov 2023 12:15:59 +0000

Greetings, fellow coding enthusiasts! Today, let's embark on an exciting journey into the world of C programming. If you're new to coding, fear not – we're about to unravel the secrets behind a common programming challenge. Picture this: you're faced with the task of calculating the value of a series, a challenge that involves mastering the art of data types, casting magic, and the dance of incrementation.

The Challenge.

Our mission is deceptively simple but carries profound lessons. We aim to calculate the value of the series S=1+21+31+…+501.

here is the code for Our little program:

#include <stdio.h>


int main (){
    float count;
    float s = 0;
    for (int  i = 1; i <= 50; i++)
    {
        count = (float)1 / i;
        s += count;

    }
    printf("%.2f", s);
}

Choosing the Right Tools:

Think of coding like an artist picking the right colors. We used a tool called 'float' to handle our numbers with decimals. It helps us keep track of the small parts of our series.

The Casting Game:

Here's where we did a little magic trick. When we divided 1 by our counting number 'i' ( 'i' represents the loop counter), there was a tiny problem. But, no worries! We used a trick called 'casting' to make sure our result had those cool decimal points. It's like turning 1 into 1.0 for our math dance.

count = (float)1 / i;

The Simple Loop:

Think of this like taking steps on a staircase. We started counting from 1 to 50, and with each count, our calculation 1 / i
changed a bit. The cool part happened when we added this new result to our total. We kept moving up the steps until we reached the end of our series.

s += count;

Conclusion:

And there you have it! We took on a coding challenge, used our tools wisely, did a little trick to keep our numbers accurate, and moved through a simple loop to find the series value. Coding is like climbing a staircase – it gets more enjoyable when you understand the steps.

So, keep it simple, enjoy the coding journey, and may your code always move in the right direction!

Happy coding,
Monsif Lam.

Discovering the Magic of 'do-while' Loops in C Programming

Monsif — Fri, 25 Aug 2023 20:21:42 +0000

Hello there, curious minds and aspiring programmers! Today, let's take a journey into the world of C programming. Don't worry if you've never coded before; we're going to explore an exciting concept called loop structures. Imagine loops as a way for your program to repeat certain tasks efficiently. Among these loops, there's one gem we're going to spotlight: the 'do-while' loop.

Unveiling the Mystery of 'do-while' Loops:

Let's paint a simple picture. Imagine you're writing a computer program using C, and you have a task that needs to be repeated, like checking if an entered number is valid. You could use different types of loops, but today, let's focus on the friendly 'do-while' loop.

Achieve More with Less Code:
Here's the cool thing: the 'do-while' loop lets you achieve tasks using fewer lines of code. Unlike some other loops, the 'do-while' loop ensures that the code inside it is executed at least once, even before checking if a condition is met. This means you don't need to repeat the same code outside the loop before entering it. The result? Cleaner, more efficient code.
Embrace the First Step:
Imagine you want to do something before you even start checking a condition. This is where the 'do-while' loop shines. It makes sure that your code inside the loop is carried out before deciding whether the condition is true or not. This is great for situations where you want certain actions to happen no matter what.
Classy Input Checking:
Let's say you're making a program that asks users for input, like their age. You want to make sure they enter a sensible value. The 'do-while' loop is like your trusty sidekick here. It shows the user the prompt before checking if their input is okay. You won't need to repeat the prompt again and again, making the interaction smoother and less cluttered.
Making Code Easier on the Eyes:
When writing code, making it easy to read and understand is super important. The 'do-while' loop helps here too. By wrapping the whole loop structure, including the initial step, it simplifies your code. It's like presenting your ideas in a neat package. This makes future changes and updates a breeze, making your coding experience more enjoyable.

Wrapping Up:

As you delve into the world of C programming, remember the 'do-while' loop. It's like a handy tool in your coding toolbox. It can simplify your code, handle input validation with grace, and make your programs easier to understand. With a bit of practice, you'll be creating well-structured, efficient, and easy-to-maintain code.

So, cheers to embracing the magic of the 'do-while' loop in your coding adventures. May your code be neat, your validations rock-solid, and your journey through loops be truly enlightening!

Wishing you happy coding,
Monsif Lam