**Explanation of components used in code:**

**builtins**: Cairo supports the implementation of predefined operations called builtin. Our program communicates with the external world by making use of the output builtin,which is specified by the directive **%builtins output**. 

**Implicit arguments**: in curly brackets are required for the storage operations. it stores the addresses of the output. This automatically adds an argument and a return value to the function. 

**serialize_word**: The library function serialize_word can be used to print the value  to the output. serialize_word takes *one argument* and one *implicit argument output ptr* 


## Solution
Add one more serialize_word function which accepts **400** as an argument.

```
// Use the output builtin.
// inscribed in the CPU(preprocessor)
%builtins output

// Import the serialize_word() function.
from starkware.cairo.common.serialize import serialize_word

func main{output_ptr: felt*}() {
// Output 100 by calling serialize_word.
serialize_word(100);
// Output 200.
serialize_word(200);
// Output 300.
serialize_word(300);
// Output 400.
serialize_word(400);
// Return.
return ();
}
```


Can you help how to change the code so that it outputs 400 as well?

```
// The following code outputs the numbers 100, 200, 300.
// 1. Click on "Run" to see the output.
// 2. Change it to output 400 as well.

// Use the output builtin.
%builtins output

// Import the serialize_word() function.
from starkware.cairo.common.serialize import serialize_word

func main{output_ptr: felt*}() {
// Output 100 by calling serialize_word.
serialize_word(100);
// Output 200.
serialize_word(200);
// Output 300.
serialize_word(300);
// Return.
return ();
}
```

---

> Answers to this question are a part of the ✨ **17 days of Cairo Lang with Playground & Newton.** ✨ 

*Vote for your favorite answer - the best answer will win a $10 award. A new day – a new reward! During the next 17 days, our goal is to attract more developers to the Cairo language and to systematize the knowledge of Cairo lang. [Read rules](https://www.notion.so/17-days-of-Cairo-Lang-with-Playground-Newton-550dfcda6a2d449ca468be293c776578)*

How to make output like "hello world" in Cairo Language (StarkNet)?


# Problem
```
// The following code is missing the function `add1`.
// 1. Click on "Run" to see the error.
// 2. Write the function `add1`, based on `add1_square`, so
//    that the program terminates successfully.
func add1_square(x: felt) -> (x: felt) {
    // Call `add1` and unpack the result into `z`.
    let (z) = add1(y=x);
    return (x=z * z);
}

func main() {
    // Call `add1_square` and save the result into `res`.
    let (res) = add1_square(x=12);

    // Verify the computation.
    assert res = (12 + 1) * (12 + 1);
    return ();
}
```

# Solution


```
func add1_square(x: felt) -> (x: felt) {
    // Call `add1` and unpack the result into `z`.
    let (z) = add1(y=x);
    return (x=z * z);
}

func main() {
    // Call `add1_square` and save the result into `res`.
    let (res) = add1_square(x=12);

    // Verify the computation.
    assert res = (12 + 1) * (12 + 1);
    return ();
}
func add1(y:felt) -> (z:felt) {
    return (z=y + 1);
}

```

# Output
```
Number of steps: 10
Program hash: 0x03856cfae0d569a83c0e2c9b9524c1e8a42730ccd24ca449ed415923a4c76fb0
```

# Explanation
 Let’s look at the flow of how this program works. 

**In main function**

The main function  calls the **add1_square** function with one parameter named x which holds value *12*. The controls go to the function add1_square. 
```
let (res) = add1_square(x=12);
```

**In add1_square function**

The add1_square accepts one argument x of value 12 and returns one argument.It  calls *add1 function* and control goes to the add1.

```
func add1_square(x: felt) -> (x: felt){ //x=12
let (z) = add1(y=x); // y=12
return (x=z * z);}
```
**In add1 function**

add1 function  accepts one argument y which is 12(see above) and returns one argument z. 
The z returns the value y+1 which is 13,  from where it is called which is add1_square function.

**In add1_square function**

 x value(z * z) returned to where it is called that is the main function. **res** holds the square of z which is 13*13. 
```
    let (z) = add1(y=x); //z=13
    return (x=z * z);//x=13*13
```
At the end computation is verified which turns out to be true as **res** holds the value x which is 13*13.

```
assert res = (12 + 1) * (12 + 1); //13*13=13*13 (checking if two variables are same)
```

**Cairo's Assert statements can be used for 2 different use cases:**

1. Check if two variables are the same
2. Set a variable's value if it's currently not set

Here, it's checking if two variables are the same as res is already defined. 

You can also use **serialize_word** to print the res. 


## With serialize_word

```
// Use the output builtin.
%builtins output

// Import the serialize_word() function.
from starkware.cairo.common.serialize import serialize_word

func add1_square(x: felt) -> (x: felt) {
    // Call `add1` and unpack the result into `z`.
    let (z) = add1(y=x);
    return (x=z * z);
}

func main{output_ptr: felt*}() {
    // Call `add1_square` and save the result into `res`.
    let (res) = add1_square(x=12);
    serialize_word(res);
    // Verify the computation.
    assert res = (12 + 1) * (12 + 1);
    return ();
}
func add1(y:felt) -> (z:felt) {
    return (z=y + 1);
}

```

# Output

```
Program output:
  169

Number of steps: 16
Program hash: 0x076e558dcac2872eb0c875a77c1f7be6401f606d62abbe327c93a36652228ab9
```


Hello! This is Day 2 of the 17 days of the Cairo challenge. And I have no idea how to solve the [playground](https://www.cairo-lang.org/playground/) exercise “Functions”. Perhaps you can help me?

```python
// The following code is missing the function `add1`.
// 1. Click on "Run" to see the error.
// 2. Write the function `add1`, based on `add1_square`, so
//    that the program terminates successfully.
//
// Note that `add1` doesn't have to call other functions.
//
// You can learn more about functions [here](https://www.cairo-lang.org/docs/how_cairo_works/functions.html).

// Write your code here.

func add1_square(x: felt) -> (x: felt) {
    // Call `add1` and unpack the result into `z`.
    let (z) = add1(y=x);
    return (x=z * z);
}

func main() {
    // Call `add1_square` and save the result into `res`.
    let (res) = add1_square(x=12);

    // Verify the computation.
    assert res = (12 + 1) * (12 + 1);
    return ();
}
```

---
> Answers to this question are a part of the ✨ **17 days of Cairo Lang with Playground & Newton.** ✨ 

*Vote for your favorite answer - the best answer will win a $10 award. A new day – a new reward! During the next 17 days, our goal is to attract more developers to the Cairo language and to systematize the knowledge of Cairo lang. [Read rules](https://www.notion.so/17-days-of-Cairo-Lang-with-Newton-550dfcda6a2d449ca468be293c776578)*

How to write a function in Cairo Lang (StarkNet)?

# Problem
```
// The function `abs_eq` should return 1 if its inputs
// are equal or differ only in sign and 0 otherwise.
// Its current implementation is incorrect.
// Returns 1 if |x| = |y| (that is, x = y or x = -y),
// 0 otherwise.
func abs_eq(x: felt, y: felt) -> (bit: felt) {
    if (x == -y) { 
        return (bit=1);
    } else {
        return (bit=0);
    }
}

func main() {
    let (bit) = abs_eq(2, -2);
    assert bit = 1;

    let (bit) = abs_eq(2, 3);
    assert bit = 0;

    let (bit) = abs_eq(2, 2);
    assert bit = 1;

    return ();
}
```

# Solution

```
func abs_eq(x: felt, y: felt) -> (bit: felt) {
    if (x == y) { //2===2 or -2 ==. -2 
        return (bit=1);
    }
    if (x == -y) { // 2 == -(-2) or -2 == -2 
        return (bit=1);
    } 
return (bit=0);
}
func main() {
    let (bit) = abs_eq(2, -2);
    assert bit = 1;

     let (bit) = abs_eq(2, 2);
    assert bit = 1;
    
     let (bit) = abs_eq(-2, 2);
    assert bit = 1;
    
     let (bit) = abs_eq(-2, -2);
    assert bit = 1;

    let (bit) = abs_eq(2, 3);
    assert bit = 0;
    
    return ();
}
```

# Explanation
**abs_eq** function accepts two arguments x and y, if x and y equal in magnitude or differ only in sign it will return 1 otherwise 0.


**First if statement** checks the both magnitude and signs should be equal to return true that is (2,2), (-2,-2)


**Second if statement** checks the both magnitude should be same but return true only if signs are different that is (-2,2) , (2,-2)


main function uses **assert** to verifies the computation of all the test cases possible for the conditions.

Hello! This is day 3 of the 17 days of the Cairo Challenge. And I have no idea how to solve the [playground](https://www.cairo-lang.org/playground/) exercise “Conditionals”. Perhaps you can help me?

```python
// The function `abs_eq` should return 1 if its inputs
// are equal or differ only in sign and 0 otherwise.
// Its current implementation is incorrect.
//
// 1. Click on "Run" to see where it fails.
// 2. Fix the body of `abs_eq`, so that the
//    program terminates successfully.

// Returns 1 if |x| = |y| (that is, x = y or x = -y),
// 0 otherwise.
func abs_eq(x: felt, y: felt) -> (bit: felt) {
    if (x == -y) {
        return (bit=1);
    } else {
        return (bit=0);
    }
}

func main() {
    let (bit) = abs_eq(2, -2);
    assert bit = 1;

    let (bit) = abs_eq(2, 3);
    assert bit = 0;

    let (bit) = abs_eq(2, 2);
    assert bit = 1;

    return ();
}
```

---


> Answers to this question are a part of the ✨ **17 days of Cairo Lang with Playground & Newton.** ✨

*Vote for your favorite answer - the best answer will win a $10 award. A new day – a new reward! During the next 17 days, our goal is to attract more developers to the Cairo language and to systematize the knowledge of Cairo lang. [Read rules](https://www.notion.so/17-days-of-Cairo-Lang-with-Newton-550dfcda6a2d449ca468be293c776578)*

How to make conditional expressions if..then..else in Cairo lang?


# Solution

```
%builtins output

// Import the serialize_word() function.
from starkware.cairo.common.serialize import serialize_word

// Outputs the value 2^9.
func main{output_ptr: felt*}() {
    // alloc_locals;
    let x = 2;
    let y = x * x * x;
    let z = y * y * y;
    // Because of the `let`s, the following line is equivalent to
    // serialize_word(x * x * x * x * x * x * x * x * x).
    serialize_word(z);
    return ();
}
```
# Output

```
Program output:
  512
Number of steps: 7
Program hash: 0x01369567b8bbbd05c7bd71fc0f26943286f30246277672185a082e4c5d5476bb
```


Hello! This is day 4 of the 17 days of the Cairo Challenge. And I have no idea how to solve the [playground](https://www.cairo-lang.org/playground/) exercise “Variables”. Can you launch this code with the instructions and write down how many steps the program has in the output?

[BONUS]: try to make it faster

```
// The following code outputs the 9th power of 2.
// 1. Click on "Debug" to run the code, and then click on
//    the arrows in the memory panel to trace the program
//    step by step.
//
// Observe that the computation of `z` take 8 steps and
// creates 8 temporary variables. This is because `let`
// simply replaces each instance of `y` with `x * x * x`
// and each instance of `z` with `y * y * y`, which is
// expanded to nine multiplications.
//
// 2. Change the two `let`s to `tempvar`s and run the program.
//
// "tempvar" stands for "temporary variable", which means that
// a variable will be allocated for the intermediate values
// (`x * x * x` and `y * y * y`). This reduces the same
// computation to use only 4 steps and 2 new variables.
//
// 3. Replace all three instance of the keyword `tempvar`
//    with `local`, uncomment the line containing `alloc_locals`
//    and run the code again.
//
// The behavior of the code doesn't change. This is because
// the keyword `local` allocates a new variables for the
// intermediate values as well. The main difference between
// `local` and `tempvar` is explained in the next challenge.

// Use the output builtin.
%builtins output

// Import the serialize_word() function.
from starkware.cairo.common.serialize import serialize_word

// Outputs the value 2^9.
func main{output_ptr: felt*}() {
    // alloc_locals;
    tempvar x = 2;
    let y = x * x * x;
    let z = y * y * y;
    // Because of the `let`s, the following line is equivalent to
    // serialize_word(x * x * x * x * x * x * x * x * x).
    serialize_word(z);
    return ();
}
```

---

> Answers to this question are a part of the ✨ 17 days of Cairo Lang with Playground & Newton. ✨
> 

*Vote for your favorite answer - the best answer will win a $10 award. A new day – a new reward! During the next 17 days, our goal is to attract more developers to the Cairo language and to systematize the knowledge of Cairo lang. [Read rules](https://www.notion.so/17-days-of-Cairo-Lang-with-Newton-550dfcda6a2d449ca468be293c776578)*

What is the difference between tempvar/let in Cairo Lang? How to use allow_locals and local?


# Solution


## Steps:

1. **Output while running the whole code:**
     
```
Error: code:18:20: Reference 'x' was revoked.
    serialize_word(x + y);
                   ^
Reference was defined here:
code:16:10
    let (x) = foo(10);
         ^
```

Explanation of error
if there is a call to another function between the definition of a reference that depends on ap and its usage, the reference may be revoked, since the compiler may not be able to compute the change of ap.
Source: Cairo docs

2 **Adding  "alloc_locals" to the beginning of main()**

In simple cases the issue can be resolved by adding the keyword, alloc_locals within function scopes, but in most complex cases you might need to create a local variable to resolve it.

```
func main{output_ptr: felt*}() {
 alloc_locals;
 let (x) = foo(10);
    let (y) = foo(5);
    serialize_word(x + y);
    return ();
}
```
Code run successfully

3 **Replace "alloc_locals" with  "ap += SIZEOF_LOCALS;"**

Same error returned 

 Cairo provides the instruction alloc_locals which is transformed to ap += SIZEOF_LOCALS but doesn't enable the mechanism that automatically resolves revoked references.


4 and 5 **Solve the problem manually by copying the value of `x` to a local variable**


```
func main{output_ptr: felt*}() {
  ap += SIZEOF_LOCALS;
  let (x) = foo(10);
  local x2 = x; // or local x = x; 
  let (y) = foo(5);
  serialize_word(x2 + y); // or serialize_word(x + y) ,when local x = x
  return ();
}
```
"local x = x": Reference Rebinding which means hat different expressions may be assigned to the same reference.

6 Using Shorter syntax

```
func main{output_ptr: felt*}() {
  ap += SIZEOF_LOCALS;
let (local x) = foo(10);  
  let (y) = foo(5);

  serialize_word(x + y);
  return ();
}
```
Code Run successfully

**Extra Points:**
Unlike temporary variables (variables created using the tempvar and let keywords) which are based on **ap** registers, Local variables are based on the fp** **register, and as such, not easily revoked.

Registers to understand better what's going behind the scenes

**Program counter (pc)** contains the address in memory of the current Cairo instruction to be executed.

**Allocation pointer (ap)** , by convention, points to the first memory cell that has not been used by the program so far.

**Frame pointer (fp)** points to the beginning of the stack frame of the current function. The value of fp allows a stack-like behavior: When a
function starts, fp is set to be the same as the current ap, and when the function returns, fp resumes its previous value. Thus, the value
of fp stays the same for all the instructions in the same invocation
of a function. 

Source: Cairo whitepaper


## Final Working code using shorter syntax

```
%builtins output

from starkware.cairo.common.serialize import serialize_word

// Returns a^3 for a != 0 and 1 otherwise.
func foo(a) -> (res: felt) {
    if (a == 0) {
        return (res=1);
    } else {
        return (res=a * a * a);
    }
}

// Outputs the value 10^3 + 5^3.
func main{output_ptr: felt*}() {
  ap += SIZEOF_LOCALS;
  let (local x) = foo(10);  
  let (y) = foo(5);

  serialize_word(x + y);
  return ();
}

```


>Hello! This is day 5 of the 17 days of the Cairo Challenge. And I have no idea how to solve the [playground](https://www.cairo-lang.org/playground/) exercise “Revoked references”. Can you run these 6 steps and write down what you see?

```
// The scope of some types of references in Cairo (e.g., return values of
// functions and temporary variables) is somewhat restricted.
// For example, a call to another function may revoke those references.
//
// 1. Try to run the following code. You should get an error that `x` was revoked
//    (this is because of the second call to `foo`).
// 2. In simple cases, like this one, the compiler can solve this automatically
//    if the "alloc_locals" keyword is used within the function's scope.
//    Add "alloc_locals;" to the beginning of main(), and make sure the code works.
// 3. To understand what happens behind the scenes, replace "alloc_locals;" with
//    "ap += SIZEOF_LOCALS;" - this command allocates memory cells for local variables
//    (you'll need them below) but doesn't enable the mechanism that
//    automatically resolves revoked references.
//    Trying to run the code now should result in the original error.
// 4. Solve the problem manually by copying the value of `x` to a local variable
//    (e.g., "local x2 = x;"). Local variables are not revoked when functions
//    are called.
//    You can read more about local variables [here](https://www.cairo-lang.org/docs/how_cairo_works/consts.html#local-vars).
// 5. You can even use the same name: "local x = x;".
//    This is called "reference rebinding", where the meaning of `x` changes:
//      Before this line, `x` refers to the return value.
//      After that, `x` refers to the local variable.
// 6. A shorter syntax is "let (local x) = foo(10);" which achieves the same goal.
//    Try it!

%builtins output

from starkware.cairo.common.serialize import serialize_word

// Returns a^3 for a != 0 and 1 otherwise.
func foo(a) -> (res: felt) {
    if (a == 0) {
        return (res=1);
    } else {
        return (res=a * a * a);
    }
}

// Outputs the value 10^3 + 5^3.
func main{output_ptr: felt*}() {
    let (x) = foo(10);
    let (y) = foo(5);
    serialize_word(x + y);
    return ();
}
```

---

> Answers to this question are a part of the ✨ 17 days of Cairo Lang with Playground & Newton. ✨
> 

*Vote for your favorite answer - the best answer will win a $10 award. A new day – a new reward! During the next 17 days, our goal is to attract more developers to the Cairo language and to systematize the knowledge of Cairo lang. [Read rules](https://www.notion.so/17-days-of-Cairo-Lang-with-Newton-550dfcda6a2d449ca468be293c776578)*



Popular tags

Profile

Ishita Rastogi

Wallet address: 0x0Db723d5863A9B33AD83aA349B27F8136b6d5360

Recent questions

Recent answers