jlandahl

import setupViewEdit from "@lib/view_edit.tsx";
import H2 from "@components/H2.tsx";
import type model from "@/model.ts";

export default function Prompt(props: any) {
    const [editMode, prompt, EditButton] = setupViewEdit<model.Prompt>(`/api/prompt/${props.id}`, data);

    function data(): string {
        const text: HTMLInputElement = document.getElementById("text");

jlandahl

object Scrabble extends App {
  import scala.io.Source

  val words = Source.fromFile("/usr/share/dict/words").getLines.toStream

  val primes: Stream[Int] =
    2 #:: Stream.from(3, 2).filter(i => primes.takeWhile(p => p * p <= i).forall(p => i % p > 0))

  val letterCounts = words.foldLeft(Map.empty[Char, Long].withDefault(_ => 0L)) { case (counts, word) =>
    word.toLowerCase.filter(_.isLetter).foldLeft(counts) { case (counts2, c) =>

jlandahl

object EveRouting extends App {
  import EveMap.{SolarSystem, SolarSystemJump, loadSystems, loadJumps}
  import scalax.collection.immutable.Graph
  import scalax.collection.GraphPredef._, scalax.collection.GraphEdge._
  import scalax.collection.edge.Implicits._

  // Load the EVE map
  val systems: List[SolarSystem] = loadSystems
  val jumps: List[SolarSystemJump] = loadJumps

jlandahl

object Dijkstra {
  case class Edge[T](node: T, cost: Double)
  case class Path[T](nodes: List[T], cost: Double)

  type Graph[T] = Map[T, List[Edge[T]]]

  def dijkstra[T](graph: Graph[T], paths: List[Path[T]], dest: T, visited: Set[T]): Option[Path[T]] = {
    def unvisitedPaths(node: T, path: Path[T]): List[Path[T]] =
      graph(node).filterNot(edge => visited.contains(edge.node))
                 .map(edge => Path(edge.node +: path.nodes, path.cost + edge.cost))

jlandahl

trait EntityBase {
  def id: String
}

trait Repository {
  type Entity <: EntityBase
  
  def get(id: String): Option[Entity]
}

jlandahl

object Primes extends App {
  val primes: Stream[Int] =
    2 #:: Stream.from(3, 2).filter(i => primes.takeWhile(p => p * p <= i).forall(p => i % p > 0))

  println(primes.take(10).toList)  // List(2, 3, 5, 7, 11, 13, 17, 19, 23, 29)
}

jlandahl

def titleScore(titleWords: Array[String], sentence: Array[String]) =
  sentence.count(w => !stopWords.contains(w) && titleWords.contains(w)) / titleWords.size.toDouble

jlandahl

val mimeTypeIsPdf = candidate.mimeType match {
  case None => false
  case Some(candidateMimeType) => candidateMimeType.equalsIgnoreCase(MimeTypes.PDF)
}

val urlHasPdfExtension = candidate.uri match {
  case None => true
  LowerCase().endsWith(FileExtensions.PDF)
}

jlandahl

case class Parameters(userId: UserId,
                      device: Option[Device] = None,
                      additionalParameters: Map[String, Iterable[String]] = Map.empty) {
  def getParameter[T](name: String, default: T)(implicit converter: (Iterable[String]) => Option[T]): T = {
    additionalParameters.get(name).flatMap(converter).getOrElse(default)
  }
}

object Parameters {
  implicit val strings2Int = (values: Iterable[String]) => {

jlandahl

import java.io.File
import scala.collection.JavaConversions._
import org.jsoup.Jsoup
import org.jsoup.nodes.Element

object ParseVehicleData extends App {
  val baseURL = "http://worldoftanks.com"

  val categories = Map(
    "Light Tanks" -> "lt",