Submission #2237175

---

Source Code Expand

import algorithm, tables, sets, lists, intsets, critbits, sequtils, strutils, future, options, macros, math
proc `?`*[T](trueOrFalse:bool,selector:bool->T):T = selector(trueOrFalse)
proc `?`*[T](trueOrFalse:int,selector:bool->T):T = selector(trueOrFalse == 1)
template `|`*[T](lhs,rhs:T):proc = (proc(trueOrFalse:bool):T = (if trueOrFalse: lhs else: rhs))
proc sort*[T](a: openArray[T], order:SortOrder=Ascending):seq[T] = sorted(a, system.cmp, order)
proc group*[T](v:seq[T]):seq[ref seq[T]] =
    var list = newSeq[ref seq[T]](0)
    var st = 0
    var last = v.len-1
    for i in 0..last:
        if i == last or v[i] != v[i+1]:
            var sec = new(seq[T])
            sec[] = v[st..i]
            list.add(sec)
            st = i + 1
    return list
proc has*[T](v:seq[T], elemList:varargs[T]):bool=
    var vCopied:seq[T] = v
    for elem in elemList:
        let itr = vCopied.find(elem)
        if itr == -1:
            return false
        else:
            vCopied.del(itr)
    return true
proc `++`*[T](t:var T):T=
    t += 1
    return t-1
proc cut*(s:var string, a, b:int):string=
    delete(s, a, b)
    return s
#proc `[]`*(s:int, i:int):bool = (s.shr(i) and 1) == 1
template mat*[T](n,m):auto =
    newSeqWith(n, newSeq[T](m))
macro ast(a:untyped):untyped = echo a.treeRepr
template `>>`(s,op:untyped):untyped =
    s.mapIt(op)
type point = object of RootObj
    x:int
    y:int
proc numin*():auto = readLine(stdin).split().map(parseInt)
proc strin*():auto = readLine(stdin).split()
proc val[T]():T =
    let line = readLine(stdin)
    when T is string:
        result = line
    when T is int:
        result = parseInt(line)
    when T is point:
        let d = line.split().map(parseInt)
        result = point(x:d[0], y:d[1])
    when T is (int, int):
        let d = line.split().map(parseInt)
        result = (d[0], d[1])
proc seq[T](length:int):seq[T] =
    result = newSeq[T](length)
    for i in result.mitems():
        i = val[T]()
#    let res = (0..length-1).mapIt(val[T]())
#    return res
#proc nCr[T,U](d:seq[T], n:int, op:seq[T]->U):seq[U] =
#    let len = d.len()
#    result = newSeq[U]()
#    for i in 0..len-1:
#        for j in i+1..len-1:
#            result.add op(@[d[i],d[j]])
proc nC2[T,U](d:seq[T], op:(T,T)->U):iterator():U =
    iterator nC2Impl():U =
        let len = d.len()
        for i in 0..len-1:
            for j in i+1..len-1:
                yield op(d[i],d[j])
    return nC2Impl
proc max[T](it:iterator():T):T =
    result = it()
    for i in it():
        result = max(result, i)

var
    n=val[int]()
    m=seq[point](n)
var lens = nC2(m, (a,b) => math.sqrt float((a.x-b.x)^2 + (a.y-b.y)^2))
echo lens.max

Submission Info

Compile Error

Hint: system [Processing]
Hint: Main [Processing]
Hint: algorithm [Processing]
Hint: tables [Processing]
Hint: hashes [Processing]
Hint: strutils [Processing]
Hint: parseutils [Processing]
Hint: etcpriv [Processing]
Hint: math [Processing]
Hint: times [Processing]
Hint: sets [Processing]
Hint: os [Processing]
Hint: posix [Processing]
Hint: lists [Processing]
Hint: intsets [Processing]
Hint: critbits [Processing]
lib/pure/collections/critbits.nim(125, 7) Hint: 'n' is declared but not used [XDeclaredButNotUsed]
Hint: sequtils [Processing]
Hint: future [Processing]
Hint: macros [Processing]
Hint: options [Processing]
Hint: typetraits [Processing]
Main.nim(35, 7) Hint: 'ast' is declared but not used [XDeclaredButNotUsed]
Main.nim(36, 10) Hint: '>>' is declared but not used [XDeclaredButNotUsed]
Hint:  [Link]
Hint: operation successful (25680 lines compiled; 2.355 sec total; 25.256MB; Release Build) [SuccessX]

Judge Result