結果

問題 No.110 しましまピラミッド
ユーザー yuppe19 😺yuppe19 😺
提出日時 2015-05-01 20:16:33
言語 Nim
(2.0.2)
結果
CE  
(最新)
AC  
(最初)
実行時間 -
コード長 1,998 bytes
コンパイル時間 675 ms
コンパイル使用メモリ 66,644 KB
最終ジャッジ日時 2024-04-27 02:07:29
合計ジャッジ時間 973 ms
ジャッジサーバーID
（参考情報） 		judge3 / judge4
このコードへのチャレンジ
（要ログイン）
コンパイルエラー時のメッセージ・ソースコードは、提出者また管理者しか表示できないようにしております。（リジャッジ後のコンパイルエラーは公開されます）
ただし、clay言語の場合は開発者のデバッグのため、公開されます。

コンパイルメッセージ
/home/judge/data/code/Main.nim(68, 16) template/generic instantiation of `solve` from here
/home/judge/data/code/Main.nim(56, 18) Error: type mismatch
Expression: <len(a1)
  [1] len(a1): int

Expected one of (first mismatch at [position]):
[1] proc `<`(x, y: bool): bool
[1] proc `<`(x, y: char): bool
[1] proc `<`(x, y: float): bool
[1] proc `<`(x, y: float32): bool
[1] proc `<`(x, y: int16): bool
[1] proc `<`(x, y: int32): bool
[1] proc `<`(x, y: int8): bool
[1] proc `<`(x, y: pointer): bool
[1] proc `<`(x, y: string): bool
[1] proc `<`(x, y: uint): bool
[1] proc `<`(x, y: uint16): bool
[1] proc `<`(x, y: uint32): bool
[1] proc `<`(x, y: uint64): bool
[1] proc `<`(x, y: uint8): bool
[1] proc `<`[A](s, t: HashSet[A]): bool
[1] proc `<`[Enum: enum](x, y: Enum): bool
[1] proc `<`[T: tuple](x, y: T): bool
[1] proc `<`[T](x, y: ptr T): bool
[1] proc `<`[T](x, y: ref T): bool
[1] proc `<`[T](x, y: set[T]): bool
[2] proc `<`(x, y: int): bool
[2] proc `<`(x, y: int64): bool

ソースコード

diff # 

import strutils, sequtils, math, sets, algorithm

#proc myzip*[S, T](seq1: seq[S], seq2: seq[T], fill: int): seq[tuple[a: S, b: T]] =
#    var (s1, s2) = (seq1, seq2)
#    if s1.len < s2.len:
#        newSeq(result, s2.len)
#        for i in 0.. <s1.len:
#            result[i] = (s1[i], s2[i])
#        for i in s1.len.. <s2.len:
#            result[i] = (fill, s2[i])
#    else:
#        newSeq(result, s1.len)
#        for i in 0.. <s2.len:
#            result[i] = (s1[i], s2[i])
#        for i in s2.len.. <s1.len:
#            result[i] = (s1[i], fill)
#
#proc myflatten*[T](seq1: seq[tuple[a: T, b: T]]): seq[T] =
#    var koko = seq1.len
#    newSeq(result, koko * 2)
#    for i in countup(0, koko, 2):
#        result[i]   = seq1[i div 2].a
#        result[i+1] = seq1[i div 2].b
#
#proc myfill*[T](seq1: seq[T], size: int, value: T) =
#    var seq1 = seq1
#    for i in seq1.len.. <size:
#        seq1.add(value)

proc sorted[T](a: var seq[T]; cmp: proc (x, y: T): int {.closure.}; order = SortOrder.Ascending): seq[T] =
    var (a, cmp, order) = (a, cmp, order)
    sort(a, cmp, order)
    return a

var
    nw = stdin.readLine.parseInt
    nanika = stdin.readLine.split.map(parseInt)
    w = newSeq[int](0)
    nb = stdin.readLine.parseInt
    doreka = stdin.readLine.split.map(parseInt)
    b = newSeq[int](0)

for e in nanika:
    w.add(e)
for e in doreka:
    b.add(e)

w = sorted(w, system.cmp[int]).reversed
b = sorted(b, system.cmp[int]).reversed

proc solve(a1: seq, a2: seq): int =
    var (a1, a2) = (a1, a2)
    result = 0
    var check = int.high
    var should1 = true
    for i in 0.. <a1.len:
        if check > a1[i] and should1:
            should1 = false
            check = a1[i]
            result += 1
        for j in 0.. <a2.len:
            if check > a2[j] and not should1:
                should1 = true
                check = a2[j]
                result += 1
                break
            
var nya = solve(w, b)
var mya = solve(b, w)

echo max(nya, mya)
0