How can I replace a letter in a char array in c? - c

Question

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main()
{
char first[15];
printf("\n\tWrite here your code");
scanf("%s",first);
if()//there is "n" in the char
//change n with 1
else
//quit
return 0;
}

Answer 1

Replace character with character
This code will replace every occurrence of the character 'n' with the character '1'.
#include <stdio.h>
int main(void)
{
char str[15];
printf("Input: ");
scanf("%14s", str); // prevent buffer overflow
for (int i = 0; str[i]; ++i) { // iterate over str
if (str[i] == 'n')
str[i] = '1';
}
printf("Modified: %s\n", str);
return 0;
}
Replace character with string
This code will replace every occurrence of the character 'n' with the string "1+k" using the function strcat. The modified string is saved to char mod[].
#include <stdio.h>
#include <string.h>
#include <stdio.h>
int main(void)
{
char str[15];
printf("Input: ");
scanf("%14s", str); // prevent buffer overflow
char mod[] = "";
for (int i = 0; str[i]; ++i) { // iterate over str
if (str[i] == 'n') {
char *repl = "1+k";
strcat(mod, repl); // add "1+k" to mod
} else {
strncat(mod, &str[i], 1); // add str[i] to mod
}
}
printf("Modified: %s\n", mod);
return 0;
}

Answer 2

Such a trivial question deserves a non trivial answer
Note that this approach with branching, demonstrated by #Andy Sukowski-Bang, is - when compiled with -O3 - roughly 6.5x time slower than my approach, illustratating the efficiency of bitwise operations over branching instructions (not to mention Meltdown and Spectre vulnerabilities and its on branching if mitigations are enabled).
The following program will convert every occurence of the letter from to the designated letter.
It is able to replace all characters from 'A' to 'z' to '8' in a string of 8,286,208 bytes in only 0.07s:
#include <stdio.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <time.h>
// gcc -O3 replace.c && ./a.out
void replace(char *s, char from, char to, long n) {
char eq;
while (n--) {
eq = !(*s ^ from);
*s = !eq * *s + eq * to;
s++;
}
}
void replace_branching(char *s, char from, char to, long n) {
while (n--) {
if (*s == from)
*s = to;
s++;
}
}
void read_file_to_buffer(FILE *f, long length) {
char buffer[length + 1];
fseek(f, 0, SEEK_SET);
void (*fptr[2]) (char *s, char from, char to, long n) = {replace_branching, replace};
if (fread (buffer, 1, length, f) ) {
buffer[length] = '\0';
fclose (f);
char subbuff[33];
subbuff[32] = '\0';
char from = 'A';
char to = '8';
clock_t start, end;
double cpu_time_used[2];
for (int j = 0; j < 2; j++){
start = clock();
for (int i = 0; i < 0x20 + 26; i++) {
fptr[j](buffer, from + i, to, length);
//memcpy( subbuff, &buffer[0], 32 );
//printf("Modified: %s\n", subbuff);
}
end = clock();
cpu_time_used[j] = ((double) (end - start)) / CLOCKS_PER_SEC;
printf("Time: %fs\n", cpu_time_used[j]);
}
printf("Without branching it is %fx faster\n", cpu_time_used[0] / cpu_time_used[1]);
}
}
int main(void)
{
FILE * f;
long length;
if ((f = fopen ("test.txt", "rb"))) // NB: test.txt is a file of 8,286,208 bytes
{
fseek (f, 0, SEEK_END);
read_file_to_buffer(f, ftell(f));
}
return 0;
}
/*
Time: 0.475005s
Time: 0.070859s
Without branching it is 6.703524x faster
*/
Some explanations
eq = !(*s ^ from); // eq will equal 0 if letters are same, else it will equal 1
*s = !eq * *s + eq * to; // we assign to the pointer its same old value with !eq if the character 'from' was absent, else we will assign the character 'to'.
PS: No malloc were used, I used VLA and it is bad, very bad, don't do this at home!