2021-12-01 22:49:48 +01:00
package helper
import (
"errors"
"io/ioutil"
"sort"
"strconv"
"strings"
)
2021-12-03 14:02:20 +01:00
type convert func ( int ) string
2021-12-01 22:49:48 +01:00
func GetInput ( filename string ) ( [ ] string , error ) {
content , err := ioutil . ReadFile ( filename )
if err != nil {
return nil , err
}
lines := strings . Split ( string ( content ) , "\r\n" )
return lines , err
}
func GetFile ( filename string ) ( string , error ) {
content , err := ioutil . ReadFile ( filename )
if err != nil {
return "" , err
}
return string ( content ) , err
}
2021-12-04 14:48:05 +01:00
func MapToNumber ( numberStrings [ ] string ) ( [ ] int , error ) {
2021-12-01 22:49:48 +01:00
var numbers [ ] int
2021-12-04 14:48:05 +01:00
for _ , numberString := range numberStrings {
trimmedNumberString := strings . TrimSpace ( numberString )
number , err := strconv . Atoi ( trimmedNumberString )
2021-12-01 22:49:48 +01:00
if err != nil {
return numbers , err
}
numbers = append ( numbers , number )
}
return numbers , nil
}
2021-12-03 14:02:20 +01:00
func RunesToNumber ( runes [ ] rune ) [ ] int {
var numbers [ ] int
for _ , r := range runes {
number := int ( r - '0' )
numbers = append ( numbers , number )
}
return numbers
}
2021-12-01 22:49:48 +01:00
func FindAddendsForSum ( possibleAddends [ ] int , sum int ) ( int , int , error ) {
var array = make ( [ ] int , len ( possibleAddends ) )
copy ( array , possibleAddends )
sort . Ints ( array )
p1 := 0
p2 := len ( array ) - 1
for p1 < p2 {
if array [ p1 ] + array [ p2 ] < sum {
p1 ++
}
if array [ p1 ] + array [ p2 ] > sum {
p2 --
}
if array [ p1 ] + array [ p2 ] == sum {
return array [ p1 ] , array [ p2 ] , nil
}
}
return 0 , 0 , errors . New ( "No fitting Addends found" )
}
func SliceIndex ( limit int , predicate func ( i int ) bool ) int {
for i := 0 ; i < limit ; i ++ {
if predicate ( i ) {
return i
}
}
return - 1
}
2021-12-03 14:02:20 +01:00
func DeleteAt ( a [ ] int , i int ) [ ] int {
2021-12-01 22:49:48 +01:00
return append ( a [ : i ] , a [ i + 1 : ] ... )
}
func Equal ( a , b [ ] int ) bool {
if len ( a ) != len ( b ) {
return false
}
for i , v := range a {
if v != b [ i ] {
return false
}
}
return true
}
2021-12-12 16:15:16 +01:00
func EqualStringArray ( a , b [ ] string ) bool {
if len ( a ) != len ( b ) {
return false
}
for i , v := range a {
if v != b [ i ] {
return false
}
}
return true
}
2021-12-03 14:02:20 +01:00
func Contains ( elem int , array [ ] int ) bool {
for _ , val := range array {
if val == elem {
2021-12-01 22:49:48 +01:00
return true
}
}
return false
}
2021-12-12 16:15:16 +01:00
func ContainsString ( elem string , array [ ] string ) int {
sum := 0
for _ , val := range array {
if val == elem {
sum ++
}
}
return sum
}
func ContainsStringArray ( elem [ ] string , array [ ] [ ] string ) int {
sum := 0
for _ , val := range array {
if EqualStringArray ( elem , val ) {
sum ++
}
}
return sum
}
func ContainsCharacter ( input string , characters string ) bool {
for _ , char := range characters {
if ! strings . ContainsRune ( input , char ) {
return false
}
}
return true
}
2021-12-01 22:49:48 +01:00
func AddNummbers ( numbers ... int ) int {
result := 0
for _ , number := range numbers {
result += number
}
return result
}
2021-12-03 14:02:20 +01:00
func Transpose ( in [ ] [ ] int ) [ ] [ ] int {
out := make ( [ ] [ ] int , len ( in [ 0 ] ) )
for i := 0 ; i < len ( in ) ; i += 1 {
for j := 0 ; j < len ( in [ 0 ] ) ; j += 1 {
out [ j ] = append ( out [ j ] , in [ i ] [ j ] )
}
}
return out
}
2021-12-04 14:48:05 +01:00
2021-12-12 16:15:16 +01:00
func RemoveElementFromStringArray ( stringArray [ ] string , selector string ) [ ] string {
2021-12-04 14:48:05 +01:00
var returnString [ ] string
for _ , str := range stringArray {
if str != selector {
returnString = append ( returnString , str )
}
}
return returnString
}
2021-12-05 16:12:59 +01:00
2021-12-15 22:50:06 +01:00
func RemovePointFromPointArray ( pointArray [ ] [ 2 ] int , selector [ 2 ] int ) [ ] [ 2 ] int {
var returnArray [ ] [ 2 ] int
for _ , point := range pointArray {
if point != selector {
returnArray = append ( returnArray , point )
}
}
return returnArray
}
2021-12-05 16:12:59 +01:00
func GCD ( x int , y int ) ( int ) {
gcd := - 1
for i := 1 ; i <= x && i <= y ; i ++ {
if ( y % i == 0 && x % i == 0 ) {
gcd = i
}
}
return gcd
}
func Abs ( x int ) int {
if x < 0 {
return - x
}
return x
}
2021-12-08 15:34:25 +01:00
func RemoveCharactersFromString ( input string , characters string ) string {
filter := func ( r rune ) rune {
if strings . IndexRune ( characters , r ) < 0 {
return r
}
return - 1
}
return strings . Map ( filter , input )
}
type sortRunes [ ] rune
func ( s sortRunes ) Less ( i , j int ) bool {
return s [ i ] < s [ j ]
}
func ( s sortRunes ) Swap ( i , j int ) {
s [ i ] , s [ j ] = s [ j ] , s [ i ]
}
func ( s sortRunes ) Len ( ) int {
return len ( s )
}
func SortString ( s string ) string {
r := [ ] rune ( s )
sort . Sort ( sortRunes ( r ) )
return string ( r )
}
2021-12-09 20:34:12 +01:00
type Pair struct {
Key string
Value int
}
type PairList [ ] Pair
func RankByValueAmount ( 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
}
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 ] }