DEVOCEAN

Function generate_random_string(length):
    Define characters = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789'
    Define random_string = ''

    For i from 1 to length:
        Generate a random index from 0 to the length of characters - 1
        Append the character at the random index in characters to random_string

    Return random_string

Function count_alnum(input_string):
    Define count_digits = 0
    Define count_letters = 0

    For each character in input_string:
        If character is a digit:
            Increment count_digits by 1
        Else if character is an alphabet letter:
            Increment count_letters by 1

    Return count_digits, count_letters

# Step 1: Generate a random string
length_of_random_string = 10  # Arbitrary length
random_string = generate_random_string(length_of_random_string)
print("Generated random string:", random_string)

# Step 2: Count numbers and alphabets in the generated string
digits_count, alphabets_count = count_alnum(random_string)
print("Digits count:", digits_count)
print("Alphabets count:", alphabets_count)

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

void* safe_malloc(size_t size) {
    void *ptr = malloc(size);
    if (ptr == NULL) {
        // Handle the memory allocation failure
        fprintf(stderr, "Error: Memory allocation failed for %zu bytes.\n", size);
        exit(EXIT_FAILURE); // Exit the program or handle the error as per your requirement
    }
    return ptr;
}

void safe_free(void **ptr) {
    if (ptr != NULL && *ptr != NULL) {
        free(*ptr);
        *ptr = NULL; // Prevents double-free errors
    }
}

int main() {
    int *numbers = safe_malloc(10 * sizeof(*numbers)); // Allocate memory for 10 integers
    
    // Use the memory...
    for(int i = 0; i < 10; i++) {
        numbers[i] = i;
    }
    
    // When done, free the memory safely
    safe_free((void**)&numbers);
    
    // After safe_free, numbers is NULL and cannot be accidentally freed again
    if(numbers == NULL) {
        printf("Memory successfully freed and pointer is NULL.\n");
    }

    return 0;
}

#include <glib.h>
#include <stdio.h>

int main() {
    // Allocate memory for 10 integers using GLib's g_new
    // Syntax: g_new(Type, Number_of_Elements)
    gint *numbers = g_new(gint, 10);

    // Use the allocated memory
    for (int i = 0; i < 10; i++) {
        numbers[i] = i * 10; // Example operation
        printf("numbers[%d] = %d\n", i, numbers[i]);
    }

    // Free the allocated memory using GLib's g_free
    g_free(numbers);

    // After g_free, it's a good practice to set the pointer to NULL to avoid accidental use
    numbers = NULL;

    return 0;
}

#include <glib.h>
#include <stdio.h>

// Automatic cleanup for GArray
G_DEFINE_AUTO_CLEANUP_FREE_FUNC(GArray, g_array_unref, NULL)

int main() {
    // Allocate a GArray with automatic cleanup
    g_autoptr(GArray) numbers = g_array_new(FALSE, FALSE, sizeof(gint));
    
    // Use the allocated array
    for (int i = 0; i < 10; i++) {
        gint num = i * 10; // Example operation
        g_array_append_val(numbers, num);
        printf("numbers[%d] = %d\n", i, g_array_index(numbers, gint, i));
    }

    // No need to manually free the array; it will be automatically freed
    // when it goes out of scope (i.e., at the end of the main function)
    
    return 0;
}

///
/// https://github.com/hwangsaeul/gaeguli/blob/110822e039888b2fcc8a400e6fd20a88dd956fa2/gaeguli/pipeline.c#L498
///
GaeguliPipeline *
gaeguli_pipeline_new (GVariant * attributes)
{
  g_autoptr (GaeguliPipeline) pipeline = NULL;
  GaeguliVideoSource source;
  const gchar *device = NULL;
  GaeguliVideoResolution resolution;
  guint framerate = 0;
  GVariantDict attr;

  g_return_val_if_fail (g_variant_is_of_type (attributes,
          G_VARIANT_TYPE_VARDICT), NULL);

  g_variant_dict_init (&attr, attributes);
  g_variant_dict_lookup (&attr, "source", "i", &source);
  g_variant_dict_lookup (&attr, "device", "s", &device);
  g_variant_dict_lookup (&attr, "resolution", "i", &resolution);
  g_variant_dict_lookup (&attr, "framerate", "u", &framerate);

  g_debug ("source: [%d / %s]", source, device);
  pipeline = g_object_new (GAEGULI_TYPE_PIPELINE, "source", source, "device",
      device, "resolution", resolution, "framerate", framerate, "attributes",
      g_variant_dict_end (&attr), NULL);

  return g_steal_pointer (&pipeline);
}

...

///
/// https://github.com/hwangsaeul/gaeguli/blob/110822e039888b2fcc8a400e6fd20a88dd956fa2/tests/test-pipeline.c#L74C1-L103C2
/// 
static void
test_gaeguli_pipeline_instance (TestFixture * fixture, gconstpointer unused)
{
  GaeguliTarget *target;
  g_autoptr (GaeguliPipeline) pipeline =
      gaeguli_pipeline_new_full (GAEGULI_VIDEO_SOURCE_VIDEOTESTSRC, NULL,
      GAEGULI_VIDEO_RESOLUTION_640X480, 30);
  g_autoptr (GError) error = NULL;

  g_signal_connect (pipeline, "stream-started", G_CALLBACK (_stream_started_cb),
      fixture);
  g_signal_connect (pipeline, "stream-stopped", G_CALLBACK (_stream_stopped_cb),
      fixture);

  target = gaeguli_pipeline_add_srt_target_full (pipeline,
      GAEGULI_VIDEO_CODEC_H264_X264, GAEGULI_VIDEO_STREAM_TYPE_MPEG_TS, 2048000,
      "srt://127.0.0.1:1111", NULL, &error);

  g_assert_no_error (error);
  g_assert_nonnull (target);
  g_assert_cmpuint (target->id, !=, 0);
  fixture->target = target;

  gaeguli_target_start (target, &error);
  g_assert_no_error (error);

  g_main_loop_run (fixture->loop);

  gaeguli_pipeline_stop (pipeline);
}