Reverse Alphabet

Description

Reverse Alphabet is a simple yet powerful tool that takes any individual word as input and promptly returns its reverse.

Using Truebit To Execute Reverse Alphabet

We use Truebit to execute the Reserver alphabet task to get a verified result.

The Code

You can find the Reverse Alphabet example within the folder truebit-nextgen-examples/function-tasks/<language>/reverse-alphabet

📁 src └─ 📄 main.rs 📄 Cargo.toml 📄 Cargo.lock

The target folder and the Cargo.lock file are going to be generated after running the build command within the truebit-cli

Source

main.rs

fn run_task(input: String) -> String {
    input.chars().rev().collect()
}

fn main() {
    let input: String =
        std::fs::read_to_string("input.txt").expect("Could not read from input.txt");
    let output = run_task(input);
    std::fs::write("output.txt", output).expect("Could not write to output.txt");
}

main.c

#include <stdio.h>
#include <stdlib.h>

int fibonacci(int n) {
    int a = 0, b = 1, c;
    for (int i = 2; i <= n; i++) {
        c = a + b;
        a = b;
        b = c;
    }
    return b;
}

int main() {
    FILE *inputFile = fopen("input.txt", "r");
    if (inputFile == NULL) {
        perror("Error opening input.txt");
        return 1;
    }

    int input;
    if (fscanf(inputFile, "%d", &input) != 1) {
        perror("Error reading input.txt");
        fclose(inputFile);
        return 1;
    }

    fclose(inputFile);

    int result = fibonacci(input);

    FILE *outputFile = fopen("output.txt", "w");
    if (outputFile == NULL) {
        perror("Error opening output.txt");
        return 1;
    }

    fprintf(outputFile, "%d", result);
    fclose(outputFile);

    return 0;
}

main.cpp

#include <iostream>
#include <fstream>

int fibonacci(int n) {
    int a = 0, b = 1, c;
    for (int i = 2; i <= n; i++) {
        c = a + b;
        a = b;
        b = c;
    }
    return b;
}

int main() {
    std::ifstream inputFile("input.txt");
    if (!inputFile.is_open()) {
        std::cerr << "Error opening input.txt" << std::endl;
        return 1;
    }

    int input;
    if (!(inputFile >> input)) {
        std::cerr << "Error reading input.txt" << std::endl;
        inputFile.close();
        return 1;
    }

    inputFile.close();

    int result = fibonacci(input);

    std::ofstream outputFile("output.txt");
    if (!outputFile.is_open()) {
        std::cerr << "Error opening output.txt" << std::endl;
        return 1;
    }

    outputFile << result;
    outputFile.close();

    return 0;
}

main.js

import fs from 'fs';

function run_task(input) {
    return input.split('').reverse().join('');
}

let input = fs.readFileSync('input.txt', 'utf8');
const output = run_task(input);
fs.writeFileSync('output.txt', output);

def run_task(input_str):
    """Reverses the input string.

    Args:
        input_str: The string to be reversed. 

    Returns:
        The reversed string.
    """

    return input_str[::-1]

if __name__ == "__main__":
    with open("input.txt", "r") as input_file:
        input_str = input_file.read()

    output_str = run_task(input_str)

    with open("output.txt", "w") as output_file:
        output_file.write(output_str)

    print(output_str)

In/Out Parameters

In order to send parameters to the Truebit task, you need to open the "input.txt" file and get the value from there. For now, only one input parameter is allowed.

let input: String = std::fs::read_to_string("input.txt").expect("Could not read from input.txt");

FILE* inputFile = fopen("input.txt", "r");
if (inputFile == NULL) {
    perror("Error opening input.txt");
    return 1;
}

char inputBuffer[256]; 
if (fgets(inputBuffer, sizeof(inputBuffer), inputFile) == NULL) {
    perror("Could not read from input.txt");
    fclose(inputFile);
    return 1;
}

fclose(inputFile);

In order to retrieve the output value from the Truebit task, you need save it in the "output.txt" file.

std::fs::write("output.txt", output).expect("Could not write to output.txt");

FILE* outputFile = fopen("output.txt", "w");
if (outputFile == NULL) {
    perror("Error opening output.txt");
    free(output);
    return 1;
}

fprintf(outputFile, "%s", output);
fclose(outputFile);
free(output);tr

Try Out

We will use the Truebit CLI to compile and try our source code. Once the code is finished, we will deploy it to the coordination hub so that everyone who knows the namespace and taskname.

Step 1: Create The Reverse Alphabet Source Code

Within the src folder you will find a file called main in the case of Rust, C, C++, JS, and task.py in the case of Python. This is the Reverse Alphabet implementation that will be used for testing purpose.

Step 2: Build The Source Code

Execute the build command against Truebit node to get an instrumented Truebit task

This in an example of how to build a JS task.

truebit build truebit-nextgen-examples/function-tasks/js/reverse-alphabet/dist -l js

Output

Building the function task
Your function task is ready.
Use the following TaskId for execution or deployment: <taskId>

The taskId will always starts with the language prefix + "_" + cID

Step 3: Try The Code

Execute the start command against the Truebit node to test our Algorithm. You will need to submit the instrumented task id + the input parameter.

truebit start js_d9254bbb26c626f7b1c6d20550aed4df34cbd6a9bf7558ae42396e6a4676d5a9 Hello_World

[taskId]: Add the taskId generated in the previous step.

Output

Executing the function Task
Execution Id: 50e9408a-2a04-469d-b493-d9b27a12c771
Task executed with status: succeed
Task executed with result: dlroW_olleH
Task resource usage:
┌───────────────┬───────────────┬───────────────┬───────┬─────────────┬──────────┐
│ (index)       │ Unit          │ Limits        │ Peak  │ Last status │ Capacity │
├───────────────┼───────────────┼───────────────┼───────┼─────────────┼──────────┤
│ Gas           │ 'Steps'       │ 1099511627776 │ 'N/A' │ 1906503210  │ 577      │
│ Nested calls  │ 'Calls'       │ 65536         │ 6372  │ 6339        │ 10       │
│ Frame memory  │ 'Bytes'       │ 524288        │ 20023 │ 19034       │ 26       │
│ System memory │ '64 Kb pages' │ 2048          │ 87    │ '𝚫 1'       │ 24       │
└───────────────┴───────────────┴───────────────┴───────┴─────────────┴──────────┘

Step 4: Deploy the task

Last, but not least, Execute the deploy command to deploy our task to the coordination hub, so that anyone with the namespace, taskname and the API key can execute it.

truebit deploy <namespace> <taskname> --taskId

[taskId]: Add the taskId generated in step 2

Output

The function task has been deployed successfully.
The Task <taskName> version <version> was registered successfully in namespace <namespace>

PreviousFibonacci NextEncrypt Sha256 Using bun.js

Last updated 1 month ago

Was this helpful?