golang sorting maps by value and returning a slice of keys

Golang 1.23 Added new slices functions to help sort. These are useful for sorting maps by values or by keys.

In my previous post I went through some examples about how to sort by the keys of a map and return an array of values.

This does the converse and I provide examples to sort by the values of a map and return an array of keys.

https://www.geeksforgeeks.org/how-to-sort-golang-map-by-keys-or-values/ was helpful to see how to do it using the sort package. When I looked at the api docs, it suggested using the slices package:

"Note: in many situations, the newer slices.SortStableFunc function is more ergonomic and runs faster."

// Sort by value with map[int]string and map[string]int

func main() {

fmt.Println("Start")

fmt.Println("Sorting by Value in a map with int keys and string values")

intStringMap := map[int]string{

22: "z",

111: "y",

3333: "x",

}

// 1) Using sort package

intKeys := slices.Collect(maps.Keys(intStringMap))

sort.SliceStable(intKeys, func(i, j int) bool {

return intStringMap[intKeys[i]] < intStringMap[intKeys[j]]

})

fmt.Println("1) Using sort package:", intKeys) // [3333 111 22]

// 2) Using slices package

intKeySlice := slices.Collect(maps.Keys(intStringMap))

slices.SortStableFunc(intKeySlice, func(a, b int) int {

return cmp.Compare(intStringMap[a], intStringMap[b])

})

fmt.Println("2) Sort Keys in place", intKeySlice) // [3333 111 22]

fmt.Println()

fmt.Println("Sorting by Value in a map with string keys and int values")

stringIntMap := map[string]int{

"z": 222,

"y": 11,

"x": 3333,

}

// 1) Using sort package. API says consider using slices package

stringKeys := slices.Collect(maps.Keys(stringIntMap))

sort.SliceStable(stringKeys, func(i, j int) bool {

return stringIntMap[stringKeys[i]] < stringIntMap[stringKeys[j]]

})

fmt.Println("1) Using sort package:", stringKeys) // [y z x]

// 2) returns a slice where the values are the keys of stringIntMap

// sorts the keys in place

keySlice := slices.Collect(maps.Keys(stringIntMap))

slices.SortStableFunc(keySlice, func(a, b string) int {

return cmp.Compare(stringIntMap[a], stringIntMap[b])

})

fmt.Printf("2) Sort In Place: %v\n", keySlice) // [y z x]

// 3) returns a slice where the values are the keys of stringIntMap

keys := maps.Keys(stringIntMap) // an Iter

keysSortedByValue := slices.SortedStableFunc(keys, func(a, b string) int {

return cmp.Compare(stringIntMap[a], stringIntMap[b])

})

fmt.Printf("3) New Variable: %v\n", keysSortedByValue) // [y z x]

// Output the keys and values

fmt.Println("Print the stringIntMap in order")

for _, k := range keysSortedByValue {

fmt.Printf("%s: %d\n", k, stringIntMap[k])

}

// y: 11

// z: 222

// x: 3333

fmt.Println("Done")

}

 

Golang how to sort the keys in a map and create a new array

Golang maps are purposely unordered. If you add the values "b": 2 and "a": 1 to a map, iterating this will sometimes get "a" first, and other times "b" first.

With many languages, they have data types like arrays or ordered maps that allow you to traverse the array in the order of keys. Others have a built a method to output a new array in key order.

Golang requires the use of a few helper methods to convert a map into a key sorted slice.

package main

import (

"fmt"

"maps"

"slices"

)

func main() {

fmt.Println("Start")

intStringMap := map[int]string{

2: "b",

1: "a",

3: "c",

}

// Two ways to get the keys from a map and sort them

// intKeys := slices.Collect(maps.Keys(intStringMap))

// sort.Ints(intKeys)

intKeys := slices.Sorted(maps.Keys(intStringMap))

sortedIntStringArray := make([]string, 0)

for _, key := range intKeys {

sortedIntStringArray = append(sortedIntStringArray, intStringMap[key])

}

fmt.Printf("%v\n", sortedIntStringArray) // [a b c]

stringIntMap := map[string]int{

"b": 2,

"a": 1,

"c": 3,

}

// Same as above but with a string int map

// stringKeys := slices.Collect(maps.Keys(stringIntMap))

// sort.Strings(stringKeys)

stringKeys := slices.Sorted(maps.Keys(stringIntMap))

sortedStringIntArray := make([]int, 0)

for _, key := range stringKeys {

sortedStringIntArray = append(sortedStringIntArray, stringIntMap[key])

}

fmt.Printf("%v\n", sortedStringIntArray) // [1 2 3]

fmt.Println("Done")

}

Creating IAM Role and Assigning it to EC2 Instance requires four steps

locals {

region = "us-west-2"

owner = "<name>"

ami = "ami-XXXXXX"

}

# Setup ECR Roles for EC2

resource "aws_iam_policy" "ecr_policy" {

name = "MyECRPolicy"

policy = jsonencode({

Version : "2012-10-17",

Statement : [

{

Effect : "Allow",

Action : [

"ecr:CompleteLayerUpload",

"ecr:UploadLayerPart",

"ecr:InitiateLayerUpload",

"ecr:BatchCheckLayerAvailability",

"ecr:PutImage",

"ecr:BatchGetImage"

],

Resource : "arn:aws:ecr:us-west-2:#############:repository/<name>/myweb"

},

{

Effect : "Allow",

Action : "ecr:GetAuthorizationToken",

Resource : "*"

}

]

})

tags = {

Name = "ECR Policy"

Owner = local.owner

}

}

resource "aws_iam_role" "ecr_role" {

name = "MyECRRole"

assume_role_policy = jsonencode({

Version : "2012-10-17",

Statement : [{

Effect : "Allow",

Action : [

"sts:AssumeRole"

],

Principal : {

Service : [

"ec2.amazonaws.com"

]

}

}]

})

tags = {

Name = "ECR Role"

Owner = local.owner

}

}

resource "aws_iam_role_policy_attachment" "ecr_policy_attach" {

role = aws_iam_role.ecr_role.name

policy_arn = aws_iam_policy.ecr_policy.arn

}

# Critical Definition

# When you use the AWS Dashboard to create a role, this will automatically

# create an instance profile. But using TF, this field "Instance profile ARN"

# doesn't appear in UI until this is defined.

#

# "An instance profile in AWS is a container for an IAM role that passes role

# information to an EC2 instance when it starts."

#

# "Instance profiles act as a bridge for IAM roles, which define a collection

# of permissions. An EC2 instance profile defines "who" the instance is, and

# then "assumes" the IAM role to gain the necessary permissions"

#

# It is then possible to select the MyECRRole and assign it to the instance

resource "aws_iam_instance_profile" "ecr_instance_profile" {

name = "MyECRInstanceProfile"

role = aws_iam_role.ecr_role.name

}

Leetcode Binary Tree Array Format in Golang

In the Binary Tree section of leetcode, they provide an Input array with values used to create a binary tree.

It isn't necessary to reproduce the trees to solve the traversal problems as you can manually build a tree by adding Left and Right nodes manually.

Still using the input data helps to suss out bugs when it fails some tests. The difficulty I ran into was trying to implement a recursive solution when the approach was understanding (with some googling help) that a queue was needed.

Below are my comments and code.

// create binary tree given a leetcode compressed array

// a verbose version of a binary tree would have a NULL_VALUE

// for every node at the full height eg.

//

// 0

// null 2

//

// null null 3 null

// Input = [0, null, 2, null, null, 3]

//

// leetcode BT format is a little more efficient as it will

// skip the 2 lower nulls

//

// Input = [0, null, 2, 3]

// To build the binary tree use a queue that will allow us to

// process each level before continue to the next level.

// When a node is created we add it to the queue. The L/R logic

// proceeds and pops the next value from the Input array.

// If the value is a null, we don't add it to the queue which stops

// further processing on that branch

//

// We loop until the queue is empty.

func (b *BinaryTree) CreateUnsorted(arr []int) {

if len(arr) <= 0 {

fmt.Println("No Elements")

return

}

val, arr := ArrayPop(arr)

b.Root = &TreeNode{Val: val}

queue := []*TreeNode{b.Root}

var node *TreeNode

leftVal := 0

rightVal := 0

for len(queue) > 0 {

node, queue = ArrayPop(queue)

if len(arr) <= 0 {

continue

}

leftVal, arr = ArrayPop(arr)

if leftVal != NULL_VALUE {

node.Left = &TreeNode{Val: leftVal}

queue = append(queue, node.Left)

}

if len(arr) <= 0 {

continue

}

rightVal, arr = ArrayPop(arr)

if rightVal != NULL_VALUE {

node.Right = &TreeNode{Val: rightVal}

queue = append(queue, node.Right)

}

}

}

Setting up Express and Typescript August 2022

To learn express and typescript, I wanted to convert the default express skeleton app into a typescript one. This uses the tutorial link below and only adds minimal changes to the express framework.

https://expressjs.com/en/starter/installing.html

and some help from this url too

https://blog.logrocket.com/how-to-set-up-node-typescript-express/

# sets up package.json
mkdir myexpress; cd myexpress
npm init -y

###
# express
npm install express

# creates an express project using pug templating instead of default jade
npx express-generator --view=pug

npm install

# to start http://localhost:3000/
DEBUG=myapp:* npm start

###
# typescript
# save-dev packages used only during dev and does not need to be deployed to prod
# ts-node is cli/repl for typescript
npm install typescript ts-node --save-dev

# https://devblogs.microsoft.com/typescript/writing-dts-files-for-types/
npm install @types/node @types/express --save-dev

npx tsc --init # creates tsconfig.json

###
# Problems
# 1. convert all the .js files into typescript
# 2. create new directory called dist or built to store the transpiled js
# 3. copy static files into dist
# 4. transpile ts into js
# 5. run the server using `node dist/index.js`
# 6. update package.json and tsconfig.json so that you can run `DEBUG=myapp:* npm start`

## 1. convert all the .js files into typescript

# adapt app.js into app.ts
npm install @types/http-errors @types/cookie-parser @types/morgan

# routes/index.ts

import express from "express";
const router = express.Router();

router.get('/', function(req, res, next) {
  res.render('index', { title: 'Express' });
});

export default router;

# app.js
import createError from "http-errors";
import express from "express";
import path from "path";
import cookieParser from "cookie-parser";
import logger from "morgan";

import indexRouter from  "./routes/index";
import usersRouter from "./routes/users";
import {NextFunction, Request, Response} from "express-serve-static-core";

const app = express();

// view engine setup
app.set('views', path.join(__dirname, '../views'));

//...

app.use(express.static(path.join(__dirname, '../public')));

//...

// error handler
app.use(function(err: any, req: Request, res: Response, next: NextFunction) {
  // set locals, only providing error in development
  res.locals.message = err.message;
  res.locals.error = req.app.get('env') === 'development' ? err : {};

  // render the error page
  res.status(err.status || 500);
  res.render('error');
});

app.listen(3000, '127.0.0.1');
export = app

## 3. Update the views/public paths used in app.js
# views and public need to be updated to ../ as app.js will be in ./dist and these two dirs will be one level up. This has been done in the above code snippet.

## 4. transpile cli
# this will search all ts files from the root directory and store the js files into the dist directory with the same hierarchy
npx tsc --outDir dist

## 5. run the server using `node dist/app.js`
With the addition of the last line above app.listen(//...), we can run node server using the `node` command.

## 6. update package.json and tsconfig.json so that you can run `DEBUG=myapp:* npm start`
# tsconfig.json
"outDir": "./dist",                                  /* Specify an output folder for all emitted files. */

# package.json
# this exists
  "scripts": {
    "start": "node ./bin/www"
  },

# edit ./bin/www
var app = require('../dist/app');

# Remove the app.listen line in app.ts as it's not needed any more
app.listen(3000, '127.0.0.1');

# and now it will work using the express way of starting the server
DEBUG=myapp:* npm start

## Bonus
# You can add a build to "scripts" in package.json
"build": "npx tsc"
# or use the cli
`npx tsc --watch`

Fedora 30 Add another port for ssh'ing to get around some wifi filters

Some ISP's that offer free wifi will not allow you to ssh. To get around this you can set your ssh server to use another port like 8080.

For Fedora 30

1) sudo vim /etc/ssh/sshd_config

Change

#Port 22
to
Port 22
Port 8080

# This allows two ports to connect to ssh

2) Update selinux to allow ssh on port 8080

sudo semanage port -m -t ssh_port_t -p tcp 8080

If you use -a you will get an error like
ValueError: Port tcp/8080 already defined

If you -d you will get another error like
ValueError: Port tcp/8080 is defined in policy, cannot be deleted

Use this to check:

sudo semanage port -l | grep 8080
http_cache_port_t              tcp      8080, 8118, 8123, 10001-10010
ssh_port_t                     tcp      8080, 22

Create an interface array consisting of a generic struct type in golang

I was looking at how to get a result set from a golang sql query. It seemed that a lot of the examples explicitly defined the fields or declared a struct that are passed into the Scan() method such as:

var id int
var name string
err = rows.Scan(&id, &name)
// or
row = MyStruct{}

err = rows.Scan(&row.Id, &row.Name)

This seemed like a lot of repetition if every query required this logic. My next thought was to see if I could pass in a struct, use reflect to obtain the fields and return a slice of values.

Here are two examples, the first one uses uses append and requires type assertion to access the fields. The second example uses reflect.append and each field can be accessed directly from the element.

Note: Additional checks should be added, such as making sure the address of the object is passed in.

First

package main

import (

    "fmt"

    "reflect"

)

type MyStruct struct {

    Id int

    Name string

}

func main() {

    me := MyStruct{}

    result := doIt(&me)

    for _, v := range result {

        fmt.Printf("%d %s\n", v.(MyStruct).Id, v.(MyStruct).Name)

    }

}

func doIt(genericStruct interface{}) []interface{} {

    params := []interface{}{}

    var myStruct reflect.Value

    structType := reflect.TypeOf(genericStruct).Elem()

    // First Element

    myStruct = reflect.New(structType).Elem()

    myStruct.FieldByName("Id").SetInt(1)

    myStruct.FieldByName("Name").SetString("one")

    fmt.Printf("%#v\n", myStruct)

    params = append(params, myStruct.Interface())

    // Second Element

    myStruct = reflect.New(structType).Elem()

    myStruct.FieldByName("Id").SetInt(2)

    myStruct.FieldByName("Name").SetString("two")

    fmt.Printf("%#v\n", myStruct)

    params = append(params, myStruct.Interface())

    return params

}

Second

package main

import (

    "fmt"

    "reflect"

)

type MyStruct struct {

    Id int

    Name string

}

func main() {

    myStruct := []MyStruct{}

    doIt(&myStruct)

    for _, v := range myStruct {

        fmt.Printf("%d %s\n", v.Id, v.Name)

    }

}

func doIt(genericStructArray interface{}) {

    var myStruct reflect.Value

    genericValue := reflect.ValueOf(genericStructArray).Elem()

    genericType := genericValue.Type().Elem()

    // First Element

    myStruct = reflect.New(genericType).Elem()

    myStruct.FieldByName("Id").SetInt(1)

    myStruct.FieldByName("Name").SetString("one")

    fmt.Printf("%#v\n", myStruct)

    genericValue.Set(reflect.Append(genericValue, myStruct))

    // Second Element

    myStruct = reflect.New(genericType).Elem()

    myStruct.FieldByName("Id").SetInt(2)

    myStruct.FieldByName("Name").SetString("two")

    fmt.Printf("%#v\n", myStruct)

    genericValue.Set(reflect.Append(genericValue, myStruct))

}

Output (same for both)

main.MyStruct{Id:5, Name:"one"}

main.MyStruct{Id:2, Name:"two"}

5 one

2 two