paolino

{-# LANGUAGE AllowAmbiguousTypes #-}
{-# LANGUAGE DataKinds #-}
{-# LANGUAGE GADTs #-}
{-# LANGUAGE KindSignatures #-}
{-# LANGUAGE RankNTypes #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE TypeApplications #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE TypeOperators #-}

paolino

{-# LANGUAGE BlockArguments #-}
{-# LANGUAGE NumericUnderscores #-}
{-# LANGUAGE OverloadedStrings #-}

import Prelude

import Data.Functor (Identity (runIdentity))
import Control.Monad.Fix (fix)
import Data.Bifunctor (Bifunctor (..), second)
import Data.List (tails)

paolino

import Data.List (tails)
import Data.List.NonEmpty (NonEmpty, toList)
import Prelude

import qualified Data.List.NonEmpty as NE

type Tries = [NonEmpty Char]

tries :: String -> Tries
tries [] = []

paolino

-- input
mgerqoirg

------------------------------------
--> step 0 : create board with couples

----- board ----------
m..rq..r. -- unordered
g  eo  ig

paolino

{-# LANGUAGE DataKinds #-}
{-# LANGUAGE DeriveFunctor #-}
{-# LANGUAGE DerivingStrategies #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE GADTs #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE InstanceSigs #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE TemplateHaskell #-}

paolino

{-# LANGUAGE DeriveFunctor #-}
{-# LANGUAGE LambdaCase #-}

-- do not import other stuff here
import Control.Applicative
    ( Alternative (empty, (<|>))
    , many
    )
import Control.Monad (forever)
import Data.Char (ord)

paolino

{-# LANGUAGE DeriveFunctor #-}
{-# LANGUAGE LambdaCase #-}

module Arith where

-- do not import other stuff here
import Control.Applicative
    ( Alternative (empty, (<|>))
    , many

paolino

{-# LANGUAGE ExistentialQuantification #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE InstanceSigs #-}
{-# LANGUAGE LambdaCase #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE RecordWildCards #-}
{-# LANGUAGE ScopedTypeVariables #-}

import Data.String (IsString)

paolino

module Change () where

import Data.List (sortOn)
import Data.Ord (Down(..))
import Control.Exception.Base (assert)

-- count the number of ways a `tot` can be realized using the given coins
-- any coin can be used any number of times
countChangeOpen :: Int -> [Int] -> Int
countChangeOpen tot coins = consumeOpen tot $ sortOn Down coins 

paolino

{-# OPTIONS_GHC -Wno-unused-top-binds #-}

module Counting () where

-- some values
type S a = [a]

-- any combining operation between 2 values (+, - , * ...)
type Op a = a -> a -> a