
# Solution

```
%builtins output

from starkware.cairo.common.serialize import serialize_word

func compute_sum{output_ptr: felt*}(n: felt) -> (sum: felt) {
    if (n == 0) {
        // When 0 is reached, return 0.
        return (sum=0);
    }

    // Otherwise, call `compute_sum` recursively to compute 1 + 2 + ... + (n-1).
    let (sum) = compute_sum(n=n - 1);
    // Add the new value `n` to the sum.
    let new_sum = sum + n;
    //print all the intermediate sums
    serialize_word(new_sum);
    return (sum=new_sum);
}

func main{output_ptr: felt*}() {
    let (res) = compute_sum(n=10);

    return ();
}
```
# Output
```
Program output:
  1
  3
  6
  10
  15
  21
  28
  36
  45
  55

Number of steps: 129
Program hash: 0x034b8ec64f54dafcc743d1af9fbfe33a41b62f19d1849abcdfe3f78dc0b51afb
```
# Explanation
main function calls **compute_sum** function by passing an argument of number of natural number(n=10). compute_sum function perform recursion by calling itself. It calls itself till n equal to zero. when base condition reached the sum returned to from where it got called. At this point sum equal to zero and n equal to 1 which results 1 and assigned it to new_sum and then print is using serialize_word. 
This repeats again sum equal to 1 and n equal to 2 which results in 3.It continues til n equal to 10.





Hello! This is day 7 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 “Recursion”.  Perhaps you can help me?

```
// The following code prints the sum of the numbers from 1 to 10.
// Modify the function `compute_sum` to print all the intermediate sums:
// 1, 1 + 2, 1 + 2 + 3, ..., 1 + 2 + ... + 10.
// Note: you'll have to add the implicit argument output_ptr to the
// declaration of compute_sum (in order to use the serialize_word function):
//   func compute_sum{output_ptr: felt*}(n: felt) -> (sum: felt)

// Use the output builtin.
%builtins output

from starkware.cairo.common.serialize import serialize_word

func compute_sum(n: felt) -> (sum: felt) {
    if (n == 0) {
        // When 0 is reached, return 0.
        return (sum=0);
    }

    // Otherwise, call `compute_sum` recursively to compute 1 + 2 + ... + (n-1).
    let (sum) = compute_sum(n=n - 1);
    // Add the new value `n` to the sum.
    let new_sum = sum + n;
    return (sum=new_sum);
}

func main{output_ptr: felt*}() {
    let (res) = compute_sum(n=10);

    // Output the result.
    serialize_word(res);
    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 recursive function in Cairo Lang?

# Solution 
```
%builtins output

from starkware.cairo.common.serialize import serialize_word

// Computes base^exp.
func pow(base: felt, exp: felt) -> (res: felt) {
    if (exp == 0) {
        return (res=1);
    }

    let (res) = pow(base=base, exp=exp - 1);
    return (res=res * base);
}
// 1. 1 + 100, 1 - 100, 9 * 9.
// 2. pow(10, 74), pow(10, 75), pow(10, 76)
// 3. 12 / 3, (-12) / 3
// 4. 13 / 3 (This is an example of division in the field)

func main{output_ptr: felt*}() {
alloc_locals;
//Addition and subtraction
serialize_word(1 + 100);
serialize_word(1-100);
serialize_word(9*9);
//power
let(result)=pow(10,74);
serialize_word(result);

let(result2)=pow(10,75);
serialize_word(result2);
//out of range
let(result3)=pow(10,76);
serialize_word(result3);
//Division
serialize_word(12/3);
serialize_word(-12/3);
//overflow will occur
serialize_word(13/3);

return ();
}
```
# Output

```
Program output:
  101
  -99
  81
  100000000000000000000000000000000000000000000000000000000000000000000000000
  1000000000000000000000000000000000000000000000000000000000000000000000000000
  -855508365998393641091968349285210316869321645994790099919276168407616061443
  4
  -4
  1206167596222043737899107594365023368541035738443865566657697352045290673498

Number of steps: 1422
Program hash: 0x06ae6cf8429a50cc2acf3ddca91271df8c4ac533750824ce0a13934991245e51
```
## Division in Cairo

Unlike regular CPUs where integer division x / y is defined as ⌊ x / y ⌋ (so 7 / 2 = 3 ) and it may or may not satisfy the equation (x / y) * y == x , in Cairo, the result of x / y is defined to always satisfy the equation (x / y) * y == x .

[https://www.cairo-lang.org/docs/hello_cairo/intro.html#the-primitive-type-field-element-felt]()

Hello! This is day 8 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 “Field Elements”.  Perhaps you can help me?

```
// Unlike most systems where the primitive type is a 32 or 64-bit integer,
// the primitive type in Cairo is "felt", which stands for "field element".
// When we say "a field element" we mean an integer in the range -P / 2 < x < P / 2,
// where P is a very large (prime) number.
// Currently we use a 252-bit number (76 decimal digits).
// When we add, subtract or multiply and the result is outside the range above,
// there is an overflow.
//
// The most important difference between integers and field elements is division:
// Division of field elements (and therefore division in Cairo) is not the
// integer division you may be used to.
// In the next challenge, you'll see how to use unsigned_div_rem()
// for truncated (i.e., rounding down) integer division.
//
// Make the code below output the results of the following expressions:
// 1. 1 + 100, 1 - 100, 9 * 9.
// 2. pow(10, 74), pow(10, 75), pow(10, 76)
// 3. 12 / 3, (-12) / 3
// 4. 13 / 3 (This is an example of division in the field)

%builtins output

from starkware.cairo.common.serialize import serialize_word

// Computes base^exp.
func pow(base: felt, exp: felt) -> (res: felt) {
    if (exp == 0) {
        return (res=1);
    }

    let (res) = pow(base=base, exp=exp - 1);
    return (res=res * base);
}

func main{output_ptr: felt*}() {
    serialize_word(1 + 100);
    // Add your code here.

    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 math operation with Field Elements (felts) in Cairo lang?

# Solution

```
%builtins output range_check

// Import unsigned_div_rem() from the math module.
from starkware.cairo.common.math import unsigned_div_rem
from starkware.cairo.common.serialize import serialize_word

func main{output_ptr: felt*, range_check_ptr}() {
    let (q, r) = unsigned_div_rem(value=12, div=3);
    // Output the quotient (12// 3).
    serialize_word(q);
    // Output the remainder (12 % 3).
    serialize_word(r);

    // Add code that outputs the quotient and remainder of 13 / 3 in addition to 12 / 3 here.

    let (a, b) = unsigned_div_rem(value=13, div=3);
    // Output the quotient (13// 3).
    serialize_word(a);
    // Output the remainder (13 % 3).
    serialize_word(b);
    return ();
}

```
# Output

```
Program output:
  4
  0
  4
  1

Number of steps: 70
Program hash: 0x0238e10075bbd2ad40c6275fc85e62ffd27a649bd13415ae8b74a5ff49647509
```

# Explanation
**unsigned_div_rem** function signature looks like this:

```
func unsigned_div_rem{range_check_ptr}(value, div) -> (q : felt, r : felt):
```
It accepts two argument value and div. The value of div is restricted to make sure there is no overflow and it returns quotient and remainder such that:

`0 <= q < rc_bound, 0 <= r < div and value = q * div + r`

Hello! This is day 9 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 “Field Elements 2”.  Perhaps you can help me?

```
// As you saw in the previous challenge, the operator '/' does not denote
// truncated (i.e., rounding down) integer division as in other programming
// languages. Instead, one can use library functions such as
// unsigned_div_rem().
//
// Note that unsigned_div_rem() does not work for negative numbers.

%builtins output range_check

// Import unsigned_div_rem() from the math module.
from starkware.cairo.common.math import unsigned_div_rem
from starkware.cairo.common.serialize import serialize_word

func main{output_ptr: felt*, range_check_ptr}() {
    let (q, r) = unsigned_div_rem(value=12, div=3);
    // Output the quotient (12 // 3).
    serialize_word(q);
    // Output the remainder (12 % 3).
    serialize_word(r);

    // Add code that outputs the quotient and remainder of 13 / 3 in addition to 12 / 3 here.

    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 divide felt in Cairo Lang using unsigned_div_rem?

# Running code as-it-is
Error Received:

```
Error: code:30:22: Using the value of fp directly, requires defining a variable named __fp__.
    local y: felt* = &x;
                     ^^
```
## Error Explanation
**From Problem comment:**

To retrieve the *address* of a local variable, it needs to be told the value of the frame pointer register, fp.This can be done by setting a reference named __fp__ to the value, which can be obtained using the library function get_fp_and_pc().

**Reason:**

When a function starts the frame pointer register (fp) is initialized to the current value of ap. During the entire scope of the function (excluding inner function calls) the value of fp remains constant.  **ap** may change in an unknown way when an inner function is called, so it cannot reliably be used to access the original function’s local variables and arguments anymore after that. Thus, fp serves as an anchor to access these values.

Source:

 [https://cairo-lang.org/docs/how_cairo_works/functions.html#the-fp-register]()

## Solution(First part)

Uncommenting line  get_fp_and_pc()

```
from starkware.cairo.common.registers import get_fp_and_pc

// 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);
    }
}

func main() -> () {
    alloc_locals;
    let (__fp__, _) = get_fp_and_pc(); 
    local x: felt;

    // let (res) = foo(a=10);
    local y: felt* = &x;
    assert [y] = 1234;

    return ();
}
```
Code run successfully.

## Final Solution
**2. Uncommenting  the function foo calling:**

Used serialize_word to print the result
```
%builtins output

from starkware.cairo.common.serialize import serialize_word
from starkware.cairo.common.registers import get_fp_and_pc

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

func main{output_ptr: felt*}() -> () {
    alloc_locals;
    let (__fp__, _) = get_fp_and_pc();
    local x: felt;
    let (res) = foo(a=10);
    local y: felt* = &x;
    assert [y] = 1234;
    serialize_word(res);

    return ();
}
```


Hello! This is day 11 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 “Address of locals”.  Perhaps you can help me?

```
// When Cairo needs to retrieve the *address* of a local variable,
// it needs to be told the value of the frame pointer register, fp
// (see [here](https://cairo-lang.org/docs/how_cairo_works/functions.html#fp-register)).
//
// This can be done by setting a reference named __fp__ to the value, which
// can be obtained using the library function get_fp_and_pc().
//
// 1. Try to run the code as-is, and make sure you understand the error.
// 2. Uncomment the line setting __fp__, and run again.
//    The code should now work and you should be able to see that `x` was set
//    to 1000.
// 3. Uncomment the line calling foo() and try to run the code.
//    Fix the code by adding exactly one word to it.
//    Hint: Revisit the "Revoked references" challenge.

from starkware.cairo.common.registers import get_fp_and_pc

// 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);
    }
}

func main() -> () {
    alloc_locals;

    // let (__fp__, _) = get_fp_and_pc();
    local x: felt;
    // let (x) = foo(a=10);
    local y: felt* = &x;
    assert [y] = 1000;
    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 use get_fp_and_pc in Cairo Lang?

# Solution


```
// In this challenge you're going to implement a stack using a linked list.
//
// Add the missing code so that main() runs successfully.

from starkware.cairo.common.registers import get_fp_and_pc

struct Node {
    // A pointer to the next node in the stack.
    next: Node*,

    // The value of the node.
    value: felt,

    // The number of elements in the stack.
    size: felt,
}

// Returns an empty stack.
func empty_stack() -> (stack: Node*) {
    alloc_locals;
    local new_node: Node;
    assert new_node.next = cast(0, Node*);
    assert new_node.value = 0;
    assert new_node.size = 0;

    // The usage of get_fp_and_pc() here is necessary in order
    // to access the address of a local variable (&new_node).
    // You can read more about get_fp_and_pc() [here](https://cairo-lang.org/docs/how_cairo_works/functions.html#retrieving-registers).
    let (local __fp__, _) = get_fp_and_pc();
    return (stack=&new_node);
}

// Adds a node to the top of the stack.
// Returns the updated stack (since Cairo is immutable, you can still use the
// old copy of the stack).
func push(stack: Node*, value: felt) -> (stack: Node*) {
    alloc_locals;
    local new_node: Node;
    assert new_node.next = stack;
    assert new_node.value = value;
    assert new_node.size = stack.size+1;

    let (__fp__, _) = get_fp_and_pc();
    return (stack=&new_node);
}

// Removes the top element of the stack.
// Returns the updated stack and the element that was removed.
func pop(stack: Node*) -> (stack: Node*, value: felt) {
    return (stack=stack.next, value=stack.value);
}

// Returns the value of the n-th element from the top of the stack.
func stack_at(stack: Node*, n: felt) -> (value: felt) {
alloc_locals;
    if (n == 0) {
        return (value=stack.value);
  }
    let (local val) = stack_at(stack=stack.next, n=n - 1);
    return (value=val);
}

func main() -> () {
    alloc_locals;
    // Start with an empty stack.
    let (stack) = empty_stack();
    // Push 1, 10, 100.
    let (stack) = push(stack, 1);
    let (stack) = push(stack, 10);
    let (local stack) = push(stack, 100);

    // Check the size of the stack.
    assert stack.size = 3;

    // Query the stack at indices 0, 1 and 2.
    let (value) = stack_at(stack, 0);
    assert value = 100;
    let (value) = stack_at(stack, 1);
    assert value = 10;
    let (value) = stack_at(stack, 2);
    assert value = 1;

    // Pop the top 2 values (100 and 10) and push 1000.
    let (stack, value) = pop(stack);
    assert value = 100;
    let (stack, value) = pop(stack);
    assert value = 10;
    let (local stack) = push(stack, 1000);

    // Query the stack at indices 0 and 1.
    let (value) = stack_at(stack, 0);
    assert value = 1000;
    let (value) = stack_at(stack, 1);
    assert value = 1;

    return ();
}

```


Hello! This is day 12 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 “Structs.  Perhaps you can help me?

```
// In this challenge you're going to implement a stack using a linked list.
//
// Add the missing code so that main() runs successfully.

from starkware.cairo.common.registers import get_fp_and_pc

struct Node {
    // A pointer to the next node in the stack.
    next: Node*,

    // The value of the node.
    value: felt,

    // The number of elements in the stack.
    size: felt,
}

// Returns an empty stack.
func empty_stack() -> (stack: Node*) {
    alloc_locals;
    local new_node: Node;
    assert new_node.next = cast(0, Node*);
    assert new_node.value = 0;
    assert new_node.size = 0;

    // The usage of get_fp_and_pc() here is necessary in order
    // to access the address of a local variable (&new_node).
    // You can read more about get_fp_and_pc() [here](https://cairo-lang.org/docs/how_cairo_works/functions.html#retrieving-registers).
    let (local __fp__, _) = get_fp_and_pc();
    return (stack=&new_node);
}

// Adds a node to the top of the stack.
// Returns the updated stack (since Cairo is immutable, you can still use the
// old copy of the stack).
func push(stack: Node*, value: felt) -> (stack: Node*) {
    alloc_locals;
    local new_node: Node;
    // Fix and uncomment below.
    // assert new_node.next = ...
    // assert new_node.value = ...
    // assert new_node.size = ...

    let (__fp__, _) = get_fp_and_pc();
    return (stack=&new_node);
}

// Removes the top element of the stack.
// Returns the updated stack and the element that was removed.
func pop(stack: Node*) -> (stack: Node*, value: felt) {
    return (stack=stack.next, value=stack.value);
}

// Returns the value of the n-th element from the top of the stack.
func stack_at(stack: Node*, n: felt) -> (value: felt) {
    if (n == 0) {
        // Add your code here.
    }

    // Add your code here.
}

func main() -> () {
    alloc_locals;
    // Start with an empty stack.
    let (stack) = empty_stack();
    // Push 1, 10, 100.
    let (stack) = push(stack, 1);
    let (stack) = push(stack, 10);
    let (local stack) = push(stack, 100);

    // Check the size of the stack.
    assert stack.size = 3;

    // Query the stack at indices 0, 1 and 2.
    let (value) = stack_at(stack, 0);
    assert value = 100;
    let (value) = stack_at(stack, 1);
    assert value = 10;
    let (value) = stack_at(stack, 2);
    assert value = 1;

    // Pop the top 2 values (100 and 10) and push 1000.
    let (stack, value) = pop(stack);
    assert value = 100;
    let (stack, value) = pop(stack);
    assert value = 10;
    let (local stack) = push(stack, 1000);

    // Query the stack at indices 0 and 1.
    let (value) = stack_at(stack, 0);
    assert value = 1000;
    let (value) = stack_at(stack, 1);
    assert value = 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)*

Popular tags

Profile

Ishita Rastogi

Wallet address: 0x4dc8b342dAe79b0426a05c4fb9d95eD1f9b97144

Recent questions

Recent answers