Explore Rust’s unique features with 24 brain-teasing puzzles. Gain insights into Rust concepts, enhancing your skills and preparing for advanced topics after completing the course.

newrust.tar.gz

codewidgetrust

livewidgetrust

livewidgetrust-cargo-toml-release

codewidgetrust-cargo

livewidgetrust-cargo-main-toml-release

livewidgetrust-cargo-clippy

livewidgetrust-cargo-main-release

livewidgetrust-cargo-nightly

livewidgetrust-cargo-release-update

livewidgetrust-cargo-languages

livewidgetrust-shadow-same

livewidgetrust-shadow-reuse

livewidgetrust-shadow-unrelated

live-cargo-clippy

live-cargo-release-update

live-cargo-nightly

live-cargo-shadow-same

live-cargo-shadow-reuse

live-cargo-shadow-unrelated

live-cargo-sleepless

livewidgetrust-cargo-release-update-puzzle11

This course provides insights into Rust’s unique features by exploring them in 24 brain-teasing puzzles. Each puzzle is explained in its following lesson. Complete all 24, and by the time you’re done, your knowledge about different concepts in Rust will definitely be improved, and you will be ready to move on to more advanced concepts.

Rust Brain Teasers

# Test it out

Hit “Run” to see the code’s output. The answer depends on how we run the program.

## Debug mode

Pressing “Run” will cause the program to crash and display an error message:

fn main() {
    let c = Box::new([0u32; 10_000_000]);
    println!("{}", c.len());
}

## Release mode

Pressing “Run” in release mode will display the following output:

``` xml
10000000
```

[package]
name = "boxes"
version = "0.1.0"
authors = ["Herbert Wolverson <herberticus@gmail.com>"]
edition = "2018"

# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

[dependencies]


fn main() {
    let c = Box::new([0u32; 10_000_000]);
    println!("{}", c.len());
}

import React from 'react';
import { shallow, configure } from 'enzyme';
import Adapter from 'enzyme-adapter-react-16';

configure({ adapter: new Adapter() });

import HelloWorld from './app';

var TestResult = function() {
    this.succeeded = false;
    this.reason = "";
    this.input = "";
    this.expected_output = "";
    this.actual_output = "";
}

export const executeTests = function() {

  var results = [];

  result = new TestResult();
  result.input = 'HelloWorld Component';
  result.expected_output = "span containing text 'Hello World'"

  let wrapper = shallow(<HelloWorld />);

  // Call your Challenge function here.

  let type = wrapper.type();
  let testSuccessful = true;
  let failureReason;

  if (type !== 'span') {
    testSuccessful = false;
    failureReason = "You need to render exactly one span HTML element";
  } else if (wrapper.props().children != "Hello World") {
     testSuccessful = false;
     failureReason = "You have rendered wrong message in your span element";
  }

  result.actual_output = wrapper.html();

  if (testSuccessful) {
    result.succeeded = true;
    result.reason = "Succeeded"
  } else {
    result.succeeded = false;
    result.reason = failureReason;
  }

  results.push(result);

  return results;
}


React

Dart

GoJS React

Typescript React

Vue.js

# Explanation
$10,000,000$ $32$-bit integers require $40$MB of memory to store. That’s larger than the default stack. Attempting to get around this limitation, the code uses `Box` to place the structure on the heap. However, in debug mode, Rust first allocates the array on the stack and then moves it to the heap which crashes the program.

To better understand the example, let’s look at how program memory is arranged. Computer programs use two distinct areas of memory while operating—the stack and the heap.

Let’s find out how stacks and heaps work in Rust.

Introduction

Puzzles

Wrapping it up

Puzzle 11: Explanation

Test it out

Debug mode

Release mode

Explanation