Kristi Jorgji

How to declare and use variables in SQLite

Kristi Jorgji — Thu, 22 Oct 2026 00:35:00 GMT

SQLite has no DECLARE @name like SQL Server, and no session user variables like MySQL. You still need named values in scripts. These are the three ways that actually work.

Bind parameters from your application

This is the right default. Keep the SQL parameterized and let the host language hold the values.

1
SELECT id, name
2
FROM users
3
WHERE created_at >= :since
4
  AND status = :status;

In Go, Node, PHP, or Python you bind :since and :status once and reuse the statement. SQLite never stores those names as database-side variables, which is a good thing: the query plan stays stable and you do not concatenate strings.

sqlite3 CLI parameters

If you are in the sqlite3 shell (3.34+), .parameter is the closest thing to variables:

1
.parameter init
2
.parameter set :user_id 42
3
.parameter set :label 'admin'
4

5
SELECT *
6
FROM users
7
WHERE id = :user_id;

.parameter list shows what you set. These exist only in that CLI session. A connection opened from your app does not see them.

A one-row temp table or CTE

When the SQL has to stand alone (migrations, reports, no host binder), store the values in SQL itself:

1
CREATE TEMP TABLE vars (
2
  user_id INTEGER,
3
  min_score REAL
4
);
5

6
INSERT INTO vars (user_id, min_score) VALUES (42, 0.8);
7

8
SELECT p.*
9
FROM posts AS p
10
JOIN vars AS v ON v.user_id = p.author_id
11
WHERE p.score >= v.min_score;

For a single statement, a CTE is enough:

1
WITH vars AS (
2
  SELECT 42 AS user_id, 0.8 AS min_score
3
)
4
SELECT p.*
5
FROM posts AS p
6
JOIN vars AS v ON v.user_id = p.author_id
7
WHERE p.score >= v.min_score;

What not to do

Do not build SQL by concatenating values. There is no SET @x = 1 that survives across statements on a normal SQLite connection. Use bind parameters from code, .parameter in the CLI, and a temp row or CTE when the SQL must stand alone.

How to use react-markdown to create custom React components

Kristi Jorgji — Wed, 02 Aug 2023 09:57:57 GMT

Are you using a CMS which provides data to the React/Next frontend ?

Did you ever want to create custom components and render them in a custom way in React but had no idea how to do it?

If both answers are yes keep reading.

I will show you very fast how to create your own custom components using react-markdown which also supports html rendering.

Our custom “product” component

Let us assume that your CMS returns for the post content the following result string

1
<h1>Below you can find our best product</h1>
2
<product price="50" year="2024">My product description</product>

You notice that I am using the product html element which does not exist by default.

We will handle and render it accordingly with the react-markdown library.

The react-markdown library can handle both html with rehype and markdown so do not get confused, we can use markdown but are not forced. I am using html here.

Install in your react application

1
yarn add react-markdown rehype-raw

Your Post.tsx file will look like:

1
import React from 'react';
2

3
import ReactMarkdown from 'react-markdown';
4
import rehypeRaw from 'rehype-raw';
5

6
interface Props {
7
    content: string;
8
}
9

10
const Post: React.FC<Props> = ({ content }) => {
11
    return (
12
        <ReactMarkdown
13
            rehypePlugins={[rehypeRaw]}
14
            components={{
15
                // @ts-ignore
16
                product: (product) => {
17
                    return (
18
                        <div>
19
                            Price: {product.price}
20
                            Year: {product.year}
21
                            Description: {product.children[0]}
22
                        </div>
23
                    );
24
                },
25
            }}
26
        >
27
            {content}
28
        </ReactMarkdown>
29
    );
30
};
31
export default Post;

Then you will see in the frontend the custom element you return for the custom product html tag!

That is all, now you can create your custom components from the cms and render them according to your wishes in React.

Enjoy!

Wordpress VS NextJS+Strapi. Is the migration worth it?

Kristi Jorgji — Sat, 29 Jul 2023 14:21:48 GMT

Hi everyone. I haven’t been much active in my blog due to other occupations and also because of the doubt whether to migrate this blog to another tech stack or not.

Regarding this last part I did extensive research on my free time and tried out NextJS + Strapi CMS to build something similar like Wordpress, and I did so got super close.

What I tried

I want to let know that everything I build is free and open source for you the reader to use and try out.

First I adjusted Strapi to

create custom data models needed for the blog and I also added seeds and provisioning to developer easier.
added script to migrate wordpress categories, tags, posts+pages to my strapi cms

My Strapi blog cms project can be found here

https://github.com/kristijorgji/strapi-blog-cms

After I had a CMS to store my data I moved on to the frontend part.

For this task I used NextJS+React (last version using app routing) as it is the most trending for the moment and gets all the attention.

Is this attention worth the hype ?

We will figure out.

My NextJS+Strapi blog project is free for all of you here

https://github.com/kristijorgji/nextjs-strapi-blog

I built:

connection to the first Strapi Blog CMS project
generated in built time routes for the posts + home page + pagination

That is the core of a functional blog, new functionalities can be added with ease and I have created “to dos” in the github project.

If you are a developer I also invite you to contribute and bring the project forward.

You might be wondering right now how the results of my project might look.

Here is a preview of this very website (currently on Wordpress) migrated automatically thanks to my script in NextJS+Strapi:

First impressions

My first impressions is that this is blazing fast, and indeed is so.

I exported statically the blog and it works great. If you want to do a “load more” or “infinite scroll pagination” then have to implement in frontend size calls to fetch the next articles.

I was very hyped about the potential of this project and the possibility of building something modern, fast and easy to maintain.

I was also very excited thinking that the site won’t crash, will be no more plugins chaos and all the issues that one might face with Wordpress. But I still dropped this project(for now) after figuring out that will not scale well for real big blogs.

The dark side of the NextJS+React hydration

The title above is the main reason why I lost hope on this project, yes the hydration.

For every component that we render on the server, even server components in the latest NextJS version, next doubles the html and injects the props and html again!!!

I can explain this in depth about what hydration is and what Next is doing but considering there are a lot of other articles online I will leave you up to them.

I use this blog only to share and receive useful information and not duplicate content, alsdo don’t expect anything in return.

The issue mentioned with NextJS is reported below and you can get fully informed:

https://github.com/vercel/next.js/discussions/42170

To cut it shortly, the html size almost doubles! due to this sort of hydration.

This does not happen in wordpress because they server-side render the html with php in the backend, return it to the client and there is no hydration involved.

But does this matter?

Do not get scared yet. If you have a small blog or an e-commerce site it is “fine” to have twice the html size or the JS bundle size. The performance benefits will make up for it and you will end up with google pagespeed score higher than wordpress anyway. In addition the customers will enjoy more using your new site than the wordpress.

BUT if you have a huge blog or big category pages you need both performance and small page size

Ok… Kristi but what shall we do for big projects?

My recommendation is to go old school and server side render the html on the backend and do not use any hydration at all, this way the bundle size will be minimal and you benefit from performance improvements as well.

You can an use templating languages to statically generate what you need and interaction observer to pre-load links when user is scrolling or hovering toward them.

Alternatively you can use React just to render the htlm in the backend and return it but disable the hydration (you need your own server and not use nextjs). The only problem here is that you cannot attach handlers to the client like click etc as React needs them and hydratio to handle these events.

You can render the html and add old style js event handlers and for performance critical pages will work wonderfully. The rest can be done in React + hydration especially for single product pages where the page size will never grow much.

I also do believe that the Next team will fix this issue at some point and then it will be the best framework ever. Please keep in mind that hydration is always needed so this is not an issue in itself or something they did wrong. They are a wonderful team of great developers doing amazing innovations.

As this particular optimisation is not something standard they haven’t considered it yet. The “server” only, or “render server side only” components need a way to render only html and not hydrate, thats all.

Then at least the user can render html only for a page with 100 blog posts, and for other places use Next+React normally with hydration.

The other factors

1. Wordpress has a huge community and plugins availability.

This is without a doubt a great thing because you can market and launch your site very fast, but on the other hand your site will be generic and like most other sites out there.

Before starting to replatform your site to Next consider this fact that many things that you will do manually are already offered with “1 click” thanks to some Wordpress plugin.

This happened to me as well. I implemented from scratch seo optimisations, dark/night mode and many other things that I just installed with 1 click in Wordpress…

2. In addition the Wordpress editor is very good and the entire CMS is built on a single specific purpose: To let you write!

You cannot adjust Strapi so easily to let you do that.

Yes you can use “RichtText” and render it correctly in Next like I did in my demo but still it is not so flexible like the Wordpress editor. Strapi will need a lot of plugin to offer you such a easy way of expressing and writing the content that you need.

The other factor is familiarity. You can easily find writers that know and can use Wordpress but you need to teach and train people to use Strapi(or any other custom CMS).

There are many Wordpress experts out there available to help you.

3. Many more other Wordpress features

Wordpress has “revisions”, drafts and many more features build-in.

You can easily see changes to the article from one version to another one and by who. It is again the idea of specificity. It is build only to blog. Of course the same can be done in any other framework but you will need so much time reinventing the wheel and probably without any need to do so.

Summary

Before I give my final tips I want again to mention that there cannot be a direct comparison between them both because one is a framework build specifically for blogging and the other(next) is a framework build for building generic websites of all kind and provides server-side rendering functionality.

Let’s move to the conclusions.

I would suggest that you use NextJS+Some Cms(ex Strapi) only if

your project does not have multiple elements on a same page. Example: many products or blog posts
You want a fully custom blog integrated to your custom site and add additional components and functionality to these blocks. This can be done with Strapi dynamic zones, example: you define a block named “subscribe” and handle it in React as you with to send some email to a particular backend endpoint and store it.
You use it for your own blog and don’t care much about possible business expansions or needing to hire writers or other authors with different accounts later. This is my use case, I might switch later the blog to something else for fun although as described Wordpress does the job perfectly.

I would suggest you to use Wordpress if:

You want only to blog and do not foresee having any flexible functionalities with complex ui and needs. Example: Blog but also create a social network in same platform
You have a lot of articles and a lot of authors! In this case sticking to Wordpress is the wisest choice. All the authors you hire know the system already and you can find experts from the community to fix your issues very fast

And if you really insist of using Next but are sceptic of what CMS to use, you can still use Wordpress as a headless cms and integrate it with Next.

This way you will reduce some of the disadvantages that I mentioned above and benefit from the great editing tools of Wordpress and from the performance of next.

I do hope you find this article useful and saves you some time on deciding.

Comment below what are your thoughts and if you can think of a solution regarding Next hydration issue.

Until next time, K.

How to use Google Optimize A/B test tool in a React SPA Application

Kristi Jorgji — Mon, 16 Jan 2023 21:17:19 GMT

Hello everyone.

How to install and use google optimize with React + Typescript in a SPA ?

I will teach you today how to use Google Optimize A/B test tool in a SPA (Single Page Application) architecture, for example while using NEXTJS like in my case.

First install the script by just adding

1
<script src="https://www.googleoptimize.com/optimize.js?id=YOURID" />

before including google analytics script.

By default google optimize is activated on page load and this is not what we want.

Change the activation event to “On custom event” and let it be “optimize.activate” (default one)

This means that we have to activate optimize manually. To do so, we are going to create a React hook in order to reuse it in all the components that rely on a particular experiment.

I am using Typescript, so the function at `useOptimizeAB.ts` will look like below:

1
import { useEffect, useState } from 'react';
2

3
export default function useOptimizeAB(experimentId: string): number | undefined {
4
    const [variant, setVariant] = useState<number>();
5
    useEffect(() => {
6
        window.dataLayer.push({ event: 'optimize.activate' });
7
        const interval = setInterval(() => {
8
            if (window.google_optimize !== undefined) {
9
                const variant = window.google_optimize.get(experimentId);
10
                if (typeof variant !== 'undefined') {
11
                    setVariant(Number(variant));
12
                }
13
                clearInterval(interval);
14
            }
15
        }, 100);
16
    }, []);
17
    return variant;
18
}

How to use this ?

Just execute

1
const variant = useOptimizeAB('experiment id');

on the component you want to behave differently based on the A/B test.

Variant 0 is the original one, variant 1 is the remaining one (for one A/B test with only 2 variants 0 and 1). If you have more variants the number corresponds to the variant you created.

It is this simple, then you can use the variant variable to change the page layout or logic whatever you want to do.

How to test locally?

Assuming you did all the steps above, the next good question will be how to test if this works locally ?

The answer is that it is very simple to do so by changing your host file.

If your domain is example.com, you can change your host file /etc/hosts (in linux systems) and add 127.0.0.1 example.com

Then every time you open example.com you will use localhost where your development site will be available. You can play around with the page you set as a target and console.log the variant and test the different results.

How to try out a new variant ?

At the time of this article you can change the last digit of the cookie named _gaexpThat is the variant id!

Simple as that, change the last digit for example from .0 to .1 and refresh the page. You will be using variant 1.

Or you can always hardcode the variant during development to see the different logics then for a integration test use the method above by modifying the cookie.

I moved WordPress inside a docker container

Kristi Jorgji — Fri, 08 Jul 2022 11:49:23 GMT

Update

Hi all,

I migrated this website from apache barebone installation to encapsulated wordpress inside a docker container with php fpm and nginx.

This is actually a test post I am making to ensure that all is working fine, but also to provide you update about the site and what I changed.

I haven’t been active for several reasons, first of all don’t want to invest time here as at a later time want to move away from WordPress to a custom blog system.

I have a lot of topics and knowledge that can share but will do that at a later point.

For the moment, the only update is that I moved this website from one old apache webserver + wordpress to a new architecture.

My “pet server” where I host this website and some other fun projects without any commercial meaning was old school one. One apache webserver and several websites.

I modernised it last weekend and I started to use docker for splitting my pet projects into several containers, and one container having nginx as reverse proxy.

How to migrate to docker

If you want to do the same, I have some public code I created for you to reuse.

First my docker image is available at

https://github.com/kristijorgji/docker-images/tree/main/wordpress-php-7.1

also with a readme how to use.

After having the wordpress site in a separate docker container, I just configured my nginx configuration in proxy container to redirect traffic to the wordpress container one.

It worked partially fine at the start, beacuse wordpress was trying to load the assets via http instead of https.

The fix for that is to configure the php site to enforce ssl and the domain where the site is served.

Just adjust `wp-config.php` and add these lines on the top and your issue will be fixed

1
// <K> to allow it to work behind reverse proxy
2

3
define('.COOKIE_DOMAIN.', '{{ kj_public_domain }}');
4
define('.SITECOOKIEPATH.', '.');
5

6
if(isset($_SERVER['HTTP_X_FORWARDED_FOR'])) {
7
    $list = explode(',',$_SERVER['HTTP_X_FORWARDED_FOR']);
8
    $_SERVER['REMOTE_ADDR'] = $list[0];
9
}
10
define( 'WP_HOME', 'https://{{ kj_public_domain }}' );
11
define( 'WP_SITEURL', 'https://{{ kj_public_domain }}' );
12
$_SERVER['HTTP_HOST'] = '{{ kj_public_domain }}';
13
$_SERVER['REMOTE_ADDR'] = 'https://{{ kj_public_domain }}';
14
$_SERVER[ 'SERVER_ADDR' ] = '{{ kj_public_domain }}';
15

16
if ($_SERVER['HTTP_X_FORWARDED_PROTO'] == 'https') {
17
    $_SERVER['HTTPS']='on';
18
}
19
// </K>

That was all. Now I can have several domains on a single server thanks to reverse proxy container (nginx) and having all separate sites in separated docker containers.

Not only that, but also can have sites in different programming languages and environments, as docker containers are partially isolated.

This is my first post after moving site to docker.

What went wrong after the migration ?

The first thing that I noticed was that I could not upload images and some cache errors.

That was because php-fpm runs under www-data user and the mounted volume is mounted by other user and wordpress cannot write files or directories.

One hacky fix is to login into your container and change permissions

docker-compose exec kj_wordpress /bin/bash

afterward

chown -R www-data .

This will work great but the problem is have to do everytime your container changes and it is deployed again.

A proper automated solution would be to mount the volume and specify user and group id in docker-compose.

My question is here

https://stackoverflow.com/questions/72914147/how-to-mount-a-volume-with-docker-compose-with-owner-www-data-user-of-the-contai

That was all for this time.

See you on the next ones, probably after I update to custom blog with pre-rendering. Cheers

Introducing goseeder - the go database seeder

Kristi Jorgji — Thu, 22 Oct 2020 14:32:33 GMT

Hi everyone. It has been a long time since my last post. I have so many ideas and topics that I want to share but could not due to time limits.

Anyway, I am back! and this time introducing one go library that I created, goseeder https://github.com/kristijorgji/goseeder

Motivation

Golang is a great language and getting better as community and frameworks, but there are still a lot of pieces missing for developing fast, accurate way and avoiding repetitions.

I was searching for a go database seeder similar to the one that Laravel/Lumen provides and could not find one.

Knowing that this is such an important key element of any big project for testing and seeding projects with dummy data I decided to create one myself and share.

Features

For now the library supports only MySql as a database driver for its utility functions like (s Seeder) FromJson but it is db agnostic for your custom seeders you can use any database that is supported by sql.DB

goseeder in your go database seed files.

Allows specifying seeds for different environments such as test,common (all envs) and more (flexible you can define them)
Provides out of the box functions like (s Seeder) FromJson to seed the table from json data and more data formats and drivers coming soon
Execute database seeder by specifying their names go run main.go --gseed --gsnames=categoriesSeeder,productsSeeder
Execute database seeders by specifying the environment go run main.go --gseed --gsenv=test

Installation

1
go get github.com/kristijorgji/goseeder

Usage

Please check examples/simpleshop for a full working separate go project that uses the seeder

Below I will explain once more all the steps needed to have goseeder up and running for your project.

1. Change Your Main Function

In order to give your executable seeding abilities and support for its command line arguments, the first thing we have to do is to wrap our main function with the provided goseeder.WithSeeder

1
func WithSeeder(conProvider func() *sql.DB, clientMain func())

The function requires as argument

one function that returns a db connection necessary to seed
your original main function, which will get executed if no seed is requested

One such main file can look like below:

1
package main
2

3
import (
4
  "database/sql"
5
  "fmt"
6
  _ "github.com/go-sql-driver/mysql"
7
  "github.com/joho/godotenv"
8
  "github.com/kristijorgji/goseeder"
9
  "log"
10
  "net/url"
11
  "os"
12
  _ "simpleshop/db/seeds"
13
)
14

15
func main() {
16
  err := godotenv.Load()
17
  if err != nil {
18
    log.Panic("Error loading .env file")
19
  }
20

21
  goseeder.WithSeeder(connectToDbOrDie, func() {
22
    myMain()
23
  })
24
}
25

26
func myMain() {
27
  fmt.Println("Here you will execute whatever you were doing before using github.com/kristijorgji/goseeder like start your webserver etc")
28
}
29

30
func connectToDbOrDie() *sql.DB {
31
  dbDriver := os.Getenv("DB_DRIVER")
32
  dbHost := os.Getenv("DB_HOST")
33
  dbPort := os.Getenv("DB_PORT")
34
  dbName := os.Getenv("DB_DATABASE")
35
  dbUser := os.Getenv("DB_USERNAME")
36
  dbPassword := os.Getenv("DB_PASSWORD")
37

38
  dbSource := fmt.Sprintf(
39
    "%s:%s@tcp(%s:%s)/%s?parseTime=true",
40
    dbUser,
41
    url.QueryEscape(dbPassword),
42
    dbHost,
43
    dbPort,
44
    dbName,
45
  )
46
  con, err := sql.Open(dbDriver, dbSource)
47
  if err != nil {
48
    log.Fatalf("Error opening DB: %v", err)
49
  }
50

51
  return con
52
}

2. Registering Your Seeds

Great! After step 1 our executable is able to run in seed mode or default mode.

Now we want to know how to register our custom seeds.

If you look at the imports in main file from step one, we might notice that we import _ "simpleshop/db/seeds" even though we do not use them directly.

This is mandatory because our seeds will get registered during package initialisation as we will see later.

The recommended project folder structure to work properly with goseeder is to have the following path for the seeders db/seeds and the package name to be seeds

Inside the folder you can add your seeders, for example lets seed some data into the categories table from one json file located at db/seeds/data/categories.json.

To do that we create our categories.go file at db/seeds folder:

1
package seeds
2

3
import (
4
  "github.com/kristijorgji/goseeder"
5
)
6

7
func categoriesSeeder(s goseeder.Seeder) {
8
  s.FromJson("categories")

To use this seed, the last step is to register it.

Seeds can be registered as:

common seeds that run for all environments
for a specific environment like test, yourcustomenv (more in step 3)

We are going to create below a seed that runs for all environments, so we will not specify any env while registering it.

To do that we create in the db/seeds folder the file common.go that will register seeds that get always executed regardless of the environment:

1
package seeds
2

3
import "github.com/kristijorgji/goseeder"
4

5
func init() {
6
  goseeder.Register(categoriesSeeder)
7
}

We used goseeder.Register to register our seed function to run for all environments.

That is all for the basic usage of goseeder!!!

Our function in categories.go file is now registered and ready to be used.

Now you can run

1
go run main.go --gseed

and it will run all your seeds against the provided db connection.

The framework will look for categories.json file in the path db/seeds/data, and insert all the entries there in a table named categories (inferred from the file name)

3. Run Seeds Only For Specific Env

Many times we want to have seeds only for test environment, test purpose and want to avoid having thousand of randomly generated rows inserted into production database by mistake!

Or we just want granular control, to have separate data to populate our app/web in different way for staging prod yourcustomenv and so on.

goseeder is designed to take care of this by using one of the following methods:

goseeder.RegisterForTest(seeder func(s Seeder) - registers the specified seed for the env named test
goseeder.RegisterForEnv(env string, seeder func(s Seeder)) - will register your seeder to be executed only for the custom specified env

Let’s add to our previous categories.go seeder one seed function specific only for test env! The file now will look like:

1
package seeds
2

3
import (
4
  "fmt"
5
  "github.com/kristijorgji/goseeder"
6
  "simpleshop/util"
7
)
8

9
func categoriesSeeder(s goseeder.Seeder) {
10
  s.FromJson("categories")
11
}
12

13
func testCategoriesSeeder(s goseeder.Seeder) {
14
  for i := 0; i < 100; i++ {
15
    stmt, _ := s.DB.Prepare(`INSERT INTO categories(id, name) VALUES (?,?)`)
16
    _, err := stmt.Exec(util.RandomInt(1, int64(^uint16(0))), []byte(fmt.Sprintf(`{"en": "%s"}`, util.RandomString(7))))
17
    if err != nil {
18
      panic(err)
19
    }
20
  }
21
}

Finally, lets create our registrator file for all test seeds same way as we did with common.go, we will create test.go now with content as below:

1
package seeds
2

3
import "github.com/kristijorgji/goseeder"
4

5
func init() {
6
  goseeder.RegisterForTest(testCategoriesSeeder)
7
}

That is all!

Now if you run your app without specifying test env, only the common env seeders will run and you cannot mess by mistake production or other environments!

To run the test seeder above you have to run:

1
go run main.go --gseed --gsenv=test

4. Run Seeds By Name

When we register a seed like shown in step 2, the seed name is the same as the function name, so our seed is called categoriesSeeder because that is the name of the function we register below

1
func init() {
2
  goseeder.Register(categoriesSeeder)
3
}

This is important because we are totally flexible and can do cool things like execute only the specific seed functions that we want!

Let’s assume that we have 100 seed functions, and want to execute only one of them which is named categoriesSeeder (that we registered above) and ignore all the other seeds.

Easy as this, just run:

1
go run main.go --gseeder --gsnames=categoriesSeeder

If you want to execute multiple seeds by specifying their names, just use comma separated value like --gsnames=categoriesSeeder,someOtherSeeder

Summary Of Cli Args

You can always run

1
run go run main.go --help

to see all the available arguments and their descriptions.

For the current version the result is:

1
INR00009:simpleshop kristi.jorgji$ go run main.go --help
2
Usage of /var/folders/rd/2bkszcpx6xgcddpn7f3bhczn1m9fb7/T/go-build810543742/b001/exe/main:
3
  -gseed
4
        goseeder - if set will seed
5
  -gsenv string
6
        goseeder - env for which seeds to execute
7
  -gsnames string
8
        goseeder - comma separated seeder names to run specific ones
9
INR00009:simpleshop kristi.jorgji$

String encoding challenge solution

Kristi Jorgji — Fri, 09 Nov 2018 18:55:21 GMT

Description

Given a non-empty string, encode the string such that its encoded length is the shortest.

The encoding rule is: k[encoded_string], where the encoded_string inside the square brackets is being repeated exactly k times.

Note:

k will be a positive integer and encoded string will not be empty or have extra space.
You may assume that the input string contains only lowercase English letters. The string’s length is at most 160.
If an encoding process does not make the string shorter, then do not encode it. If there are several solutions, return any of them is fine.

Examples

Example 1:

1
Input: "aaa"
2
Output: "aaa"
3
Explanation: There is no way to encode it such that it is shorter than the input string, so we do not encode it.

Example 2:

1
Input: "aaaaa"
2
Output: "5[a]"
3
Explanation: "5[a]" is shorter than "aaaaa" by 1 character.

Example 3:

1
Input: "aaaaaaaaaa"
2
Output: "10[a]"
3
Explanation: "a9[a]" or "9[a]a" are also valid solutions, both of them have the same length = 5, which is the same as "10[a]".

Example 4:

1
Input: "aabcaabcd"
2
Output: "2[aabc]d"
3
Explanation: "aabc" occurs twice, so one answer can be "2[aabc]d".

Example 5:

1
Input: "abbbabbbcabbbabbbc"
2
Output: "2[2[abbb]c]"
3
Explanation: "abbbabbbc" occurs twice, but "abbbabbbc" can also be encoded to "2[abbb]c", so one answer can be "2[2[abbb]c]".

Solution

Before I provide my solution, first I want to reference below the existing brute force solution that you can easily find online:

http://massivealgorithms.blogspot.com/2016/12/leetcode-471-encode-string-with.html

The solution above returns always the best possible encoding (by giving the shortest output possible), but it is very slow and has high time and space complexity, respectively O(N^4) and O(N^2).

I made a benchmark with an input string of 1000 characters by running 100 times each solution. My solution took in average 160ms, while the brute force one 3m 19s 316ms.

The logical steps of my solution are as follow:

While iterating over the input string, I store in a LinkedHashMap all the start and end indexes of parts which are repeated and need to get encoded in the output string.
As long as one character is repeated, I count its repetitions and then add it to the replaceMap.
At a certain index i, the longest string that can repeat itself has length N - i, where N is the length of the input string. Knowing this, we can start to check if any pattern is repeating itself from the index i - (N - i). If the previous value is negative, we start the check from index 0 until i.
If we find a repeating pattern, we check in the already found repetitions in replaceMap, if the previous repetitions were the same as the existing one. If so, we update the replaceMap to leave only one repetition with the lowest start index, and proper repetition count.
I check if encoding the found repetition(s) will actually reduce the string size or not. If yes, then this repetition is checked against all the existing other ones and only the longest one is left.
The previous repetitions which use fewer characters are removed, and we can break the loop. We can break the loop because if we find a repetition starting at index X, there is no need to check the repetitions starting at index Y, when X < Y. The length of the repetition starting at X will be greater and provide us better encoding.
Form the encoded output string by making us of the formed replaceMap.

This solution can of course be further optimized and cleaned up, but for now it offers an alternative point of view on this challenge.

The code and some explanatory comments are given below:

1
package com.kristijorgji;
2

3
import java.util.LinkedHashMap;
4

5
class Compress {
6
    String compress(String S)
7
    {
8
        final int N = S.length();
9
        LinkedHashMap<Integer, RepetitionTuple> replaceMap = new LinkedHashMap<>();
10

11
        for (int i = 1; i < N; i++) {
12
            //handle the case in which adjacent characters are equal, ex aaaaa...
13
            int same = 0;
14
            while (i < N && S.charAt(i) == S.charAt(i - 1)) { same++; i++; } //2 character for opening and closing brackets, plus the characters for the digit and the char itself if (same > 0 && getDigitsNumber(same) + 2 + 1 < same + 1) {
15
                replaceMap.put(i - 1 - same, new RepetitionTuple(i - 1 - same, i - same, 1, same));
16
            }
17

18
            /*
19
                handle the case of group repetitions one after each other, ex abcabc...
20
                search all possible matching from left side until end of string
21
             */
22
            int matchCheckStartIndex = N - i;
23
            int ci = Math.max(0, i - matchCheckStartIndex);
24

25
            for (;ci < i; ci++) {
26
                String value = S.substring(ci, i);
27

28
                int timesRepeated = 0;
29
                int j = i;
30
                int k = 0;
31
                while (k < value.length() && S.charAt(j) == value.charAt(k)) { j++; k++; if (k % value.length() == 0) { timesRepeated++; } } int last = ci - k; while (timesRepeated > 0 && replaceMap.containsKey(last) && replaceMap.get(last).length == k) {
32
                    timesRepeated++;
33
                    replaceMap.remove(last);
34
                    last -= k;
35
                }
36

37
                //add to repetition map only if it minimizes the chunk size
38
                if (k > 0 && ci + k == i && k + 3 < value.length() * (timesRepeated + 1)) {
39
                    /*
40
                        check if a previous replacement overlaps with the current one
41
                        and if so, decide to keep the one which minimizes more the string
42
                     */
43
                    boolean doesLongerReplacementExist = false;
44
                    for (int d = 0; d < ci; d++) { if (replaceMap.containsKey(d)) { RepetitionTuple rt = replaceMap.get(d); int endIndex = rt.length * (rt.times + 1) + rt.start; if (endIndex >= ci) {
45
                                if (rt.length * (rt.times + 1) > k * (timesRepeated + 1)) {
46
                                    doesLongerReplacementExist = true;
47
                                } else if (rt.length * (rt.times + 1) < k * (timesRepeated + 1)) {
48
                                    replaceMap.remove(d);
49
                                }
50
                            }
51
                        }
52
                    }
53

54
                    if (!doesLongerReplacementExist) {
55
                        replaceMap.put(
56
                                last + k,
57
                                new RepetitionTuple(
58
                                        last + k,
59
                                        last + 2 * k,
60
                                        k,
61
                                        timesRepeated
62
                                )
63
                        );
64
                        /*
65
                            We found a compression which uses more characters, the ones with less can be removed now
66
                         */
67
                        for (int d = last + k + 1; d < i; d++) { replaceMap.remove(d); } break; } } } } StringBuilder sb = buildCompressedString(S, replaceMap); return sb.length() > N ? S : sb.toString();
68
    }
69

70
    private int getDigitsNumber(int number)
71
    {
72
        int c = 1;
73
        while (number / 10 != 0) {
74
            c++;
75
            number /= 10;
76
        }
77
        return c;
78
    }
79

80
    /**
81
     * O(N) complexity
82
     */
83
    private StringBuilder buildCompressedString(String S, LinkedHashMap<Integer, RepetitionTuple> replaceMap)
84
    {
85
        int i = 0;
86
        int N = S.length();
87
        StringBuilder sb = new StringBuilder();
88
        StringBuilder capture = new StringBuilder();
89

90
        if (replaceMap.size() == 0) {
91
            return sb.append(S);
92
        }
93

94
        while (i < N) {
95
            while  (i < N && !replaceMap.containsKey(i)) {
96
                capture.append(S.charAt(i));
97
                i++;
98
            }
99

100
            sb.append(compress(capture.toString()));
101
            capture = new StringBuilder();
102

103
            if (replaceMap.containsKey(i)) {
104
                RepetitionTuple repetitionTuple = replaceMap.get(i);
105
                sb.append(repetitionTuple.times + 1)
106
                        .append("[")
107
                        .append(compress(S.substring(repetitionTuple.start, repetitionTuple.end)))
108
                        .append("]");
109
                i += (repetitionTuple.times + 1) * repetitionTuple.length;
110
                continue;
111
            }
112

113
            i++;
114
        }
115

116
        return  sb;
117
    }
118

119
    class RepetitionTuple {
120
        int start;
121
        int end;
122
        int length;
123
        private int times;
124

125
        RepetitionTuple(int start, int end, int length, int times) {
126
            this.start = start;
127
            this.end = end;
128
            this.length = length;
129
            this.times = times;
130
        }
131
    }
132
}

String decompression challenge solution

Kristi Jorgji — Sun, 21 Oct 2018 16:31:09 GMT

I am sharing my solution in Java to one of the former Google interview questions, which is posted by Google itself here:

https://techdevguide.withgoogle.com/resources/compress-decompression/

I am copying the description below just in case the original link gets removed, and without it the solution will not have any meaning.

The Challenge

In this exercise, you’re going to decompress a compressed string.

Your input is a compressed string of the format number[string] and the decompressed output form should be the string written number times. For example:

The input

3[abc]4[ab]c

Would be output as

abcabcabcababababc

Other rules

Number can have more than one digit. For example, 10[a] is allowed, and just means aaaaaaaaaa

One repetition can occur inside another. For example, 2[3[a]b] decompresses into aaabaaab

Characters allowed as input include digits, small English letters and brackets [ ].

Digits are only to represent amount of repetitions.

Letters are just letters.

Brackets are only part of syntax of writing repeated substring.

Input is always valid, so no need to check its validity.

Solution

My solution uses the approach which I find the most intuitive for this case, the recursive one. The recursive solution can also be converted to iterative by using a stack instead of recursive function calls.

We know that we need to iterate over the input string, and when we notice the encoding pattern (digits followed by opening square bracket), we have to repeat the same logic for the capture group by calling again the same function.

We do not want the called function to write to the output sb buffer directly, because the returned value will need to get repeated and the number of repetitions is known only by the parent call, which captured the digits. For this reason we pass an empty current buffer as output buffer.

On the other hand, as long as we are not capturing digits, we add to the current characters to the current buffer. This buffer will be flushed to the output buffer once we encounter one opening square bracket [.

As any recursive solution, we need to identify the base case; otherwise we will have infinite calls. The base case is that case which will not call itself anymore.

In this challenge the base case is when a string does not contain another encoded nested string, for example abcd is a base case. It does not have any encoded string (starting with number, followed by [, then the string inside, and finally the closing bracket ]).

For all the other cases, once we notice that an encoded string is starting (started capturing digits), when we find the opening bracket (in this case this will be always after the number as per the problem description), we call the recursive function to do the same for the rest of the string. We do this until the closing bracket is found, or until another encoded string is found. If the latter happens then we call the recursive function itself to handle it.

Another important point here is that we need to skip the parts already processed by the recursive calls, and we do this by returning the index of the last processed character as the return value of the function.

The upper function in the call stack sets its i variable value to the returned one, and then proceeds from there. The groups captured by the recursive call, are then repeated by the parent call and a and added to the output buffer sb.

The full solution in Java is given below:

1
package com.kristijorgji;
2

3
/**
4
 * @see <a href="https://techdevguide.withgoogle.com/resources/compress-decompression/">Compression and Decompression</a>
5
 */
6
public class Decompress {
7
    String decompress(String input)
8
    {
9
        StringBuilder sb = new StringBuilder();
10
        decompress(input, 0, sb);
11
        return sb.toString();
12
    }
13

14
    private int decompress(String input, int start, StringBuilder sb)
15
    {
16
        StringBuilder times = new StringBuilder();
17
        StringBuilder current = new StringBuilder();
18

19
        int i = start;
20
        while (i < input.length()) {
21
            while (Character.isDigit(input.charAt(i))) {
22
                times.append(input.charAt(i));
23
                i++;
24
            }
25

26
            if (input.charAt(i) == '[' && times.length() > 0) {
27
                if (current.length() > 0) {
28
                    sb.append(current);
29
                    current = new StringBuilder();
30
                }
31

32
                i = decompress(input, i + 1, current);
33

34
                int repeatTimes = Integer.parseInt(times.toString());
35
                for (int j = 0; j < repeatTimes; j++) {
36
                    sb.append(current);
37
                }
38

39
                current = new StringBuilder();
40
                times = new StringBuilder();
41
            } else if (input.charAt(i) == ']') {
42
                return i + 1;
43
            } else {
44
                sb.append(input.charAt(i));
45
                i++;
46
            }
47
        }
48

49
        return i;
50
    }
51
}

In case of questions, feel free to comment and I will be glad to answer.

Simulating object oriented programming (OOP) in C

Kristi Jorgji — Sat, 13 Oct 2018 08:33:17 GMT

Most of the languages support OOP out of the box, but many people are not aware that OOP and even functional programming can be done also in C (even though it is not very practical, unless we use some macros to hack our way through and make it more convenient by reducing the boilerplate code).

In this tutorial I will provide some insight on how to simulate an object in C language in order to write in OOP style. Before let us review again the definition of a class and object in OOP.

What is a class in OOP ?

A class is a blueprint that describes the contents of the objects that belong to it. It describes the data fields (also known as instance variables), and defines the operations (functions or methods).

Depending on the programming language, the data fields and operations can have different access modifiers, usually private, protected and public. The role of the access modifiers is to provide a way for the programmer to enforce encapsulation of the data (hiding implementation details from the user).

What is an object in OOP ?

An object in its simplest terms is an instance of a class, a “living” instance of the blueprint known as class. It contains its own set of instance data fields, and shares the methods with all the other instances of the same class.

Simulating objects in C

From the definitions above, we realize that we need to find a way to encapsulate related data fields and methods to define a class and then instantiate objects of this particular class.

In C we can group related data fields by using structures, so this part is already covered. What is left is to find a way to provide methods to our structures. This can be done by using function pointers.

Let us see an example. I will create a class named Faker, which will be responsible for generating dummy data that are going to be used for testing.

The header file faker.h looks like:

1
#ifndef faker_H_
2
#define faker_H_
3

4
typedef struct Faker Faker; //forward declaration to allow self referencing in the struct declaration
5
struct Faker {
6
    int minAge;
7
    char* (*address) ();
8
    char* (*email) ();
9
    int age(Faker* self)
10
};
11

12
Faker* newFaker(int minAge);
13

14
#endif

The function newFaker will serve as the constructor, it will be responsible for initializing an instance of the Faker class.

The header serves a very important role: provides a public interface to the other parts of the system. This means that the implementation is up to us, and we can enforce the encapsulation and hide the way its functionality is implemented (especially the private variables necessary to provide the desired functionality).

The faker implementation file faker.c looks like:

1
#include <stdlib.h>
2
#include <string.h>
3
#include "faker.h"
4

5
char* pickRandomFromArray(const char* array[], int size)
6
{
7
    int randomIndex = rand() % size;
8
    return (char*) array[randomIndex];
9
}
10

11
const char* addressesPool[] = {
12
    "Forest Run Way 72",
13
    "Vera Parkway 70",
14
    "3 East Sulphur Springs St. Murfreesboro, TN 37128"
15
};
16
const int NR_ADDRESSES = (sizeof (addressesPool) / sizeof (const char *));
17

18
const char* emailsPool[] = {
19
    "asommomepu-9364@yopmail.com",
20
    "iArmstrong@Lazzy.com",
21
    "ut@Gabspot.biz"
22
};
23
const int NR_EMAILS = (sizeof (emailsPool) / sizeof (const char *));
24

25
char* address()
26
{
27
    return pickRandomFromArray(addressesPool, NR_ADDRESSES);
28
}
29

30
char* email()
31
{
32
    return pickRandomFromArray(emailsPool, NR_EMAILS);
33
}
34

35
int age(Faker* self)
36
{
37
    return rand() % 120 + self-&gt;minAge + 1;
38
}
39

40
Faker* newFaker()
41
{
42
    Faker* self = (Faker*)malloc(sizeof(Faker));
43
    self-&gt;address = &amp;address;
44
    self-&gt;email = &amp;email;
45
    self-&gt;age = &amp;age;
46
    return self;
47
}

An important point to notice here is how we bind the instance to its methods. We are passing Faker* self to the age method, and then we can access the minAge property.
Another important point to take away is the way we are hiding the implementation details. The variables addressesPool and emailsPool will not be accessible by the clients of the faker.h interface. So we provide the desired functionality, while we hide the implementation details. We can as well compile the faker library to a shared runtime library so the source code will not be visible.

The client of the faker, can look like:

1
#include <stdio.h>
2
#include "faker.h"
3

4
int main()
5
{
6
    Faker* faker = newFaker(18);
7
    printf("Random age %d\n", faker->age(faker));
8
    printf("Random address: %s\n", faker->address());
9
    printf("Random email: %s\n", faker->email());
10
}

I usually use Faker to seed random users and populate a database, or create random users for testing certain functionalities of my software.
This was just a short introduction to OOP in C.

If you have any questions, feel free to comment below.

Functional programming in C

Kristi Jorgji — Sun, 16 Sep 2018 10:44:46 GMT

Before explaining how to implement functional programming in C, I will explain shortly what functional programming is.

What is functional programming?

Functional programming is a way of building software by composing pure functions, avoiding shared state, mutable data and side effects.

Pure functions

Pure functions are those functions which always return the same result, for the giving arguments and do not cause side effects.

For example, the following is a pure function:

1
int sum(int n, int m) {
2
    return n + m;
3
}

This function does not have side effects, and if called with same arguments will return always the same result.

Shared state

Any variable, or memory space that is shared, ex: global scope, or any scope accessible by many functions or objects.

Below is an example of changing the shared state by the sum function:

1
int totalSum = 0; //shared state variable
2

3
int sum(int n, int m) {
4
    totalSum = n + m;
5
    return totalSum;
6
}

The function sum changes the shared state by changing the value of the variable totalSum.

Mutable data

Mutable data is data that can be changed after its creation, ex: passing by reference an object and changing its properties will also change these properties outside of the functions scope.

On the other hand immutable data are data that cannot be changed after being created, ex: an object that has only “getter” methods, or read only properties**.**

Side effects

A side effect is an application state change that is observable outside the called function, other than its return value. Examples:

Changes in variables outside of the function’s scope
Making network requests
Doing I/O operations
Logging to screen
Calling external processes and changing their state

As described above, functions are first class citizens in functional programming. They can be referred by variables, and can also be passed as arguments to other functions.

Functional programming in C

We can also treat functions as first class citizens in C language, by using function pointers.

Function pointers are variables which hold the memory address of a particular function.

The pointer itself takes 32 or 64 bits of space, depending on the CPU addressing system, which is enough to store the memory address of the function.

After we initialize a function pointer, we can pass it as an argument to another function (or we can also pass directly the address of a particular function as argument too).

Functions that accept other functions as arguments, or return functions as their return types, are known as higher order functions.

Example of using a function pointer and a higher level function:

1
#include <stdio.h>
2

3
int sum(int n, int m) {
4
    return n + m;
5
}
6

7
int highOrderSumOfThreeAndFour(int (*functionPtr)(int, int)) {
8
    return (*functionPtr)(3, 4);
9
}
10

11
int main()
12
{
13
    int (*sumFuncPtr)(int,int) = &sum;
14
    int sum = (*sumFuncPtr)(2, 3);
15
    printf("%d\n", sum); //prints 5
16
    printf("%d", highOrderSumOfThreeAndFour(sumFuncPtr)); //prints 7
17
}

sumFuncPtr is a function pointer to the sum function. This pointer can be used to call the underlying function like in the first example when, where the result of the call is assigned to the variable sum. This function pointer can also be passed as an argument to higher order functions.

In this example highOrderSumOfThreeAndFour is a high order function because accepts a function pointer as argument.

In my other posts I will write about how to implement Lambdas in C by using gcc macros.