# Introduction

## "Hello World" in C

<figure><img src="/files/ZJoFqYgPhbmuZBEUy155" alt=""><figcaption></figcaption></figure>

{% tabs %}
{% tab title="C" %}

```c
#include <stdio.h>

int main() {
    char input[100];
    
    // Read until a new line is received
    scanf("%[^\n]%*c", input);
    
    printf("Hello, World!");
    printf("\n%s", input);
    
    return 0
}
```

{% endtab %}

{% tab title="Rust" %}

```rust
use std::io;

fn main() {
    let mut input: String = String::new();

    io::stdin()
        .read_line(&mut input)
        .expect("Give an Input.");

    println!("Hello, world!");
    println!("{input}")
}
```

{% endtab %}
{% endtabs %}

***

## Playing with Characters

<figure><img src="/files/h9YGcn8mJNQa6v8MMC6O" alt=""><figcaption></figcaption></figure>

{% tabs %}
{% tab title="C" %}

```c
#include <stdio.h>

int main() {
    char ch;
    char s[100];
    char sen[100];
    
    scanf("%c", &ch);
    scanf("%s", s);
    // Reading the \n from the previous line
    scanf("\n");
    // Reading until a \n is received
    scanf("%[^\n]%*c", sen);
    
    printf("%c", ch);
    printf("\n%s", s);
    printf("\n%s", sen);
    
    return 0
}
```

{% endtab %}

{% tab title="Rust" %}

```rust
use std::io;

fn main() {
    let mut ch: String = String::new();
    let mut s: String = String::new();
    let mut sen: String = String::new();

    io::stdin()
        .read_line(&mut ch)
        .expect("Enter a Character.");

    io::stdin()
        .read_line(&mut s)
        .expect("Enter a Word.");

    io::stdin()
        .read_line(&mut sen)
        .expect("Enter a Sentence");

    print!("{ch}");
    print!("{s}");
    print!("{sen}");
}
```

{% endtab %}
{% endtabs %}

***

## Sum and Difference of Two Numbers

<figure><img src="/files/YLjsAZYA98on66wQ1rK0" alt=""><figcaption></figcaption></figure>

{% tabs %}
{% tab title="C" %}

```c
#include <stdio.h>

int main()
{
	int int_a, int_b;
    float float_a, float_b;
    
    scanf("%d %d", &int_a, &int_b);
    scanf("%f %f", &float_a, &float_b);
    
    printf("%d %d", int_a + int_b, int_a - int_b);
    printf("\n%.1f %.1f", float_a + float_b, float_a - float_b);
    
    return 0;
}
```

{% endtab %}

{% tab title="Rust" %}

```rust
use std::io;

fn main() {
    let mut line1: String = String::new();
    let mut line2: String = String::new();

    io::stdin()
        .read_line(&mut line1)
        .expect("Enter two positive integers.");

    io::stdin()
        .read_line(&mut line2)
        .expect("Enter two positive floating-point numbers.");

    let line1: Vec<isize> = line1.trim()
                                .split_whitespace()
                                .map(|number| number.parse().expect("Expected Integers."))
                                .collect();

    let line2: Vec<f64> = line2.trim()
                            .split_whitespace()
                            .map(|float| float.parse().expect("Expected Floating-Point Numbers."))
                            .collect();

    let int_a = line1[0];
    let int_b = line1[1];
    let float_a = line2[0];
    let float_b = line2[1];

    println!("{} {}", int_a + int_b, int_a - int_b);
    println!("{:.1} {:.1}", float_a + float_b, float_a - float_b);
}
```

{% endtab %}
{% endtabs %}

***

## Functions in C

<figure><img src="/files/eq17fbp7NLou7wtBJPuI" alt=""><figcaption></figcaption></figure>

{% tabs %}
{% tab title="C" %}

```c
#include <stdio.h>

int max_of_four(int a, int b, int c, int d) {
    int max = a;
    
    if (max < b) max = b;
    if (max < c) max = c;
    if (max < d) max = d;
    
    return max;
}


int main() {
    int a, b, c, d;
    scanf("%d %d %d %d", &a, &b, &c, &d);
    int ans = max_of_four(a, b, c, d);
    printf("%d", ans);
    
    return 0;
}
```

{% endtab %}

{% tab title="Rust" %}

```rust
use std::io;

fn max_of_four(a: usize, b: usize, c: usize, d: usize) -> usize {
    let mut max = a;

    if max < b {
        max = b;
    }

    if max < c {
        max = c;
    }

    if max < d {
        max = d;
    }

    max
}

fn main() {
    let mut a: String = String::new();
    let mut b: String = String::new();
    let mut c: String = String::new();
    let mut d: String = String::new();

    io::stdin().read_line(&mut a).expect("Enter the 1st number.");
    let a: usize = a.trim().parse().expect("Expecting a valid 1st number.");

    io::stdin().read_line(&mut b).expect("Enter the 2nd number.");
    let b: usize = b.trim().parse().expect("Expecting a valid 2nd number.");

    io::stdin().read_line(&mut c).expect("Enter the 3rd number.");
    let c: usize = c.trim().parse().expect("Expecting a valid 3rd number.");

    io::stdin().read_line(&mut d).expect("Enter the 4th number.");
    let d: usize = d.trim().parse().expect("Expecting a valid 4th number.");

    let ans = max_of_four(a, b, c, d);

    println!("{ans}");
}
```

{% endtab %}
{% endtabs %}

***

## Pointers in C

<figure><img src="/files/A9NDBeX6hQmMtndinkZ4" alt=""><figcaption></figcaption></figure>

{% tabs %}
{% tab title="C" %}

```c
#include <stdio.h>

void update(int *a,int *b) {
    int temp = *a;
    *a = *a + *b;
    *b = abs(temp - *b);
}

int main() {
    int a, b;
    int *pa = &a, *pb = &b;
    
    scanf("%d %d", &a, &b);
    update(pa, pb);
    printf("%d\n%d", a, b);

    return 0;
}
```

{% endtab %}

{% tab title="Rust" %}

```rust
use std::io;

fn update(a: &mut isize, b: &mut isize) {
    let temp: isize = *a;
    *a = *a + *b;
    *b = (temp - *b).abs();
}

fn main() {
    let mut a: String = String::new();
    let mut b: String = String::new();

    io::stdin().read_line(&mut a).expect("Failed to read input. Expected a valid number.");
    let mut a: isize = a.trim().parse().expect("Failed to parse input. Expected a valid number.");

    io::stdin().read_line(&mut b).expect("Failed to read input. Expected a valid number.");
    let mut b: isize = b.trim().parse().expect("Failed to parse input. Expected a valid number.");

    update(&mut a, &mut b);

    println!("{a}");
    println!("{b}");
}
```

{% endtab %}
{% endtabs %}


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://thamizhiniyancs.gitbook.io/writeups/hackerrank/c/introduction.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.