BYOA Model Features

Input: recency_minutes

we calculate recencyDays := math.Max(recencyMinutes/1440.0, 1.0)

and limit recencyDays as follows:
recencyDaysFn = 1.0 / math.Min(200, recencyDays) // math.Min(200, recencyDays) will limit recencyDaysFn in the range 0.005...1

If frequency > 200 frequency will be set to 200.

{
  "24": {
    "1": {
      "targeted": [],
      "untargeted": [
        "br_Chrome:ve_60.0.3112"
      ]
    }
  },
  "25": {
    "1": {
      "targeted": [],
      "untargeted": [
        "os_Windows:ve_10.0.0"
      ]
    }
  },
  "26": {
    "1": {
      "targeted": [],
      "untargeted": [
        "fo_Desktop"
      ]
    }
  },
  "27": {
    "1": {
      "targeted": [],
      "untargeted": [
        "ma_Desktop Make:mo_Desktop Model"
      ]
    }
  },
  "28": {
    "1": {},
    "2": {},
    "3": {}
  }
}

browser = "br_Chrome"
browser_version = "br_Chrome:ve_60.0.3112"
os = "os_Windows"
os_version = "os_Windows:ve_10.0.0"
device_model = "ma_Desktop Make:mo_Desktop Model"
device_manufacturer = "ma_Desktop Make"
device_type = "fo_Desktop"

package main

import (
    "fmt"
    "strconv"
)

//Round is a bit slower but easier to read
func Round(input string, numberDec int) (string, error) {
    flval, err := strconv.ParseFloat(input, 64)
    if err != nil {
        return "", err
    }
    if flval < 0 {
        return "", nil
    }
    if numberDec == 3 && flval > 0 {
        return TrimRight(fmt.Sprintf("%.3f", flval), '0'), nil
    }
    return fmt.Sprintf("%.1f", flval), nil
}

// RoundAndTrim Rounds and Trims
func RoundAndTrim(input string, numberDec int) (string, error) {
    res, err := Round(input, numberDec)
    if err != nil {
        return "", err
    }
    return TrimRight(res, '0'), nil
}

// TrimRight removes zero padding. E.g.,
// 10.000 -> 10.0
// 10.100 -> 10.1
// 10.120 -> 10.12
func TrimRight(input string, cut byte) string {
    count := 0
    for i := len(input) - 1; i > 0; i-- {
        if input[i] == cut && input[i-1] != '.' {
            count++
        } else {
            break
        }
    }

    return input[0 : len(input)-count]
}

func exchange_id_cs_vcr(exchangeID, videoCompletion string) {
    vcRounded, _ := RoundAndTrim(videoCompletion, 1)
    fmt.Println("exchange_id_cs_vcr^" + exchangeID + "-" + vcRounded)
}

func main() {
    exchangeID := "10"
    prebidVideoCompletion := "20"
    exchange_id_cs_vcr(exchangeID, prebidVideoCompletion)
}

package main

import (
    "fmt"
    "strconv"
)

//Round is a bit slower but easier to read
func Round(input string, numberDec int) (string, error) {
    flval, err := strconv.ParseFloat(input, 64)
    if err != nil {
        return "", err
    }
    if flval < 0 {
        return "", nil
    }
    if numberDec == 3 && flval > 0 {
        return TrimRight(fmt.Sprintf("%.3f", flval), '0'), nil
    }
    return fmt.Sprintf("%.1f", flval), nil
}

// RoundAndTrim Rounds and Trims
func RoundAndTrim(input string, numberDec int) (string, error) {
    res, err := Round(input, numberDec)
    if err != nil {
        return "", err
    }
    return TrimRight(res, '0'), nil
}

// TrimRight removes zero padding. E.g.,
// 10.000 -> 10.0
// 10.100 -> 10.1
// 10.120 -> 10.12
func TrimRight(input string, cut byte) string {
    count := 0
    for i := len(input) - 1; i > 0; i-- {
        if input[i] == cut && input[i-1] != '.' {
            count++
        } else {
            break
        }
    }
    return input[0 : len(input)-count]
}

func exchange_id_cs_ctr(exchangeID, prebidHistoricalCtr string) {
    ctRounded, _ := RoundAndTrim(prebidHistoricalCtr, 3)
    fmt.Println("exchange_id_cs_ctr^" + exchangeID + "-" + ctRounded)
}

func main() {
    exchangeID := "10"
    prebidHistoricalCtr := "0.002"
    exchange_id_cs_ctr(exchangeID, prebidHistoricalCtr)
}

package main

import (
    "fmt"
    "math"
    "strconv"
)

func exchange_id_cs_vrate(exchangeID, prebidViewability string) {
    vr, _ := strconv.ParseFloat(prebidViewability, 64)
    finalVal := int64(math.Floor(vr/10)) * 10
    fmt.Println("exchange_id_cs_vrate^" + exchangeID + "-" + strconv.FormatInt(finalVal, 10))
}

func main() {
    exchangeID := "10"
    prebidViewability := "19"
    exchange_id_cs_vrate(exchangeID, prebidViewability)
}

Use Boost Library 1.58

uint32_t m_HashedAppId = 0;

void setHashedAppId(const char* appid)
{
    if (appid) {
        m_HashedAppId = atoi(appid);
        if (m_HashedAppId == 0) {
            m_HashedAppId = MM::Utils::pstr_ihash()(appid) % INT_MAX;
        }
    }
}

struct pstr_ihash
    : std::unary_function<const char*, std::size_t>
{
    std::size_t operator()(const char* x) const
    {
        std::size_t seed = 0;

        while (*x) {
            boost::hash_combine(seed, ::toupper(*x++));
        }
        return seed;
    }
};

#include <iostream>
#include <string>
#include <boost/functional/hash.hpp>
#include <climits>
#include <cassert>
#include <cstring>

struct pstr_ihash
    : std::unary_function<const char*, std::size_t>
{
    std::size_t operator()(const char* x) const
    {
        std::size_t seed = 0;

        while (*x) {
            boost::hash_combine(seed, ::toupper(*x++));
        }
        return seed;
    }
};

// pass appId from impressions
// TODO: add handling for special case:
// If App ID is absent, LLDS Impressions logs N/A for app_id
// if app_id = N/A -> hashed_app_id = 0
unsigned int calcHashedAppId(const char* appid)
{
    unsigned int m_HashedAppId = 0;
    if (appid) {
        if (std::strcmp(appid, "N/A") == 0) {
            return 0;
        }
        m_HashedAppId = atoi(appid);
        if (m_HashedAppId == 0) {
            m_HashedAppId = pstr_ihash()(appid) % INT_MAX;
        }
    }
    return m_HashedAppId;
}

struct testcase {
    const char* input;
    unsigned int expected_output;
};
  
int main() {
   // your code goes here

   std::vector<testcase> tests {
      {"com.fivemobile.thescore", 1453566594},
      {"605581486", 605581486},
      {"tunein.player", 1173358324},
      {"com.aws.android", 1903276095},
      {"com.document.pdf.scanner.docscan", 1812585910},
      {"com.apalon.weatherlive.free", 591449217},
      {"com.pandora.android", 1387399900},
      {"com.weather.weather", 447752198},
      {"de.wetteronline.wetterapp", 1107246225},
      {"439873467", 439873467},
      {"N/A", 0},
   };

   for (unsigned int i = 0; i < tests.size(); i++) {
      assert(calcHashedAppId(tests[i].input) == tests[i].expected_output);
   }

   return 0;
}

//encore_decode_size.go
package main

import (
	"errors"
	"fmt"
	"strconv"
)

func encode(width uint32, height uint32) uint32 {
	var size uint32
	size = (0xFFFF & height)
	size |= (width << 16)
	return size
}

func decode(val string) (int, int, error) {
	size, err := strconv.ParseUint(val, 10, 32)
	if err != nil {
		return 0, 0, errors.New("strconv.ParseUint() failed")
	}
	width := int((size >> 16) & 0xffff)
	height := int(size & 0xffff)

	return width, height, nil
}

func main() {
	fmt.Printf("%d\n", encode(320, 50)) // Will output 20971570

	width, height, err := decode("20971570")
	if err != nil {
		fmt.Println(err)
		return
	}
	fmt.Printf("%dx%d\n", width, height) // Will output 320x50
}