hackerrank | various languages from the site Hacker Rank | Learning library

As you can see this is the same evaluation as your code but with optimized approach, FizzBuzz questions are to test on how to write an efficient algorithm. Just because the code is working it doesn't mean it shouldn't be optimized.

In here you can see I'm checking every interval and appending the string by words. If you use modulo(%) operator, then it uses more cpu clocks, I know it is nothing for current generation computers, but it's good practice with problems like this

So we have an actually correct answer here, the issue is that you're writing to the boolean but never reading from it. Without the Println(), it's not used in a conditional or any other expression anywhere that depends on its value, so the assignments to it don't affect the program flow. You could remove all of the lines assigning values to insideValley and the program would act no differently than it does right now (excepting the Println(), of course, which is why adding that "fixed" the issue).

Go is specifically designed to flag "junk" code like that, that adds nothing to the program flow, as a compiler error (well, in most cases. Unused globals and unused functions are some exceptions to that). Simply add in whatever is supposed to be using that boolean's value (such as a conditional based on its value), and you'll stop getting the "variable unused" error.

And as noted in the comments of Vishwa Ratna's answer, vars do not have to be used in every logical pathway. They only need to be used (ie. read from) in at least one logical pathway.

I would say CTF challenges are a good way to learn. https://tryhackme.com/ is a good place to start. Most of the rooms are aimed at beginners and it will give you a good understanding, of some of the programs you will use like nmap, burpsuite and wireshark. https://www.hackthebox.eu/ is a good place, when you are a bit more experienced.

I am also gonna share some GitHub links, you might find interesting:

• https://github.com/Hack-with-Github/Awesome-Hacking
• https://github.com/OWASP/CheatSheetSeries
• https://github.com/gerryguy311/Free_CyberSecurity_Professional_Development_Resources

The behavior for Java is documented in Pattern:

In this class, \1 through \9 are always interpreted as back references, and a larger number is accepted as a back reference if at least that many subexpressions exist at that point in the regular expression, otherwise the parser will drop digits until the number is smaller or equal to the existing number of groups or it is one digit.

The only problem I see with your code is s.slice(start_i - 1, end_i). That is problematic when start_i = 0 and end_i = s.size - 1. For example, "abc".slice(0-1, 2) #=> "2", because -1 and 2 both index the last character of the string.

Note you can replace reduce(&:+) || 0 with reduce(0, &:+), or, better, sum.

I do think substring.gsub!('|', '||') is a bit hokey. You could instead write

The first argument to diagonalDiff method is an array (2-D). But you're passing an int while calling it. (a[i][j] will be an int)

try calling it this way:

You cannot, the maximum value for int is 2,147,483,647 (32 bits of value). If you need big numbers you must use the appropriate variable type.

If for some reason you want to avoid BigInteger at all and your are not going to do any arithmetic operation later, you can always return a String

About the hackerrank problem, just modify the result variable type to BigInteger. Actually, they seem to be aware of the 32/64 bits issue... they are using a String value to prevent it.

There's no reason to keep the whole code-template structure. They just care about input/output. You are allowed to modify EVERYTHING but those two things.

This is their input:

This is their output (here you can see their output is expected to be a String):

You have three problems with this code:

1. An actual bug. You don't handle when a prime divides the number multiple times. I'm fairly sure the four lines before the println output are a workaround you put in when you encountered a failure this causes, that fixed the specific failure you found but don't actually address the root cause. I just tested it, your code outputs 3 for the input 252. The correct output for 252 is 7.
2. Part of your code invokes a library method that may be significantly expensive. You should not be using isProbablePrime.
3. Your algorithm's logic scales poorly. Hackerrank's test cases probably include something where the correct output is something like 20 digits long. A major point of Project Euler is that it's not enough to write code that will find the correct answer. You need to write code that will find the correct answer efficiently. To fix this, you will need new logic for the fundamental design of the program.

You have put the Solution class within your Result class. HackerRank wants you to put the Solution class as its own class, like this: