DEV Community: manuel

Shamazing

manuel — Wed, 09 Mar 2022 10:20:00 +0000

Find the longest string or integer in a SHA1 Hash (or whatever). It’s just sha-mazing and without any sense :)

package shamazing
import (
   "regexp"
   "strconv"
)

// FindLongestString will retrieve a string like a SHA1, MD5 or whatever
// and return the longest string (first one)
func FindLongestString(str string) string {
   var re = regexp.MustCompile("[a-zA-Z]+")
   var values = re.FindAll([]byte(str), -1)
   return string(findLongest(values))
}
// FindLongestInteger will retrieve a string like a SHA1, MD5 or whatever
// and return longest integer (first one)
func FindLongestInteger(str string) (int64, error) {
   var re = regexp.MustCompile("[0-9]+")
   var values = re.FindAll([]byte(str), -1)
   var max = findLongest(values)
   var a, err = strconv.Atoi(string(max))
   if err != nil {
      return 0, err
   }
   return int64(a), nil
}
func findLongest(values [][]byte) []byte {
   var max []byte
   for _, value := range values {
      if len(value) > len(max) {
         max = value
      }
   }
   return max
}

shamazing on GitHub

Retrieve the current price for an crypto currency

manuel — Wed, 16 Feb 2022 10:11:00 +0000

You can use this to retrieve the current price for an crypto currency. I used this in another project and thought it will make sense to publish this as an own package.

How to use it #

import "https://github.com/mnlwldr/coinbase"

Usage #

response, err := Get("SHIB-EUR")
fmt.Printf("%.7f\n", response.Amount)

Output #

0.0000253

A Simple PAYONE Integration in Golang

manuel — Mon, 14 Feb 2022 10:20:00 +0000

If you want to process payments with Payone, here is a simple package.

How to use it #

import "https://github.com/mnlwldr/payone"

Usage #

response, err := sendRequest(parameters)

Parameters #

You can find the documentation for PAYONE here

parameters := url.Values{}
// classic payone accoint informations.
parameters.Set("aid", "")
parameters.Set("mid", "")
parameters.Set("portalid", "")
parameters.Set("key", "") // the key has to be hashed as md5
parameters.Set("mode", "test") // can be "live" for actual transactions
parameters.Set("api_version", "3.8")
parameters.Set("encoding", "UTF-8")
// payment type parameters
parameters.Set("clearingtype", "wlt")
parameters.Set("wallettype", "PPE")
parameters.Set("request", "authorization")
parameters.Set("narrative_text", "Just a test")
parameters.Set("reference", fmt.Sprintf("%d", rand.Intn(100)))
parameters.Set("currency", "EUR")
parameters.Set("amount", "1234") // in cent
parameters.Set("successurl", "https://example.com/success")
parameters.Set("errorurl", "https://example.com/error")
parameters.Set("backurl", "https://example.com/back")
// personal data. Not everything is mandatory
parameters.Set("salutation", "Frau")
parameters.Set("title", "")
parameters.Set("firstname", "Maraike")
parameters.Set("lastname", "Musterfrau")
parameters.Set("street", "Musterstrasse")
parameters.Set("zip", "12345")
parameters.Set("city", "Somewhere over the rainbow")
parameters.Set("country", "DE")
parameters.Set("email", "maraike.musterfrau@example.com")
parameters.Set("language", "de")
parameters.Set("gender", "f")

Response #

type Response struct {
   Status string
   TxId string
   UserId string
   RedirectUrl string
   Token string
}

RSS to HTML

manuel — Fri, 04 Feb 2022 10:20:00 +0000

Inspired by engineeringblogs.xyz (GitHub). Generate a HTML output from several rss feeds.

go run Reader.go example-urls > example-output.html

PREVIEW

rss-feeds-to-html on GitHub

Hi-Lo

manuel — Fri, 21 Jan 2022 10:26:00 +0000

Inspired from this blog post and basic-computer-games.

This game is an adaptation of the game GUESS; however, instead of just guessing a number between 1 and 100, in this game you win dollars when you guess the number. The directions, in the words of the author, are as follows:

package main
import (
   "fmt"
   "math/rand"
   "strings"
   "time"
)
const (
   MAX_ATTEMPTS = 6
   MIN = 1
   MAX = 100
)
func welcome() {
   fmt.Println("HI LO")
   fmt.Printf("CREATIVE COMPUTING MORRISTOWN, NEW JERSEY\n\n\n")
   fmt.Printf("THIS IS THE GAME OF HI LO.\n")
   fmt.Printf("YOU WILL HAVE %d TRIES TO GUESS THE AMOUNT OF MONEY IN THE\n", MAX_ATTEMPTS)
   fmt.Printf("HI LO JACKPOT, WHICH IS BETWEEN %d AND %d DOLLARS. IF YOU\n", MIN, MAX)
   fmt.Println("GUESS THE AMOUNT, YOU WIN ALL THE MONEY IN THE JACKPOT!")
   fmt.Println("THEN YOU GET ANOTHER CHANCE TO WIN MORE MONEY. HOWEVER,")
   fmt.Printf("IF YOU DO NOT GUESS THE AMOUNT, THE GAME ENDS.\n\n\n")
}

func play() {
   total_winnings := 0
   for {
      secret := randomNumber()
      guessed_correctly := false
      for i := 1; i <= MAX_ATTEMPTS; i++ {
         var in int
         fmt.Printf("YOUR GUESS: ")
         _, err := fmt.Scanf("%d", &in)
         if err != nil {
             panic(err)
         }
         if in == secret {
            fmt.Printf("GOT IT!!!!!!!!!! YOU WIN %d DOLLARS\n", secret)
            guessed_correctly = true
            break
         } else if in > secret { 
            fmt.Printf("YOUR GUESS IS TOO HIGH.\n")
         } else if in < secret {
            fmt.Printf("YOUR GUESS IS TOO LOW.\n")
         }
      }
      if guessed_correctly {
         total_winnings += secret
         fmt.Printf("YOUR TOTAL WINNINGS ARE NOW %d DOLLARS\n", total_winnings)
      } else {
         fmt.Printf("YOU BLEW IT...TOO BAD...THE NUMBER WAS %d\n", secret)
      }
      fmt.Printf("\n")
      fmt.Printf("PLAY AGAIN (YES OR NO)?: ")
      var answer string
      _, err := fmt.Scanf("%s", &answer)
      if err != nil {
         panic(err)
      }
      if strings.ToUpper(answer) != "YES" {
         fmt.Printf("\nSO LONG. HOPE YOU ENJOYED YOURSELF!!!\n")
      break
      } else {
      }  
   }
}

func randomNumber() int {
   rand.Seed(time.Now().UnixNano())
   return rand.Intn(MAX-MIN+1) + MIN
}

func main() {
   welcome()
   play()
}

Hi-Lo on GitHub

Wordle solver

manuel — Fri, 21 Jan 2022 00:00:00 +0000

Just for fun tool to search in the Wordle wordlist.

Usage

Usage of ./wordle-solver:
  -except string
        Characters to except (e.g.: "aeou")
  -match string
        The string to match (placeholder: .) (default ".....")
  -wordlist string
        Wordlist to use (default "Wordlist")

Example Todays Worlde is “BRAND” for example and we started with “IRATE”.

wordle-solver -match ".ra.." -except "ite"

You got a list of 27 possible words.

Wordle solver on GitHub

package main

import (
    "bufio"
    "flag"
    "fmt"
    "log"
    "os"
    "regexp"
)

func main() {
    wordlistFlag := flag.String("wordlist", "Wordlist", "Wordlist to use")
    matchFlag := flag.String("match", ".....", "The string to match (placeholder: .)")
    exceptFlag := flag.String("except", "", "Characters to except (e.g.: \"aeou\")")
    flag.Parse()

    file, err := os.Open(*wordlistFlag)
    if err != nil {
        log.Fatal(err)
    }
    defer file.Close()

    scanner := bufio.NewScanner(file)
    for scanner.Scan() {
        match, _ := regexp.MatchString(*matchFlag, scanner.Text())
        except, _ := regexp.MatchString(fmt.Sprintf(`[%s]`, *exceptFlag), scanner.Text())
        if match && !except {
            fmt.Println(scanner.Text())
        }
    }
}

How I found a good opener for Wordle

manuel — Thu, 13 Jan 2022 18:48:30 +0000

Like some other people, I played Wordle the last days.

Today, I wrote a little tool to find out whats can be a good opener. Jotto is a similar game so it's easy to find a list of words like this https://www.easysurf.cc/list1.htm.

I downloaded and checked it against my helper tool. The code is not a beauty but it works (and I hope correctly)

package main

import (
    "bufio"
    "fmt"
    "os"
    "sort"
)

func main() {
    checkAgainstWordlist()
}

func checkAgainstWordlist() {
    lettercount := make(map[string]int)

    file, err := os.Open("Wordlist")
    if err != nil {
        panic("panic")
    }
    defer file.Close()

    scanner := bufio.NewScanner(file)
    for scanner.Scan() {

        for _, letter := range scanner.Text() {
            if val, ok := lettercount[rune2c(letter)]; ok {
                lettercount[rune2c(letter)] = val + 1
            } else {
                lettercount[rune2c(letter)] = 1
            }
        }
    }
    fmt.Println(rankByWordCount(lettercount))

    if err := scanner.Err(); err != nil {
        panic(err)
    }
}

func rune2c(r rune) string {
    return fmt.Sprintf("%c", r)
}

func rankByWordCount(wordFrequencies map[string]int) PairList {
    pl := make(PairList, len(wordFrequencies))
    i := 0
    for k, v := range wordFrequencies {
        pl[i] = Pair{k, v}
        i++
    }
    sort.Sort(sort.Reverse(pl))
    return pl
}

type Pair struct {
    Key   string
    Value int
}

type PairList []Pair

func (p PairList) Len() int {
    return len(p)
}

func (p PairList) Less(i, j int) bool {
    return p[i].Value < p[j].Value
}

func (p PairList) Swap(i, j int) {
    p[i], p[j] = p[j], p[i]
}

The result was [{e 709} {a 679} {r 565} {t 499} {i 480} {o 457} {s 429} {l 428} {n 418} {c 352} {u 335} {h 302} {d 258} {p 240} {y 238} {m 222} {g 203} {b 185} {k 154} {w 137} {f 137} {v 99} {x 30} {q 26} {z 24} {j 19}]

(e = 709 times, a = 679 times, ...)

That means e,a,r,t, and i are the most used letters in the list. A word for this combination of letters can be "IRATE".
I checked this on Wordle and yeah, it's a accepted word :)

I checked this against the last 9 days and got following matches:

Now, the next letters are o,s,l,n, and c. A word for this combination of letters can be "CLONS". I checked this on Wordle and it's a accepted word too. I got following improvements against the last 9 days:

200: 3 => 3
201: 1 => 3
202: 0 => 2
203: 2 => 4
204: 2 => 3
205: 2 => 2
206: 2 => 3
207: 2 => 3
208: 2 => 2

I wrote this really quickly, hope I haven't made many mistakes.

Update

I got the Wordlist from Wordle itself an run my code again.
The result are
[{s 6665} {e 6662} {a 5990} {o 4438} {r 4158} {i 3759} {l 3371} {t 3295} {n 2952} {u 2511} {d 2453} {y 2074} {c 2028} {p 2019} {m 1976} {h 1760} {g 1644} {b 1627} {k 1505} {f 1115} {w 1039} {v 694} {z 434} {j 291} {x 288} {q 112}]

That means a got opener is arose followed by until

What are your words to open the game?

Merge several individual ssh configuration files to one single file in Golang

manuel — Thu, 29 Jul 2021 00:00:00 +0000

The easiest way to achieve this is to write something like cat ~/.ssh/config_* >> ~/.ssh/config in the shell or add an alias, but that’s not so funny.

Usage

ssh-merge-config ~/.ssh/config.d/ ~/.ssh/config

The first parameter is the source folder to read and the second parameter is the destination file.

Output

~ ssh-merge-config ~/.ssh/config.d/ ~/.ssh/config
done

That’s it. The code is on GitHub https://github.com/mnlwldr/ssh-merge-config.

package main

import (
    "bytes"
    "fmt"
    "io/ioutil"
    "log"
    "os"
    "time"
)

func main() {

    name := os.Args[0]

    if len(os.Args) < 3 {
        help(name)
        os.Exit(255)
    }

    directory := os.Args[1]
    output := os.Args[2]

    if _, err := os.Stat(directory); os.IsNotExist(err) {
        log.Printf("%s does not exist", directory)
        os.Exit(255)
    }

    files, err := ioutil.ReadDir(directory)
    checkErr(err)

    var content bytes.Buffer
    for _, f := range files {
        readFile,err := ioutil.ReadFile(directory + string(os.PathSeparator) + f.Name())
        checkErr(err)
        content.WriteString(string(readFile))
    }

    if _, err := os.Stat(output); err == nil {
        backup(output)
    }

    out, err := os.Create(output)
    checkErr(err)
    defer func(out *os.File) {
        err := out.Close()
        checkErr(err)
    }(out)

    _, err2 := out.WriteString(content.String())
    checkErr(err2)

    fmt.Println("done")
}

func checkErr(err error) {
    if err != nil {
        log.Fatal(err)
    }
}

func help(name string) {
    fmt.Printf("Usage: %s [input directory] [output file]\n", name)
    fmt.Println("Example: ")
    fmt.Printf("\t %s ~/.ssh/config.d/ ~/.ssh/config\n", name)
}

func backup(filename string) {
    var backupFile bytes.Buffer
    backupFile.WriteString(filename)
    backupFile.WriteString(".")
    backupFile.WriteString(time.Now().Format("20060102"))

    err := os.Rename(filename, backupFile.String())
    if err != nil {
        checkErr(err)
    }
}

println() and fmt.Println()

manuel — Wed, 14 Apr 2021 00:00:00 +0000

println() is a built-in function and looks useful to developers, because they lack dependencies. But there is a difference between fmt.Println() and println().

println() write to stderr instead of stdout and I never noticed that before, maybe because I didn’t used println so much in the past.

I discovered this because I wanted to compare the throughput of

for {
    fmt.Println("y")
}

and

for {    
    println("y")    
}

by pipe this to pv -r. So I wondered why I got a lot of “y” in the println() variant.

The println built-in function formats its arguments in an implementation-specific way and writes the result to standard error. Spaces are always added between arguments and a newline is appended. Println is useful for bootstrapping and debugging; it is not guaranteed to stay in the language.

println in the Golang built-in documentation

Filewatcher in Golang

manuel — Thu, 28 Jan 2021 00:00:00 +0000

This is a simple example of how to move files from one folder to another automatically with Go and fsnotify/fsnotify.

func main() {
    srcDir := "path/to/a"
    destDir := "path/to/b"

    watcher, err := fsnotify.NewWatcher()
    if err != nil {
        fmt.Println(err)
        os.Exit(1)
    }
    defer watcher.Close()

    done := make(chan bool)
    go func() {
        for {

            event, ok := <-watcher.Events
            if !ok {
                return
            }
            if event.Op.String() == "CREATE" {
                log.Println("[event] ", event)
                newPath := destDir + filepath.Base(event.Name)
                err := os.Rename(event.Name, newPath)
                if err != nil {
                    log.Fatal(err)
                }
            }
        }
    }()
    err = watcher.Add(srcDir)
    if err != nil {
        log.Fatal(err)
    }
    <-done
}

Microblogging

manuel — Thu, 10 Dec 2020 12:22:21 +0000

Some weeks ago, I started microblogging on my regular blog. At first it was just an experiment, but I like it and I think I am going to stick with it.

I found some other examples:

Is anyone else microblogging on his own "plattform" like Jekyll, Hugo etc.?

URL in C

manuel — Tue, 01 Dec 2020 09:55:00 +0000

Did you know that URLs are a valid syntactic element in C? Maybe the syntax highlighting will give you a hint :)

#include <stdio.h>

int main()
{
    https://wildauer.io/
    printf("hello, world\n");
    return 0;
}

~ gcc hello.c -o hello && ./hello
hello, world

The code compiles and runs successfully, because https: is a label and // following begins a comment.