Coder Legion - Recent posts tagged arrays

Arrays are dumb. So are tuples.

Tue, 29 Sep 2026 14:43:13 +0000

The array/tuple question was never meant to be a long running thing. And as it often happens, the solution was right there in front of me the whole time.

Arrays are intuitive, fast, and let you do (basically) anything. Therein lies the problem with them, no type-constraint, no tracking (other than what you keep in your head).

Tuples are almost exactly the opposite. Powerful, dependable (in and of themselves), type-safe at the position level. But they are awkward, and tend to make code that depends on them, more brittle.

When a debate goes back and forth multiple times with NO NEW INFORMATION being submitted; it tends to devolve into an interminable loop. The only way to break the cycle is to add data, or perspective. The second is honestly the more powerful, by far.

So, what is the perspective that this question is inspected from? "a programming language needs arrays, tuples, or both." There, simply by stating what the subject is in clear terms, we can start to see that the problem is in the perspective itself.

"A programming language needs an ordered-sequence data-structure" (hyphens were hand typed, mmm). Now just look at that! The solution practically bites you on the nose.

Don't use arrays or tuples.

A "tape" is a "constrained by use-case" data sequence. You can think of it as an array with a la carte permissions. With no permissions, a tape explicitly declared will remain exactly that forever.

<primes:int[]=[2, 3, 5, 7]/>

@primes.push(11)                       // error: length is fixed
@primes[0] = 1                         // error: positions are read-only
@primes = [1, 2, 3]                    // error: replacing the whole thing is its own permission
const big = @primes.map(p => p * 10)   // fine: map returns a new value

The sequence itself is frozen: no appends, no removals, no reordering, no swapping one element for another. The elements are exactly as frozen as their own type says. If the type of the thing on the tape has a writable field, that field is writable, tape or no tape. Same rule, all the way down.

<todo:struct>
    <title:string=""/>
    <let done:bool=false/>       // this field grants its own write
</>

<todos:todo[]=[...]/>            // a tape with no permissions

@todos[0].done = true            // fine: judged by `done`, not by the tape
@todos[0].title = "x"            // error: title is locked
@todos.push(t)                   // error: the tape is frozen

The obvious way to build this is a list of allowed methods: this tape may push, that one may pop. That breaks immediately. @log = @log.slice(1) throws away the first entry using nothing but a non-mutating method and an assignment. No banned method was called. So a tape's permissions aren't a list of methods, they're axes: how the length may change, where changes may happen, whether a position may be rewritten. The compiler judges every write by what it DOES to the value, not by how it's spelled. slice(1) is a change at the front. If the tape doesn't allow front changes, that line doesn't compile.

Here's an audit log. Free length, changes only at the end, and nothing else:

type Entry:struct = { at: number, actor: string, action: string }

<audit:Entry[free, end]=[]/>

@audit.push(entry)                          // fine
@audit = [...@audit, entry]                 // same edit, different spelling: fine
@audit.shift()                              // error: a change at the front
@audit = @audit.slice(1)                    // error: still a change at the front
@audit = @audit.filter(e => e.actor != "x") // error: a removal from anywhere
@audit = []                                 // error: a replace
reset(@audit)                               // error: reset is a replace too

No statement anywhere in the program can remove or rewrite an entry, however it's spelled. That log is provably append-only, and the proof costs you one line.

The permissions are part of the tape's type, so they travel. A function only gets to do what its parameter says:

fn pushEdit(s: Edit[end], e: Edit) -> Edit[end] {
    return [...s, e]             // the only thing this function CAN do to `s`
}

<undo:Edit[end]=[]/>
@undo = pushEdit(@undo, e)       // fine: the compiler reads the body and sees an append at the end

There's no "all permissions" switch. A fully mutable tape has to name every axis it wants. An all-grant is a leaky abstraction, unacceptable.

<todos:Todo[free, anywhere, writable, replace]=[]/>

Every axis named. No shorthand. That's the point.

The tape is specified in the scrml language spec (§66.12) and is being built into the new compiler now. It is not in the shipping compiler yet, and the permission syntax shown here is the proposed spelling.

Write a java program to count the letters, spaces, numbers and other characters of an input string.

Thu, 03 Sep 2026 12:40:15 +0000

First take the input form the user as a string
copy that string into a character array
write logic for checking each character of character array is a letter/number/space/other-character
print all the updated values of variables

Note :- There is pre-built fuctions to copy all characters of string into a character array which is :
char name_of_character_array[ ] = name_of_string.toCharArray and There are also pre-bilut functions are there to check weather character is letter/number/space in an array which are : Character.isLetter(ch[i]) , Character.isDigit(ch[i]) , Character.isSpaceChar(ch[i]) respectively

Implode(): invalid arguments passed

Wed, 03 Jun 2026 12:05:55 +0000

Today, we're going to discuss a common error in php, "Implode(): invalid arguments passed". It occurs whenever we pass in invalid arguments to the implode() function. In the next few sections, we'll explore what is "Implode(): invalid arguments passed", why it occurs and how to resolve it.

What is "Implode(): invalid arguments passed" #

First, let's understand what's implode() function. It requires an input array and an optional string separator to work. It will return a string which concatenate all the elemenets in the array orderly with the separator between each element. Let's see:


<?php
$elements = ["Today", "is", "Friday"];
$txt = implode(" ", $elements);
var_dump($txt);
?>

This is the result:


string(15) "Today is Friday"

Look, it is a string text of length 15 and each element in the array is separated by a space.

Tip If you didn't provide a separator, the default separator is empty string ("").

Let's see another example:


<?php
$elements = "Today is Friday";
$txt = implode(" ", $elements);
var_dump($txt);
?>

This is the result:


NULL

PHP Warning:  implode(): Invalid arguments passed in HelloWorld.php on line 3

You may notice that the result is NULL because there's error during runtime and hence the variable, $txt is assigned a NULL value. But why PHP Warning: implode(): Invalid arguments passed happens? Let's move to the next section.

Causes #

The reason behind this error is we didn't pass in an input array as argument to implode() function. This function will only accept an input array to work. Let's see another example:


<?php
$elements = 3;
$txt = implode(" ", $elements);
var_dump($txt);
?>

This is the result:


NULL

PHP Warning:  implode(): Invalid arguments passed in HelloWorld.php on line 3

Even you pass in an integer value, the result is still the same, because it's not an array. So, how to resolve it? Let's see the next section.

Solution #

You may guess the solution easily. Yes, it's passing in an array argument to implode() function.


<?php
$elements = array("Hello","World");
$txt = implode(" ", $elements);
var_dump($txt);
?>

This is the result:


string(11) "Hello World"

Note array() function can generate an array from its several number of arguments. For deep understanding on how to manipulate an array using array() function, you may visit https://www.php.net/manual/en/function.array.php.

You may even pass in an empty array:


<?php
$elements = [];
$txt = implode(" ", $elements);
var_dump($txt);
?>

This is the result:


string(0) ""

You'll notice that this error will never occur as long as you're passing an input array. Pretty simple right?

The Conclusion #

In this study blog, we've understood what's "Implode(): invalid arguments passed", why it occurs and how to simply resolve it. Remember, always pass in array argument to implode() function to omit this error. Hope it helps you and have a nice day! :)

The Reference #

For further information, please visit:

implode(): https://www.php.net/manual/en/function.implode.php
array(): https://www.php.net/manual/en/function.array.php

Index was outside the bounds of the array

Thu, 21 May 2026 12:28:19 +0000

Today, we're going to fix a C# Error: Index was outside the bounds of the array that usually occurs when we try to access the index less than 0 or greater than or equal to the array length - 1. In this study blog, we'll explore why it happens and how to resolve it.

What is "Index was outside the bounds of the array" #

This error happens when we try to access the elements in the array using invalid index. Let's see an example:


int[] numbers = new int[] { 1,2,3,4,5,6,7,8,9 };
for(int i = 0; i <= numbers.Length; i++)
{
    Console.WriteLine(numbers[i]);
}
  </span>

This is the output:


1
2
3
4
5
6
7
8
9
System.IndexOutOfRangeException: 'Index was outside the bounds of the array.'

Why? Because the numbers array has 9 elements, and thus its length is 9. However, in programming, each collection like array has indices in the range of [0 - N-1], where N = array.length and we can access each element in the array within that range. In the above example, after accessing index 8 with element 9 in numbers array, we tend to access element at index 9, which is an invalid index for numbers array. That's why this error occur.

Let's look at another example:


int[] numbers = new int[] { 1,2,3,4,5,6,7,8,9 };
numbers[-1] = 10;

This is the output:


System.IndexOutOfRangeException: 'Index was outside the bounds of the array.'

Why? we're trying to assign value to the element of numbers array at index -1, which is also an invalid index for numbers array. Hence, the error will also occur.

Causes #

The error, Index was outside the bounds of the array is actually under IndexOutOfRangeException Class in C#. IndexOutOfRangeException: The exception is thrown when the attempt to access the element of a collection or an array using the index outside its bounds is made. Hence, System.IndexOutOfRangeException: 'Index was outside the bounds of the array.' occurs when we're trying to access the element of an array using invalid index. Don't fret; it can be simply resolved.

Note Every collection such as list, array or the other has only indices in the range of [0, N-1], where N is the length of the array itself.

Solution #

The solution is pretty simple, we just need to ensure we're accessing the elements of the array using the indices within its bounds. Let's say:


int[] numbers = new int[] { 1,2,3,4,5,6,7,8,9 };
for(int i = 0; i < numbers.Length; i++)
{
    Console.WriteLine(numbers[i]);
}

This is the output:

or you may also do like this:


int[] numbers = new int[] { 1,2,3,4,5,6,7,8,9 };
for(int i = 0; i <= numbers.Length-1; i++)
{
    Console.WriteLine(numbers[i]);
}
  </span>

This is the output:

Both examples above are having the same output. What we do is to ensure that the iteration will only be in the range of [0 - N-1], where N = array.length. The numbers array has the length of 9, and thus can only iterate from 0 to 8. These are the valid indices for the numbers array.

Tip You may also use GetLowerBound(Int32) and GetUpperBound(Int32) to avoid this error.


int[] numbers = new int[] { 1,2,3,4,5,6,7,8,9 };
for(int i = numbers.GetLowerBound(0); i <= numbers.GetUpperBound(0); i++)
{
    Console.WriteLine(numbers[i]);
}
  </span>

This is the output:

For the case above, GetLowerBound(0) is used to get the index of the first element, which is 0 while GetUpperBound(0) is used to get the index of last element. Hence, we can omit the error by using these two functions together.

Note The dimension for both GetLowerBound(int dimension) and GetUpperBound(int dimension) is determined by the array type, whether it is one-dimensional array or two-dimensional array as they have the different Rank. Make sure the dimension has the value of greater than 0 or Rank - 1.

The Conclusion #

In this study blog, we've explore what is Index was outside the bounds of the array in C#, why it happens and how to resolve it. You should always be aware with the indices of the array when you want to access its element. Make sure not to access index outside of its bound, which is the range [0 - N - 1], where N = length of the array. Thanks!

The Reference #

For further information, please visit:

IndexOutOfRangeException: https://learn.microsoft.com/en-us/dotnet/api/system.indexoutofrangeexception?view=net-7.0
GetLowerBound(Int32) in LINQ: https://learn.microsoft.com/en-us/dotnet/api/system.array.getlowerbound?view=net-7.0#system-array-getlowerbound(system-int32)
GetUpperBound(Int32): https://learn.microsoft.com/en-us/dotnet/api/system.array.getupperbound?view=net-7.0#system-array-getupperbound(system-int32)

Actual and formal argument lists differ in length

Thu, 14 May 2026 05:55:50 +0000

Today, we're going to discuss a compilation error in Java: "Actual and formal argument lists differ in length". This error is produced when the number of arguments passed in doesn't match the number of parameters defined in the method or constructor. In this study blog, we'll explore what's "Actual and formal argument lists differ in length", why it happens and how to resolve it.

What is "Actual and formal argument lists differ in length" #

First, let's understand what is actual argument and formal argument.

Formal argument: The arguments we define for a method or constructor.
Actual argument: The arguments we pass into a method or constructor.

Let's see an example:


  public static void main(String[] args) {
        int num_1 = 10;
        int num_2 = 20;
        int sum = addition(num_1, num_2);
        }
    
     public static int addition(int a, int b){
        return a + b;
    }

From the above example, a and b is the formal arguments while num_1 and num_2 is the actual arguments that we pass into the method addition.

Now, we've understood the difference between actual argument and formal argument. Let's see another example:


        public static void main(String[] args) {
        int num_1 = 10;
        int num_2 = 20;
        int sum = addition(num_1);
        }
    
     public static int addition(int a, int b){
        return a + b;
    }

The compilation error occurs:


  method addition in class NewMain cannot be applied to given types;
  required: int,int
  found:    int
  reason: actual and formal argument lists differ in length

Here, we pass in only one actual argument, num_1 but the method, addition actually defines two formal arguments, a and b to work. Let's see another example:


        public static void main(String[] args) {
        int num_1 = 10;
        int num_2 = 20;
        int num_3 = 30;
        int sum = addition(num_1, num_2, num_3);
        }
    
     public static int addition(int a, int b){
        return a + b;
    }

The compilation error also occurs:


  method addition in class NewMain cannot be applied to given types;
  required: int,int
  found:    int,int,int
  reason: actual and formal argument lists differ in length

Here, we pass in three actual arguments, num_1, num_2, and num_3 while the method, addition only need two formal arguments to work.

So far we've discovered this problem in the method invocation. Let's see some examples of constructor:


public class Student {
    private String first_Name;
    private String last_Name;
    
    public Student(String first_Name, String last_Name){
        this.first_Name = first_Name;
        this.last_Name = last_Name;
    }
}

Here, we declare a class, Student, where we need first_Name and last_Name arguments in the constructor to create an instance of Student.


Student student = new Student("Alex");

Here is the compilation error:


constructor Student in class Student cannot be applied to given types;
required: String,String
found:    String
reason: actual and formal argument lists differ in length

Let's move on to the next section to see why it occurs.

Causes #

From the above examples, we can see that this compilation error occurs when the number of actual arguments we pass into the method or constructor doesn't match the number of formal arguments we define for the method or constructor. As long as there's mismatch between the number of actual arguments and the number of formal arguments, this error will always be produced. Don't fret; it can be simply solved, let's move on to the next section:

Solution #

You may guess the solution. Yes, you just need to remember the main concept while defining and using the methods / constructors:

The actual and formal argument lists should always be same in length

What means? Before using the methods or constructors, you should check the number of formal arguments defined for a method or constructor. When you want to invoke a method or initiate an instance of object using constructor, make sure the number of actual arguments passed in is same as the number of formal arguments.


public static void main(String[] args) {
        int num_1 = 10;
        int num_2 = 20;
        int num_3 = 30;
        int sum = addition(num_1, num_2, num_3);
        System.out.println(sum);
        }
    
     public static int addition(int a, int b, int c){
        return a + b + c;
    }

This is the output:

We can either increase / decrease the number of formal arguments defined or the number of actual arguments passed in. Just to make sure both are having the same length.

Tip For a Class, if you didn't override its constructor, the constructor has no any formal arguments


public class Student {
    private String first_Name;
    private String last_Name;

    public String getFirst_Name() {
        return first_Name;
    }

    public void setFirst_Name(String first_Name) {
        this.first_Name = first_Name;
    }

    public String getLast_Name() {
        return last_Name;
    }

    public void setLast_Name(String last_Name) {
        this.last_Name = last_Name;
    }
}

I define a class, Student without overriding its default constructor.


Student student = new Student();

The compilation error will not occur and we can assign value to the variable, student using setter method in the class.

The Conclusion #

Thanks for sticking with this blog until the end. In this lesson, we've learned about what's "Actual and formal argument lists differ in length" in Java. Besides, we've known what is the causes of this compilation error and how to solve it simply. Just to remind again, we should always make sure the formal arguments and actual arguments have the same length. Otherwise, this error will be thrown during compilation.

The Reference #

You may go through this reference for more information:

Constructors: https://docs.oracle.com/javase/tutorial/java/javaOO/constructors.html

Understanding Basic Data Structures for Web Development

Mon, 16 Feb 2026 12:00:00 +0000

In the world of web development, grasping basic data structures is vital. They form the backbone of efficient algorithms and applications. Let's dive into some fundamental data structures: arrays, linked lists, and trees.

Arrays

Arrays are collections of elements stored in contiguous memory locations. They offer fast access to elements, making them ideal for scenarios where you need to access or modify data frequently.

Use cases:

Storing lists: Arrays are great for managing items like user profiles or product lists.
Data manipulation: Many algorithms work seamlessly with arrays for sorting or searching data.

Performance:

Access: O(1)
Insertion/Deletion: O(n) (in worst case)

Linked Lists

Linked lists consist of nodes where each node points to the next. This structure allows for dynamic memory allocation, making it easier to manage data that grows or shrinks.

Use cases:

Dynamic data: If you’re building applications like chat systems where messages keep coming and going, a linked list can efficiently manage this dynamic set of data.
Implementing stacks and queues: Both can be easily implemented using linked lists for LIFO (Last In, First Out) and FIFO (First In, First Out) structures respectively.

Performance:

Access: O(n)
Insertion/Deletion: O(1) (when you have a pointer to the node)

Trees

Trees are hierarchical structures made up of nodes. The most common type is the binary tree, where each node has at most two children. Trees excel at representing data that has a relational structure.

Use cases:

Hierarchical data representation: Think about website navigation or organizational structures.
Search operations: Binary search trees allow for efficient searching, inserting, and deleting of data.

Performance:

Access: O(log n) (in balanced trees)
Insertion/Deletion: O(log n) (in balanced trees)

Conclusion

Understanding data structures not only enhances your programming skills but also allows you to optimize web applications for better performance. Choosing the right data structure for the right job is crucial in building scalable and efficient applications. As web developers, mastering these basics is essential to solve complex problems effectively.

Don’t hesitate to experiment with these structures in your next project. Whether you’re managing state in a React application or dealing with database results, being well-versed in these data structures will give you the edge you need to create efficient solutions.

Coder Legion - Recent posts tagged arrays

Arrays are dumb. So are tuples.

Write a java program to count the letters, spaces, numbers and other characters of an input string.

Implode(): invalid arguments passed

Table of Contents:

What is "Implode(): invalid arguments passed" #

Causes #

Solution #

The Conclusion #

The Reference #

Index was outside the bounds of the array

Table of Contents:

What is "Index was outside the bounds of the array" #

Causes #

Solution #

The Conclusion #

The Reference #

Actual and formal argument lists differ in length

Table of Contents:

What is "Actual and formal argument lists differ in length" #

Causes #

Solution #

The Conclusion #

The Reference #

Understanding Basic Data Structures for Web Development

Arrays

Use cases:

Performance:

Linked Lists

Use cases:

Performance:

Trees

Use cases:

Performance:

Conclusion