Tasks Details
medium
Find the minimal nucleotide from a range of sequence DNA.
Task Score
75%
Correctness
60%
Performance
100%
A DNA sequence can be represented as a string consisting of the letters A, C, G and T, which correspond to the types of successive nucleotides in the sequence. Each nucleotide has an impact factor, which is an integer. Nucleotides of types A, C, G and T have impact factors of 1, 2, 3 and 4, respectively. You are going to answer several queries of the form: What is the minimal impact factor of nucleotides contained in a particular part of the given DNA sequence?
The DNA sequence is given as a non-empty string S = S[0]S[1]...S[N-1] consisting of N characters. There are M queries, which are given in non-empty arrays P and Q, each consisting of M integers. The K-th query (0 ≤ K < M) requires you to find the minimal impact factor of nucleotides contained in the DNA sequence between positions P[K] and Q[K] (inclusive).
For example, consider string S = CAGCCTA and arrays P, Q such that:
P[0] = 2 Q[0] = 4 P[1] = 5 Q[1] = 5 P[2] = 0 Q[2] = 6The answers to these M = 3 queries are as follows:
- The part of the DNA between positions 2 and 4 contains nucleotides G and C (twice), whose impact factors are 3 and 2 respectively, so the answer is 2.
- The part between positions 5 and 5 contains a single nucleotide T, whose impact factor is 4, so the answer is 4.
- The part between positions 0 and 6 (the whole string) contains all nucleotides, in particular nucleotide A whose impact factor is 1, so the answer is 1.
Write a function:
def solution(s, p, q)
that, given a non-empty string S consisting of N characters and two non-empty arrays P and Q consisting of M integers, returns an array consisting of M integers specifying the consecutive answers to all queries.
Result array should be returned as an array of integers.
For example, given the string S = CAGCCTA and arrays P, Q such that:
P[0] = 2 Q[0] = 4 P[1] = 5 Q[1] = 5 P[2] = 0 Q[2] = 6the function should return the values [2, 4, 1], as explained above.
Write an efficient algorithm for the following assumptions:
- N is an integer within the range [1..100,000];
- M is an integer within the range [1..50,000];
- each element of arrays P and Q is an integer within the range [0..N - 1];
- P[K] ≤ Q[K], where 0 ≤ K < M;
- string S consists only of upper-case English letters A, C, G, T.
Copyright 2009–2024 by Codility Limited. All Rights Reserved. Unauthorized copying, publication or disclosure prohibited.
Solution
Programming language used Ruby
Total time used 98 minutes
Effective time used 98 minutes
Notes
not defined yet
Task timeline
Code: 15:00:37 UTC,
rb,
verify,
result: Failed
def solution(string, slice_start, slice_end)
# The challenge here is to find a way to return
# the minimum value present in an array slice in
# without having to iterate through the entire
# slice – i.e. in constant O(1) time.
# Initialise an array to hold the number of
# times each character occurs at each point
# in the original string. It's just a running
# total for each character.
prefix_sums = Array.new(string.length, { A: 0, C: 0, G: 0, T: 0 })
# Iterating through each character, increment
# the counter for that character at that position.
string.split('').each_with_index do |char, i|
running_total = prefix_sums[i][char.to_sym]
prefix_sums[i][char.to_sym] = running_total + 1
end
prefix_sums.each_with_index do |p,i|
puts "i: #{i}, p: #{p.join {|k, v| k + ' ' + v}"
end
Analysis
expand all
Example tests
1.
0.109 s
RUNTIME ERROR,
tested program terminated unexpectedly
stderr:
user.rb:21: syntax error, unexpected tSTRING_BEG, expecting tSTRING_DEND
user.rb:62: syntax error, unexpected tCONSTANT, expecting tSTRING_DEND
STDERR.puts "Invalid result type, Integer expecte...
^
user.rb:62: syntax error, unexpected tIDENTIFIER, expecting keyword_do or '{' or '('
...d result type, Integer expected, #{inp.class} found"
... ^
user.rb:63: syntax error, unexpected '\n', expecting :: or '[' or '.'
user.rb:66: syntax error, unexpected keyword_end, expecting tSTRING_DEND
user.rb:147: syntax error, unexpected end-of-input, expecting tSTRING_DEND
Code: 15:00:42 UTC,
rb,
verify,
result: Failed
def solution(string, slice_start, slice_end)
# The challenge here is to find a way to return
# the minimum value present in an array slice in
# without having to iterate through the entire
# slice – i.e. in constant O(1) time.
# Initialise an array to hold the number of
# times each character occurs at each point
# in the original string. It's just a running
# total for each character.
prefix_sums = Array.new(string.length, { A: 0, C: 0, G: 0, T: 0 })
# Iterating through each character, increment
# the counter for that character at that position.
string.split('').each_with_index do |char, i|
running_total = prefix_sums[i][char.to_sym]
prefix_sums[i][char.to_sym] = running_total + 1
end
prefix_sums.each_with_index do |p,i|
puts "i: #{i}, p: #{p.join {|k, v| k + ' ' + v}}"
end
Analysis
expand all
Example tests
1.
0.110 s
RUNTIME ERROR,
tested program terminated unexpectedly
stderr:
user.rb:147: syntax error, unexpected end-of-input, expecting keyword_end
Code: 15:00:56 UTC,
rb,
verify,
result: Failed
def solution(string, slice_start, slice_end)
# The challenge here is to find a way to return
# the minimum value present in an array slice in
# without having to iterate through the entire
# slice – i.e. in constant O(1) time.
# Initialise an array to hold the number of
# times each character occurs at each point
# in the original string. It's just a running
# total for each character.
prefix_sums = Array.new(string.length, { A: 0, C: 0, G: 0, T: 0 })
# Iterating through each character, increment
# the counter for that character at that position.
string.split('').each_with_index do |char, i|
running_total = prefix_sums[i][char.to_sym]
prefix_sums[i][char.to_sym] = running_total + 1
end
prefix_sums.each_with_index do |p,i|
puts "i: #{i}, p: #{p}"
end
Analysis
expand all
Example tests
1.
0.102 s
RUNTIME ERROR,
tested program terminated unexpectedly
stderr:
user.rb:147: syntax error, unexpected end-of-input, expecting keyword_end
Code: 15:01:32 UTC,
rb,
verify,
result: Failed
def solution(string, slice_start, slice_end)
# The challenge here is to find a way to return
# the minimum value present in an array slice in
# without having to iterate through the entire
# slice – i.e. in constant O(1) time.
# Initialise an array to hold the number of
# times each character occurs at each point
# in the original string. It's just a running
# total for each character.
prefix_sums = Array.new(string.length, { A: 0, C: 0, G: 0, T: 0 })
# Iterating through each character, increment
# the counter for that character at that position.
string.split('').each_with_index do |char, i|
running_total = prefix_sums[i][char.to_sym]
prefix_sums[i][char.to_sym] = running_total + 1
end
prefix_sums.each_with_index do |p, i|
puts "i: #{i}, p: #{p}"
end
Analysis
expand all
Example tests
1.
0.101 s
RUNTIME ERROR,
tested program terminated unexpectedly
stderr:
user.rb:147: syntax error, unexpected end-of-input, expecting keyword_end
Code: 15:01:45 UTC,
rb,
verify,
result: Failed
def solution(string, slice_start, slice_end)
# The challenge here is to find a way to return
# the minimum value present in an array slice in
# without having to iterate through the entire
# slice – i.e. in constant O(1) time.
# Initialise an array to hold the number of
# times each character occurs at each point
# in the original string. It's just a running
# total for each character.
prefix_sums = Array.new(string.length, { A: 0, C: 0, G: 0, T: 0 })
# Iterating through each character, increment
# the counter for that character at that position.
string.split('').each_with_index do |char, i|
running_total = prefix_sums[i][char.to_sym]
prefix_sums[i][char.to_sym] = running_total + 1
end
prefix_sums.each_with_index do |p, i|
puts "i: #{i}, p: #{p}"
end
end
Analysis
expand all
Example tests
1.
0.100 s
RUNTIME ERROR,
tested program terminated unexpectedly
stderr:
Invalid result type, Integer expected, Hash foundstdout:
i: 0, p: {:A=>2, :C=>3, :G=>1, :T=>1}
i: 1, p: {:A=>2, :C=>3, :G=>1, :T=>1}
i: 2, p: {:A=>2, :C=>3, :G=>1, :T=>1}
i: 3, p: {:A=>2, :C=>3, :G=>1, :T=>1}
i: 4, p: {:A=>2, :C=>3, :G=>1, :T=>1}
i: 5, p: {:A=>2, :C=>3, :G=>1, :T=>1}
i: 6, p: {:A=>2, :C=>3, :G=>1, :T=>1}
Code: 15:02:30 UTC,
rb,
verify,
result: Failed
def solution(string, slice_start, slice_end)
# The challenge here is to find a way to return
# the minimum value present in an array slice in
# without having to iterate through the entire
# slice – i.e. in constant O(1) time.
# Initialise an array to hold the number of
# times each character occurs at each point
# in the original string. It's just a running
# total for each character.
prefix_sums = Array.new(string.length, { A: 0, C: 0, G: 0, T: 0 })
# Iterating through each character, increment
# the counter for that character at that position.
string.split('').each_with_index do |char, i|
running_total = prefix_sums[i][char.to_sym]
prefix_sums[i + 1][char.to_sym] = running_total + 1
end
prefix_sums.each_with_index do |p, i|
puts "i: #{i}, p: #{p}"
end
end
Analysis
expand all
Example tests
1.
0.100 s
RUNTIME ERROR,
tested program terminated unexpectedly
stderr:
user.rb:17:in `block in solution': undefined method `[]=' for nil:NilClass (NoMethodError) from user.rb:15:in `each' from user.rb:15:in `each_with_index' from user.rb:15:in `solution' from user.rb:146:in `<main>'
Code: 15:03:16 UTC,
rb,
verify,
result: Failed
def solution(string, slice_start, slice_end)
# The challenge here is to find a way to return
# the minimum value present in an array slice in
# without having to iterate through the entire
# slice – i.e. in constant O(1) time.
# Initialise an array to hold the number of
# times each character occurs at each point
# in the original string. It's just a running
# total for each character.
prefix_sums = Array.new(string.length, { A: 0, C: 0, G: 0, T: 0 })
# Iterating through each character, increment
# the counter for that character at that position.
string.split('').each_with_index do |char, i|
running_total = prefix_sums[i - 1][char.to_sym]
prefix_sums[i][char.to_sym] = running_total + 1
end
prefix_sums.each_with_index do |p, i|
puts "i: #{i}, p: #{p}"
end
end
Analysis
expand all
Example tests
1.
0.120 s
RUNTIME ERROR,
tested program terminated unexpectedly
stderr:
Invalid result type, Integer expected, Hash foundstdout:
i: 0, p: {:A=>2, :C=>3, :G=>1, :T=>1}
i: 1, p: {:A=>2, :C=>3, :G=>1, :T=>1}
i: 2, p: {:A=>2, :C=>3, :G=>1, :T=>1}
i: 3, p: {:A=>2, :C=>3, :G=>1, :T=>1}
i: 4, p: {:A=>2, :C=>3, :G=>1, :T=>1}
i: 5, p: {:A=>2, :C=>3, :G=>1, :T=>1}
i: 6, p: {:A=>2, :C=>3, :G=>1, :T=>1}
Code: 15:03:28 UTC,
rb,
verify,
result: Failed
def solution(string, slice_start, slice_end)
# The challenge here is to find a way to return
# the minimum value present in an array slice in
# without having to iterate through the entire
# slice – i.e. in constant O(1) time.
# Initialise an array to hold the number of
# times each character occurs at each point
# in the original string. It's just a running
# total for each character.
prefix_sums = Array.new(string.length, { A: 0, C: 0, G: 0, T: 0 })
# Iterating through each character, increment
# the counter for that character at that position.
string.split('').each_with_index do |char, i|
running_total = prefix_sums[i - 1][char.to_sym] || 0
prefix_sums[i][char.to_sym] = running_total + 1
end
prefix_sums.each_with_index do |p, i|
puts "i: #{i}, p: #{p}"
end
end
Analysis
expand all
Example tests
1.
0.100 s
RUNTIME ERROR,
tested program terminated unexpectedly
stderr:
Invalid result type, Integer expected, Hash foundstdout:
i: 0, p: {:A=>2, :C=>3, :G=>1, :T=>1}
i: 1, p: {:A=>2, :C=>3, :G=>1, :T=>1}
i: 2, p: {:A=>2, :C=>3, :G=>1, :T=>1}
i: 3, p: {:A=>2, :C=>3, :G=>1, :T=>1}
i: 4, p: {:A=>2, :C=>3, :G=>1, :T=>1}
i: 5, p: {:A=>2, :C=>3, :G=>1, :T=>1}
i: 6, p: {:A=>2, :C=>3, :G=>1, :T=>1}
Code: 15:04:03 UTC,
rb,
verify,
result: Failed
def solution(string, slice_start, slice_end)
# The challenge here is to find a way to return
# the minimum value present in an array slice in
# without having to iterate through the entire
# slice – i.e. in constant O(1) time.
# Initialise an array to hold the number of
# times each character occurs at each point
# in the original string. It's just a running
# total for each character.
prefix_sums = Array.new(string.length, { A: 0, C: 0, G: 0, T: 0 })
# Iterating through each character, increment
# the counter for that character at that position.
string.split('').each_with_index do |char, i|
puts "char: #{char}"
running_total = prefix_sums[i - 1][char.to_sym] || 0
prefix_sums[i][char.to_sym] = running_total + 1
end
prefix_sums.each_with_index do |p, i|
puts "i: #{i}, p: #{p}"
end
end
Analysis
expand all
Example tests
1.
0.100 s
RUNTIME ERROR,
tested program terminated unexpectedly
stderr:
Invalid result type, Integer expected, Hash foundstdout:
char: C
char: A
char: G
char: C
char: C
char: T
char: A
i: 0, p: {:A=>2, :C=>3, :G=>1, :T=>1}
i: 1, p: {:A=>2, :C=>3, :G=>1, :T=>1}
i: 2, p: {:A=>2, :C=>3, :G=>1, :T=>1}
i: 3, p: {:A=>2, :C=>3, :G=>1, :T=>1}
i: 4, p: {:A=>2, :C=>3, :G=>1, :T=>1}
i: 5, p: {:A=>2, :C=>3, :G=>1, :T=>1}
i: 6, p: {:A=>2, :C=>3, :G=>1, :T=>1}
Code: 15:19:40 UTC,
rb,
verify,
result: Failed
def solution(string, slice_start, slice_end)
# The challenge here is to find a way to return
# the minimum value present in an array slice in
# without having to iterate through the entire
# slice – i.e. in constant O(1) time.
# Initialise an array to hold the number of
# times each character occurs at each point
# in the original string. It's just a running
# total for each character.
prefix_sums = Array.new(string.length) { { A: 0, C: 0, G: 0, T: 0 } }
# Iterating through each character, increment
# the counter for that character at that position.
string.split('').each_with_index do |char, i|
puts "char: #{char}"
running_total = prefix_sums[i - 1][char.to_sym] || 0
prefix_sums[i][char.to_sym] = running_total + 1
end
prefix_sums.each_with_index do |p, i|
puts "i: #{i}, p: #{p}"
end
end
Analysis
expand all
Example tests
1.
0.099 s
RUNTIME ERROR,
tested program terminated unexpectedly
stderr:
Invalid result type, Integer expected, Hash foundstdout:
char: C
char: A
char: G
char: C
char: C
char: T
char: A
i: 0, p: {:A=>0, :C=>1, :G=>0, :T=>0}
i: 1, p: {:A=>1, :C=>0, :G=>0, :T=>0}
i: 2, p: {:A=>0, :C=>0, :G=>1, :T=>0}
i: 3, p: {:A=>0, :C=>1, :G=>0, :T=>0}
i: 4, p: {:A=>0, :C=>2, :G=>0, :T=>0}
i: 5, p: {:A=>0, :C=>0, :G=>0, :T=>1}
i: 6, p: {:A=>1, :C=>0, :G=>0, :T=>0}
Code: 15:20:40 UTC,
rb,
verify,
result: Failed
def solution(string, slice_start, slice_end)
# The challenge here is to find a way to return
# the minimum value present in an array slice in
# without having to iterate through the entire
# slice – i.e. in constant O(1) time.
# Initialise an array to hold the number of
# times each character occurs at each point
# in the original string. It's just a running
# total for each character.
prefix_sums = Array.new(string.length) { { A: 0, C: 0, G: 0, T: 0 } }
# Iterating through each character, increment
# the counter for that character at that position.
string.split('').each_with_index do |char, i|
puts "char: #{char}"
running_total = prefix_sums[i - 1][char.to_sym]
prefix_sums[i][char.to_sym] = running_total + 1
end
prefix_sums.each_with_index do |p, i|
puts "i: #{i}, p: #{p}"
end
end
Analysis
expand all
Example tests
1.
0.103 s
RUNTIME ERROR,
tested program terminated unexpectedly
stderr:
Invalid result type, Integer expected, Hash foundstdout:
char: C
char: A
char: G
char: C
char: C
char: T
char: A
i: 0, p: {:A=>0, :C=>1, :G=>0, :T=>0}
i: 1, p: {:A=>1, :C=>0, :G=>0, :T=>0}
i: 2, p: {:A=>0, :C=>0, :G=>1, :T=>0}
i: 3, p: {:A=>0, :C=>1, :G=>0, :T=>0}
i: 4, p: {:A=>0, :C=>2, :G=>0, :T=>0}
i: 5, p: {:A=>0, :C=>0, :G=>0, :T=>1}
i: 6, p: {:A=>1, :C=>0, :G=>0, :T=>0}
Code: 15:22:31 UTC,
rb,
verify,
result: Failed
def solution(string, slice_start, slice_end)
# The challenge here is to find a way to return
# the minimum value present in an array slice in
# without having to iterate through the entire
# slice – i.e. in constant O(1) time.
# Initialise an array to hold the number of
# times each character occurs at each point
# in the original string. It's just a running
# total for each character.
prefix_sums = Array.new(string.length) { { A: 0, C: 0, G: 0, T: 0 } }
# Iterating through each character, increment
# the counter for that character at that position.
string.split('').each_with_index do |char, i|
prefix_sums[i].each do |k, v|
prefix_sums[i][k] = prefix_sums[i - 1][k]
end
prefix_sums[i][char.to_sym] += 1
end
prefix_sums.each_with_index do |p, i|
puts "i: #{i}, p: #{p}"
end
end
Analysis
expand all
Example tests
1.
0.112 s
RUNTIME ERROR,
tested program terminated unexpectedly
stderr:
Invalid result type, Integer expected, Hash foundstdout:
i: 0, p: {:A=>0, :C=>1, :G=>0, :T=>0}
i: 1, p: {:A=>1, :C=>1, :G=>0, :T=>0}
i: 2, p: {:A=>1, :C=>1, :G=>1, :T=>0}
i: 3, p: {:A=>1, :C=>2, :G=>1, :T=>0}
i: 4, p: {:A=>1, :C=>3, :G=>1, :T=>0}
i: 5, p: {:A=>1, :C=>3, :G=>1, :T=>1}
i: 6, p: {:A=>2, :C=>3, :G=>1, :T=>1}
Code: 15:34:33 UTC,
rb,
verify,
result: Failed
def solution(string, slice_start, slice_end)
# The challenge here is to find a way to return
# the minimum value present in an array slice in
# without having to iterate through the entire
# slice – i.e. in constant O(1) time.
# Initialise an array to hold the number of
# times each character occurs at each point
# in the original string. It's just a running
# total for each character.
prefix_sums = Array.new(string.length) { { A: 0, C: 0, G: 0, T: 0 } }
# Iterate through the original string,
# incrementing the counters.
string.split('').each_with_index do |char, i|
prefix_sums[i].each do |k, v|
# Set each value at this index to whatever
# it was last index, so the counters grow.
prefix_sums[i][k] = prefix_sums[i - 1][k]
end
# Increment the counter for this character.
prefix_sums[i][char.to_sym] += 1
end
# For each slice, we can now look up whether the
# character occured by looking at the total for
# that character at the beginning and end of the
# slice.
slice_start.each_with_index.map do |s, i|
e = slice_end[i]
prefix_sums[0].each do |char, v|
# Subtracting the number of occurences at the
# end of the range from the same number at the
# start tells us if the character occured.
break s if (prefix_sums[s] - prefix_sums[e]) > 0
end
end
end
Analysis
expand all
Example tests
1.
0.100 s
RUNTIME ERROR,
tested program terminated unexpectedly
stderr:
user.rb:37:in `block (2 levels) in solution': undefined method `-' for {:A=>1, :C=>1, :G=>1, :T=>0}:Hash (NoMethodError)
from user.rb:33:in `each'
from user.rb:33:in `block in solution'
from user.rb:30:in `each'
from user.rb:30:in `each_with_index'
from user.rb:30:in `each'
from user.rb:30:in `map'
from user.rb:30:in `solution'
from user.rb:163:in `<main>'
Code: 15:34:52 UTC,
rb,
verify,
result: Failed
def solution(string, slice_start, slice_end)
# The challenge here is to find a way to return
# the minimum value present in an array slice in
# without having to iterate through the entire
# slice – i.e. in constant O(1) time.
# Initialise an array to hold the number of
# times each character occurs at each point
# in the original string. It's just a running
# total for each character.
prefix_sums = Array.new(string.length) { { A: 0, C: 0, G: 0, T: 0 } }
# Iterate through the original string,
# incrementing the counters.
string.split('').each_with_index do |char, i|
prefix_sums[i].each do |k, v|
# Set each value at this index to whatever
# it was last index, so the counters grow.
prefix_sums[i][k] = prefix_sums[i - 1][k]
end
# Increment the counter for this character.
prefix_sums[i][char.to_sym] += 1
end
# For each slice, we can now look up whether the
# character occured by looking at the total for
# that character at the beginning and end of the
# slice.
slice_start.each_with_index.map do |s, i|
e = slice_end[i]
prefix_sums[0].each do |char, v|
# Subtracting the number of occurences at the
# end of the range from the same number at the
# start tells us if the character occured.
break s if (prefix_sums[s][char] - prefix_sums[e][char]) > 0
end
end
end
Analysis
expand all
Example tests
1.
0.098 s
RUNTIME ERROR,
tested program terminated unexpectedly
stderr:
Invalid result type, Integer expected, Hash found
Code: 15:36:01 UTC,
rb,
verify,
result: Failed
def solution(string, slice_start, slice_end)
# The challenge here is to find a way to return
# the minimum value present in an array slice in
# without having to iterate through the entire
# slice – i.e. in constant O(1) time.
# Initialise an array to hold the number of
# times each character occurs at each point
# in the original string. It's just a running
# total for each character.
prefix_sums = Array.new(string.length) { { A: 0, C: 0, G: 0, T: 0 } }
# Iterate through the original string,
# incrementing the counters.
string.split('').each_with_index do |char, i|
prefix_sums[i].each do |k, v|
# Set each value at this index to whatever
# it was last index, so the counters grow.
prefix_sums[i][k] = prefix_sums[i - 1][k]
end
# Increment the counter for this character.
prefix_sums[i][char.to_sym] += 1
end
# For each slice, we can now look up whether the
# character occured by looking at the total for
# that character at the beginning and end of the
# slice.
r = slice_start.each_with_index.map do |s, i|
e = slice_end[i]
prefix_sums[0].each do |char, v|
# Subtracting the number of occurences at the
# end of the range from the same number at the
# start tells us if the character occured.
break s if (prefix_sums[s][char] - prefix_sums[e][char]) > 0
end
end
puts r
r
end
Analysis
expand all
Example tests
1.
0.117 s
RUNTIME ERROR,
tested program terminated unexpectedly
stderr:
Invalid result type, Integer expected, Hash foundstdout:
{:A=>0, :C=>1, :G=>0, :T=>0}
{:A=>0, :C=>1, :G=>0, :T=>0}
{:A=>0, :C=>1, :G=>0, :T=>0}
Code: 15:42:18 UTC,
rb,
verify,
result: Failed
def solution(string, slice_start, slice_end)
# The challenge here is to find a way to return
# the minimum value present in an array slice in
# without having to iterate through the entire
# slice – i.e. in constant O(1) time.
m = slice_start.length
# Initialise an array to hold the number of
# times each character occurs at each point
# in the original string. It's just a running
# total for each character.
prefix_sums = Array.new(string.length) { { A: 0, C: 0, G: 0, T: 0 } }
# Iterate through the original string,
# incrementing the counters.
string.split('').each_with_index do |char, i|
prefix_sums[i].each do |k, v|
# Set each value at this index to whatever
# it was last index, so the counters grow.
prefix_sums[i][k] = prefix_sums[i - 1][k]
end
# Increment the counter for this character.
prefix_sums[i][char.to_sym] += 1
end
# For each slice, we can now look up whether each
# character occured.
chars = prefix_sums[0].keys
(0..m).map do |i|
s = slice_start[i]
e = slice_end[i]
chars.detect do |char|
# Subtracting the number of occurences at the
# end of the range from the same number at the
# start tells us if the character occured.
(prefix_sums[s][char] - prefix_sums[e][char]) > 0
end
end
puts r
r
end
Analysis
expand all
Example tests
1.
0.111 s
RUNTIME ERROR,
tested program terminated unexpectedly
stderr:
user.rb:38:in `[]': no implicit conversion from nil to integer (TypeError) from user.rb:38:in `block (2 levels) in solution' from user.rb:34:in `each' from user.rb:34:in `detect' from user.rb:34:in `block in solution' from user.rb:30:in `each' from user.rb:30:in `map' from user.rb:30:in `solution' from user.rb:167:in `<main>'
Code: 15:42:44 UTC,
rb,
verify,
result: Failed
def solution(string, slice_start, slice_end)
# The challenge here is to find a way to return
# the minimum value present in an array slice in
# without having to iterate through the entire
# slice – i.e. in constant O(1) time.
m = slice_start.length
# Initialise an array to hold the number of
# times each character occurs at each point
# in the original string. It's just a running
# total for each character.
prefix_sums = Array.new(string.length) { { A: 0, C: 0, G: 0, T: 0 } }
# Iterate through the original string,
# incrementing the counters.
string.split('').each_with_index do |char, i|
prefix_sums[i].each do |k, v|
# Set each value at this index to whatever
# it was last index, so the counters grow.
prefix_sums[i][k] = prefix_sums[i - 1][k]
end
# Increment the counter for this character.
prefix_sums[i][char.to_sym] += 1
end
# For each slice, we can now look up whether each
# character occured.
chars = prefix_sums[0].keys
(0..m).map do |i|
s = slice_start[i]
e = slice_end[i]
chars.detect do |char|
puts "char: #{char}"
# Subtracting the number of occurences at the
# end of the range from the same number at the
# start tells us if the character occured.
(prefix_sums[s][char] - prefix_sums[e][char]) > 0
end
end
puts r
r
end
Analysis
expand all
Example tests
1.
0.104 s
RUNTIME ERROR,
tested program terminated unexpectedly
stderr:
user.rb:39:in `[]': no implicit conversion from nil to integer (TypeError) from user.rb:39:in `block (2 levels) in solution' from user.rb:34:in `each' from user.rb:34:in `detect' from user.rb:34:in `block in solution' from user.rb:30:in `each' from user.rb:30:in `map' from user.rb:30:in `solution' from user.rb:168:in `<main>'stdout:
char: A char: C char: G char: T char: A char: C char: G char: T char: A char: C char: G char: T char: A
Code: 15:42:59 UTC,
rb,
verify,
result: Failed
def solution(string, slice_start, slice_end)
# The challenge here is to find a way to return
# the minimum value present in an array slice in
# without having to iterate through the entire
# slice – i.e. in constant O(1) time.
m = slice_start.length
# Initialise an array to hold the number of
# times each character occurs at each point
# in the original string. It's just a running
# total for each character.
prefix_sums = Array.new(string.length) { { A: 0, C: 0, G: 0, T: 0 } }
# Iterate through the original string,
# incrementing the counters.
string.split('').each_with_index do |char, i|
prefix_sums[i].each do |k, v|
# Set each value at this index to whatever
# it was last index, so the counters grow.
prefix_sums[i][k] = prefix_sums[i - 1][k]
end
# Increment the counter for this character.
prefix_sums[i][char.to_sym] += 1
end
# For each slice, we can now look up whether each
# character occured.
chars = prefix_sums[0].keys
(0..m).map do |i|
s = slice_start[i]
e = slice_end[i]
chars.detect do |char|
puts "char: #{char}, #{char.inspect}, #{char.class}"
# Subtracting the number of occurences at the
# end of the range from the same number at the
# start tells us if the character occured.
(prefix_sums[s][char] - prefix_sums[e][char]) > 0
end
end
puts r
r
end
Analysis
expand all
Example tests
1.
0.110 s
RUNTIME ERROR,
tested program terminated unexpectedly
stderr:
user.rb:39:in `[]': no implicit conversion from nil to integer (TypeError) from user.rb:39:in `block (2 levels) in solution' from user.rb:34:in `each' from user.rb:34:in `detect' from user.rb:34:in `block in solution' from user.rb:30:in `each' from user.rb:30:in `map' from user.rb:30:in `solution' from user.rb:168:in `<main>'stdout:
char: A, :A, Symbol char: C, :C, Symbol char: G, :G, Symbol char: T, :T, Symbol char: A, :A, Symbol char: C, :C, Symbol char: G, :G, Symbol char: T, :T, Symbol char: A, :A, Symbol char: C, :C, Symbol char: G, :G, Symbol char: T, :T, Symbol char: A, :A, Symbol
Code: 15:43:45 UTC,
rb,
verify,
result: Failed
def solution(string, slice_start, slice_end)
# The challenge here is to find a way to return
# the minimum value present in an array slice in
# without having to iterate through the entire
# slice – i.e. in constant O(1) time.
m = slice_start.length
# Initialise an array to hold the number of
# times each character occurs at each point
# in the original string. It's just a running
# total for each character.
prefix_sums = Array.new(string.length) { { A: 0, C: 0, G: 0, T: 0 } }
# Iterate through the original string,
# incrementing the counters.
string.split('').each_with_index do |char, i|
prefix_sums[i].each do |k, v|
# Set each value at this index to whatever
# it was last index, so the counters grow.
prefix_sums[i][k] = prefix_sums[i - 1][k]
end
# Increment the counter for this character.
prefix_sums[i][char.to_sym] += 1
end
# For each slice, we can now look up whether each
# character occured.
chars = prefix_sums[0].keys
(0..m).map do |i|
s = slice_start[i]
e = slice_end[i]
chars.detect do |char|
puts "char: #{char}, #{char.inspect}, #{char.class}"
puts "slice s: #{prefix_sums[s][char]}"
puts "slice e: #{prefix_sums[e][char]}"
# Subtracting the number of occurences at the
# end of the range from the same number at the
# start tells us if the character occured.
(prefix_sums[s][char] - prefix_sums[e][char]) > 0
end
end
puts r
r
end
Analysis
expand all
Example tests
1.
0.112 s
RUNTIME ERROR,
tested program terminated unexpectedly
stderr:
user.rb:36:in `[]': no implicit conversion from nil to integer (TypeError) from user.rb:36:in `block (2 levels) in solution' from user.rb:34:in `each' from user.rb:34:in `detect' from user.rb:34:in `block in solution' from user.rb:30:in `each' from user.rb:30:in `map' from user.rb:30:in `solution' from user.rb:170:in `<main>'stdout:
char: A, :A, Symbol slice s: 1 slice e: 1 char: C, :C, Symbol slice s: 1 slice e: 3 char: G, :G, Symbol slice s: 1 slice e: 1 char: T, :T, Symbol slice s: 0 slice e: 0 char: A, :A, Symbol slice s: 1 slice e: 1 char: C, :C, Symbol slice s: 3 slice e: 3 char: G, :G, Symbol slice s: 1 slice e: 1 char: T, :T, Symbol slice s: 1 slice e: 1 char: A, :A, Symbol slice s: 0 slice e: 2 char: C, :C, Symbol slice s: 1 slice e: 3 char: G, :G, Symbol slice s: 0 slice e: 1 char: T, :T, Symbol slice s: 0 slice e: 1 char: A, :A, Symbol
Code: 15:44:19 UTC,
rb,
verify,
result: Failed
def solution(string, slice_start, slice_end)
# The challenge here is to find a way to return
# the minimum value present in an array slice in
# without having to iterate through the entire
# slice – i.e. in constant O(1) time.
m = slice_start.length
# Initialise an array to hold the number of
# times each character occurs at each point
# in the original string. It's just a running
# total for each character.
prefix_sums = Array.new(string.length) { { A: 0, C: 0, G: 0, T: 0 } }
# Iterate through the original string,
# incrementing the counters.
string.split('').each_with_index do |char, i|
prefix_sums[i].each do |k, v|
# Set each value at this index to whatever
# it was last index, so the counters grow.
prefix_sums[i][k] = prefix_sums[i - 1][k]
end
# Increment the counter for this character.
prefix_sums[i][char.to_sym] += 1
end
# For each slice, we can now look up whether each
# character occured.
chars = prefix_sums[0].keys
(0..m).map do |i|
s = slice_start[i]
e = slice_end[i]
chars.detect do |char|
puts "char: #{char}, #{char.inspect}, #{char.class}"
puts "slice s: #{prefix_sums[s][char]}"
puts "slice e: #{prefix_sums[e][char]}"
# Subtracting the number of occurences at the
# end of the range from the same number at the
# start tells us if the character occured.
(prefix_sums[e][char] - prefix_sums[s][char]) > 0
end
end
puts r
r
end
Analysis
expand all
Example tests
1.
0.111 s
RUNTIME ERROR,
tested program terminated unexpectedly
stderr:
user.rb:36:in `[]': no implicit conversion from nil to integer (TypeError) from user.rb:36:in `block (2 levels) in solution' from user.rb:34:in `each' from user.rb:34:in `detect' from user.rb:34:in `block in solution' from user.rb:30:in `each' from user.rb:30:in `map' from user.rb:30:in `solution' from user.rb:170:in `<main>'stdout:
char: A, :A, Symbol slice s: 1 slice e: 1 char: C, :C, Symbol slice s: 1 slice e: 3 char: A, :A, Symbol slice s: 1 slice e: 1 char: C, :C, Symbol slice s: 3 slice e: 3 char: G, :G, Symbol slice s: 1 slice e: 1 char: T, :T, Symbol slice s: 1 slice e: 1 char: A, :A, Symbol slice s: 0 slice e: 2 char: A, :A, Symbol
Code: 15:45:22 UTC,
rb,
verify,
result: Failed
def solution(string, slice_start, slice_end)
# The challenge here is to find a way to return
# the minimum value present in an array slice in
# without having to iterate through the entire
# slice – i.e. in constant O(1) time.
m = slice_start.length - 1
# Initialise an array to hold the number of
# times each character occurs at each point
# in the original string. It's just a running
# total for each character.
prefix_sums = Array.new(string.length) { { A: 0, C: 0, G: 0, T: 0 } }
# Iterate through the original string,
# incrementing the counters.
string.split('').each_with_index do |char, i|
prefix_sums[i].each do |k, v|
# Set each value at this index to whatever
# it was last index, so the counters grow.
prefix_sums[i][k] = prefix_sums[i - 1][k]
end
# Increment the counter for this character.
prefix_sums[i][char.to_sym] += 1
end
# For each slice, we can now look up whether each
# character occured.
chars = prefix_sums[0].keys
(0..m).map do |i|
s = slice_start[i]
e = slice_end[i]
chars.detect do |char|
puts "char: #{char}, #{char.inspect}, #{char.class}"
puts "slice s: #{prefix_sums[s][char]}"
puts "slice e: #{prefix_sums[e][char]}"
# Subtracting the number of occurences at the
# end of the range from the same number at the
# start tells us if the character occured.
(prefix_sums[e][char] - prefix_sums[s][char]) > 0
end
end
puts r
r
end
Analysis
expand all
Example tests
1.
0.097 s
RUNTIME ERROR,
tested program terminated unexpectedly
stderr:
user.rb:45:in `solution': undefined local variable or method `r' for main:Object (NameError) from user.rb:170:in `<main>'stdout:
char: A, :A, Symbol slice s: 1 slice e: 1 char: C, :C, Symbol slice s: 1 slice e: 3 char: A, :A, Symbol slice s: 1 slice e: 1 char: C, :C, Symbol slice s: 3 slice e: 3 char: G, :G, Symbol slice s: 1 slice e: 1 char: T, :T, Symbol slice s: 1 slice e: 1 char: A, :A, Symbol slice s: 0 slice e: 2
Code: 15:45:41 UTC,
rb,
verify,
result: Failed
def solution(string, slice_start, slice_end)
# The challenge here is to find a way to return
# the minimum value present in an array slice in
# without having to iterate through the entire
# slice – i.e. in constant O(1) time.
m = slice_start.length - 1
# Initialise an array to hold the number of
# times each character occurs at each point
# in the original string. It's just a running
# total for each character.
prefix_sums = Array.new(string.length) { { A: 0, C: 0, G: 0, T: 0 } }
# Iterate through the original string,
# incrementing the counters.
string.split('').each_with_index do |char, i|
prefix_sums[i].each do |k, v|
# Set each value at this index to whatever
# it was last index, so the counters grow.
prefix_sums[i][k] = prefix_sums[i - 1][k]
end
# Increment the counter for this character.
prefix_sums[i][char.to_sym] += 1
end
# For each slice, we can now look up whether each
# character occured.
chars = prefix_sums[0].keys
(0..m).map do |i|
s = slice_start[i]
e = slice_end[i]
chars.detect do |char|
puts "char: #{char}, #{char.inspect}, #{char.class}"
puts "slice s: #{prefix_sums[s][char]}"
puts "slice e: #{prefix_sums[e][char]}"
# Subtracting the number of occurences at the
# end of the range from the same number at the
# start tells us if the character occured.
(prefix_sums[e][char] - prefix_sums[s][char]) > 0
end
end
end
Analysis
expand all
Example tests
1.
0.100 s
RUNTIME ERROR,
tested program terminated unexpectedly
stderr:
Invalid result type, Integer expected, Symbol foundstdout:
char: A, :A, Symbol slice s: 1 slice e: 1 char: C, :C, Symbol slice s: 1 slice e: 3 char: A, :A, Symbol slice s: 1 slice e: 1 char: C, :C, Symbol slice s: 3 slice e: 3 char: G, :G, Symbol slice s: 1 slice e: 1 char: T, :T, Symbol slice s: 1 slice e: 1 char: A, :A, Symbol slice s: 0 slice e: 2
Code: 15:48:58 UTC,
rb,
verify,
result: Failed
def solution(string, slice_start, slice_end)
# The challenge here is to find a way to return
# the minimum value present in an array slice in
# without having to iterate through the entire
# slice – i.e. in constant O(1) time.
m = slice_start.length - 1
# Initialise an array to hold the number of
# times each character occurs at each point
# in the original string. It's just a running
# total for each character.
prefix_sums = Array.new(string.length) { { A: 0, C: 0, G: 0, T: 0 } }
# Iterate through the original string,
# incrementing the counters.
string.split('').each_with_index do |char, i|
prefix_sums[i].each do |k, v|
# Set each value at this index to whatever
# it was last index, so the counters grow.
prefix_sums[i][k] = prefix_sums[i - 1][k]
end
# Increment the counter for this character.
prefix_sums[i][char.to_sym] += 1
end
# For each slice, we can now look up whether each
# character occured and find the lowest.
chars = prefix_sums[0].keys
(0..m).map do |i|
s = slice_start[i]
e = slice_end[i]
lowest_char = chars.detect do |char|
puts "char: #{char}, #{char.inspect}, #{char.class}"
puts "slice s: #{prefix_sums[s][char]}"
puts "slice e: #{prefix_sums[e][char]}"
# Subtracting the number of occurences at the
# end of the range from the same number at the
# start tells us if the character occured.
(prefix_sums[e][char] - prefix_sums[s][char]) > 0
end
chars.index(lowest_char) + 1
end
end
Analysis
expand all
Example tests
1.
0.099 s
RUNTIME ERROR,
tested program terminated unexpectedly
stderr:
user.rb:44:in `block in solution': undefined method `+' for nil:NilClass (NoMethodError) from user.rb:30:in `each' from user.rb:30:in `map' from user.rb:30:in `solution' from user.rb:169:in `<main>'stdout:
char: A, :A, Symbol slice s: 1 slice e: 1 char: C, :C, Symbol slice s: 1 slice e: 3 char: A, :A, Symbol slice s: 1 slice e: 1 char: C, :C, Symbol slice s: 3 slice e: 3 char: G, :G, Symbol slice s: 1 slice e: 1 char: T, :T, Symbol slice s: 1 slice e: 1
Code: 15:50:47 UTC,
rb,
verify,
result: Failed
def solution(string, slice_start, slice_end)
# The challenge here is to find a way to return
# the minimum value present in an array slice in
# without having to iterate through the entire
# slice – i.e. in constant O(1) time.
m = slice_start.length - 1
# Initialise an array to hold the number of
# times each character occurs at each point
# in the original string. It's just a running
# total for each character.
prefix_sums = Array.new(string.length) { { A: 0, C: 0, G: 0, T: 0 } }
# Iterate through the original string,
# incrementing the counters.
string.split('').each_with_index do |char, i|
prefix_sums[i].each do |k, v|
# Set each value at this index to whatever
# it was last index, so the counters grow.
prefix_sums[i][k] = prefix_sums[i - 1][k]
end
# Increment the counter for this character.
prefix_sums[i][char.to_sym] += 1
end
# For each slice, we can now look up whether each
# character occured and find the lowest.
chars = prefix_sums[0].keys
(0..m).map do |i|
s = slice_start[i]
e = slice_end[i]
lowest_char = chars.detect do |char|
puts "char: #{char}, #{char.inspect}, #{char.class}"
puts "slice s: #{prefix_sums[s][char]}"
puts "slice e: #{prefix_sums[e][char]}"
# Subtracting the number of occurences at the
# end of the range from the same number at the
# start tells us if the character occured.
(prefix_sums[e][char] - prefix_sums[s][char]) > 0
end
chars.index(lowest_char)
end
end
Analysis
expand all
Example tests
1.
0.099 s
RUNTIME ERROR,
tested program terminated unexpectedly
stderr:
Invalid result type, Integer expected, NilClass foundstdout:
char: A, :A, Symbol slice s: 1 slice e: 1 char: C, :C, Symbol slice s: 1 slice e: 3 char: A, :A, Symbol slice s: 1 slice e: 1 char: C, :C, Symbol slice s: 3 slice e: 3 char: G, :G, Symbol slice s: 1 slice e: 1 char: T, :T, Symbol slice s: 1 slice e: 1 char: A, :A, Symbol slice s: 0 slice e: 2
Code: 15:51:33 UTC,
rb,
verify,
result: Failed
def solution(string, slice_start, slice_end)
# The challenge here is to find a way to return
# the minimum value present in an array slice in
# without having to iterate through the entire
# slice – i.e. in constant O(1) time.
m = slice_start.length - 1
# Initialise an array to hold the number of
# times each character occurs at each point
# in the original string. It's just a running
# total for each character.
prefix_sums = Array.new(string.length) { { A: 0, C: 0, G: 0, T: 0 } }
# Iterate through the original string,
# incrementing the counters.
string.split('').each_with_index do |char, i|
prefix_sums[i].each do |k, v|
# Set each value at this index to whatever
# it was last index, so the counters grow.
prefix_sums[i][k] = prefix_sums[i - 1][k]
end
# Increment the counter for this character.
prefix_sums[i][char.to_sym] += 1
end
# For each slice, we can now look up whether each
# character occured and find the lowest.
chars = prefix_sums[0].keys
(0..m).map do |i|
s = slice_start[i]
e = slice_end[i]
lowest_char = chars.detect do |char|
puts "char: #{char}, #{char.inspect}, #{char.class}"
puts "slice s: #{prefix_sums[s]}"
puts "slice e: #{prefix_sums[e]}"
# Subtracting the number of occurences at the
# end of the range from the same number at the
# start tells us if the character occured.
(prefix_sums[e][char] - prefix_sums[s][char]) > 0
end
puts "lowest_char: #{lowest_char}"
chars.index(lowest_char)
end
end
Analysis
expand all
Example tests
1.
0.100 s
RUNTIME ERROR,
tested program terminated unexpectedly
stderr:
Invalid result type, Integer expected, NilClass foundstdout:
char: A, :A, Symbol
slice s: {:A=>1, :C=>1, :G=>1, :T=>0}
slice e: {:A=>1, :C=>3, :G=>1, :T=>0}
char: C, :C, Symbol
slice s: {:A=>1, :C=>1, :G=>1, :T=>0}
slice e: {:A=>1, :C=>3, :G=>1, :T=>0}
lowest_char: C
char: A, :A, Symbol
slice s: {:A=>1, :C=>3, :G=>1, :T=>1}
slice e: {:A=>1, :C=>3, :G=>1, :T=>1}
char: C, :C, Symbol
slice s: {:A=>1, :C=>3, :G=>1, :T=>1}
slice e: {:A=>1, :C=>3, :G=>1, :T=>1}
char: G, :G, Symbol
slice s: {:A=>1, :C=>3, :G=>1, :T=>1}
slice e: {:A=>1, :C=>3, :G=>1, :T=>1}
char: T, :T, Symbol
slice s: {:A=>1, :C=>3, :G=>1, :T=>1}
slice e: {:A=>1, :C=>3, :G=>1, :T=>1}
lowest_char:
char: A, :A, Symbol
slice s: {:A=>0, :C=>1, :G=>0, :T=>0}
slice e: {:A=>2, :C=>3, :G=>1, :T=>1}
lowest_char: A
Code: 15:52:47 UTC,
rb,
verify,
result: Failed
def solution(input_string, slice_start, slice_end)
# The challenge here is to find a way to return
# the minimum value present in an array slice in
# without having to iterate through the entire
# slice – i.e. in constant O(1) time.
m = slice_start.length - 1
# Initialise an array to hold the number of
# times each character occurs at each point
# in the original string. It's just a running
# total for each character.
prefix_sums = Array.new(string.length) { { A: 0, C: 0, G: 0, T: 0 } }
# Iterate through the original string,
# incrementing the counters.
input_string.split('').each_with_index do |char, i|
prefix_sums[i].each do |k, v|
# Set each value at this index to whatever
# it was last index, so the counters grow.
prefix_sums[i][k] = prefix_sums[i - 1][k]
end
# Increment the counter for this character.
prefix_sums[i][char.to_sym] += 1
end
# For each slice, we can now look up whether each
# character occured and find the lowest.
chars = prefix_sums[0].keys
(0..m).map do |i|
s = slice_start[i]
e = slice_end[i]
lowest_char = chars.detect do |char|
puts "char: #{char}, #{char.inspect}, #{char.class}"
puts "slice: #{s}..#{e} (...#{input_string[s..e]}...)"
# Subtracting the number of occurences at the
# end of the range from the same number at the
# start tells us if the character occured.
(prefix_sums[e][char] - prefix_sums[s][char]) > 0
end
puts "lowest_char: #{lowest_char}"
chars.index(lowest_char)
end
end
Analysis
expand all
Example tests
1.
0.099 s
RUNTIME ERROR,
tested program terminated unexpectedly
stderr:
user.rb:12:in `solution': undefined local variable or method `string' for main:Object (NameError) from user.rb:169:in `<main>'
Code: 15:53:13 UTC,
rb,
verify,
result: Failed
def solution(input_str, slice_start, slice_end)
# The challenge here is to find a way to return
# the minimum value present in an array slice in
# without having to iterate through the entire
# slice – i.e. in constant O(1) time.
m = slice_start.length - 1
# Initialise an array to hold the number of
# times each character occurs at each point
# in the original string. It's just a running
# total for each character.
prefix_sums = Array.new(input_str.length) { { A: 0, C: 0, G: 0, T: 0 } }
# Iterate through the original string,
# incrementing the counters.
input_str.split('').each_with_index do |char, i|
prefix_sums[i].each do |k, v|
# Set each value at this index to whatever
# it was last index, so the counters grow.
prefix_sums[i][k] = prefix_sums[i - 1][k]
end
# Increment the counter for this character.
prefix_sums[i][char.to_sym] += 1
end
# For each slice, we can now look up whether each
# character occured and find the lowest.
chars = prefix_sums[0].keys
(0..m).map do |i|
s = slice_start[i]
e = slice_end[i]
lowest_char = chars.detect do |char|
puts "char: #{char}, #{char.inspect}, #{char.class}"
puts "slice: #{s}..#{e} (...#{input_str[s..e]}...)"
# Subtracting the number of occurences at the
# end of the range from the same number at the
# start tells us if the character occured.
(prefix_sums[e][char] - prefix_sums[s][char]) > 0
end
puts "lowest_char: #{lowest_char}"
chars.index(lowest_char)
end
end
Analysis
expand all
Example tests
1.
0.100 s
RUNTIME ERROR,
tested program terminated unexpectedly
stderr:
Invalid result type, Integer expected, NilClass foundstdout:
char: A, :A, Symbol slice: 2..4 (...GCC...) char: C, :C, Symbol slice: 2..4 (...GCC...) lowest_char: C char: A, :A, Symbol slice: 5..5 (...T...) char: C, :C, Symbol slice: 5..5 (...T...) char: G, :G, Symbol slice: 5..5 (...T...) char: T, :T, Symbol slice: 5..5 (...T...) lowest_char: char: A, :A, Symbol slice: 0..6 (...CAGCCTA...) lowest_char: A
Code: 15:55:10 UTC,
rb,
verify,
result: Failed
def solution(input_str, slice_start, slice_end)
# The challenge here is to find a way to return
# the minimum value present in an array slice in
# without having to iterate through the entire
# slice – i.e. in constant O(1) time.
m = slice_start.length - 1
# Initialise an array to hold the number of
# times each character occurs at each point
# in the original string. It's just a running
# total for each character.
prefix_sums = Array.new(input_str.length) { { A: 0, C: 0, G: 0, T: 0 } }
# Iterate through the original string,
# incrementing the counters.
input_str.split('').each_with_index do |char, i|
prefix_sums[i].each do |k, v|
# Set each value at this index to whatever
# it was last index, so the counters grow.
prefix_sums[i][k] = prefix_sums[i - 1][k]
end
# Increment the counter for this character.
prefix_sums[i][char.to_sym] += 1
end
# For each slice, we can now look up whether each
# character occured and find the lowest.
chars = prefix_sums[0].keys
(0..m).map do |i|
s = slice_start[i]
e = slice_end[i]
lowest_char = chars.detect do |char|
puts "char: #{char}, #{char.inspect}, #{char.class}"
puts " slice: #{s}..#{e} (...#{input_str[s..e]}...)"
puts " start: #{prefix_sums[s][char]}"
puts " end: #{prefix_sums[e][char]}"
# Subtracting the number of occurences at the
# end of the range from the same number at the
# start tells us if the character occured.
(prefix_sums[e][char] - prefix_sums[s][char]) > 0
end
puts "lowest_char: #{lowest_char}"
chars.index(lowest_char)
end
end
Analysis
expand all
Example tests
1.
0.103 s
RUNTIME ERROR,
tested program terminated unexpectedly
stderr:
Invalid result type, Integer expected, NilClass foundstdout:
char: A, :A, Symbol slice: 2..4 (...GCC...) start: 1 end: 1 char: C, :C, Symbol slice: 2..4 (...GCC...) start: 1 end: 3 lowest_char: C char: A, :A, Symbol slice: 5..5 (...T...) start: 1 end: 1 char: C, :C, Symbol slice: 5..5 (...T...) start: 3 end: 3 char: G, :G, Symbol slice: 5..5 (...T...) start: 1 end: 1 char: T, :T, Symbol slice: 5..5 (...T...) start: 1 end: 1 lowest_char: char: A, :A, Symbol slice: 0..6 (...CAGCCTA...) start: 0 end: 2 lowest_char: A
Code: 16:02:19 UTC,
rb,
verify,
result: Failed
def solution(input_str, slice_start, slice_end)
# The challenge here is to find a way to return
# the minimum value present in an array slice in
# without having to iterate through the entire
# slice – i.e. in constant O(1) time.
m = slice_start.length - 1
# Initialise an array to hold the number of
# times each character occurs at each point
# in the original string. It's just a running
# total for each character.
prefix_sums = Array.new(input_str.length) { { A: 0, C: 0, G: 0, T: 0 } }
# Iterate through the original string,
# incrementing the counters.
input_str.split('').each_with_index do |char, i|
prefix_sums[i].each do |k, v|
# Set each value at this index to whatever
# it was last index, so the counters grow.
prefix_sums[i][k] = prefix_sums[i - 1][k]
end
# Increment the counter for this character.
prefix_sums[i][char.to_sym] += 1
end
# For each slice, we can now look up whether each
# character occured and find the lowest.
chars = prefix_sums[0].keys
(0..m).map do |i|
s = slice_start[i]
e = slice_end[i]
lowest_char = chars.detect do |char|
# Subtracting the number of occurences at the
# end of the range from the same number at the
# start tells us if the character occured.
(prefix_sums[e + 1][char] - prefix_sums[s][char]) > 0
end
puts "lowest_char: #{lowest_char}"
chars.index(lowest_char)
end
end
Analysis
expand all
Example tests
1.
0.118 s
RUNTIME ERROR,
tested program terminated unexpectedly
stderr:
user.rb:38:in `block (2 levels) in solution': undefined method `[]' for nil:NilClass (NoMethodError) from user.rb:34:in `each' from user.rb:34:in `detect' from user.rb:34:in `block in solution' from user.rb:30:in `each' from user.rb:30:in `map' from user.rb:30:in `solution' from user.rb:167:in `<main>'stdout:
lowest_char: C lowest_char: A
Code: 16:03:11 UTC,
rb,
verify,
result: Failed
def solution(input_str, slice_start, slice_end)
# The challenge here is to find a way to return
# the minimum value present in an array slice in
# without having to iterate through the entire
# slice – i.e. in constant O(1) time.
m = slice_start.length - 1
# Initialise an array to hold the number of
# times each character occurs at each point
# in the original string. It's just a running
# total for each character.
prefix_sums = Array.new(input_str.length) { { A: 0, C: 0, G: 0, T: 0 } }
# Iterate through the original string,
# incrementing the counters.
input_str.split('').each_with_index do |char, i|
prefix_sums[i].each do |k, v|
# Set each value at this index to whatever
# it was last index, so the counters grow.
prefix_sums[i][k] = prefix_sums[i - 1][k]
end
# Increment the counter for this character.
prefix_sums[i][char.to_sym] += 1
end
# For each slice, we can now look up whether each
# character occured and find the lowest.
chars = prefix_sums[0].keys
(0..m).map do |i|
s = slice_start[i]
e = slice_end[i]
lowest_char = chars.detect do |char|
return char if s == e && prefix_sums[s][char] == prefix_sums[e][char]
# Subtracting the number of occurences at the
# end of the range from the same number at the
# start tells us if the character occured.
(prefix_sums[e][char] - prefix_sums[s][char]) > 0
end
chars.index(lowest_char)
end
end
Analysis
expand all
Example tests
1.
0.098 s
RUNTIME ERROR,
tested program terminated unexpectedly
stderr:
Invalid result type, Integer expected, String found
Code: 16:03:36 UTC,
rb,
verify,
result: Failed
def solution(input_str, slice_start, slice_end)
# The challenge here is to find a way to return
# the minimum value present in an array slice in
# without having to iterate through the entire
# slice – i.e. in constant O(1) time.
m = slice_start.length - 1
# Initialise an array to hold the number of
# times each character occurs at each point
# in the original string. It's just a running
# total for each character.
prefix_sums = Array.new(input_str.length) { { A: 0, C: 0, G: 0, T: 0 } }
# Iterate through the original string,
# incrementing the counters.
input_str.split('').each_with_index do |char, i|
prefix_sums[i].each do |k, v|
# Set each value at this index to whatever
# it was last index, so the counters grow.
prefix_sums[i][k] = prefix_sums[i - 1][k]
end
# Increment the counter for this character.
prefix_sums[i][char.to_sym] += 1
end
# For each slice, we can now look up whether each
# character occured and find the lowest.
chars = prefix_sums[0].keys
(0..m).map do |i|
s = slice_start[i]
e = slice_end[i]
lowest_char = chars.detect do |char|
return char if s == e && prefix_sums[s][char] == prefix_sums[e][char]
# Subtracting the number of occurences at the
# end of the range from the same number at the
# start tells us if the character occured.
(prefix_sums[e][char] - prefix_sums[s][char]) > 0
end
low = chars.index(lowest_char)
puts low
low
end
end
Analysis
expand all
Example tests
1.
0.099 s
RUNTIME ERROR,
tested program terminated unexpectedly
stderr:
Invalid result type, Integer expected, String foundstdout:
1
Code: 16:05:24 UTC,
rb,
verify,
result: Failed
def solution(input_str, slice_start, slice_end)
# The challenge here is to find a way to return
# the minimum value present in an array slice in
# without having to iterate through the entire
# slice – i.e. in constant O(1) time.
m = slice_start.length - 1
# Initialise an array to hold the number of
# times each character occurs at each point
# in the original string. It's just a running
# total for each character.
prefix_sums = Array.new(input_str.length) { { A: 0, C: 0, G: 0, T: 0 } }
# Iterate through the original string,
# incrementing the counters.
input_str.split('').each_with_index do |char, i|
prefix_sums[i].each do |k, v|
# Set each value at this index to whatever
# it was last index, so the counters grow.
prefix_sums[i][k] = prefix_sums[i - 1][k]
end
# Increment the counter for this character.
prefix_sums[i][char.to_sym] += 1
end
# For each slice, we can now look up whether each
# character occured and find the lowest.
chars = prefix_sums[0].keys
(0..m).map do |i|
s = slice_start[i]
e = slice_end[i]
lowest_char = chars.detect do |char|
# Subtracting the number of occurences at the
# end of the range from the same number at the
# start tells us if the character occured.
occurences = prefix_sums[e][char] - prefix_sums[s][char]
if s == e
occurences >= 0
else
occurences > 0
end
end
low = chars.index(lowest_char)
puts low
low
end
end
Analysis
expand all
Example tests
1.
0.100 s
WRONG ANSWER,
got [1, 0, 0] expected [2, 4, 1]
stdout:
1 0 0
Code: 16:05:53 UTC,
rb,
verify,
result: Failed
def solution(input_str, slice_start, slice_end)
# The challenge here is to find a way to return
# the minimum value present in an array slice in
# without having to iterate through the entire
# slice – i.e. in constant O(1) time.
m = slice_start.length - 1
# Initialise an array to hold the number of
# times each character occurs at each point
# in the original string. It's just a running
# total for each character.
prefix_sums = Array.new(input_str.length) { { A: 0, C: 0, G: 0, T: 0 } }
# Iterate through the original string,
# incrementing the counters.
input_str.split('').each_with_index do |char, i|
prefix_sums[i].each do |k, v|
# Set each value at this index to whatever
# it was last index, so the counters grow.
prefix_sums[i][k] = prefix_sums[i - 1][k]
end
# Increment the counter for this character.
prefix_sums[i][char.to_sym] += 1
end
# For each slice, we can now look up whether each
# character occured and find the lowest.
chars = prefix_sums[0].keys
(0..m).map do |i|
s = slice_start[i]
e = slice_end[i]
lowest_char = chars.detect do |char|
# Subtracting the number of occurences at the
# end of the range from the same number at the
# start tells us if the character occured.
occurences = prefix_sums[e][char] - prefix_sums[s][char]
if s == e
occurences >= 0
else
occurences > 0
end
end
low = chars.index(lowest_char)
puts low
low + 1
end
end
Analysis
expand all
Example tests
1.
0.100 s
WRONG ANSWER,
got [2, 1, 1] expected [2, 4, 1]
stdout:
1 0 0
Code: 16:06:00 UTC,
rb,
verify,
result: Failed
def solution(input_str, slice_start, slice_end)
# The challenge here is to find a way to return
# the minimum value present in an array slice in
# without having to iterate through the entire
# slice – i.e. in constant O(1) time.
m = slice_start.length - 1
# Initialise an array to hold the number of
# times each character occurs at each point
# in the original string. It's just a running
# total for each character.
prefix_sums = Array.new(input_str.length) { { A: 0, C: 0, G: 0, T: 0 } }
# Iterate through the original string,
# incrementing the counters.
input_str.split('').each_with_index do |char, i|
prefix_sums[i].each do |k, v|
# Set each value at this index to whatever
# it was last index, so the counters grow.
prefix_sums[i][k] = prefix_sums[i - 1][k]
end
# Increment the counter for this character.
prefix_sums[i][char.to_sym] += 1
end
# For each slice, we can now look up whether each
# character occured and find the lowest.
chars = prefix_sums[0].keys
(0..m).map do |i|
s = slice_start[i]
e = slice_end[i]
lowest_char = chars.detect do |char|
# Subtracting the number of occurences at the
# end of the range from the same number at the
# start tells us if the character occured.
occurences = prefix_sums[e][char] - prefix_sums[s][char]
if s == e
occurences >= 0
else
occurences > 0
end
end
low = chars.index(lowest_char)
low + 1
end
end
Analysis
expand all
Example tests
1.
0.099 s
WRONG ANSWER,
got [2, 1, 1] expected [2, 4, 1]
Code: 16:06:40 UTC,
rb,
verify,
result: Failed
def solution(input_str, slice_start, slice_end)
# The challenge here is to find a way to return
# the minimum value present in an array slice in
# without having to iterate through the entire
# slice – i.e. in constant O(1) time.
m = slice_start.length - 1
# Initialise an array to hold the number of
# times each character occurs at each point
# in the original string. It's just a running
# total for each character.
prefix_sums = Array.new(input_str.length) { { A: 0, C: 0, G: 0, T: 0 } }
# Iterate through the original string,
# incrementing the counters.
input_str.split('').each_with_index do |char, i|
prefix_sums[i].each do |k, v|
# Set each value at this index to whatever
# it was last index, so the counters grow.
prefix_sums[i][k] = prefix_sums[i - 1][k]
end
# Increment the counter for this character.
prefix_sums[i][char.to_sym] += 1
end
# For each slice, we can now look up whether each
# character occured and find the lowest.
chars = prefix_sums[0].keys
(0..m).map do |i|
s = slice_start[i]
e = slice_end[i]
lowest_char = chars.detect do |char|
# Subtracting the number of occurences at the
# end of the range from the same number at the
# start tells us if the character occured.
occurences = prefix_sums[e][char] - prefix_sums[s][char]
puts prefix_sums[s][char]
puts prefix_sums[e][char]
if s == e
occurences >= 0
else
occurences > 0
end
end
low = chars.index(lowest_char)
low + 1
end
end
Analysis
expand all
Example tests
1.
0.101 s
WRONG ANSWER,
got [2, 1, 1] expected [2, 4, 1]
stdout:
1 1 1 3 1 1 0 2
Code: 16:06:54 UTC,
rb,
verify,
result: Failed
def solution(input_str, slice_start, slice_end)
# The challenge here is to find a way to return
# the minimum value present in an array slice in
# without having to iterate through the entire
# slice – i.e. in constant O(1) time.
m = slice_start.length - 1
# Initialise an array to hold the number of
# times each character occurs at each point
# in the original string. It's just a running
# total for each character.
prefix_sums = Array.new(input_str.length) { { A: 0, C: 0, G: 0, T: 0 } }
# Iterate through the original string,
# incrementing the counters.
input_str.split('').each_with_index do |char, i|
prefix_sums[i].each do |k, v|
# Set each value at this index to whatever
# it was last index, so the counters grow.
prefix_sums[i][k] = prefix_sums[i - 1][k]
end
# Increment the counter for this character.
prefix_sums[i][char.to_sym] += 1
end
# For each slice, we can now look up whether each
# character occured and find the lowest.
chars = prefix_sums[0].keys
(0..m).map do |i|
s = slice_start[i]
e = slice_end[i]
lowest_char = chars.detect do |char|
# Subtracting the number of occurences at the
# end of the range from the same number at the
# start tells us if the character occured.
occurences = prefix_sums[e][char] - prefix_sums[s][char]
puts prefix_sums[s]
puts prefix_sums[e]
if s == e
occurences >= 0
else
occurences > 0
end
end
low = chars.index(lowest_char)
low + 1
end
end
Analysis
expand all
Example tests
1.
0.099 s
WRONG ANSWER,
got [2, 1, 1] expected [2, 4, 1]
stdout:
{:A=>1, :C=>1, :G=>1, :T=>0}
{:A=>1, :C=>3, :G=>1, :T=>0}
{:A=>1, :C=>1, :G=>1, :T=>0}
{:A=>1, :C=>3, :G=>1, :T=>0}
{:A=>1, :C=>3, :G=>1, :T=>1}
{:A=>1, :C=>3, :G=>1, :T=>1}
{:A=>0, :C=>1, :G=>0, :T=>0}
{:A=>2, :C=>3, :G=>1, :T=>1}
Code: 16:08:47 UTC,
rb,
verify,
result: Failed
def solution(input_str, slice_start, slice_end)
# The challenge here is to find a way to return
# the minimum value present in an array slice in
# without having to iterate through the entire
# slice – i.e. in constant O(1) time.
m = slice_start.length - 1
# Initialise an array to hold the number of
# times each character occurs at each point
# in the original string. It's just a running
# total for each character.
prefix_sums = Array.new(input_str.length) { { A: 0, C: 0, G: 0, T: 0 } }
# Iterate through the original string,
# incrementing the counters.
input_str.split('').each_with_index do |char, i|
prefix_sums[i].each do |k, v|
# Set each value at this index to whatever
# it was last index, so the counters grow.
prefix_sums[i][k] = prefix_sums[i - 1][k]
end
# Increment the counter for this character.
prefix_sums[i][char.to_sym] += 1
end
# For each slice, we can now look up whether each
# character occured and find the lowest.
chars = prefix_sums[0].keys
(0..m).map do |i|
s = slice_start[i]
e = slice_end[i]
puts prefix_sums[s]
puts prefix_sums[e]
lowest_char = chars.detect do |char|
# Subtracting the number of occurences at the
# end of the range from the same number at the
# start tells us if the character occured.
occurences = prefix_sums[e][char] - prefix_sums[s][char]
if s == e
occurences >= 0
else
occurences > 0
end
end
low = chars.index(lowest_char)
low + 1
end
end
Analysis
expand all
Example tests
1.
0.098 s
WRONG ANSWER,
got [2, 1, 1] expected [2, 4, 1]
stdout:
{:A=>1, :C=>1, :G=>1, :T=>0}
{:A=>1, :C=>3, :G=>1, :T=>0}
{:A=>1, :C=>3, :G=>1, :T=>1}
{:A=>1, :C=>3, :G=>1, :T=>1}
{:A=>0, :C=>1, :G=>0, :T=>0}
{:A=>2, :C=>3, :G=>1, :T=>1}
Code: 16:09:31 UTC,
rb,
verify,
result: Failed
def solution(input_str, slice_start, slice_end)
# The challenge here is to find a way to return
# the minimum value present in an array slice in
# without having to iterate through the entire
# slice – i.e. in constant O(1) time.
m = slice_start.length
# Initialise an array to hold the number of
# times each character occurs at each point
# in the original string. It's just a running
# total for each character.
prefix_sums = Array.new(input_str.length) { { A: 0, C: 0, G: 0, T: 0 } }
# Iterate through the original string,
# incrementing the counters.
input_str.split('').each_with_index do |char, i|
prefix_sums[i].each do |k, v|
# Set each value at this index to whatever
# it was last index, so the counters grow.
prefix_sums[i][k] = prefix_sums[i - 1][k]
end
# Increment the counter for this character.
prefix_sums[i][char.to_sym] += 1
end
# For each slice, we can now look up whether each
# character occured and find the lowest.
chars = prefix_sums[0].keys
(0..m).map do |i|
s = slice_start[i]
e = slice_end[i]
puts prefix_sums[s]
puts prefix_sums[e]
lowest_char = chars.detect do |char|
# Subtracting the number of occurences at the
# end of the range from the same number at the
# start tells us if the character occured.
occurences = prefix_sums[e][char] - prefix_sums[s][char]
if s == e
occurences >= 0
else
occurences > 0
end
end
low = chars.index(lowest_char)
low + 1
end
end
Analysis
expand all
Example tests
1.
0.100 s
RUNTIME ERROR,
tested program terminated unexpectedly
stderr:
user.rb:33:in `[]': no implicit conversion from nil to integer (TypeError) from user.rb:33:in `block in solution' from user.rb:30:in `each' from user.rb:30:in `map' from user.rb:30:in `solution' from user.rb:173:in `<main>'stdout:
{:A=>1, :C=>1, :G=>1, :T=>0}
{:A=>1, :C=>3, :G=>1, :T=>0}
{:A=>1, :C=>3, :G=>1, :T=>1}
{:A=>1, :C=>3, :G=>1, :T=>1}
{:A=>0, :C=>1, :G=>0, :T=>0}
{:A=>2, :C=>3, :G=>1, :T=>1}
Code: 16:09:46 UTC,
rb,
verify,
result: Failed
def solution(input_str, slice_start, slice_end)
# The challenge here is to find a way to return
# the minimum value present in an array slice in
# without having to iterate through the entire
# slice – i.e. in constant O(1) time.
m = slice_start.length - 1
# Initialise an array to hold the number of
# times each character occurs at each point
# in the original string. It's just a running
# total for each character.
prefix_sums = Array.new(input_str.length) { { A: 0, C: 0, G: 0, T: 0 } }
# Iterate through the original string,
# incrementing the counters.
input_str.split('').each_with_index do |char, i|
prefix_sums[i].each do |k, v|
# Set each value at this index to whatever
# it was last index, so the counters grow.
prefix_sums[i][k] = prefix_sums[i - 1][k]
end
# Increment the counter for this character.
prefix_sums[i][char.to_sym] += 1
end
# For each slice, we can now look up whether each
# character occured and find the lowest.
chars = prefix_sums[0].keys
(0..m).map do |i|
s = slice_start[i]
e = slice_end[i]
puts prefix_sums[s]
puts prefix_sums[e]
lowest_char = chars.detect do |char|
# Subtracting the number of occurences at the
# end of the range from the same number at the
# start tells us if the character occured.
occurences = prefix_sums[e][char] - prefix_sums[s][char]
if s == e
occurences >= 0
else
occurences > 0
end
end
low = chars.index(lowest_char)
low + 1
end
end
Analysis
expand all
Example tests
1.
0.113 s
WRONG ANSWER,
got [2, 1, 1] expected [2, 4, 1]
stdout:
{:A=>1, :C=>1, :G=>1, :T=>0}
{:A=>1, :C=>3, :G=>1, :T=>0}
{:A=>1, :C=>3, :G=>1, :T=>1}
{:A=>1, :C=>3, :G=>1, :T=>1}
{:A=>0, :C=>1, :G=>0, :T=>0}
{:A=>2, :C=>3, :G=>1, :T=>1}
Code: 16:10:23 UTC,
rb,
verify,
result: Failed
def solution(input_str, slice_start, slice_end)
# The challenge here is to find a way to return
# the minimum value present in an array slice in
# without having to iterate through the entire
# slice – i.e. in constant O(1) time.
m = slice_start.length - 1
# Initialise an array to hold the number of
# times each character occurs at each point
# in the original string. It's just a running
# total for each character.
prefix_sums = Array.new(input_str.length) { { A: 0, C: 0, G: 0, T: 0 } }
# Iterate through the original string,
# incrementing the counters.
input_str.split('').each_with_index do |char, i|
prefix_sums[i].each do |k, v|
# Set each value at this index to whatever
# it was last index, so the counters grow.
prefix_sums[i][k] = prefix_sums[i - 1][k]
end
# Increment the counter for this character.
prefix_sums[i][char.to_sym] += 1
puts prefix_sums[i]
end
# For each slice, we can now look up whether each
# character occured and find the lowest.
chars = prefix_sums[0].keys
(0..m).map do |i|
s = slice_start[i]
e = slice_end[i]
# puts prefix_sums[s]
# puts prefix_sums[e]
lowest_char = chars.detect do |char|
# Subtracting the number of occurences at the
# end of the range from the same number at the
# start tells us if the character occured.
occurences = prefix_sums[e][char] - prefix_sums[s][char]
if s == e
occurences >= 0
else
occurences > 0
end
end
low = chars.index(lowest_char)
low + 1
end
end
Analysis
expand all
Example tests
1.
0.101 s
WRONG ANSWER,
got [2, 1, 1] expected [2, 4, 1]
stdout:
{:A=>0, :C=>1, :G=>0, :T=>0}
{:A=>1, :C=>1, :G=>0, :T=>0}
{:A=>1, :C=>1, :G=>1, :T=>0}
{:A=>1, :C=>2, :G=>1, :T=>0}
{:A=>1, :C=>3, :G=>1, :T=>0}
{:A=>1, :C=>3, :G=>1, :T=>1}
{:A=>2, :C=>3, :G=>1, :T=>1}
Code: 16:14:14 UTC,
rb,
verify,
result: Failed
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859
def solution(input_str, slice_start, slice_end)
# The challenge here is to find a way to return
# the minimum value present in an array slice in
# without having to iterate through the entire
# slice – i.e. in constant O(1) time.
m = slice_start.length - 1
# Initialise an array to hold the number of
# times each character occurs at each point
# in the original string. It's just a running
# total for each character.
prefix_sums = Array.new(input_str.length) { { A: 0, C: 0, G: 0, T: 0 } }
# Iterate through the original string,
# incrementing the counters.
input_str.split('').each_with_index do |char, i|
prefix_sums[i].each do |k, v|
# Set each value at this index to whatever
# it was last index, so the counters grow.
prefix_sums[i][k] = prefix_sums[i - 1][k]
end
# Increment the counter for this character.
prefix_sums[i][char.to_sym] += 1
end
# We now have an array of hashes that looks
# something like this:
#
# {:A=>0, :C=>1, :G=>0, :T=>0}
# {:A=>1, :C=>1, :G=>0, :T=>0}
# {:A=>1, :C=>1, :G=>1, :T=>0}
# {:A=>1, :C=>2, :G=>1, :T=>0}
# {:A=>1, :C=>3, :G=>1, :T=>0}
# {:A=>1, :C=>3, :G=>1, :T=>1}
# {:A=>2, :C=>3, :G=>1, :T=>1}
# For each slice, we can now look up whether each
# character occured.
chars = prefix_sums[0].keys
(0..m).map do |i|
s = slice_start[i]
e = slice_end[i]
if s == e
return chars.index(prefix_sums[s][char]) + 1
end
lowest_char = chars.detect do |char|
# Subtracting the number of occurences at the
# end of the range from the same number at the
# start tells us if the character occured.
occurences = prefix_sums[e][char] - prefix_sums[s][char]
occurences > 0
end
chars.index(lowest_char) + 1
end
end
Analysis
expand all
Example tests
1.
0.100 s
RUNTIME ERROR,
tested program terminated unexpectedly
stderr:
user.rb:46:in `block in solution': undefined local variable or method `char' for main:Object (NameError) from user.rb:41:in `each' from user.rb:41:in `map' from user.rb:41:in `solution' from user.rb:182:in `<main>'
Code: 16:14:52 UTC,
rb,
verify,
result: Failed
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859
def solution(input_str, slice_start, slice_end)
# The challenge here is to find a way to return
# the minimum value present in an array slice in
# without having to iterate through the entire
# slice – i.e. in constant O(1) time.
m = slice_start.length - 1
# Initialise an array to hold the number of
# times each character occurs at each point
# in the original string. It's just a running
# total for each character.
prefix_sums = Array.new(input_str.length) { { A: 0, C: 0, G: 0, T: 0 } }
# Iterate through the original string,
# incrementing the counters.
input_str.split('').each_with_index do |char, i|
prefix_sums[i].each do |k, v|
# Set each value at this index to whatever
# it was last index, so the counters grow.
prefix_sums[i][k] = prefix_sums[i - 1][k]
end
# Increment the counter for this character.
prefix_sums[i][char.to_sym] += 1
end
# We now have an array of hashes that looks
# something like this:
#
# {:A=>0, :C=>1, :G=>0, :T=>0}
# {:A=>1, :C=>1, :G=>0, :T=>0}
# {:A=>1, :C=>1, :G=>1, :T=>0}
# {:A=>1, :C=>2, :G=>1, :T=>0}
# {:A=>1, :C=>3, :G=>1, :T=>0}
# {:A=>1, :C=>3, :G=>1, :T=>1}
# {:A=>2, :C=>3, :G=>1, :T=>1}
# For each slice, we can now look up whether each
# character occured.
chars = prefix_sums[0].keys
(0..m).map do |i|
s = slice_start[i]
e = slice_end[i]
if s == e
return chars.index(input_str.to_sym) + 1
end
lowest_char = chars.detect do |char|
# Subtracting the number of occurences at the
# end of the range from the same number at the
# start tells us if the character occured.
occurences = prefix_sums[e][char] - prefix_sums[s][char]
occurences > 0
end
chars.index(lowest_char) + 1
end
end
Analysis
expand all
Example tests
1.
0.099 s
RUNTIME ERROR,
tested program terminated unexpectedly
stderr:
user.rb:46:in `block in solution': undefined method `+' for nil:NilClass (NoMethodError) from user.rb:41:in `each' from user.rb:41:in `map' from user.rb:41:in `solution' from user.rb:182:in `<main>'
Code: 16:15:21 UTC,
rb,
verify,
result: Failed
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859
def solution(input_str, slice_start, slice_end)
# The challenge here is to find a way to return
# the minimum value present in an array slice in
# without having to iterate through the entire
# slice – i.e. in constant O(1) time.
m = slice_start.length - 1
# Initialise an array to hold the number of
# times each character occurs at each point
# in the original string. It's just a running
# total for each character.
prefix_sums = Array.new(input_str.length) { { A: 0, C: 0, G: 0, T: 0 } }
# Iterate through the original string,
# incrementing the counters.
input_str.split('').each_with_index do |char, i|
prefix_sums[i].each do |k, v|
# Set each value at this index to whatever
# it was last index, so the counters grow.
prefix_sums[i][k] = prefix_sums[i - 1][k]
end
# Increment the counter for this character.
prefix_sums[i][char.to_sym] += 1
end
# We now have an array of hashes that looks
# something like this:
#
# {:A=>0, :C=>1, :G=>0, :T=>0}
# {:A=>1, :C=>1, :G=>0, :T=>0}
# {:A=>1, :C=>1, :G=>1, :T=>0}
# {:A=>1, :C=>2, :G=>1, :T=>0}
# {:A=>1, :C=>3, :G=>1, :T=>0}
# {:A=>1, :C=>3, :G=>1, :T=>1}
# {:A=>2, :C=>3, :G=>1, :T=>1}
# For each slice, we can now look up whether each
# character occured.
chars = prefix_sums[0].keys
(0..m).map do |i|
s = slice_start[i]
e = slice_end[i]
if s == e
return chars.index(input_str[s].to_sym) + 1
end
lowest_char = chars.detect do |char|
# Subtracting the number of occurences at the
# end of the range from the same number at the
# start tells us if the character occured.
occurences = prefix_sums[e][char] - prefix_sums[s][char]
occurences > 0
end
chars.index(lowest_char) + 1
end
end
Analysis
expand all
Example tests
1.
0.101 s
RUNTIME ERROR,
tested program terminated unexpectedly
stderr:
user.rb:162:in `_codility_save_result': undefined method `length' for 4:Fixnum (NoMethodError) from user.rb:183:in `<main>'
Code: 16:18:39 UTC,
rb,
verify,
result: Failed
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657
def solution(input_str, slice_start, slice_end)
# The challenge here is to find a way to return
# the minimum value present in an array slice in
# without having to iterate through the entire
# slice – i.e. in constant O(1) time.
m = slice_start.length - 1
char_values = { A: 1, C: 2, G: 3, T: 4 }
# Initialise an array to hold the number of
# times each character occurs at each point
# in the original string. It's just a running
# total for each character.
prefix_sums = Array.new(input_str.length) { { A: 0, C: 0, G: 0, T: 0 } }
# Iterate through the original string,
# incrementing the counters.
input_str.split('').each_with_index do |char, i|
prefix_sums[i].each do |k, v|
# Set each value at this index to whatever
# it was last index, so the counters grow.
prefix_sums[i][k] = prefix_sums[i - 1][k]
end
# Increment the counter for this character.
prefix_sums[i][char.to_sym] += 1
end
# We now have an array of hashes that looks
# something like this:
#
# {:A=>0, :C=>1, :G=>0, :T=>0}
# {:A=>1, :C=>1, :G=>0, :T=>0}
# {:A=>1, :C=>1, :G=>1, :T=>0}
# {:A=>1, :C=>2, :G=>1, :T=>0}
# {:A=>1, :C=>3, :G=>1, :T=>0}
# {:A=>1, :C=>3, :G=>1, :T=>1}
# {:A=>2, :C=>3, :G=>1, :T=>1}
# For each slice, we can now look up whether each
# character occured.
chars = char_values.keys
(0..m).map do |i|
s = slice_start[i]
e = slice_end[i]
if s == e
return char_values(input_str[s].to_sym)
end
lowest_char = chars.detect do |char|
occurences = prefix_sums[e][char] - prefix_sums[s][char]
occurences > 0
end
char_values(lowest_char)
end
end
Analysis
expand all
Example tests
1.
0.110 s
RUNTIME ERROR,
tested program terminated unexpectedly
stderr:
user.rb:55:in `block in solution': undefined method `char_values' for main:Object (NoMethodError) from user.rb:42:in `each' from user.rb:42:in `map' from user.rb:42:in `solution' from user.rb:180:in `<main>'
Code: 16:19:03 UTC,
rb,
verify,
result: Failed
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657
def solution(input_str, slice_start, slice_end)
# The challenge here is to find a way to return
# the minimum value present in an array slice in
# without having to iterate through the entire
# slice – i.e. in constant O(1) time.
m = slice_start.length - 1
char_values = { A: 1, C: 2, G: 3, T: 4 }
# Initialise an array to hold the number of
# times each character occurs at each point
# in the original string. It's just a running
# total for each character.
prefix_sums = Array.new(input_str.length) { { A: 0, C: 0, G: 0, T: 0 } }
# Iterate through the original string,
# incrementing the counters.
input_str.split('').each_with_index do |char, i|
prefix_sums[i].each do |k, v|
# Set each value at this index to whatever
# it was last index, so the counters grow.
prefix_sums[i][k] = prefix_sums[i - 1][k]
end
# Increment the counter for this character.
prefix_sums[i][char.to_sym] += 1
end
# We now have an array of hashes that looks
# something like this:
#
# {:A=>0, :C=>1, :G=>0, :T=>0}
# {:A=>1, :C=>1, :G=>0, :T=>0}
# {:A=>1, :C=>1, :G=>1, :T=>0}
# {:A=>1, :C=>2, :G=>1, :T=>0}
# {:A=>1, :C=>3, :G=>1, :T=>0}
# {:A=>1, :C=>3, :G=>1, :T=>1}
# {:A=>2, :C=>3, :G=>1, :T=>1}
# For each slice, we can now look up whether each
# character occured.
chars = char_values.keys
(0..m).map do |i|
s = slice_start[i]
e = slice_end[i]
if s == e
return char_values(input_str[s].to_sym)
end
lowest_char = chars.detect do |char|
occurences = prefix_sums[e][char] - prefix_sums[s][char]
occurences > 0
end
char_values[lowest_char]
end
end
Analysis
expand all
Example tests
1.
0.110 s
RUNTIME ERROR,
tested program terminated unexpectedly
stderr:
user.rb:47:in `block in solution': undefined method `char_values' for main:Object (NoMethodError) from user.rb:42:in `each' from user.rb:42:in `map' from user.rb:42:in `solution' from user.rb:180:in `<main>'
Code: 16:19:17 UTC,
rb,
verify,
result: Failed
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657
def solution(input_str, slice_start, slice_end)
# The challenge here is to find a way to return
# the minimum value present in an array slice in
# without having to iterate through the entire
# slice – i.e. in constant O(1) time.
m = slice_start.length - 1
char_values = { A: 1, C: 2, G: 3, T: 4 }
# Initialise an array to hold the number of
# times each character occurs at each point
# in the original string. It's just a running
# total for each character.
prefix_sums = Array.new(input_str.length) { { A: 0, C: 0, G: 0, T: 0 } }
# Iterate through the original string,
# incrementing the counters.
input_str.split('').each_with_index do |char, i|
prefix_sums[i].each do |k, v|
# Set each value at this index to whatever
# it was last index, so the counters grow.
prefix_sums[i][k] = prefix_sums[i - 1][k]
end
# Increment the counter for this character.
prefix_sums[i][char.to_sym] += 1
end
# We now have an array of hashes that looks
# something like this:
#
# {:A=>0, :C=>1, :G=>0, :T=>0}
# {:A=>1, :C=>1, :G=>0, :T=>0}
# {:A=>1, :C=>1, :G=>1, :T=>0}
# {:A=>1, :C=>2, :G=>1, :T=>0}
# {:A=>1, :C=>3, :G=>1, :T=>0}
# {:A=>1, :C=>3, :G=>1, :T=>1}
# {:A=>2, :C=>3, :G=>1, :T=>1}
# For each slice, we can now look up whether each
# character occured.
chars = char_values.keys
(0..m).map do |i|
s = slice_start[i]
e = slice_end[i]
if s == e
return char_values[input_str[s].to_sym]
end
lowest_char = chars.detect do |char|
occurences = prefix_sums[e][char] - prefix_sums[s][char]
occurences > 0
end
char_values[lowest_char]
end
end
Analysis
expand all
Example tests
1.
0.098 s
RUNTIME ERROR,
tested program terminated unexpectedly
stderr:
user.rb:160:in `_codility_save_result': undefined method `length' for 4:Fixnum (NoMethodError) from user.rb:181:in `<main>'
Code: 16:20:27 UTC,
rb,
verify,
result: Passed
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657
def solution(input_str, slice_start, slice_end)
# The challenge here is to find a way to return
# the minimum value present in an array slice in
# without having to iterate through the entire
# slice – i.e. in constant O(1) time.
m = slice_start.length - 1
char_values = { A: 1, C: 2, G: 3, T: 4 }
# Initialise an array to hold the number of
# times each character occurs at each point
# in the original string. It's just a running
# total for each character.
prefix_sums = Array.new(input_str.length) { { A: 0, C: 0, G: 0, T: 0 } }
# Iterate through the original string,
# incrementing the counters.
input_str.split('').each_with_index do |char, i|
prefix_sums[i].each do |k, v|
# Set each value at this index to whatever
# it was last index, so the counters grow.
prefix_sums[i][k] = prefix_sums[i - 1][k]
end
# Increment the counter for this character.
prefix_sums[i][char.to_sym] += 1
end
# We now have an array of hashes that looks
# something like this:
#
# {:A=>0, :C=>1, :G=>0, :T=>0}
# {:A=>1, :C=>1, :G=>0, :T=>0}
# {:A=>1, :C=>1, :G=>1, :T=>0}
# {:A=>1, :C=>2, :G=>1, :T=>0}
# {:A=>1, :C=>3, :G=>1, :T=>0}
# {:A=>1, :C=>3, :G=>1, :T=>1}
# {:A=>2, :C=>3, :G=>1, :T=>1}
# For each slice, we can now look up whether each
# character occured.
chars = char_values.keys
(0..m).map do |i|
s = slice_start[i]
e = slice_end[i]
if s == e
next char_values[input_str[s].to_sym]
end
lowest_char = chars.detect do |char|
occurences = prefix_sums[e][char] - prefix_sums[s][char]
occurences > 0
end
char_values[lowest_char]
end
end
Analysis
Code: 16:23:21 UTC,
rb,
verify,
result: Passed
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859
def solution(input_str, slice_start, slice_end)
# The challenge here is to find a way to return
# the minimum value present in an array slice
# without having to iterate through the entire
# slice – i.e. in constant O(1) time.
m = slice_start.length - 1
char_values = { A: 1, C: 2, G: 3, T: 4 }
# Initialise an array to hold the number of
# times each character has occured at each point
# in the original string. It's just a running
# total for each character.
prefix_sums = Array.new(input_str.length) { { A: 0, C: 0, G: 0, T: 0 } }
# Iterate through the original string,
# incrementing the counters.
input_str.split('').each_with_index do |char, i|
prefix_sums[i].each do |k, v|
# Set each value at this index to whatever
# it was last index, so the counters grow.
prefix_sums[i][k] = prefix_sums[i - 1][k]
end
# Increment the counter for this character.
prefix_sums[i][char.to_sym] += 1
end
# We now have an array of hashes that looks
# something like this:
#
# {:A=>0, :C=>1, :G=>0, :T=>0}
# {:A=>1, :C=>1, :G=>0, :T=>0}
# {:A=>1, :C=>1, :G=>1, :T=>0}
# {:A=>1, :C=>2, :G=>1, :T=>0}
# {:A=>1, :C=>3, :G=>1, :T=>0}
# {:A=>1, :C=>3, :G=>1, :T=>1}
# {:A=>2, :C=>3, :G=>1, :T=>1}
# For each slice, we can now look up whether each
# character occured in the character range.
chars = char_values.keys
(0..m).map do |i|
s = slice_start[i]
e = slice_end[i]
if s == e
# If the start and end of the slice are the same,
# we can just return the value at that position.
next char_values[input_str[s].to_sym]
end
lowest_char = chars.detect do |char|
occurences = prefix_sums[e][char] - prefix_sums[s][char]
occurences > 0
end
char_values[lowest_char]
end
end
Analysis
Code: 16:23:23 UTC,
rb,
final,
score:
75
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859
def solution(input_str, slice_start, slice_end)
# The challenge here is to find a way to return
# the minimum value present in an array slice
# without having to iterate through the entire
# slice – i.e. in constant O(1) time.
m = slice_start.length - 1
char_values = { A: 1, C: 2, G: 3, T: 4 }
# Initialise an array to hold the number of
# times each character has occured at each point
# in the original string. It's just a running
# total for each character.
prefix_sums = Array.new(input_str.length) { { A: 0, C: 0, G: 0, T: 0 } }
# Iterate through the original string,
# incrementing the counters.
input_str.split('').each_with_index do |char, i|
prefix_sums[i].each do |k, v|
# Set each value at this index to whatever
# it was last index, so the counters grow.
prefix_sums[i][k] = prefix_sums[i - 1][k]
end
# Increment the counter for this character.
prefix_sums[i][char.to_sym] += 1
end
# We now have an array of hashes that looks
# something like this:
#
# {:A=>0, :C=>1, :G=>0, :T=>0}
# {:A=>1, :C=>1, :G=>0, :T=>0}
# {:A=>1, :C=>1, :G=>1, :T=>0}
# {:A=>1, :C=>2, :G=>1, :T=>0}
# {:A=>1, :C=>3, :G=>1, :T=>0}
# {:A=>1, :C=>3, :G=>1, :T=>1}
# {:A=>2, :C=>3, :G=>1, :T=>1}
# For each slice, we can now look up whether each
# character occured in the character range.
chars = char_values.keys
(0..m).map do |i|
s = slice_start[i]
e = slice_end[i]
if s == e
# If the start and end of the slice are the same,
# we can just return the value at that position.
next char_values[input_str[s].to_sym]
end
lowest_char = chars.detect do |char|
occurences = prefix_sums[e][char] - prefix_sums[s][char]
occurences > 0
end
char_values[lowest_char]
end
endAnalysis summary
The following issues have been detected: wrong answers.
Analysis
expand all
Correctness tests
1.
0.117 s
OK
2.
0.103 s
OK
3.
0.110 s
OK
4.
0.112 s
OK
1.
0.106 s
WRONG ANSWER,
got [1, 2, 2] expected [1, 1, 2]
2.
0.113 s
WRONG ANSWER,
got [3, 4, 4] expected [3, 3, 4]
3.
0.119 s
OK
4.
0.112 s
OK
1.
0.121 s
WRONG ANSWER,
got [1, 3, 4, 4] expected [1, 3, 3, 4]
2.
0.110 s
OK
3.
0.108 s
WRONG ANSWER,
got [4, 1, 4, 4] expected [4, 1, 1, 4]
1.
0.109 s
OK
1.
0.102 s
OK