Test results - Codility

Code: 07:16:33 UTC, java, autosave

1 2 3 4 5 6 7 8 9 10 11

// you can also use imports, for example:
// import java.util.*;

// you can write to stdout for debugging purposes, e.g.
// System.out.println("this is a debug message");

class Solution {
    public int solution(int[] A) {
        // write your code in Java SE 8
    }
}

Code: 07:16:44 UTC, swift4, autosave

1 2 3 4 5 6 7 8 9

import Foundation
import Glibc

// you can write to stdout for debugging purposes, e.g.
// print("this is a debug message")

public func solution(_ A : inout [Int]) -> Int {
    // write your code in Swift 4.2.1 (Linux)
}

Code: 07:16:54 UTC, swift4, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49

import Foundation
import Glibc

// you can write to stdout for debugging purposes, e.g.
// print("this is a debug message")

public func solution(_ A : inout [Int]) -> Int {
		int index = 0;
		int daysCount = 0;
		int finalAmount = 0;
		int seventh = 0;
		int totalCount = 0;
		boolean isJLoopFinish = false;

        if (A.length >= 25) { return 25; }
		if (A.length <= 3) { return (A.length * 2); }

		for (int i = 0; i < A.length; i++) {
			if (isJLoopFinish == true) {
				seventh++;
				break;
			}

			daysCount = 0;
			index = A[i] + 7;
			totalCount++;

			for (int j = i+1; j < A.length ; j++) {
				if ((daysCount >= 3)  && (A[j] < index) && (j == (A.length-1))) { isJLoopFinish = true; }

				if (A[j] < index) {
					daysCount++;
				} else {
					if (daysCount > 3) {
						seventh++;
						daysCount = 0;
						i = j-1;
					} else { daysCount = 0; }
					break;
				}
			}
		}

		totalCount = totalCount - seventh;
		finalAmount = (totalCount * 2) + (seventh * 7);

		if (finalAmount > 25) { finalAmount = 25; }
		return finalAmount;
}

Code: 07:16:59 UTC, swift4, verify, result: Failed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46

import Foundation
import Glibc

public func solution(_ A : inout [Int]) -> Int {
		int index = 0;
		int daysCount = 0;
		int finalAmount = 0;
		int seventh = 0;
		int totalCount = 0;
		boolean isJLoopFinish = false;

        if (A.length >= 25) { return 25; }
		if (A.length <= 3) { return (A.length * 2); }

		for (int i = 0; i < A.length; i++) {
			if (isJLoopFinish == true) {
				seventh++;
				break;
			}

			daysCount = 0;
			index = A[i] + 7;
			totalCount++;

			for (int j = i+1; j < A.length ; j++) {
				if ((daysCount >= 3)  && (A[j] < index) && (j == (A.length-1))) { isJLoopFinish = true; }

				if (A[j] < index) {
					daysCount++;
				} else {
					if (daysCount > 3) {
						seventh++;
						daysCount = 0;
						i = j-1;
					} else { daysCount = 0; }
					break;
				}
			}
		}

		totalCount = totalCount - seventh;
		finalAmount = (totalCount * 2) + (seventh * 7);

		if (finalAmount > 25) { finalAmount = 25; }
		return finalAmount;
}

The submission is being evaluated.

Code: 07:17:07 UTC, swift4, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46

import Foundation
import Glibc

public func solution(_ A : inout [Int]) -> Int {
		int index = 0;
		int daysCount = 0;
		int finalAmount = 0;
		int seventh = 0;
		int totalCount = 0;
		bool isJLoopFinish = false;

        if (A.length >= 25) { return 25; }
		if (A.length <= 3) { return (A.length * 2); }

		for (int i = 0; i < A.length; i++) {
			if (isJLoopFinish == true) {
				seventh++;
				break;
			}

			daysCount = 0;
			index = A[i] + 7;
			totalCount++;

			for (int j = i+1; j < A.length ; j++) {
				if ((daysCount >= 3)  && (A[j] < index) && (j == (A.length-1))) { isJLoopFinish = true; }

				if (A[j] < index) {
					daysCount++;
				} else {
					if (daysCount > 3) {
						seventh++;
						daysCount = 0;
						i = j-1;
					} else { daysCount = 0; }
					break;
				}
			}
		}

		totalCount = totalCount - seventh;
		finalAmount = (totalCount * 2) + (seventh * 7);

		if (finalAmount > 25) { finalAmount = 25; }
		return finalAmount;
}

Code: 07:17:08 UTC, swift4, verify, result: Failed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46

import Foundation
import Glibc

public func solution(_ A : inout [Int]) -> Int {
		int index = 0;
		int daysCount = 0;
		int finalAmount = 0;
		int seventh = 0;
		int totalCount = 0;
		bool isJLoopFinish = false;

        if (A.length >= 25) { return 25; }
		if (A.length <= 3) { return (A.length * 2); }

		for (int i = 0; i < A.length; i++) {
			if (isJLoopFinish == true) {
				seventh++;
				break;
			}

			daysCount = 0;
			index = A[i] + 7;
			totalCount++;

			for (int j = i+1; j < A.length ; j++) {
				if ((daysCount >= 3)  && (A[j] < index) && (j == (A.length-1))) { isJLoopFinish = true; }

				if (A[j] < index) {
					daysCount++;
				} else {
					if (daysCount > 3) {
						seventh++;
						daysCount = 0;
						i = j-1;
					} else { daysCount = 0; }
					break;
				}
			}
		}

		totalCount = totalCount - seventh;
		finalAmount = (totalCount * 2) + (seventh * 7);

		if (finalAmount > 25) { finalAmount = 25; }
		return finalAmount;
}

The submission is being evaluated.

Code: 07:17:38 UTC, swift4, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46

import Foundation
import Glibc

public func solution(_ A : inout [Int]) -> Int {
		var index = 0;
		var daysCount = 0;
		var finalAmount = 0;
		var seventh = 0;
		var totalCount = 0;
		bool isJLoopFinish = false;

        if (A.length >= 25) { return 25; }
		if (A.length <= 3) { return (A.length * 2); }

		for (int i = 0; i < A.length; i++) {
			if (isJLoopFinish == true) {
				seventh++;
				break;
			}

			daysCount = 0;
			index = A[i] + 7;
			totalCount++;

			for (int j = i+1; j < A.length ; j++) {
				if ((daysCount >= 3)  && (A[j] < index) && (j == (A.length-1))) { isJLoopFinish = true; }

				if (A[j] < index) {
					daysCount++;
				} else {
					if (daysCount > 3) {
						seventh++;
						daysCount = 0;
						i = j-1;
					} else { daysCount = 0; }
					break;
				}
			}
		}

		totalCount = totalCount - seventh;
		finalAmount = (totalCount * 2) + (seventh * 7);

		if (finalAmount > 25) { finalAmount = 25; }
		return finalAmount;
}

Code: 07:17:39 UTC, swift4, verify, result: Failed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46

import Foundation
import Glibc

public func solution(_ A : inout [Int]) -> Int {
		var index = 0;
		var daysCount = 0;
		var finalAmount = 0;
		var seventh = 0;
		var totalCount = 0;
		bool isJLoopFinish = false;

        if (A.length >= 25) { return 25; }
		if (A.length <= 3) { return (A.length * 2); }

		for (int i = 0; i < A.length; i++) {
			if (isJLoopFinish == true) {
				seventh++;
				break;
			}

			daysCount = 0;
			index = A[i] + 7;
			totalCount++;

			for (int j = i+1; j < A.length ; j++) {
				if ((daysCount >= 3)  && (A[j] < index) && (j == (A.length-1))) { isJLoopFinish = true; }

				if (A[j] < index) {
					daysCount++;
				} else {
					if (daysCount > 3) {
						seventh++;
						daysCount = 0;
						i = j-1;
					} else { daysCount = 0; }
					break;
				}
			}
		}

		totalCount = totalCount - seventh;
		finalAmount = (totalCount * 2) + (seventh * 7);

		if (finalAmount > 25) { finalAmount = 25; }
		return finalAmount;
}

The submission is being evaluated.

Code: 07:17:58 UTC, swift4, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46

import Foundation
import Glibc

public func solution(_ A : inout [Int]) -> Int {
		var index = 0
		var daysCount = 0
		var finalAmount = 0
		var seventh = 0
		var totalCount = 0
		var isJLoopFinish = false

        if (A.length >= 25) { return 25; }
		if (A.length <= 3) { return (A.length * 2); }

		for (int i = 0; i < A.length; i++) {
			if (isJLoopFinish == true) {
				seventh++;
				break;
			}

			daysCount = 0;
			index = A[i] + 7;
			totalCount++;

			for (int j = i+1; j < A.length ; j++) {
				if ((daysCount >= 3)  && (A[j] < index) && (j == (A.length-1))) { isJLoopFinish = true; }

				if (A[j] < index) {
					daysCount++;
				} else {
					if (daysCount > 3) {
						seventh++;
						daysCount = 0;
						i = j-1;
					} else { daysCount = 0; }
					break;
				}
			}
		}

		totalCount = totalCount - seventh;
		finalAmount = (totalCount * 2) + (seventh * 7);

		if (finalAmount > 25) { finalAmount = 25; }
		return finalAmount;
}

Code: 07:18:08 UTC, swift4, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46

import Foundation
import Glibc

public func solution(_ A : inout [Int]) -> Int {
		var index = 0
		var daysCount = 0
		var finalAmount = 0
		var seventh = 0
		var totalCount = 0
		var isJLoopFinish = false

        if (A.count >= 25) { return 25 }
		if (A.length <= 3) { return (A.count * 2) }

		for (int i = 0; i < A.length; i++) {
			if (isJLoopFinish == true) {
				seventh++;
				break;
			}

			daysCount = 0;
			index = A[i] + 7;
			totalCount++;

			for (int j = i+1; j < A.length ; j++) {
				if ((daysCount >= 3)  && (A[j] < index) && (j == (A.length-1))) { isJLoopFinish = true; }

				if (A[j] < index) {
					daysCount++;
				} else {
					if (daysCount > 3) {
						seventh++;
						daysCount = 0;
						i = j-1;
					} else { daysCount = 0; }
					break;
				}
			}
		}

		totalCount = totalCount - seventh;
		finalAmount = (totalCount * 2) + (seventh * 7);

		if (finalAmount > 25) { finalAmount = 25; }
		return finalAmount;
}

Code: 07:18:12 UTC, swift4, verify, result: Failed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46

import Foundation
import Glibc

public func solution(_ A : inout [Int]) -> Int {
		var index = 0
		var daysCount = 0
		var finalAmount = 0
		var seventh = 0
		var totalCount = 0
		var isJLoopFinish = false

        if (A.count >= 25) { return 25 }
		if (A.count <= 3) { return (A.count * 2) }

		for (int i = 0; i < A.length; i++) {
			if (isJLoopFinish == true) {
				seventh++;
				break;
			}

			daysCount = 0;
			index = A[i] + 7;
			totalCount++;

			for (int j = i+1; j < A.length ; j++) {
				if ((daysCount >= 3)  && (A[j] < index) && (j == (A.length-1))) { isJLoopFinish = true; }

				if (A[j] < index) {
					daysCount++;
				} else {
					if (daysCount > 3) {
						seventh++;
						daysCount = 0;
						i = j-1;
					} else { daysCount = 0; }
					break;
				}
			}
		}

		totalCount = totalCount - seventh;
		finalAmount = (totalCount * 2) + (seventh * 7);

		if (finalAmount > 25) { finalAmount = 25; }
		return finalAmount;
}

The submission is being evaluated.

Code: 07:18:26 UTC, swift4, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46

import Foundation
import Glibc

public func solution(_ A : inout [Int]) -> Int {
		var index = 0
		var daysCount = 0
		var finalAmount = 0
		var seventh = 0
		var totalCount = 0
		var isJLoopFinish = false

        if (A.count >= 25) { return 25 }
		if (A.count <= 3) { return (A.count * 2) }

		for (let i = 0; i < A.count; i++) {
			if (isJLoopFinish == true) {
				seventh++;
				break;
			}

			daysCount = 0;
			index = A[i] + 7;
			totalCount++;

			for (int j = i+1; j < A.length ; j++) {
				if ((daysCount >= 3)  && (A[j] < index) && (j == (A.length-1))) { isJLoopFinish = true; }

				if (A[j] < index) {
					daysCount++;
				} else {
					if (daysCount > 3) {
						seventh++;
						daysCount = 0;
						i = j-1;
					} else { daysCount = 0; }
					break;
				}
			}
		}

		totalCount = totalCount - seventh;
		finalAmount = (totalCount * 2) + (seventh * 7);

		if (finalAmount > 25) { finalAmount = 25; }
		return finalAmount;
}

Code: 07:18:39 UTC, swift4, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46

import Foundation
import Glibc

public func solution(_ A : inout [Int]) -> Int {
		var index = 0
		var daysCount = 0
		var finalAmount = 0
		var seventh = 0
		var totalCount = 0
		var isJLoopFinish = false

        if (A.count >= 25) { return 25 }
		if (A.count <= 3) { return (A.count * 2) }

		for (let i = 0; i < A.count; i++) {
			if (isJLoopFinish == true) {
				seventh++
				break
			}

			daysCount = 0
			index = A[i] + 7
			totalCount += 1

			for (let j = i+1; j < A.length ; j++) {
				if ((daysCount >= 3)  && (A[j] < index) && (j == (A.length-1))) { isJLoopFinish = true; }

				if (A[j] < index) {
					daysCount++;
				} else {
					if (daysCount > 3) {
						seventh++;
						daysCount = 0;
						i = j-1;
					} else { daysCount = 0; }
					break;
				}
			}
		}

		totalCount = totalCount - seventh;
		finalAmount = (totalCount * 2) + (seventh * 7);

		if (finalAmount > 25) { finalAmount = 25; }
		return finalAmount;
}

Code: 07:18:48 UTC, swift4, verify, result: Failed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46

import Foundation
import Glibc

public func solution(_ A : inout [Int]) -> Int {
		var index = 0
		var daysCount = 0
		var finalAmount = 0
		var seventh = 0
		var totalCount = 0
		var isJLoopFinish = false

        if (A.count >= 25) { return 25 }
		if (A.count <= 3) { return (A.count * 2) }

		for (let i = 0; i < A.count; i++) {
			if (isJLoopFinish == true) {
				seventh++
				break
			}

			daysCount = 0
			index = A[i] + 7
			totalCount += 1

			for (let j = i + 1; j < A.count; j++) {
				if ((daysCount >= 3)  && (A[j] < index) && (j == (A.length-1))) { isJLoopFinish = true; }

				if (A[j] < index) {
					daysCount++;
				} else {
					if (daysCount > 3) {
						seventh++;
						daysCount = 0;
						i = j-1;
					} else { daysCount = 0; }
					break;
				}
			}
		}

		totalCount = totalCount - seventh;
		finalAmount = (totalCount * 2) + (seventh * 7);

		if (finalAmount > 25) { finalAmount = 25; }
		return finalAmount;
}

The submission is being evaluated.

Code: 07:19:10 UTC, swift4, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46

import Foundation
import Glibc

public func solution(_ A : inout [Int]) -> Int {
		var index = 0
		var daysCount = 0
		var finalAmount = 0
		var seventh = 0
		var totalCount = 0
		var isJLoopFinish = false

        if (A.count >= 25) { return 25 }
		if (A.count <= 3) { return (A.count * 2) }

		for (let i = 0; i < A.count; i++) {
			if (isJLoopFinish == true) {
				seventh++
				break
			}

			daysCount = 0
			index = A[i] + 7
			totalCount += 1

			for (let j = i + 1; j < A.count; j++) {
				if ((daysCount >= 3)  && (A[j] < index) && (j == (A.length-1))) { isJLoopFinish = true; }

				if (A[j] < index) {
					daysCount++;
				} else {
					if (daysCount > 3) {
						seventh++
						daysCount = 0
						i = j - 1
					} else { daysCount = 0 }
					break;
				}
			}
		}

		totalCount = totalCount - seventh;
		finalAmount = (totalCount * 2) + (seventh * 7)

		if (finalAmount > 25) { finalAmount = 25 }
		return finalAmount;
}

Code: 07:19:23 UTC, swift4, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46

import Foundation
import Glibc

public func solution(_ A : inout [Int]) -> Int {
		var index = 0
		var daysCount = 0
		var finalAmount = 0
		var seventh = 0
		var totalCount = 0
		var isJLoopFinish = false

        if (A.count >= 25) { return 25 }
		if (A.count <= 3) { return (A.count * 2) }

		for (let i = 0; i < A.count; i++) {
			if (isJLoopFinish == true) {
				seventh++
				break
			}

			daysCount = 0
			index = A[i] + 7
			totalCount += 1

			for (let j = i + 1; j < A.count; j++) {
				if ((daysCount >= 3)  && (A[j] < index) && (j == (A.length-1))) { isJLoopFinish = true; }

				if (A[j] < index) {
					daysCount += 1
				} else {
					if (daysCount > 3) {
						seventh += 1
						daysCount = 0
						i = j - 1
					} else { daysCount = 0 }
					break;
				}
			}
		}

		totalCount = totalCount - seventh
		finalAmount = (totalCount * 2) + (seventh * 7)

		if (finalAmount > 25) { finalAmount = 25 }
		return finalAmount
}

Code: 07:19:33 UTC, swift4, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46

import Foundation
import Glibc

public func solution(_ A : inout [Int]) -> Int {
		var index = 0
		var daysCount = 0
		var finalAmount = 0
		var seventh = 0
		var totalCount = 0
		var isJLoopFinish = false

        if (A.count >= 25) { return 25 }
		if (A.count <= 3) { return (A.count * 2) }

		for (let i = 0; i < A.count; i++) {
			if (isJLoopFinish == true) {
				seventh++
				break
			}

			daysCount = 0
			index = A[i] + 7
			totalCount += 1

			for (let j = i + 1; j < A.count; j++) {
				if ((daysCount >= 3)  && (A[j] < index) && (j == (A.count - 1))) { isJLoopFinish = true }

				if (A[j] < index) {
					daysCount += 1
				} else {
					if (daysCount > 3) {
						seventh += 1
						daysCount = 0
						i = j - 1
					} else { daysCount = 0 }
					break;
				}
			}
		}

		totalCount = totalCount - seventh
		finalAmount = (totalCount * 2) + (seventh * 7)

		if (finalAmount > 25) { finalAmount = 25 }
		return finalAmount
}

Code: 07:20:04 UTC, swift4, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46

import Foundation
import Glibc

public func solution(_ A : inout [Int]) -> Int {
		var index = 0
		var daysCount = 0
		var finalAmount = 0
		var seventh = 0
		var totalCount = 0
		var isJLoopFinish = false

        if (A.count >= 25) { return 25 }
		if (A.count <= 3) { return (A.count * 2) }

		for let i in 0.. (let i = 0; i < A.count; i++) {
			if (isJLoopFinish == true) {
				seventh++
				break
			}

			daysCount = 0
			index = A[i] + 7
			totalCount += 1

			for (let j = i + 1; j < A.count; j++) {
				if ((daysCount >= 3)  && (A[j] < index) && (j == (A.count - 1))) { isJLoopFinish = true }

				if (A[j] < index) {
					daysCount += 1
				} else {
					if (daysCount > 3) {
						seventh += 1
						daysCount = 0
						i = j - 1
					} else { daysCount = 0 }
					break;
				}
			}
		}

		totalCount = totalCount - seventh
		finalAmount = (totalCount * 2) + (seventh * 7)

		if (finalAmount > 25) { finalAmount = 25 }
		return finalAmount
}

Code: 07:20:15 UTC, swift4, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46

import Foundation
import Glibc

public func solution(_ A : inout [Int]) -> Int {
		var index = 0
		var daysCount = 0
		var finalAmount = 0
		var seventh = 0
		var totalCount = 0
		var isJLoopFinish = false

        if (A.count >= 25) { return 25 }
		if (A.count <= 3) { return (A.count * 2) }

		for let i in 0 .. A.count {
			if (isJLoopFinish == true) {
				seventh++
				break
			}

			daysCount = 0
			index = A[i] + 7
			totalCount += 1

			for (let j = i + 1; j < A.count; j++) {
				if ((daysCount >= 3)  && (A[j] < index) && (j == (A.count - 1))) { isJLoopFinish = true }

				if (A[j] < index) {
					daysCount += 1
				} else {
					if (daysCount > 3) {
						seventh += 1
						daysCount = 0
						i = j - 1
					} else { daysCount = 0 }
					break;
				}
			}
		}

		totalCount = totalCount - seventh
		finalAmount = (totalCount * 2) + (seventh * 7)

		if (finalAmount > 25) { finalAmount = 25 }
		return finalAmount
}

Code: 07:20:17 UTC, swift4, verify, result: Failed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46

import Foundation
import Glibc

public func solution(_ A : inout [Int]) -> Int {
		var index = 0
		var daysCount = 0
		var finalAmount = 0
		var seventh = 0
		var totalCount = 0
		var isJLoopFinish = false

        if (A.count >= 25) { return 25 }
		if (A.count <= 3) { return (A.count * 2) }

		for i in 0 .. A.count {
			if (isJLoopFinish == true) {
				seventh++
				break
			}

			daysCount = 0
			index = A[i] + 7
			totalCount += 1

			for (let j = i + 1; j < A.count; j++) {
				if ((daysCount >= 3)  && (A[j] < index) && (j == (A.count - 1))) { isJLoopFinish = true }

				if (A[j] < index) {
					daysCount += 1
				} else {
					if (daysCount > 3) {
						seventh += 1
						daysCount = 0
						i = j - 1
					} else { daysCount = 0 }
					break;
				}
			}
		}

		totalCount = totalCount - seventh
		finalAmount = (totalCount * 2) + (seventh * 7)

		if (finalAmount > 25) { finalAmount = 25 }
		return finalAmount
}

The submission is being evaluated.

Code: 07:20:28 UTC, swift4, verify, result: Failed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46

import Foundation
import Glibc

public func solution(_ A : inout [Int]) -> Int {
		var index = 0
		var daysCount = 0
		var finalAmount = 0
		var seventh = 0
		var totalCount = 0
		var isJLoopFinish = false

        if (A.count >= 25) { return 25 }
		if (A.count <= 3) { return (A.count * 2) }

		for i in 0..A.count {
			if (isJLoopFinish == true) {
				seventh++
				break
			}

			daysCount = 0
			index = A[i] + 7
			totalCount += 1

			for (let j = i + 1; j < A.count; j++) {
				if ((daysCount >= 3)  && (A[j] < index) && (j == (A.count - 1))) { isJLoopFinish = true }

				if (A[j] < index) {
					daysCount += 1
				} else {
					if (daysCount > 3) {
						seventh += 1
						daysCount = 0
						i = j - 1
					} else { daysCount = 0 }
					break;
				}
			}
		}

		totalCount = totalCount - seventh
		finalAmount = (totalCount * 2) + (seventh * 7)

		if (finalAmount > 25) { finalAmount = 25 }
		return finalAmount
}

The submission is being evaluated.

Code: 07:20:45 UTC, swift4, verify, result: Failed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46

import Foundation
import Glibc

public func solution(_ A : inout [Int]) -> Int {
		var index = 0
		var daysCount = 0
		var finalAmount = 0
		var seventh = 0
		var totalCount = 0
		var isJLoopFinish = false

        if (A.count >= 25) { return 25 }
		if (A.count <= 3) { return (A.count * 2) }

		for let i in 0 .. A.count {
			if (isJLoopFinish == true) {
				seventh++
				break
			}

			daysCount = 0
			index = A[i] + 7
			totalCount += 1

			for (let j = i + 1; j < A.count; j++) {
				if ((daysCount >= 3)  && (A[j] < index) && (j == (A.count - 1))) { isJLoopFinish = true }

				if (A[j] < index) {
					daysCount += 1
				} else {
					if (daysCount > 3) {
						seventh += 1
						daysCount = 0
						i = j - 1
					} else { daysCount = 0 }
					break;
				}
			}
		}

		totalCount = totalCount - seventh
		finalAmount = (totalCount * 2) + (seventh * 7)

		if (finalAmount > 25) { finalAmount = 25 }
		return finalAmount
}

The submission is being evaluated.

Code: 07:20:52 UTC, swift4, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46

import Foundation
import Glibc

public func solution(_ A : inout [Int]) -> Int {
		var index = 0
		var daysCount = 0
		var finalAmount = 0
		var seventh = 0
		var totalCount = 0
		var isJLoopFinish = false

        if (A.count >= 25) { return 25 }
		if (A.count <= 3) { return (A.count * 2) }

		for i in 0 .. A.count {
			if (isJLoopFinish == true) {
				seventh++
				break
			}

			daysCount = 0
			index = A[i] + 7
			totalCount += 1

			for (let j = i + 1; j < A.count; j++) {
				if ((daysCount >= 3)  && (A[j] < index) && (j == (A.count - 1))) { isJLoopFinish = true }

				if (A[j] < index) {
					daysCount += 1
				} else {
					if (daysCount > 3) {
						seventh += 1
						daysCount = 0
						i = j - 1
					} else { daysCount = 0 }
					break;
				}
			}
		}

		totalCount = totalCount - seventh
		finalAmount = (totalCount * 2) + (seventh * 7)

		if (finalAmount > 25) { finalAmount = 25 }
		return finalAmount
}

Code: 07:21:03 UTC, swift4, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46

import Foundation
import Glibc

public func solution(_ A : inout [Int]) -> Int {
		var index = 0
		var daysCount = 0
		var finalAmount = 0
		var seventh = 0
		var totalCount = 0
		var isJLoopFinish = false

        if (A.count >= 25) { return 25 }
		if (A.count <= 3) { return (A.count * 2) }

		for i in 0 ... A.count {
			if (isJLoopFinish == true) {
				seventh++
				break
			}

			daysCount = 0
			index = A[i] + 7
			totalCount += 1

			for (let j = i + 1; j < A.count; j++) {
				if ((daysCount >= 3)  && (A[j] < index) && (j == (A.count - 1))) { isJLoopFinish = true }

				if (A[j] < index) {
					daysCount += 1
				} else {
					if (daysCount > 3) {
						seventh += 1
						daysCount = 0
						i = j - 1
					} else { daysCount = 0 }
					break;
				}
			}
		}

		totalCount = totalCount - seventh
		finalAmount = (totalCount * 2) + (seventh * 7)

		if (finalAmount > 25) { finalAmount = 25 }
		return finalAmount
}

Code: 07:21:04 UTC, swift4, verify, result: Failed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46

import Foundation
import Glibc

public func solution(_ A : inout [Int]) -> Int {
		var index = 0
		var daysCount = 0
		var finalAmount = 0
		var seventh = 0
		var totalCount = 0
		var isJLoopFinish = false

        if (A.count >= 25) { return 25 }
		if (A.count <= 3) { return (A.count * 2) }

		for i in 0 ... A.count {
			if (isJLoopFinish == true) {
				seventh++
				break
			}

			daysCount = 0
			index = A[i] + 7
			totalCount += 1

			for (let j = i + 1; j < A.count; j++) {
				if ((daysCount >= 3)  && (A[j] < index) && (j == (A.count - 1))) { isJLoopFinish = true }

				if (A[j] < index) {
					daysCount += 1
				} else {
					if (daysCount > 3) {
						seventh += 1
						daysCount = 0
						i = j - 1
					} else { daysCount = 0 }
					break;
				}
			}
		}

		totalCount = totalCount - seventh
		finalAmount = (totalCount * 2) + (seventh * 7)

		if (finalAmount > 25) { finalAmount = 25 }
		return finalAmount
}

The submission is being evaluated.

Code: 07:21:29 UTC, swift4, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46

import Foundation
import Glibc

public func solution(_ A : inout [Int]) -> Int {
		var index = 0
		var daysCount = 0
		var finalAmount = 0
		var seventh = 0
		var totalCount = 0
		var isJLoopFinish = false

        if (A.count >= 25) { return 25 }
		if (A.count <= 3) { return (A.count * 2) }

		for i in 0 ... A.count {
			if (isJLoopFinish == true) {
				seventh++
				break
			}

			daysCount = 0
			index = A[i] + 7
			totalCount += 1

			for j in i + 1 ... A.count - 1(let j = i + 1; j < A.count; j++) {
				if ((daysCount >= 3)  && (A[j] < index) && (j == (A.count - 1))) { isJLoopFinish = true }

				if (A[j] < index) {
					daysCount += 1
				} else {
					if (daysCount > 3) {
						seventh += 1
						daysCount = 0
						i = j - 1
					} else { daysCount = 0 }
					break;
				}
			}
		}

		totalCount = totalCount - seventh
		finalAmount = (totalCount * 2) + (seventh * 7)

		if (finalAmount > 25) { finalAmount = 25 }
		return finalAmount
}

Code: 07:21:34 UTC, swift4, verify, result: Failed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46

import Foundation
import Glibc

public func solution(_ A : inout [Int]) -> Int {
		var index = 0
		var daysCount = 0
		var finalAmount = 0
		var seventh = 0
		var totalCount = 0
		var isJLoopFinish = false

        if (A.count >= 25) { return 25 }
		if (A.count <= 3) { return (A.count * 2) }

		for i in 0 ... A.count - 1 {
			if (isJLoopFinish == true) {
				seventh++
				break
			}

			daysCount = 0
			index = A[i] + 7
			totalCount += 1

			for j in i + 1 ... A.count - 1 {
				if ((daysCount >= 3)  && (A[j] < index) && (j == (A.count - 1))) { isJLoopFinish = true }

				if (A[j] < index) {
					daysCount += 1
				} else {
					if (daysCount > 3) {
						seventh += 1
						daysCount = 0
						i = j - 1
					} else { daysCount = 0 }
					break;
				}
			}
		}

		totalCount = totalCount - seventh
		finalAmount = (totalCount * 2) + (seventh * 7)

		if (finalAmount > 25) { finalAmount = 25 }
		return finalAmount
}

The submission is being evaluated.

Code: 07:21:47 UTC, swift4, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46

import Foundation
import Glibc

public func solution(_ A : inout [Int]) -> Int {
		var index = 0
		var daysCount = 0
		var finalAmount = 0
		var seventh = 0
		var totalCount = 0
		var isJLoopFinish = false

        if (A.count >= 25) { return 25 }
		if (A.count <= 3) { return (A.count * 2) }

		for i in 0 ... A.count - 1 {
			if (isJLoopFinish == true) {
				seventh += 1
				break
			}

			daysCount = 0
			index = A[i] + 7
			totalCount += 1

			for j in i + 1 ... A.count - 1 {
				if ((daysCount >= 3)  && (A[j] < index) && (j == (A.count - 1))) { isJLoopFinish = true }

				if (A[j] < index) {
					daysCount += 1
				} else {
					if (daysCount > 3) {
						seventh += 1
						daysCount = 0
						i = j - 1
					} else { daysCount = 0 }
					break;
				}
			}
		}

		totalCount = totalCount - seventh
		finalAmount = (totalCount * 2) + (seventh * 7)

		if (finalAmount > 25) { finalAmount = 25 }
		return finalAmount
}

Code: 07:21:47 UTC, swift4, verify, result: Failed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46

import Foundation
import Glibc

public func solution(_ A : inout [Int]) -> Int {
		var index = 0
		var daysCount = 0
		var finalAmount = 0
		var seventh = 0
		var totalCount = 0
		var isJLoopFinish = false

        if (A.count >= 25) { return 25 }
		if (A.count <= 3) { return (A.count * 2) }

		for i in 0 ... A.count - 1 {
			if (isJLoopFinish == true) {
				seventh += 1
				break
			}

			daysCount = 0
			index = A[i] + 7
			totalCount += 1

			for j in i + 1 ... A.count - 1 {
				if ((daysCount >= 3)  && (A[j] < index) && (j == (A.count - 1))) { isJLoopFinish = true }

				if (A[j] < index) {
					daysCount += 1
				} else {
					if (daysCount > 3) {
						seventh += 1
						daysCount = 0
						i = j - 1
					} else { daysCount = 0 }
					break;
				}
			}
		}

		totalCount = totalCount - seventh
		finalAmount = (totalCount * 2) + (seventh * 7)

		if (finalAmount > 25) { finalAmount = 25 }
		return finalAmount
}

The submission is being evaluated.

Code: 07:22:26 UTC, swift4, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47

import Foundation
import Glibc

public func solution(_ A : inout [Int]) -> Int {
		var index = 0
		var daysCount = 0
		var finalAmount = 0
		var seventh = 0
		var totalCount = 0
		var isJLoopFinish = false

        if (A.count >= 25) { return 25 }
		if (A.count <= 3) { return (A.count * 2) }


		for i in 0 ... A.count - 1 {
			if (isJLoopFinish == true) {
				seventh += 1
				break
			}

			daysCount = 0
			index = A[i] + 7
			totalCount += 1

			for j in i + 1 ... A.count - 1 {
				if ((daysCount >= 3)  && (A[j] < index) && (j == (A.count - 1))) { isJLoopFinish = true }

				if (A[j] < index) {
					daysCount += 1
				} else {
					if (daysCount > 3) {
						seventh += 1
						daysCount = 0
						i = j - 1
					} else { daysCount = 0 }
					break;
				}
			}
		}

		totalCount = totalCount - seventh
		finalAmount = (totalCount * 2) + (seventh * 7)

		if (finalAmount > 25) { finalAmount = 25 }
		return finalAmount
}

Code: 07:22:54 UTC, swift4, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49

import Foundation
import Glibc

public func solution(_ A : inout [Int]) -> Int {
		var index = 0
		var daysCount = 0
		var finalAmount = 0
		var seventh = 0
		var totalCount = 0
		var isJLoopFinish = false

        if (A.count >= 25) { return 25 }
		if (A.count <= 3) { return (A.count * 2) }

        var i = 0

		while i < A.count {
			if (isJLoopFinish == true) {
				seventh += 1
				break
			}

			daysCount = 0
			index = A[i] + 7
			totalCount += 1

			for j in i + 1 ... A.count - 1 {
				if ((daysCount >= 3)  && (A[j] < index) && (j == (A.count - 1))) { isJLoopFinish = true }

				if (A[j] < index) {
					daysCount += 1
				} else {
					if (daysCount > 3) {
						seventh += 1
						daysCount = 0
						i = j - 1
					} else { daysCount = 0 }
					break;
				}
			}
            i += 1
		}

		totalCount = totalCount - seventh
		finalAmount = (totalCount * 2) + (seventh * 7)

		if (finalAmount > 25) { finalAmount = 25 }
		return finalAmount
}

Code: 07:22:54 UTC, swift4, verify, result: Failed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49

import Foundation
import Glibc

public func solution(_ A : inout [Int]) -> Int {
		var index = 0
		var daysCount = 0
		var finalAmount = 0
		var seventh = 0
		var totalCount = 0
		var isJLoopFinish = false

        if (A.count >= 25) { return 25 }
		if (A.count <= 3) { return (A.count * 2) }

        var i = 0

		while i < A.count {
			if (isJLoopFinish == true) {
				seventh += 1
				break
			}

			daysCount = 0
			index = A[i] + 7
			totalCount += 1

			for j in i + 1 ... A.count - 1 {
				if ((daysCount >= 3)  && (A[j] < index) && (j == (A.count - 1))) { isJLoopFinish = true }

				if (A[j] < index) {
					daysCount += 1
				} else {
					if (daysCount > 3) {
						seventh += 1
						daysCount = 0
						i = j - 1
					} else { daysCount = 0 }
					break;
				}
			}
            i += 1
		}

		totalCount = totalCount - seventh
		finalAmount = (totalCount * 2) + (seventh * 7)

		if (finalAmount > 25) { finalAmount = 25 }
		return finalAmount
}

The submission is being evaluated.

Code: 07:26:37 UTC, swift4, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50

import Foundation
import Glibc

public func solution(_ A : inout [Int]) -> Int {
		var index = 0
		var daysCount = 0
		var finalAmount = 0
		var seventh = 0
		var totalCount = 0
		var isJLoopFinish = false

        if (A.count >= 25) { return 25 }
		if (A.count <= 3) { return (A.count * 2) }

        var i = 0

		while i < A.count {
			if (isJLoopFinish == true) {
				seventh += 1
				break
			}

			daysCount = 0
			index = A[i] + 7
			totalCount += 1

			for j in i + 1 ... A.count - 1 {
				if ((daysCount >= 3)  && (A[j] < index) && (j == (A.count - 1))) { isJLoopFinish = true }

				if (A[j] < index) {
					daysCount += 1
				} else {
					if (daysCount > 3) {
						seventh += 1
						daysCount = 0
						i = j - 1
					} else { daysCount = 0 }
					break;
				}
			}
            i += 1
		}

		totalCount = totalCount - seventh
		finalAmount = (totalCount * 2) + (seventh * 7)

		if (finalAmount > 25) { finalAmount = 25 }
		return finalAmount
}

Code: 07:26:55 UTC, swift4, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76

import Foundation
import Glibc

// - Complexity:
//   - time: O(n), where n is the number of the days in the travel plan.
//   - space: O(n), where n is the number of the days in the travel plan.

public func solution(_ A : inout [Int]) -> Int {
		var index = 0
		var daysCount = 0
		var finalAmount = 0
		var seventh = 0
		var totalCount = 0
		var isJLoopFinish = false

        if (A.count >= 25) { return 25 }
		if (A.count <= 3) { return (A.count * 2) }

        var i = 0

		while i < A.count {
			if (isJLoopFinish == true) {
				seventh += 1
				break
			}

			daysCount = 0
			index = A[i] + 7
			totalCount += 1

			for j in i + 1 ... A.count - 1 {
				if ((daysCount >= 3)  && (A[j] < index) && (j == (A.count - 1))) { isJLoopFinish = true }

				if (A[j] < index) {
					daysCount += 1
				} else {
					if (daysCount > 3) {
						seventh += 1
						daysCount = 0
						i = j - 1
					} else { daysCount = 0 }
					break;
				}
			}
            i += 1
		}

		totalCount = totalCount - seventh
		finalAmount = (totalCount * 2) + (seventh * 7)

		if (finalAmount > 25) { finalAmount = 25 }
		return finalAmount
}


    func mincostTickets(_ days: [Int], _ costs: [Int]) -> Int {
        var memo = [Int](repeating: -1, count: days.count)
        let durations = [1, 7, 30]
        return dp(0, days, costs, &memo, durations)
    }

    
    private func dp(_ i: Int, _ days: [Int], _ costs: [Int], _ memo: inout [Int], _ durations: [Int]) -> Int {
        guard i < days.count else { return 0 }
        guard memo[i] == -1 else { return memo[i] }
        var ans = Int.max
        var j = i

        for k in 0..<3 {
            while j < days.count, days[j] < days[i] + durations[k] { j += 1 }
            ans = min(ans, dp(j, days, costs, &memo, durations) + costs[k])
        }

        memo[i] = ans
        return ans
    }

Code: 07:27:05 UTC, swift4, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33

import Foundation
import Glibc

// - Complexity:
//   - time: O(n), where n is the number of the days in the travel plan.
//   - space: O(n), where n is the number of the days in the travel plan.

public func solution(_ A : inout [Int]) -> Int {

}


    func mincostTickets(_ days: [Int], _ costs: [Int]) -> Int {
        var memo = [Int](repeating: -1, count: days.count)
        let durations = [1, 7, 30]
        return dp(0, days, costs, &memo, durations)
    }

    
    private func dp(_ i: Int, _ days: [Int], _ costs: [Int], _ memo: inout [Int], _ durations: [Int]) -> Int {
        guard i < days.count else { return 0 }
        guard memo[i] == -1 else { return memo[i] }
        var ans = Int.max
        var j = i

        for k in 0..<3 {
            while j < days.count, days[j] < days[i] + durations[k] { j += 1 }
            ans = min(ans, dp(j, days, costs, &memo, durations) + costs[k])
        }

        memo[i] = ans
        return ans
    }

Code: 07:27:15 UTC, swift4, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33

import Foundation
import Glibc

// - Complexity:
//   - time: O(n), where n is the number of the days in the travel plan.
//   - space: O(n), where n is the number of the days in the travel plan.

public func solution(_ A : inout [Int]) -> Int {
    mincostTickets()
}


    func mincostTickets(_ days: [Int], _ costs: [Int]) -> Int {
        var memo = [Int](repeating: -1, count: days.count)
        let durations = [1, 7, 30]
        return dp(0, days, costs, &memo, durations)
    }

    
    private func dp(_ i: Int, _ days: [Int], _ costs: [Int], _ memo: inout [Int], _ durations: [Int]) -> Int {
        guard i < days.count else { return 0 }
        guard memo[i] == -1 else { return memo[i] }
        var ans = Int.max
        var j = i

        for k in 0..<3 {
            while j < days.count, days[j] < days[i] + durations[k] { j += 1 }
            ans = min(ans, dp(j, days, costs, &memo, durations) + costs[k])
        }

        memo[i] = ans
        return ans
    }

Code: 07:27:34 UTC, swift4, verify, result: Failed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33

import Foundation
import Glibc

// - Complexity:
//   - time: O(n), where n is the number of the days in the travel plan.
//   - space: O(n), where n is the number of the days in the travel plan.

public func solution(_ A : inout [Int]) -> Int {
    mincostTickets(A, A)
}


    func mincostTickets(_ days: [Int], _ costs: [Int]) -> Int {
        var memo = [Int](repeating: -1, count: days.count)
        let durations = [1, 7, 30]
        return dp(0, days, costs, &memo, durations)
    }

    
    private func dp(_ i: Int, _ days: [Int], _ costs: [Int], _ memo: inout [Int], _ durations: [Int]) -> Int {
        guard i < days.count else { return 0 }
        guard memo[i] == -1 else { return memo[i] }
        var ans = Int.max
        var j = i

        for k in 0..<3 {
            while j < days.count, days[j] < days[i] + durations[k] { j += 1 }
            ans = min(ans, dp(j, days, costs, &memo, durations) + costs[k])
        }

        memo[i] = ans
        return ans
    }

The submission is being evaluated.

Code: 07:27:45 UTC, swift4, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33

import Foundation
import Glibc

// - Complexity:
//   - time: O(n), where n is the number of the days in the travel plan.
//   - space: O(n), where n is the number of the days in the travel plan.

public func solution(_ A : inout [Int]) -> Int {
    _ = mincostTickets(A, A)
}


    func mincostTickets(_ days: [Int], _ costs: [Int]) -> Int {
        var memo = [Int](repeating: -1, count: days.count)
        let durations = [1, 7, 30]
        return dp(0, days, costs, &memo, durations)
    }

    
    private func dp(_ i: Int, _ days: [Int], _ costs: [Int], _ memo: inout [Int], _ durations: [Int]) -> Int {
        guard i < days.count else { return 0 }
        guard memo[i] == -1 else { return memo[i] }
        var ans = Int.max
        var j = i

        for k in 0..<3 {
            while j < days.count, days[j] < days[i] + durations[k] { j += 1 }
            ans = min(ans, dp(j, days, costs, &memo, durations) + costs[k])
        }

        memo[i] = ans
        return ans
    }

Code: 07:27:48 UTC, swift4, verify, result: Failed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33

import Foundation
import Glibc

// - Complexity:
//   - time: O(n), where n is the number of the days in the travel plan.
//   - space: O(n), where n is the number of the days in the travel plan.

public func solution(_ A : inout [Int]) -> Int {
    _ = mincostTickets(A, A)
}


    func mincostTickets(_ days: [Int], _ costs: [Int]) -> Int {
        var memo = [Int](repeating: -1, count: days.count)
        let durations = [1, 7, 30]
        return dp(0, days, costs, &memo, durations)
    }

    
    private func dp(_ i: Int, _ days: [Int], _ costs: [Int], _ memo: inout [Int], _ durations: [Int]) -> Int {
        guard i < days.count else { return 0 }
        guard memo[i] == -1 else { return memo[i] }
        var ans = Int.max
        var j = i

        for k in 0..<3 {
            while j < days.count, days[j] < days[i] + durations[k] { j += 1 }
            ans = min(ans, dp(j, days, costs, &memo, durations) + costs[k])
        }

        memo[i] = ans
        return ans
    }

The submission is being evaluated.

Code: 07:28:02 UTC, swift4, verify, result: Failed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33

import Foundation
import Glibc

// - Complexity:
//   - time: O(n), where n is the number of the days in the travel plan.
//   - space: O(n), where n is the number of the days in the travel plan.

public func solution(_ A : inout [Int]) -> Int {
    return mincostTickets(A, A)
}


    func mincostTickets(_ days: [Int], _ costs: [Int]) -> Int {
        var memo = [Int](repeating: -1, count: days.count)
        let durations = [1, 7, 30]
        return dp(0, days, costs, &memo, durations)
    }

    
    private func dp(_ i: Int, _ days: [Int], _ costs: [Int], _ memo: inout [Int], _ durations: [Int]) -> Int {
        guard i < days.count else { return 0 }
        guard memo[i] == -1 else { return memo[i] }
        var ans = Int.max
        var j = i

        for k in 0..<3 {
            while j < days.count, days[j] < days[i] + durations[k] { j += 1 }
            ans = min(ans, dp(j, days, costs, &memo, durations) + costs[k])
        }

        memo[i] = ans
        return ans
    }

The submission is being evaluated.

Code: 07:30:02 UTC, swift4, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33

import Foundation
import Glibc

// - Complexity:
//   - time: O(n), where n is the number of the days in the travel plan.
//   - space: O(n), where n is the number of the days in the travel plan.

public func solution(_ A : inout [Int]) -> Int {
    return mincostTickets(A, )
}


    func mincostTickets(_ days: [Int], _ costs: [Int]) -> Int {
        var memo = [Int](repeating: -1, count: days.count)
        let durations = [1, 7, 30]
        return dp(0, days, costs, &memo, durations)
    }

    
    private func dp(_ i: Int, _ days: [Int], _ costs: [Int], _ memo: inout [Int], _ durations: [Int]) -> Int {
        guard i < days.count else { return 0 }
        guard memo[i] == -1 else { return memo[i] }
        var ans = Int.max
        var j = i

        for k in 0..<3 {
            while j < days.count, days[j] < days[i] + durations[k] { j += 1 }
            ans = min(ans, dp(j, days, costs, &memo, durations) + costs[k])
        }

        memo[i] = ans
        return ans
    }

Code: 07:30:12 UTC, swift4, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33

import Foundation
import Glibc

// - Complexity:
//   - time: O(n), where n is the number of the days in the travel plan.
//   - space: O(n), where n is the number of the days in the travel plan.

public func solution(_ A : inout [Int]) -> Int {
    return mincostTickets(A, [2, 7])
}


    func mincostTickets(_ days: [Int], _ costs: [Int]) -> Int {
        var memo = [Int](repeating: -1, count: days.count)
        let durations = [1, 7, 30]
        return dp(0, days, costs, &memo, durations)
    }

    
    private func dp(_ i: Int, _ days: [Int], _ costs: [Int], _ memo: inout [Int], _ durations: [Int]) -> Int {
        guard i < days.count else { return 0 }
        guard memo[i] == -1 else { return memo[i] }
        var ans = Int.max
        var j = i

        for k in 0..<3 {
            while j < days.count, days[j] < days[i] + durations[k] { j += 1 }
            ans = min(ans, dp(j, days, costs, &memo, durations) + costs[k])
        }

        memo[i] = ans
        return ans
    }

Code: 07:30:22 UTC, swift4, verify, result: Passed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33

import Foundation
import Glibc

// - Complexity:
//   - time: O(n), where n is the number of the days in the travel plan.
//   - space: O(n), where n is the number of the days in the travel plan.

public func solution(_ A : inout [Int]) -> Int {
    return mincostTickets(A, [2, 7, 25])
}


    func mincostTickets(_ days: [Int], _ costs: [Int]) -> Int {
        var memo = [Int](repeating: -1, count: days.count)
        let durations = [1, 7, 30]
        return dp(0, days, costs, &memo, durations)
    }

    
    private func dp(_ i: Int, _ days: [Int], _ costs: [Int], _ memo: inout [Int], _ durations: [Int]) -> Int {
        guard i < days.count else { return 0 }
        guard memo[i] == -1 else { return memo[i] }
        var ans = Int.max
        var j = i

        for k in 0..<3 {
            while j < days.count, days[j] < days[i] + durations[k] { j += 1 }
            ans = min(ans, dp(j, days, costs, &memo, durations) + costs[k])
        }

        memo[i] = ans
        return ans
    }

The submission is being evaluated.

Code: 07:30:36 UTC, swift4, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32

import Foundation
import Glibc

// - Complexity:
//   - time: O(n), where n is the number of the days in the travel plan.
//   - space: O(n), where n is the number of the days in the travel plan.

public func solution(_ A : inout [Int]) -> Int {
    return mincostTickets(A, [2, 7, 25])
}

func mincostTickets(_ days: [Int], _ costs: [Int]) -> Int {
    var memo = [Int](repeating: -1, count: days.count)
        let durations = [1, 7, 30]
        return dp(0, days, costs, &memo, durations)
    }

    
    private func dp(_ i: Int, _ days: [Int], _ costs: [Int], _ memo: inout [Int], _ durations: [Int]) -> Int {
        guard i < days.count else { return 0 }
        guard memo[i] == -1 else { return memo[i] }
        var ans = Int.max
        var j = i

        for k in 0..<3 {
            while j < days.count, days[j] < days[i] + durations[k] { j += 1 }
            ans = min(ans, dp(j, days, costs, &memo, durations) + costs[k])
        }

        memo[i] = ans
        return ans
    }

Code: 07:31:00 UTC, swift4, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32

import Foundation
import Glibc

// - Complexity:
//   - time: O(n), where n is the number of the days in the travel plan.
//   - space: O(n), where n is the number of the days in the travel plan.

public func solution(_ A : inout [Int]) -> Int {
    return mincostTickets(A, [2, 7, 25])
}

func mincostTickets(_ days: [Int], _ costs: [Int]) -> Int {
    var memo = [Int](repeating: -1, count: days.count)
    let durations = [1, 7, 30]
    return dp(0, days, costs, &memo, durations)
}

    
private func dp(_ i: Int, _ days: [Int], _ costs: [Int], _ memo: inout [Int], _ durations: [Int]) -> Int {
    guard i < days.count else { return 0 }
    guard memo[i] == -1 else { return memo[i] }
    var ans = Int.max
    var j = i

    for k in 0..<3 {
        while j < days.count, days[j] < days[i] + durations[k] { j += 1 }
        ans = min(ans, dp(j, days, costs, &memo, durations) + costs[k])
    }

    memo[i] = ans
    return ans
}

Code: 07:31:04 UTC, swift4, verify, result: Passed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32

import Foundation
import Glibc

// - Complexity:
//   - time: O(n), where n is the number of the days in the travel plan.
//   - space: O(n), where n is the number of the days in the travel plan.

public func solution(_ A : inout [Int]) -> Int {
    return mincostTickets(A, [2, 7, 25])
}

func mincostTickets(_ days: [Int], _ costs: [Int]) -> Int {
    var memo = [Int](repeating: -1, count: days.count)
    let durations = [1, 7, 30]
    return dp(0, days, costs, &memo, durations)
}

    
private func dp(_ i: Int, _ days: [Int], _ costs: [Int], _ memo: inout [Int], _ durations: [Int]) -> Int {
    guard i < days.count else { return 0 }
    guard memo[i] == -1 else { return memo[i] }
    var ans = Int.max
    var j = i

    for k in 0..<3 {
        while j < days.count, days[j] < days[i] + durations[k] { j += 1 }
        ans = min(ans, dp(j, days, costs, &memo, durations) + costs[k])
    }

    memo[i] = ans
    return ans
}

The submission is being evaluated.

Code: 07:31:26 UTC, swift4, verify, result: Passed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32

import Foundation
import Glibc

// - Complexity:
//   - time: O(n), where n is the number of the days in the travel plan.
//   - space: O(n), where n is the number of the days in the travel plan.

public func solution(_ A : inout [Int]) -> Int {
    return mincostTickets(A, [2, 7, 25])
}

func mincostTickets(_ days: [Int], _ costs: [Int]) -> Int {
    var memo = [Int](repeating: -1, count: days.count)
    let durations = [1, 7, 30]
    return dp(0, days, costs, &memo, durations)
}

    
private func dp(_ i: Int, _ days: [Int], _ costs: [Int], _ memo: inout [Int], _ durations: [Int]) -> Int {
    guard i < days.count else { return 0 }
    guard memo[i] == -1 else { return memo[i] }
    var ans = Int.max
    var j = i

    for k in 0..<3 {
        while j < days.count, days[j] < days[i] + durations[k] { j += 1 }
        ans = min(ans, dp(j, days, costs, &memo, durations) + costs[k])
    }

    memo[i] = ans
    return ans
}

The submission is being evaluated.

Code: 07:31:31 UTC, swift4, final, score: 100

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32

import Foundation
import Glibc

// - Complexity:
//   - time: O(n), where n is the number of the days in the travel plan.
//   - space: O(n), where n is the number of the days in the travel plan.

public func solution(_ A : inout [Int]) -> Int {
    return mincostTickets(A, [2, 7, 25])
}

func mincostTickets(_ days: [Int], _ costs: [Int]) -> Int {
    var memo = [Int](repeating: -1, count: days.count)
    let durations = [1, 7, 30]
    return dp(0, days, costs, &memo, durations)
}

    
private func dp(_ i: Int, _ days: [Int], _ costs: [Int], _ memo: inout [Int], _ durations: [Int]) -> Int {
    guard i < days.count else { return 0 }
    guard memo[i] == -1 else { return memo[i] }
    var ans = Int.max
    var j = i

    for k in 0..<3 {
        while j < days.count, days[j] < days[i] + durations[k] { j += 1 }
        ans = min(ans, dp(j, days, costs, &memo, durations) + costs[k])
    }

    memo[i] = ans
    return ans
}

The submission is being evaluated.