module Main where
import qualified Control.Applicative
import Control.Monad (replicateM)
import qualified Control.Monad as Data.Foldable
import Control.Monad.ST ()
import Control.Monad.State
import qualified Data.Array as A
import Data.Array.Base (UArray (UArray))
import qualified Data.Array.Unboxed as AU
import Data.ByteString (ByteString)
import qualified Data.ByteString.Char8 as BS
import Data.Char (digitToInt, isSpace, readLitChar)
import qualified Data.Foldable as AU
import qualified Data.Functor as F
import qualified Data.IntMap.Strict as IM
import qualified Data.IntSet as IntSet
import Data.List
import qualified Data.List as L
import Data.List.Split
import Data.Maybe (fromJust, maybeToList)
import Data.Ord (Down (Down), comparing)
import qualified Data.Set as Set
import qualified Data.Vector as V
import qualified Data.Vector.Algorithms as VA
import qualified Data.Vector.Unboxed as VU
import Debug.Trace (traceShow, traceShowId)
main :: IO ()
main = do
n <- readInt
let res = [(x, y, z) | x <- [0 .. n], y <- [0 .. n], z <- [0 .. n], x + y + z <= n]
mapM_ (putStrLn . (\(x, y, z) -> show x ++ " " ++ show y ++ " " ++ show z)) res
{- Library -}
readInt :: IO Int
readInt = readLn
readInputIntList :: IO [Int]
readInputIntList = L.unfoldr (BS.readInt . BS.dropWhile isSpace) <$> BS.getLine
readPairInt :: IO (Int, Int)
readPairInt = (\[a, b] -> (a, b)) . parseLineIntList <$> BS.getLine
readIntPairIntLineV :: Int -> IO (V.Vector (Int, Int))
readIntPairIntLineV n = V.fromList <$> replicateM n readPairInt
readIntPairIntLineVU :: Int -> IO (VU.Vector (Int, Int))
readIntPairIntLineVU n = VU.fromList <$> replicateM n readPairInt
parseLineIntList :: BS.ByteString -> [Int]
parseLineIntList = L.unfoldr (BS.readInt . BS.dropWhile isSpace)
readTuple :: String -> (String, Int)
readTuple input = (str, read num :: Int)
where
[str, num] = words input
withInTime :: Int -> Int -> Bool
withInTime start time
| start <= end = time >= start && time < end
| otherwise = time >= start || time < end
where
end = (start + 9) `mod` 24
readGrid :: Int -> IO (V.Vector (V.Vector Char))
readGrid n = V.fromList <$> replicateM n (V.fromList <$> getLine)
trisect :: (Int, Int) -> (Int -> Int) -> (Int, Int)
trisect (l, r) f
| r - l <= 2 = (l, r)
| f m1 > f m2 = trisect (m1, r) f
| otherwise = trisect (l, m2) f
where
m1 = (l * 2 + r) `div` 3
m2 = (l + r * 2) `div` 3
binarySearch :: (Ord t2, AU.Ix t1, Integral t1) => AU.Array t1 t2 -> t2 -> t1 -> t1 -> t1
binarySearch arr val low high
| high < low = low
| otherwise =
let mid = low + (high - low) `div` 2
in if arr AU.! mid <= val
then binarySearch arr val (mid + 1) high
else binarySearch arr val low (mid - 1)
isPrime :: Int -> Bool
isPrime x = all (\n -> x `mod` n /= 0) lst
where
xSqrt = floor (sqrt $ fromIntegral x :: Double) :: Int
lst = [2 .. xSqrt]
sieve :: Int -> IntSet.IntSet
sieve n = go 2 (IntSet.fromList [2 .. n])
where
go p s
| p * p > n = s
| otherwise = go (p + 1) (IntSet.difference s (IntSet.fromList [p * p, p * p + p .. n]))
app/Main.hs:3:1: warning: [-Wunused-imports]
The qualified import of ‘Control.Applicative’ is redundant
except perhaps to import instances from ‘Control.Applicative’
To import instances alone, use: import Control.Applicative()
|
3 | import qualified Control.Applicative
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
app/Main.hs:5:1: warning: [-Wunused-imports]
The qualified import of ‘Control.Monad’ is redundant
except perhaps to import instances from ‘Control.Monad’
To import instances alone, use: import Control.Monad()
|
5 | import qualified Control.Monad as Data.Foldable
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
app/Main.hs:7:1: warning: [-Wunused-imports]
The import of ‘Control.Monad.State’ is redundant
except perhaps to import instances from ‘Control.Monad.State’
To import instances alone, use: import Control.Monad.State()
|
7 | import Control.Monad.State
| ^^^^^^^^^^^^^^^^^^^^^^^^^^
app/Main.hs:8:1: warning: [-Wunused-imports]
The qualified import of ‘Data.Array’ is redundant
except perhaps to import instances from ‘Data.Array’
To import instances alone, use: import Data.Array()
|
8 | import qualified Data.Array as A
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
app/Main.hs:9:1: warning: [-Wunused-imports]
The import of ‘Data.Array.Base’ is redundant
except perhaps to import instances from ‘Data.Array.Base’
To import instances alone, use: import Data.Array.Base()
|
9 | import Data.Array.Base (UArray (UArray))
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
app/Main.hs:11:1: warning: [-Wunused-imports]
The import of ‘Data.ByteString’ is redundant
except perhaps to import instances from ‘Data.ByteString’
To import instances alone, use: import Data.ByteString()
|
11 | import Data.ByteString (ByteString)
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
app/Main.hs:13:1: warning: [-Wunused-imports]
The import of ‘digitToInt, readLitChar’
from module ‘Data.Char’ is redundant
|
13 | import Data.Char (digitToInt, isSpace, readLitChar)
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
app/Main.hs:14:1: warning: [-Wunused-imports]
The qualified import of ‘Data.Foldable’ is redundant
except perhaps to import instances from ‘Data.Foldable’
To import instances alone, use: import Data.Foldable()
|
14 | import qualified Data.Foldable as AU
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
app/Main.hs:15:1: warning: [-Wunused-imports]
The qualified import of ‘Data.Functor’ is redundant
except perhaps to import instances from ‘Data.Functor’
To import instances alone, use: import Data.Functor()
|
15 | import qualified Data.Functor as F
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
app/Main.hs:16:1: warning: [-Wunused-imports]
The qualified import of ‘Data.IntMap.Strict’ is redundant
except perhaps to import instances from ‘Data.IntMap.Strict’
To import instances alone, use: import Data.IntMap.Strict()
|
16 | import qualified Data.IntMap.Strict as IM
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
app/Main.hs:18:1: warning: [-Wunused-imports]
The import of ‘Data.List’ is redundant
except perhaps to import instances from ‘Data.List’
To import instances alone, use: import Data.List()
|
18 | import Data.List
| ^^^^^^^^^^^^^^^^
app/Main.hs:20:1: warning: [-Wunused-imports]
The import of ‘Data.List.Split’ is redundant
except perhaps to import instances from ‘Data.List.Split’
To import instances alone, use: import Data.List.Split()
|
20 | import Data.List.Split
| ^^^^^^^^^^^^^^^^^^^^^^
app/Main.hs:21:1: warning: [-Wunused-imports]
The import of ‘Data.Maybe’ is redundant
except perhaps to import instances from ‘Data.Maybe’
To import instances alone, use: import Data.Maybe()
|
21 | import Data.Maybe (fromJust, maybeToList)
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
app/Main.hs:22:1: warning: [-Wunused-imports]
The import of ‘Data.Ord’ is redundant
except perhaps to import instances from ‘Data.Ord’
To import instances alone, use: import Data.Ord()
|
22 | import Data.Ord (Down (Down), comparing)
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
app/Main.hs:23:1: warning: [-Wunused-imports]
The qualified import of ‘Data.Set’ is redundant
except perhaps to import instances from ‘Data.Set’
To import instances alone, use: import Data.Set()
|
23 | import qualified Data.Set as Set
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
app/Main.hs:25:1: warning: [-Wunused-imports]
The qualified import of ‘Data.Vector.Algorithms’ is redundant
except perhaps to import instances from ‘Data.Vector.Algorithms’
To import instances alone, use: import Data.Vector.Algorithms()
|
25 | import qualified Data.Vector.Algorithms as VA
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
app/Main.hs:27:1: warning: [-Wunused-imports]
The import of ‘Debug.Trace’ is redundant
except perhaps to import instances from ‘Debug.Trace’
To import instances alone, use: import Debug.Trace()
|
27 | import Debug.Trace (traceShow, traceShowId)
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
app/Main.hs:45:16: warning: [-Wincomplete-uni-patterns]
Pattern match(es) are non-exhaustive
In a lambda abstraction:
Patterns of type ‘[Int]’ not matched:
[]
[_]
(_:_:_:_)
|
45 | readPairInt = (\[a, b] -> (a, b)) . parseLineIntList <$> BS.getLine
| ^^^^^^^^^^^^^^^^^
app/Main.hs:59:5: warning: [-Wincomplete-uni-patterns]
Pattern match(es) are non-exhaustive
In a pattern binding:
Patterns of type ‘[String]’ not matched:
[]
[_]
(_:_:_:_)
|
59 | [str, num] = words input
| ^^^^^^^^^^^^^^^^^^^^^^^^