Building a training set of tags for vlang about vlang HOT 22 CLOSED

module main

fn hello() string {
	return "Hello, World!"
}

module main

// reverse_string returns a given string in reverse order
fn reverse_string(str string) string {
    return str.split('').reverse().join('')
}

module main

fn is_equilateral(a f64, b f64, c f64) bool {
    return is_triangle(a, b, c) && a == b && b == c
}

fn is_isosceles(a f64, b f64, c f64) bool {
    return is_triangle(a, b, c) && (a == b || b == c || c == a)
}

fn is_scalene(a f64, b f64, c f64) bool {
    return is_triangle(a, b, c) &&  a != b && b != c && c != a
}

fn is_triangle(a f64, b f64, c f64) bool {
    return a + b >= c && b + c >= a && a + c >= b
}

module main

fn prime_factors(n i64) []i64 {
	mut prime_list := []i64{}
	mut prime := 2
	mut number := n
	for number != 1 {
		if number % prime == 0 {
			prime_list << prime
			number /= prime
			continue
		}
		prime++
	}
	return prime_list
}

module main

fn accumulate_ints(values []int, operation fn (int) int) []int {
	mut result := []int{}

	for i in values {
		result << operation(i)
	}

	return result
}

// Because V functions cannot be overloaded[1], make another function
//  called `accumulate_strs` that does the same thing for strings
// instead of ints

fn accumulate_strs(values []string, operation fn (string) string) []string {
	mut result := []string{}
	for i in values {
		result << operation(i)
	}

	return result
}

module main

enum Command as u8 {
	wink						= 0b00001
	double_blink		= 0b00010
	close_your_eyes	= 0b00100
	jump						= 0b01000
	reverse					= 0b10000
}

pub fn commands(encoded_message int) []Command {
	mut ret := []Command{}
	for cmd in [Command.wink, Command.double_blink, Command.close_your_eyes, Command.jump] {
		if encoded_message & int(cmd) != 0 { ret << cmd }
	}
	if encoded_message & int(Command.reverse) != 0 { ret.reverse_in_place() }
	
	return ret
}

// ---------------------------------------------------------------------------
// exercism.org
// V Track Exercise: gigasecond
// Contributed: Anthony J. Borla ([email protected])
// ---------------------------------------------------------------------------

module main

import time

fn add_gigasecond(t time.Time) time.Time {
   return time.Time{ unix : (t.unix + 1000000000) }
}

module main

import math

fn rebase(input_base int, digits []int, output_base int) ![]int {
	if input_base < 2 {
		return error('input base must be >= 2')
	}
	if output_base < 2 {
		return error('output base must be >= 2')
	}
	if digits.len < 1 {
		return [0]
	}

	mut res := []int{}
	mut deci := int(0)
	for idx, e in digits.reverse() {
		if e < 0 || e >= input_base {
			return error('all digits must satisfy 0 <= d < input base')
		}
		deci += int(math.powi(input_base, idx) * e)
	}
	for deci > 0 {
		res << deci % output_base
		deci /= output_base
	}
	return if res.len == 0 {
		[0]
	} else {
		res.reverse()
	}
}

module main

fn response(hey_bob string) string {
  mut is_silence := true
  mut is_question := false
  mut contains_upper := false
  mut contains_lower := false

  for ch in hey_bob.bytes() {
    if ch.is_space() {
      continue
    }
    is_silence = false

    if ch == u8(`?`) {
      // The last non-whitespace character is a question mark.
      is_question = true
      continue
    }
    is_question = false

    if ch.is_letter() {
      if ch.is_capital() {
        contains_upper = true
      } else {
        contains_lower = true
      }
    }
  }

  if is_silence {
    return 'Fine. Be that way!'
  }

  if contains_upper && !contains_lower {
    if is_question {
      return "Calm down, I know what I'm doing!"
    }
    return 'Whoa, chill out!'
  }

  if is_question {
    return 'Sure.'
  }
  return 'Whatever.'
}

module main

import datatypes { Stack }

const (
    opening = ['(', '[', '{']
    closing = [')', ']', '}']
    not_found = -1
)

fn is_paired(input string) bool {
    mut stack := Stack[string]{}

    for bracket in input.split('') {
        if bracket in opening {
            stack.push(bracket)    
        } else if bracket in closing {
            o := stack.pop() or { return false }
            c_i := closing.index(bracket)
            o_i := opening.index(o)
    
            if c_i == not_found || o_i == not_found || c_i != o_i {
                return false
            }
        }
    }
    return stack.is_empty()
}

module main

import arrays { chunk }

fn to_protein(codon string) string {
	return match codon {
		'AUG' { 'Methionine' }
		'UUU', 'UUC' { 'Phenylalanine' }
		'UUA', 'UUG' { 'Leucine' }
		'UCU', 'UCC', 'UCA', 'UCG' { 'Serine' }
		'UAU', 'UAC' { 'Tyrosine' }
		'UGU', 'UGC' { 'Cysteine' }
		'UGG' { 'Tryptophan' }
        'UAA', 'UAG', 'UGA' { 'STOP' }
		else { 'UNKNOWN' }
	}
}

fn codons(rna string) []string {
	return chunk(rna.split(''), 3).map(it.join(''))
}

fn proteins(strand string) ![]string {
    mut result := []string{}
    for protein in codons(strand).map(to_protein(it)) {
        match protein {
            'STOP' { return result }
            'UNKNOWN' { return error('Invalid codon') }
            else { result << protein }
        }
    }
    return result
}

module main

const side_none = 0

// Bitwise XOR with a side can be used to find a player's other side.
const side_opposite = 1

const side_top = 2

const side_bottom = 3

const side_left = 4

const side_right = 5

struct Cell {
	row    int
	column int
	side   int = side_none
}

// Each cell has 6 adjacent cells.
const deltas = [
	Cell{
		row: 0
		column: -1
	},
	Cell{
		row: 0
		column: 1
	},
	Cell{
		row: -1
		column: 0
	},
	Cell{
		row: 1
		column: 0
	},
	Cell{
		row: -1
		column: 1
	},
	Cell{
		row: 1
		column: -1
	},
]

fn winner(board []string) ?rune {
	row_count := board.len
	column_count := (board[0].len + 1) >> 1

	mut pending := []Cell{cap: (row_count + 2) * (column_count + 2)}
	for column in 0 .. column_count {
		pending << Cell{
			row: -1
			column: column
			side: side_top
		}
		pending << Cell{
			row: row_count
			column: column
			side: side_bottom
		}
	}
	for row in 0 .. row_count {
		pending << Cell{
			row: row
			column: -1
			side: side_left
		}
		pending << Cell{
			row: row
			column: column_count
			side: side_right
		}
	}

	mut reached := [][]int{len: row_count, init: []int{len: column_count, init: side_none}}

	for pending.len > 0 {
		current := pending.pop()

		// "Player `O`" plays from top to bottom,
		// "Player `X`" plays from left to right.
		player := if current.side <= side_bottom { `O` } else { `X` }

		// We consider the 6 cells adjacent to current, excluding those we don't occupy.
		// If any have not previously been reached, we queue them.
		// If any have been reached from the opposite side, we have won.
		for delta in deltas {
			row := current.row + delta.row
			column := current.column + delta.column
			if row < 0 || row >= row_count || column < 0 || column >= column_count {
				continue
			}
			occupant := board[row][row + 2 * column]
			if occupant != player {
				continue
			}
			if reached[row][column] == current.side {
				continue
			}
			if reached[row][column] == side_none {
				reached[row][column] = current.side
				pending << Cell{
					row: row
					column: column
					side: current.side
				}
				continue
			}
			assert reached[row][column] == current.side ^ side_opposite
			return player
		}
	}

	// No player has won.
	return none
}

module main

import strings

fn generate_row(index int, n int) string {
        if index > n {
                return generate_row(2 * n - index, n)
        }
        len := 2 * n + 1
        mut builder := strings.new_builder(len)
        builder.write_string(strings.repeat(u8(` `), n - index))
        builder.write_rune(`A` + index)
        if index > 0 {
                builder.write_string(strings.repeat(u8(` `), 2 * index - 1))
                builder.write_rune(`A` + index)
        }
        builder.write_string(strings.repeat(u8(` `), n - index))
        assert builder.len == len
        return builder.str()
}

fn rows(letter rune) []string {
        assert `A` <= letter && letter <= `Z`
        n := int(letter - `A`)
        len := 2 * n + 1
        mut result := []string{cap: len}
        for i in 0 .. len {
                result << generate_row(i, n)
        }
        return result
}

module main

fn abbreviate(phrase string) string {
    return phrase.replace_each(['-', ' ', '_', '']) // Replace hyphens with spaces and remove other undesired characters
        .split(' ')                                // Split into words
        .filter(it.len > 0)                        // Filter out empty words
        .map(it[0].ascii_str().to_upper())         // Get the first letter of each word and convert to uppercase
        .join('')                                  // Join the results to form the acronym
}

module main

const directions = [-1, 0, 1]

struct Pair {
	column int
	row    int
}

struct WordLocation {
	start Pair
	end   Pair
}

// Checks if the given position is within the grid boundaries
fn is_valid_position(row int, column int, rows int, columns int) bool {
	return row >= 0 && row < rows && column >= 0 && column < columns
}

// Moves from a starting position in the specified direction for a given distance
fn move_in_direction(row int, column int, delta_row int, delta_column int, distance int) Pair {
	return Pair{
		column: column + delta_column * distance,
		row: row + delta_row * distance,
	}
}

// Searches for a word in the grid starting from a specific position and following a given direction
fn search_word_in_direction(grid []string, word string, start_row int, start_column int, delta_row int, delta_column int) ?WordLocation {
    mut position := Pair{column: 0, row: 0}
	for i in 0..word.len {
		position = move_in_direction(start_row, start_column, delta_row, delta_column, i)
		if !is_valid_position(position.row, position.column, grid.len, grid[0].len) || grid[position.row][position.column] != word[i] {
			return none
		}
	}
	return ?WordLocation{
        start: Pair{column: start_column + 1, row: start_row + 1},
        end: Pair{column: position.column + 1, row: position.row + 1}
    }
}

// Searches for a word in the grid starting from a specific position
fn find_word_starting_at(grid []string, word string, start_row int, start_column int) ?WordLocation {
	for delta_row in directions {
		for delta_column in directions {
			if delta_row == 0 && delta_column == 0 {
				continue
			}
			if location := search_word_in_direction(grid, word, start_row, start_column, delta_row, delta_column) {
				return location
			}
		}
	}
	return none
}

// Searches for multiple words in the grid and returns their positions
fn search(grid []string, words_to_search_for []string) map[string]?WordLocation {
	mut result := map[string]?WordLocation{}
	for word in words_to_search_for {
		mut found_location := ?WordLocation(none)
		for row in 0..grid.len {
			for column in 0..grid[0].len {
				if location := find_word_starting_at(grid, word, row, column) {
					found_location = location
					break
				}
			}
			if found_location != none {
				break
			}
		}
		result[word] = found_location
	}
	return result
}

module main

import math

struct Key {
	a int
	b int
}

// Returns a non-negative value, even if a is negative.
fn mod(a int, b int) int {
	assert 0 < b
	r := a % b
	return if 0 <= r { r } else { b + r }
}

// modular multiplicative inverse
fn mmi(a int, m int) int {
	_, _, y := math.egcd(m, a)
	return int(y)
}

fn encode(phrase string, key Key) !string {
	if key.a == 0 || math.gcd(26, key.a) != 1 {
		return error('a and m must be coprime.')
	}
	mut buffer := []u8{cap: phrase.len * 6 / 5}
	for ch in phrase {
		if !ch.is_alnum() {
			continue
		}
		if buffer.len % 6 == 5 {
			buffer << u8(` `)
		}
		if ch.is_digit() {
			buffer << ch
			continue
		}
		i := if ch >= `a` { int(ch - `a`) } else { int(ch - `A`) }
		assert 0 <= i && i < 26
		j := mod(key.a * i + key.b, 26)
		buffer << u8(`a` + j)
	}
	return buffer.bytestr()
}

fn decode(phrase string, key Key) !string {
	if key.a == 0 || math.gcd(26, key.a) != 1 {
		return error('a and m must be coprime.')
	}
	a_inverse := mmi(key.a, 26)
	assert mod(a_inverse * key.a, 26) == 1
	mut buffer := []u8{cap: phrase.len}
	for ch in phrase {
		if !ch.is_alnum() {
			continue
		}
		if ch.is_digit() {
			buffer << ch
			continue
		}
		j := int(ch - `a`)
		assert 0 <= j && j < 26
		i := mod(a_inverse * (j - key.b), 26)
		buffer << u8(`a` + i)
	}
	return buffer.bytestr()
}

module main

import math

pub fn is_armstrong_number(number u32) bool {
    mut digits := []u32{}
    mut n := number
    for n != 0 {
        digits << n % 10
        n = n / 10
    }
    mut sum := i64(0)
    for digit in digits {
        sum += math.powi(digit, digits.len)
    }
    return sum == number
}

module main

import math

pub fn square_of_sum(n u32) u32 {
	mut res := u32(0)
	for e in 1 .. n + 1 {
		res += e
	}
	return u32(math.powi(res, 2))
}

pub fn sum_of_squares(n u32) u32 {
	mut res := u32(0)
	for e in 1 .. n + 1 {
		res += u32(math.powi(e, 2))
	}
	return res
}

pub fn difference(n u32) u32 {
	return square_of_sum(n) - sum_of_squares(n)
}

module main

import math

struct Complex {
  re f64
  im f64
}

// build a Complex number
pub fn Complex.new(real f64, imaginary f64) Complex {
    return Complex {
        re: real,
        im: imaginary
    }
}

pub fn (c Complex) real() f64 {
    return c.re
}

pub fn (c Complex) imaginary() f64 {
    return c.im
}

pub fn (c Complex) conjugate() Complex {
    return Complex {
        re: c.re,
        im: -c.im
    }
}

pub fn (c Complex) absolute_square() f64 {
    return c.re * c.re + c.im * c.im
}

pub fn (c Complex) abs() f64 {
    return math.sqrt(c.absolute_square())
}

pub fn (c Complex) add(other Complex) Complex {
    return Complex {
        re: c.re + other.re,
        im: c.im + other.im
    }
}

pub fn (c Complex) sub(other Complex) Complex {
    return Complex {
        re: c.re - other.re,
        im: c.im - other.im
    }
}

pub fn (c Complex) exp() Complex {
    return Complex {
        re: math.cos(c.im),
        im: math.sin(c.im)
    }.mul_by_real(math.exp(c.re))
}

pub fn (c Complex) mul(other Complex) Complex {
    return Complex {
        re: c.re * other.re - c.im * other.im,
        im: c.im * other.re + c.re * other.im
    }
}

pub fn (c Complex) div(other Complex) Complex {
    return c.mul(other.conjugate()).div_by_real(other.absolute_square())
}

// add a real number 'r' to complex number 'c'
//  c + r
pub fn (c Complex) add_real(r f64) Complex {
    return Complex {
        re: c.re + r,
        im: c.im
    }
}

// add a complex number 'c' to a real number 'r':
//  r + c
pub fn (c Complex) real_add(r f64) Complex {
    return c.add_real(r)
}

// subtract a real number 'r' from a complex number 'c':
//  c - r
pub fn (c Complex) sub_real(r f64) Complex {
    return Complex {
        re: c.re - r,
        im: c.im
    }
}

// subtract a complex number 'c' from 'r':
//  r - c
pub fn (c Complex) real_sub(r f64) Complex {
    return Complex {
        re: r - c.re,
        im: -c.im
    }
}

// multiply a complex number 'c' by real number 'r'
//  c * r
pub fn (c Complex) mul_by_real(r f64) Complex {
    return Complex {
        re: c.re * r,
        im: c.im * r
    }
}

// multiply a real number 'r' by a complex number 'c':
//  r * c
pub fn (c Complex) real_mul(r f64) Complex {
    return c.mul_by_real(r)
}

// divide complex number 'c' by real number 'r'
//  c / r
pub fn (c Complex) div_by_real(r f64) Complex {
    return Complex {
        re: c.re / r,
        im: c.im / r
    }
}

// divide a real number 'r' by a complex number 'c'
//  r / c
pub fn (c Complex) real_div(r f64) Complex {
    return c.conjugate().mul_by_real(r).div_by_real(c.absolute_square())
}

module main

pub enum Number {
	perfect
	abundant
	deficient
}

// Returns a `Result` type, now using `!` instead of `?`
pub fn classify(candidate int) !Number {
	if candidate <= 0 {
		// returning an error with the exact message expected by the tests
		return error('Classification is only possible for positive integers.')
	}

	mut aliquot_sum := 0 // making `aliquot_sum` mutable
	for i in 1 .. candidate {
		if candidate % i == 0 {
			aliquot_sum += i
		}
	}

	// The rest of your function remains unchanged
	if aliquot_sum == candidate {
		return Number.perfect
	} else if aliquot_sum > candidate {
		return Number.abundant
	} else {
		return Number.deficient
	}
}

fn main() {
	// handling potential errors with `or` block
	result := classify(28) or {
		println(err) // directly use `err` without redefinition
		return
	}
	println(result)
}