Tasks Details
hard
Given a string of letters 'M' and 'L', compute the minimum number of changes needed to obtain a string such that the length of its longest interval of letters 'M' is equal to K.
Task Score
100%
Correctness
100%
Performance
100%
A long time ago, when the most basic model of an HP3000 computer used to cost $95,000 (over half a million in today's dollars), a very wise man called Gordon Moore made predictions about how computers would become cheaper and more powerful each year. According to Moore, the number of components per integrated circuit would double every two years. Thanks to the creative, determined engineers working in circuit printing technology, we do indeed have smaller, cheaper and more powerful computers today.
Circuit printing, as we call photolithography, is an extremely complex yet rewarding field, and ASML needs the best software engineers in the world to make this magic happen. We work closely with our clients to help them print their circuits in the most effective way. One of our clients requests us to write a method to optimize their circuit efficiency. The circuit is represented as a string consisting of the letters "M" and "L", where M represents Memory units and L represents Logic units. The efficiency of the circuit is measured as the length of the longest interval of letters "M". For example, given input string "LMMMLMMMMLLLM", the longest interval is 4.
Our customer wants to change the circuit in such a way that the longest M-interval will be equal to K. We can change any unit at any position in the circuit, i.e. either we can change any "M" to "L" or any "L" to "M". The objective of this challenge is to calculate the minimum number of changes we have to make in order to achieve the desired longest M-interval length K.
Write a function:
class Solution { public int solution(String S, int K); }
where the first argument, S, represents the circuit as a string of length N that consists of only characters "M" and/or "L" and the second argument, K, is the desired longest M-interval in the string. The return value shall be the minimum number of changes to achieve K as the longest M-interval in the input string.
For example, given S = "MLMMLLM" and K = 3, your function should return 1. We can change the letter at position 4 (counting from 0) to obtain "MLMMMLM", in which the longest interval of letters "M" is exactly three characters long.
For another example, given S = "MLMMMLMMMM" and K = 2, your function should return 2. We can, for example, modify the letters at positions 2 and 7 to get the string "MLLMMLMLMM", which satisfies the desired property.
Write an efficient algorithm for the following assumptions:
- string S is made only of the characters 'M' and/or 'L';
- N is an integer within the range [1..100,000];
- K is an integer within the range [0..N].
Copyright 2009–2025 by Codility Limited. All Rights Reserved. Unauthorized copying, publication or disclosure prohibited.
Solution
Programming language used Java 21
Time spent on task 62 minutes
Notes
not defined yet
Code: 11:25:01 UTC,
java,
autosave
Code: 11:29:01 UTC,
java,
autosave
Code: 11:29:56 UTC,
java,
autosave
Code: 11:30:26 UTC,
java,
autosave
// 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(String S, int K) {
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=3
//Um die langen Ms zu verkürzen m
}
}
Code: 11:30:45 UTC,
java,
autosave
// 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(String S, int K) {
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=3
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen -> MMMMM
}
}
Code: 11:30:55 UTC,
java,
autosave
// 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(String S, int K) {
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=3
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen -> MMMMMMM
}
}
Code: 11:31:26 UTC,
java,
autosave
// 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(String S, int K) {
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=3
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen -> MMMMMMMM
}
}
Code: 11:31:56 UTC,
java,
autosave
// 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(String S, int K) {
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=3
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen -> MMMMMMMM
}
}
Code: 11:32:26 UTC,
java,
autosave
// 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(String S, int K) {
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=3
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=
}
}
Code: 11:32:37 UTC,
java,
autosave
// 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(String S, int K) {
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=3
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
}
}
Code: 11:32:57 UTC,
java,
autosave
// 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(String S, int K) {
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=3
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
//Ich muss nur die langen ver
}
}
Code: 11:33:19 UTC,
java,
autosave
// 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(String S, int K) {
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=3
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
//Ich muss die langen verkürzen und sonst nichts machen, wenn alle Ms
}
}
Code: 11:33:49 UTC,
java,
autosave
// 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(String S, int K) {
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=3
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
//Ich muss die langen verkürzen und sonst nichts machen, wenn nicht alle Ms < K sind
//-> Case1: Alle Ms < K
}
}
Code: 11:34:05 UTC,
java,
autosave
// 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(String S, int K) {
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=3
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
//Ich muss die langen verkürzen und sonst nichts machen, wenn nicht alle Ms < K sind
//-> Case1: Alle Ms < K
//-> Case2: Es gibt
}
}
Code: 11:34:21 UTC,
java,
autosave
// 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(String S, int K) {
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=3
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
//Ich muss die langen verkürzen und sonst nichts machen, wenn nicht alle Ms < K sind
//-> Case1: Alle Ms < K
//-> Case2: Es gibt Ms >= K
}
}
Code: 11:34:37 UTC,
java,
autosave
// 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(String S, int K) {
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=3
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
//Ich muss die langen verkürzen und sonst nichts machen, wenn nicht alle Ms < K sind
//-> Case1: Alle Ms < K
//-> Case2: Es gibt Ms >= K
}
}
Code: 11:34:47 UTC,
java,
autosave
// 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(String S, int K) {
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=3
//-> Case1: Alle Ms < K
//-> Case2: Es gibt Ms >= K
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
//Ich muss die langen verkürzen und sonst nichts machen, wenn nicht alle Ms < K sind
}
}
Code: 11:34:57 UTC,
java,
autosave
// 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(String S, int K) {
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=3
//-> Case1: Alle Ms < K
//-> Case2: Es gibt Ms >= K
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
}
}
Code: 11:35:07 UTC,
java,
autosave
// 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(String S, int K) {
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=3
//-> Case1: Alle Ms < K
//-> Case2: Es gibt Ms >= K
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
}
}
Code: 11:35:33 UTC,
java,
autosave
// 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(String S, int K) {
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=3
//
//-> Case1: Alle Ms < K
//-> Case2: Es gibt Ms >= K
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
}
}
Code: 11:35:43 UTC,
java,
autosave
// 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(String S, int K) {
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=3
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=7
//-> Case1: Alle Ms < K
//-> Case2: Es gibt Ms >= K
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
}
}
Code: 11:36:13 UTC,
java,
autosave
// 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(String S, int K) {
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=3
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=7
//-> Case1: Alle Ms < K
//-> Case2: Es gibt Ms >= K
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
/
}
}
Code: 11:36:44 UTC,
java,
autosave
// 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(String S, int K) {
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=3
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=7
//-> Case1: Alle Ms < K
//-> Case2: Es gibt Ms >= K
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
//Algorithmus vorschlag:
//1.Einmal durchiterieren und schauen ob es Case 2 ist.
//2.Ggfls
}
}
Code: 11:37:01 UTC,
java,
autosave
// 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(String S, int K) {
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=3
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=7
//-> Case1: Alle Ms < K
//
//-> Case2: Es gibt Ms >= K
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
//Algorithmus vorschlag:
//1.Einmal durchiterieren und schauen ob es Case 2 ist.
//2.Ggfls nochmal durchiterieren und Case 1 fixen
}
}
Code: 11:37:32 UTC,
java,
autosave
// 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(String S, int K) {
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=3
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=7
//-> Case1: Alle Ms < K
//
//-> Case2: Es gibt Ms >= K
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
//Algorithmus vorschlag:
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
//2.Ggfls nochmal durchiterieren und Case 1 fixen
}
}
Code: 11:38:01 UTC,
java,
autosave
// 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(String S, int K) {
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=3
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=7
//-> Case1: Alle Ms < K
//Bei allen Ms anfangen und die nötigen changes zählen, das minimum nehmen
//-> Case2: Es gibt Ms >= K
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
//Algorithmus vorschlag:
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
//2.Ggfls nochmal durchiterieren und Case 1 fixen
}
}
Code: 11:38:30 UTC,
java,
autosave
// 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(String S, int K) {
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=3
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=7
//-> Case1: Alle Ms < K
//Bei allen Ms anfangen und die nötigen changes zählen, das minimum nehmen
//-> Case2: Es gibt Ms >= K
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
//Algorithmus vorschlag:
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
//2.Ggfls nochmal durchiterieren und Case 1 fixen
//Optimierung kommt später
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
for(int i=0;i<S.length)
}
}
Code: 11:38:41 UTC,
java,
autosave
// 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(String S, int K) {
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=3
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=7
//-> Case1: Alle Ms < K
//Bei allen Ms anfangen und die nötigen changes zählen, das minimum nehmen
//-> Case2: Es gibt Ms >= K
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
//Algorithmus vorschlag:
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
//2.Ggfls nochmal durchiterieren und Case 1 fixen
//Optimierung kommt später
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
for(int i=0;i<S.length();i++){
}
}
}
Code: 11:39:01 UTC,
java,
autosave
// 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(String S, int K) {
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=3
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=7
//-> Case1: Alle Ms < K
//Bei allen Ms anfangen und die nötigen changes zählen, das minimum nehmen
//-> Case2: Es gibt Ms >= K
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
//Algorithmus vorschlag:
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
//2.Ggfls nochmal durchiterieren und Case 1 fixen
//Optimierung kommt später
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
int lastMLength=0;
for(int i=0;i<S.length();i++){
}
}
}
Code: 11:39:17 UTC,
java,
autosave
// 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(String S, int K) {
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=3
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=7
//-> Case1: Alle Ms < K
//Bei allen Ms anfangen und die nötigen changes zählen, das minimum nehmen
//-> Case2: Es gibt Ms >= K
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
//Algorithmus vorschlag:
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
//2.Ggfls nochmal durchiterieren und Case 1 fixen
//Optimierung kommt später
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
boolean isCase2 = false;
int lastMLength=0;
for(int i=0;i<S.length();i++){
}
}
}
Code: 11:39:48 UTC,
java,
autosave
// 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(String S, int K) {
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=3
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=7
//-> Case1: Alle Ms < K
//Bei allen Ms anfangen und die nötigen changes zählen, das minimum nehmen
//-> Case2: Es gibt Ms >= K
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
//Algorithmus vorschlag:
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
//2.Ggfls nochmal durchiterieren und Case 1 fixen
//Optimierung kommt später
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
boolean isCase2 = false;
int lastMLength=0;
for(int i=0;i<S.length();i++){
char c = S.charAt(i);
if()
}
}
}
Code: 11:40:03 UTC,
java,
autosave
// 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(String S, int K) {
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=3
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=7
//-> Case1: Alle Ms < K
//Bei allen Ms anfangen und die nötigen changes zählen, das minimum nehmen
//-> Case2: Es gibt Ms >= K
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
//Algorithmus vorschlag:
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
//2.Ggfls nochmal durchiterieren und Case 1 fixen
//Optimierung kommt später
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
boolean isCase2 = false;
int lastMLength=0;
for(int i=0;i<S.length();i++){
char c = S.charAt(i);
if(c=='M'){
lastMLength++;
}
}
}
}
Code: 11:40:21 UTC,
java,
autosave
// 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(String S, int K) {
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=3
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=7
//-> Case1: Alle Ms < K
//Bei allen Ms anfangen und die nötigen changes zählen, das minimum nehmen
//-> Case2: Es gibt Ms >= K
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
//Algorithmus vorschlag:
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
//2.Ggfls nochmal durchiterieren und Case 1 fixen
//Optimierung kommt später
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
boolean isCase2 = false;
int lastMLength=0;
for(int i=0;i<S.length();i++){
char c = S.charAt(i);
if(c=='M'){
lastMLength++;
}
else{ //Can only be L
}
}
}
}
Code: 11:40:51 UTC,
java,
autosave
// 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(String S, int K) {
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=3
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=7
//-> Case1: Alle Ms < K
//Bei allen Ms anfangen und die nötigen changes zählen, das minimum nehmen
//-> Case2: Es gibt Ms >= K
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
//Algorithmus vorschlag:
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
//2.Ggfls nochmal durchiterieren und Case 1 fixen
//Optimierung kommt später
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
boolean isCase2 = false;
int lastMLength=0;
for(int i=0;i<S.length();i++){
char c = S.charAt(i);
if(c=='M'){
lastMLength++;
}
else{ //Can only be L
if(lastMLength)
}
}
}
}
Code: 11:41:02 UTC,
java,
autosave
// 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(String S, int K) {
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=3
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=7
//-> Case1: Alle Ms < K
//Bei allen Ms anfangen und die nötigen changes zählen, das minimum nehmen
//-> Case2: Es gibt Ms >= K
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
//Algorithmus vorschlag:
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
//2.Ggfls nochmal durchiterieren und Case 1 fixen
//Optimierung kommt später
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
boolean isCase2 = false;
int lastMLength=0;
for(int i=0;i<S.length();i++){
char c = S.charAt(i);
if(c=='M'){
lastMLength++;
}
else{ //Can only be L
if(lastMLength >= K)
}
}
}
}
Code: 11:41:16 UTC,
java,
autosave
// 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(String S, int K) {
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=3
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=7
//-> Case1: Alle Ms < K
//Bei allen Ms anfangen und die nötigen changes zählen, das minimum nehmen
//-> Case2: Es gibt Ms >= K
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
//Algorithmus vorschlag:
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
//2.Ggfls nochmal durchiterieren und Case 1 fixen
//Optimierung kommt später
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
boolean isCase2 = false;
int lastMLength=0;
for(int i=0;i<S.length();i++){
char c = S.charAt(i);
if(c=='M'){
lastMLength++;
}
else{ //Can only be L
if(lastMLength >= K)
isCase2 = true;
}
}
}
}
Code: 11:41:55 UTC,
java,
autosave
// 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(String S, int K) {
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=3
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=7
//-> Case1: Alle Ms < K
//Bei allen Ms anfangen und die nötigen changes zählen, das minimum nehmen
//-> Case2: Es gibt Ms >= K
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
//Algorithmus vorschlag:
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
//2.Ggfls nochmal durchiterieren und Case 1 fixen
//Optimierung kommt später
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
boolean isCase2 = false;
int lastMLength=0;
for(int i=0;i<S.length();i++){
char c = S.charAt(i);
if(c=='M'){
lastMLength++;
}
else{ //Can only be L
if(lastMLength >= K)
isCase2 = true;
}
}
}
}
Code: 11:42:08 UTC,
java,
autosave
// 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(String S, int K) {
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=3
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=7
//-> Case1: Alle Ms < K
//Bei allen Ms anfangen und die nötigen changes zählen, das minimum nehmen
//-> Case2: Es gibt Ms >= K
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
//Algorithmus vorschlag:
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
//2.Ggfls nochmal durchiterieren und Case 1 fixen
//Optimierung kommt später
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
boolean isCase2 = false;
int totalNeededOperationsCase2=0;
int lastMLength=0;
for(int i=0;i<S.length();i++){
char c = S.charAt(i);
if(c=='M'){
lastMLength++;
}
else{ //Can only be L
if(lastMLength >= K)
isCase2 = true;
}
}
}
}
Code: 11:42:20 UTC,
java,
autosave
// 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(String S, int K) {
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=3
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=7
//-> Case1: Alle Ms < K
//Bei allen Ms anfangen und die nötigen changes zählen, das minimum nehmen
//-> Case2: Es gibt Ms >= K
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
//Algorithmus vorschlag:
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
//2.Ggfls nochmal durchiterieren und Case 1 fixen
//Optimierung kommt später
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
boolean isCase2 = false;
int totalNeededOperationsCase2=0;
int lastMLength=0;
for(int i=0;i<S.length();i++){
char c = S.charAt(i);
if(c=='M'){
lastMLength++;
}
else{ //Can only be L
if(lastMLength >= K){
isCase2 = true;
}
}
}
}
}
Code: 11:42:50 UTC,
java,
autosave
// 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(String S, int K) {
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=3
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=7
//-> Case1: Alle Ms < K
//Bei allen Ms anfangen und die nötigen changes zählen, das minimum nehmen
//-> Case2: Es gibt Ms >= K
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
//Algorithmus vorschlag:
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
//2.Ggfls nochmal durchiterieren und Case 1 fixen
//Optimierung kommt später
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
boolean isCase2 = false;
int totalNeededOperationsCase2=0;
int lastMLength=0;
for(int i=0;i<S.length();i++){
char c = S.charAt(i);
if(c=='M'){
lastMLength++;
}
else{ //Can only be L
if(lastMLength >= K){
isCase2 = true;
}
totalNeededOperationsCase2+=lastMLength
}
}
}
}
Code: 11:43:03 UTC,
java,
autosave
// 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(String S, int K) {
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=3
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=7
//-> Case1: Alle Ms < K
//Bei allen Ms anfangen und die nötigen changes zählen, das minimum nehmen
//-> Case2: Es gibt Ms >= K
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
//Algorithmus vorschlag:
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
//2.Ggfls nochmal durchiterieren und Case 1 fixen
//Optimierung kommt später
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
boolean isCase2 = false;
int totalNeededOperationsCase2=0;
int lastMLength=0;
for(int i=0;i<S.length();i++){
char c = S.charAt(i);
if(c=='M'){
lastMLength++;
}
else{ //Can only be L
if(lastMLength >= K){
isCase2 = true;
}
if(isCase2){
totalNeededOperationsCase2+=lastMLength
}
}
}
}
}
Code: 11:43:26 UTC,
java,
autosave
// 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(String S, int K) {
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=3
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=7
//-> Case1: Alle Ms < K
//Bei allen Ms anfangen und die nötigen changes zählen, das minimum nehmen
//-> Case2: Es gibt Ms >= K
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
//Algorithmus vorschlag:
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
//2.Ggfls nochmal durchiterieren und Case 1 fixen
//Optimierung kommt später
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
boolean isCase2 = false;
int totalNeededOperationsCase2=0;
int lastMLength=0;
for(int i=0;i<S.length();i++){
char c = S.charAt(i);
if(c=='M'){
lastMLength++;
}
else{ //Can only be L
if(lastMLength >= K){
isCase2 = true;
}
if(isCase2){
totalNeededOperationsCase2+=Math.floor(lastMLength/K+0.5)-1;
}
}
}
}
}
Code: 11:43:38 UTC,
java,
autosave
// 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(String S, int K) {
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=3
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=7
//-> Case1: Alle Ms < K
//Bei allen Ms anfangen und die nötigen changes zählen, das minimum nehmen
//-> Case2: Es gibt Ms >= K
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
//Algorithmus vorschlag:
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
//2.Ggfls nochmal durchiterieren und Case 1 fixen
//Optimierung kommt später
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
boolean isCase2 = false;
int totalNeededOperationsCase2=0;
int lastMLength=0;
for(int i=0;i<S.length();i++){
char c = S.charAt(i);
if(c=='M'){
lastMLength++;
}
else{ //Can only be L
if(lastMLength >= K){
isCase2 = true;
}
if(isCase2){
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
totalNeededOperationsCase2+=Math.floor(lastMLength/K+0.5)-1;
}
}
}
}
}
Code: 11:44:08 UTC,
java,
autosave
// 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(String S, int K) {
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=3
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=7
//-> Case1: Alle Ms < K
//Bei allen Ms anfangen und die nötigen changes zählen, das minimum nehmen
//-> Case2: Es gibt Ms >= K
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
//Algorithmus vorschlag:
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
//2.Ggfls nochmal durchiterieren und Case 1 fixen
//Optimierung kommt später
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
boolean isCase2 = false;
int totalNeededOperationsCase2=0;
int lastMLength=0;
for(int i=0;i<S.length();i++){
char c = S.charAt(i);
if(c=='M'){
lastMLength++;
}
else{ //Can only be L
if(lastMLength >= K){
isCase2 = true;
}
if(isCase2){
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
totalNeededOperationsCase2+=Math.floor(lastMLength/K+0.5)-1;
}
}
}
if(!isCase2){
}
}
}
Code: 11:44:18 UTC,
java,
autosave
// 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(String S, int K) {
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=3
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=7
//-> Case1: Alle Ms < K
//Bei allen Ms anfangen und die nötigen changes zählen, das minimum nehmen
//-> Case2: Es gibt Ms >= K
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
//Algorithmus vorschlag:
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
//2.Ggfls nochmal durchiterieren und Case 1 fixen
//Optimierung kommt später
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
boolean isCase2 = false;
int totalNeededOperationsCase2=0;
int lastMLength=0;
for(int i=0;i<S.length();i++){
char c = S.charAt(i);
if(c=='M'){
lastMLength++;
}
else{ //Can only be L
if(lastMLength >= K){
isCase2 = true;
}
if(isCase2){
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
totalNeededOperationsCase2+=Math.floor(lastMLength/K+0.5)-1;
}
}
}
if(!isCase2){
for()
}
}
}
Code: 11:44:38 UTC,
java,
autosave
// 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(String S, int K) {
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=3
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=7
//-> Case1: Alle Ms < K
//Bei allen Ms anfangen und die nötigen changes zählen, das minimum nehmen
//-> Case2: Es gibt Ms >= K
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
//Algorithmus vorschlag:
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
//2.Ggfls nochmal durchiterieren und Case 1 fixen
//Optimierung kommt später
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
boolean isCase2 = false;
int totalNeededOperationsCase2=0;
int lastMLength=0;
for(int i=0;i<S.length();i++){
char c = S.charAt(i);
if(c=='M'){
lastMLength++;
}
else{ //Can only be L
if(lastMLength >= K){
isCase2 = true;
}
if(isCase2){
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
totalNeededOperationsCase2+=Math.floor(lastMLength/K+0.5)-1;
}
}
}
if(!isCase2){
for(int i=0;i<S.length();i++){
char c = S.charAt(i);
}
}
}
}
Code: 11:44:53 UTC,
java,
autosave
// 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(String S, int K) {
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=3
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=7
//-> Case1: Alle Ms < K
//Bei allen Ms anfangen und die nötigen changes zählen, das minimum nehmen
//-> Case2: Es gibt Ms >= K
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
//Algorithmus vorschlag:
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
//2.Ggfls nochmal durchiterieren und Case 1 fixen
//Optimierung kommt später
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
boolean isCase2 = false;
int totalNeededOperationsCase2=0;
int lastMLength=0;
for(int i=0;i<S.length();i++){
char c = S.charAt(i);
if(c=='M'){
lastMLength++;
}
else{ //Can only be L
if(lastMLength >= K){
isCase2 = true;
}
if(isCase2){
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
totalNeededOperationsCase2+=Math.floor(lastMLength/K+0.5)-1;
}
}
}
if(!isCase2){
for(int i=0;i<S.length();i++){
char c = S.charAt(i);
}
}
else{
return totalNeededOperationsCase2;
}
}
}
Code: 11:45:05 UTC,
java,
autosave
// 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(String S, int K) {
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=3
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=7
//-> Case1: Alle Ms < K
//Bei allen Ms anfangen und die nötigen changes zählen, das minimum nehmen
//-> Case2: Es gibt Ms >= K
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
//Algorithmus vorschlag:
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
//2.Ggfls nochmal durchiterieren und Case 1 fixen
//Optimierung kommt später
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
boolean isCase2 = false;
int totalNeededOperationsCase2=0;
int totalNeededOperationsCase1=0;
int lastMLength=0;
for(int i=0;i<S.length();i++){
char c = S.charAt(i);
if(c=='M'){
lastMLength++;
}
else{ //Can only be L
if(lastMLength >= K){
isCase2 = true;
}
if(isCase2){
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
totalNeededOperationsCase2+=Math.floor(lastMLength/K+0.5)-1;
}
}
}
if(!isCase2){
for(int i=0;i<S.length();i++){
char c = S.charAt(i);
}
}
else{
return totalNeededOperationsCase2;
}
}
}
Code: 11:45:26 UTC,
java,
autosave
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556
// 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(String S, int K) {
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=3
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=7
//-> Case1: Alle Ms < K
//Bei allen Ms anfangen und die nötigen changes zählen, das minimum nehmen
//-> Case2: Es gibt Ms >= K
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
//Algorithmus vorschlag:
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
//2.Ggfls nochmal durchiterieren und Case 1 fixen
//Optimierung kommt später
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
boolean isCase2 = false;
int totalNeededOperationsCase2=0;
int totalNeededOperationsCase1=0;
int lastMLength=0;
for(int i=0;i<S.length();i++){
char c = S.charAt(i);
if(c=='M'){
lastMLength++;
}
else{ //Can only be L
if(lastMLength >= K){
isCase2 = true;
}
if(isCase2){
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
totalNeededOperationsCase2+=Math.floor(lastMLength/K+0.5)-1;
}
}
}
if(!isCase2){
for(int i=0;i<S.length();i++){
char c = S.charAt(i);
if(c=='M'){
}
}
}
else{
return totalNeededOperationsCase2;
}
}
}
Code: 11:45:36 UTC,
java,
autosave
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556
// 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(String S, int K) {
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=3
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=7
//-> Case1: Alle Ms < K
//Bei allen Ms anfangen und die nötigen changes zählen, das minimum nehmen
//-> Case2: Es gibt Ms >= K
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
//Algorithmus vorschlag:
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
//2.Ggfls nochmal durchiterieren und Case 1 fixen
//Optimierung kommt später
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
boolean isCase2 = false;
int totalNeededOperationsCase2=0;
int minNeededOperationsCase1=0;
int lastMLength=0;
for(int i=0;i<S.length();i++){
char c = S.charAt(i);
if(c=='M'){
lastMLength++;
}
else{ //Can only be L
if(lastMLength >= K){
isCase2 = true;
}
if(isCase2){
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
totalNeededOperationsCase2+=Math.floor(lastMLength/K+0.5)-1;
}
}
}
if(!isCase2){
for(int i=0;i<S.length();i++){
char c = S.charAt(i);
if(c=='M'){
}
}
}
else{
return totalNeededOperationsCase2;
}
}
}
Code: 11:45:47 UTC,
java,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758
// 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(String S, int K) {
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=3
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=7
//-> Case1: Alle Ms < K
//Bei allen Ms anfangen und die nötigen changes zählen, das minimum nehmen
//-> Case2: Es gibt Ms >= K
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
//Algorithmus vorschlag:
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
//2.Ggfls nochmal durchiterieren und Case 1 fixen
//Optimierung kommt später
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
boolean isCase2 = false;
int totalNeededOperationsCase2=0;
int minNeededOperationsCase1=0;
int lastMLength=0;
for(int i=0;i<S.length();i++){
char c = S.charAt(i);
if(c=='M'){
lastMLength++;
}
else{ //Can only be L
if(lastMLength >= K){
isCase2 = true;
}
if(isCase2){
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
totalNeededOperationsCase2+=Math.floor(lastMLength/K+0.5)-1;
}
}
}
if(!isCase2){
for(int i=0;i<S.length();i++){
char c = S.charAt(i);
if(c=='M'){
}
}
return minNeededOperationsCase1;
}
else{
return totalNeededOperationsCase2;
}
}
}
Code: 11:45:57 UTC,
java,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758
// 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(String S, int K) {
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=3
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=7
//-> Case1: Alle Ms < K
//Bei allen Ms anfangen und die nötigen changes zählen, das minimum nehmen
//-> Case2: Es gibt Ms >= K
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
//Algorithmus vorschlag:
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
//2.Ggfls nochmal durchiterieren und Case 1 fixen
//Optimierung kommt später
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
boolean isCase2 = false;
int totalNeededOperationsCase2=0;
int minNeededOperationsCase1=0;
int lastMLength=0;
for(int i=0;i<S.length();i++){
char c = S.charAt(i);
if(c=='M'){
lastMLength++;
}
else{ //Can only be L
if(lastMLength >= K){
isCase2 = true;
}
if(isCase2){
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
totalNeededOperationsCase2+=Math.floor(lastMLength/K+0.5)-1;
}
}
}
if(!isCase2){
for(int i=0;i<S.length();i++){
char c = S.charAt(i);
if(c=='M'){
}
}
return minNeededOperationsCase1;
}
else{
return totalNeededOperationsCase2;
}
}
}
Code: 11:49:10 UTC,
java,
autosave
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859
// 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(String S, int K) {
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=3
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=7
//
//-> Case1: Alle Ms < K
//Bei allen Ms anfangen und die nötigen changes zählen, das minimum nehmen
//-> Case2: Es gibt Ms >= K
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
//Algorithmus vorschlag:
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
//2.Ggfls nochmal durchiterieren und Case 1 fixen
//Optimierung kommt später
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
boolean isCase2 = false;
int totalNeededOperationsCase2=0;
int minNeededOperationsCase1=0;
int lastMLength=0;
for(int i=0;i<S.length();i++){
char c = S.charAt(i);
if(c=='M'){
lastMLength++;
}
else{ //Can only be L
if(lastMLength >= K){
isCase2 = true;
}
if(isCase2){
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
totalNeededOperationsCase2+=Math.floor(lastMLength/K+0.5)-1;
}
}
}
if(!isCase2){
for(int i=0;i<S.length();i++){
char c = S.charAt(i);
if(c=='M'){
}
}
return minNeededOperationsCase1;
}
else{
return totalNeededOperationsCase2;
}
}
}
Code: 11:49:41 UTC,
java,
autosave
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859
// 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(String S, int K) {
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=3
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=7
//1,-1,3,-3,1,-1,1,-1,2,-3,5
//-> Case1: Alle Ms < K
//Bei allen Ms anfangen und die nötigen changes zählen, das minimum nehmen
//-> Case2: Es gibt Ms >= K
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
//Algorithmus vorschlag:
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
//2.Ggfls nochmal durchiterieren und Case 1 fixen
//Optimierung kommt später
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
boolean isCase2 = false;
int totalNeededOperationsCase2=0;
int minNeededOperationsCase1=0;
int lastMLength=0;
for(int i=0;i<S.length();i++){
char c = S.charAt(i);
if(c=='M'){
lastMLength++;
}
else{ //Can only be L
if(lastMLength >= K){
isCase2 = true;
}
if(isCase2){
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
totalNeededOperationsCase2+=Math.floor(lastMLength/K+0.5)-1;
}
}
}
if(!isCase2){
for(int i=0;i<S.length();i++){
char c = S.charAt(i);
if(c=='M'){
}
}
return minNeededOperationsCase1;
}
else{
return totalNeededOperationsCase2;
}
}
}
Code: 11:49:54 UTC,
java,
autosave
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859
// 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(String S, int K) {
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=3
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=7
//1,-1,3,-3,1,-1,1,-1,2,-3,5,-1,1,-1,1,-2,2
//-> Case1: Alle Ms < K
//Bei allen Ms anfangen und die nötigen changes zählen, das minimum nehmen
//-> Case2: Es gibt Ms >= K
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
//Algorithmus vorschlag:
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
//2.Ggfls nochmal durchiterieren und Case 1 fixen
//Optimierung kommt später
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
boolean isCase2 = false;
int totalNeededOperationsCase2=0;
int minNeededOperationsCase1=0;
int lastMLength=0;
for(int i=0;i<S.length();i++){
char c = S.charAt(i);
if(c=='M'){
lastMLength++;
}
else{ //Can only be L
if(lastMLength >= K){
isCase2 = true;
}
if(isCase2){
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
totalNeededOperationsCase2+=Math.floor(lastMLength/K+0.5)-1;
}
}
}
if(!isCase2){
for(int i=0;i<S.length();i++){
char c = S.charAt(i);
if(c=='M'){
}
}
return minNeededOperationsCase1;
}
else{
return totalNeededOperationsCase2;
}
}
}
Code: 11:50:05 UTC,
java,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960
// 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(String S, int K) {
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=3
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=7
//1,-1,3,-3,1,-1,1,-1,2,-3,5,-1,1,-1,1,-2,2
//-> Case1: Alle Ms < K
//Bei allen Ms anfangen und die nötigen changes zählen, das minimum nehmen
//-> Case2: Es gibt Ms >= K
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
//Algorithmus vorschlag:
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
//2.Ggfls nochmal durchiterieren und Case 1 fixen
//Optimierung kommt später
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
boolean isCase2 = false;
int totalNeededOperationsCase2=0;
int minNeededOperationsCase1=0;
int lastMLength=0;
for(int i=0;i<S.length();i++){
char c = S.charAt(i);
if(c=='M'){
lastMLength++;
}
else{ //Can only be L
if(lastMLength >= K){
isCase2 = true;
}
if(isCase2){
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
totalNeededOperationsCase2+=Math.floor(lastMLength/K+0.5)-1;
}
}
}
if(!isCase2){
for(int i=0;i<S.length();i++){
char c = S.charAt(i);
if(c=='M'){
}
}
return minNeededOperationsCase1;
}
else{
return totalNeededOperationsCase2;
}
}
}
Code: 11:56:25 UTC,
java,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960
// 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(String S, int K) {
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=3
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=7
//1,-1,3,-3,1,-1,1,-1,2,-3,5,-1,1,-1,1,-2,2
//-> Case1: Alle Ms < K
//Alle
//-> Case2: Es gibt Ms >= K
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
//Algorithmus vorschlag:
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
//2.Ggfls nochmal durchiterieren und Case 1 fixen
//Optimierung kommt später
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
boolean isCase2 = false;
int totalNeededOperationsCase2=0;
int minNeededOperationsCase1=0;
int lastMLength=0;
for(int i=0;i<S.length();i++){
char c = S.charAt(i);
if(c=='M'){
lastMLength++;
}
else{ //Can only be L
if(lastMLength >= K){
isCase2 = true;
}
if(isCase2){
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
totalNeededOperationsCase2+=Math.floor(lastMLength/K+0.5)-1;
}
}
}
if(!isCase2){
for(int i=0;i<S.length();i++){
char c = S.charAt(i);
if(c=='M'){
}
}
return minNeededOperationsCase1;
}
else{
return totalNeededOperationsCase2;
}
}
}
Code: 11:56:51 UTC,
java,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960
// 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(String S, int K) {
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=3
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=7
//1,-1,3,-3,1,-1,1,-1,2,-3,5,-1,1,-1,1,-2,2
//-> Case1: Alle Ms < K
//Alle Substrings der länge K ansehen und die Ls zählen (+1 pro M an der Grenze)
//-> Case2: Es gibt Ms >= K
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
//Algorithmus vorschlag:
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
//2.Ggfls nochmal durchiterieren und Case 1 fixen
//Optimierung kommt später
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
boolean isCase2 = false;
int totalNeededOperationsCase2=0;
int minNeededOperationsCase1=0;
int lastMLength=0;
for(int i=0;i<S.length();i++){
char c = S.charAt(i);
if(c=='M'){
lastMLength++;
}
else{ //Can only be L
if(lastMLength >= K){
isCase2 = true;
}
if(isCase2){
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
totalNeededOperationsCase2+=Math.floor(lastMLength/K+0.5)-1;
}
}
}
if(!isCase2){
for(int i=0;i<S.length();i++){
char c = S.charAt(i);
if(c=='M'){
}
}
return minNeededOperationsCase1;
}
else{
return totalNeededOperationsCase2;
}
}
}
Code: 11:57:19 UTC,
java,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061
// 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(String S, int K) {
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=3
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=7
//1,-1,3,-3,1,-1,1,-1,2,-3,5,-1,1,-1,1,-2,2
//-> Case1: Alle Ms < K
//Alle Substrings der länge K ansehen und die Ls zählen (+1 pro M an der Grenze)
//-> Case2: Es gibt Ms >= K
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
//Algorithmus vorschlag:
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
//2.Ggfls nochmal durchiterieren und Case 1 fixen
//Optimierung kommt später
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
boolean isCase2 = false;
int totalNeededOperationsCase2=0;
int minNeededOperationsCase1=0;
int lastMLength=0;
for(int i=0;i<S.length();i++){
char c = S.charAt(i);
if(c=='M'){
lastMLength++;
}
else{ //Can only be L
if(lastMLength >= K){
isCase2 = true;
}
if(isCase2){
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
totalNeededOperationsCase2+=Math.floor(lastMLength/K+0.5)-1;
}
}
}
if(!isCase2){
for(int i=0;i<S.length();i++){
char c = S.charAt(i);
if(c=='M'){
}
}
return minNeededOperationsCase1;
}
else{
return totalNeededOperationsCase2;
}
}
}
Code: 11:57:40 UTC,
java,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061
// 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(String S, int K) {
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=3
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=7
//1,-1,3,-3,1,-1,1,-1,2,-3,5,-1,1,-1,1,-2,2
//-> Case1: Alle Ms < K
//Alle Substrings der länge K ansehen und die Ls zählen (+1 pro M an der Grenze)
//-> Case2: Es gibt Ms >= K
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
//Algorithmus vorschlag:
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
//2.Ggfls nochmal durchiterieren und Case 1 fixen
//Optimierung kommt später
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
boolean isCase2 = false;
int totalNeededOperationsCase2=0;
int minNeededOperationsCase1=0;
int lastMLength=0;
for(int i=0;i<S.length();i++){
char c = S.charAt(i);
if(c=='M'){
lastMLength++;
}
else{ //Can only be L
if(lastMLength >= K){
isCase2 = true;
}
if(isCase2){
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
totalNeededOperationsCase2+=Math.floor(lastMLength/K+0.5)-1;
}
}
}
if(!isCase2){
int lCounter=0;
for(int i=0;i<S.length();i++){
char c = S.charAt(i);
if(c=='M'){
}
}
return minNeededOperationsCase1;
}
else{
return totalNeededOperationsCase2;
}
}
}
Code: 11:58:10 UTC,
java,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263
// 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(String S, int K) {
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=3
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=7
//1,-1,3,-3,1,-1,1,-1,2,-3,5,-1,1,-1,1,-2,2
//-> Case1: Alle Ms < K
//Alle Substrings der länge K ansehen und die Ls zählen (+1 pro M an der Grenze)
//-> Case2: Es gibt Ms >= K
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
//Algorithmus vorschlag:
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
//2.Ggfls nochmal durchiterieren und Case 1 fixen
//Optimierung kommt später
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
boolean isCase2 = false;
int totalNeededOperationsCase2=0;
int minNeededOperationsCase1=0;
int lastMLength=0;
for(int i=0;i<S.length();i++){
char c = S.charAt(i);
if(c=='M'){
lastMLength++;
}
else{ //Can only be L
if(lastMLength >= K){
isCase2 = true;
}
if(isCase2){
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
totalNeededOperationsCase2+=Math.floor(lastMLength/K+0.5)-1;
}
}
}
if(!isCase2){
int lCounter=0;
for(int i=0;i<k)
for(int i=0;i<S.length();i++){
char c = S.charAt(i);
if(c=='M'){
}
}
return minNeededOperationsCase1;
}
else{
return totalNeededOperationsCase2;
}
}
}
Code: 11:58:27 UTC,
java,
autosave
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465
// 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(String S, int K) {
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=3
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=7
//1,-1,3,-3,1,-1,1,-1,2,-3,5,-1,1,-1,1,-2,2
//-> Case1: Alle Ms < K
//Alle Substrings der länge K ansehen und die Ls zählen (+1 pro M an der Grenze)
//-> Case2: Es gibt Ms >= K
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
//Algorithmus vorschlag:
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
//2.Ggfls nochmal durchiterieren und Case 1 fixen
//Optimierung kommt später
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
boolean isCase2 = false;
int totalNeededOperationsCase2=0;
int minNeededOperationsCase1=0;
int lastMLength=0;
for(int i=0;i<S.length();i++){
char c = S.charAt(i);
if(c=='M'){
lastMLength++;
}
else{ //Can only be L
if(lastMLength >= K){
isCase2 = true;
}
if(isCase2){
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
totalNeededOperationsCase2+=Math.floor(lastMLength/K+0.5)-1;
}
}
}
if(!isCase2){
int lCounter=0;
for(int i=0;i<k;i++){
}
for(int i=0;i<S.length();i++){
char c = S.charAt(i);
if(c=='M'){
}
}
return minNeededOperationsCase1;
}
else{
return totalNeededOperationsCase2;
}
}
}
Code: 11:58:56 UTC,
java,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667
// 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(String S, int K) {
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=3
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=7
//1,-1,3,-3,1,-1,1,-1,2,-3,5,-1,1,-1,1,-2,2
//-> Case1: Alle Ms < K
//Alle Substrings der länge K ansehen und die Ls zählen (+1 pro M an der Grenze)
//-> Case2: Es gibt Ms >= K
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
//Algorithmus vorschlag:
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
//2.Ggfls nochmal durchiterieren und Case 1 fixen
//Optimierung kommt später
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
boolean isCase2 = false;
int totalNeededOperationsCase2=0;
int minNeededOperationsCase1=0;
int lastMLength=0;
for(int i=0;i<S.length();i++){
char c = S.charAt(i);
if(c=='M'){
lastMLength++;
}
else{ //Can only be L
if(lastMLength >= K){
isCase2 = true;
}
if(isCase2){
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
totalNeededOperationsCase2+=Math.floor(lastMLength/K+0.5)-1;
}
}
}
if(!isCase2){
int lCounter=0;
for(int i=0;i<k;i++){
if(c!='M'){
lCounter++;
}
}
for(int i=0;i<S.length();i++){
char c = S.charAt(i);
if(c=='M'){
}
}
return minNeededOperationsCase1;
}
else{
return totalNeededOperationsCase2;
}
}
}
Code: 11:59:26 UTC,
java,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667
// 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(String S, int K) {
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=3
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=7
//1,-1,3,-3,1,-1,1,-1,2,-3,5,-1,1,-1,1,-2,2
//-> Case1: Alle Ms < K
//Alle Substrings der länge K ansehen und die Ls zählen (+1 pro M an der Grenze)
//-> Case2: Es gibt Ms >= K
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
//Algorithmus vorschlag:
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
//2.Ggfls nochmal durchiterieren und Case 1 fixen
//Optimierung kommt später
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
boolean isCase2 = false;
int totalNeededOperationsCase2=0;
int minNeededOperationsCase1=0;
int lastMLength=0;
for(int i=0;i<S.length();i++){
char c = S.charAt(i);
if(c=='M'){
lastMLength++;
}
else{ //Can only be L
if(lastMLength >= K){
isCase2 = true;
}
if(isCase2){
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
totalNeededOperationsCase2+=Math.floor(lastMLength/K+0.5)-1;
}
}
}
if(!isCase2){
int lCounter=0;
for(int i=0;i<k;i++){
if(c!='M'){
lCounter++;
}
}
minNeededOperationsCase1 = lCounter
for(int i=0;i<S.length();i++){
char c = S.charAt(i);
if(c=='M'){
}
}
return minNeededOperationsCase1;
}
else{
return totalNeededOperationsCase2;
}
}
}
Code: 11:59:36 UTC,
java,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667
// 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(String S, int K) {
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=3
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=7
//1,-1,3,-3,1,-1,1,-1,2,-3,5,-1,1,-1,1,-2,2
//-> Case1: Alle Ms < K
//Alle Substrings der länge K ansehen und die Ls zählen (+1 pro M an der Grenze)
//-> Case2: Es gibt Ms >= K
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
//Algorithmus vorschlag:
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
//2.Ggfls nochmal durchiterieren und Case 1 fixen
//Optimierung kommt später
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
boolean isCase2 = false;
int totalNeededOperationsCase2=0;
int minNeededOperationsCase1=0;
int lastMLength=0;
for(int i=0;i<S.length();i++){
char c = S.charAt(i);
if(c=='M'){
lastMLength++;
}
else{ //Can only be L
if(lastMLength >= K){
isCase2 = true;
}
if(isCase2){
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
totalNeededOperationsCase2+=Math.floor(lastMLength/K+0.5)-1;
}
}
}
if(!isCase2){
int lCounter=0;
for(int i=0;i<k;i++){
if(c!='M'){
lCounter++;
}
}
minNeededOperationsCase1 = lCounter;
for(int i=0;i<S.length();i++){
char c = S.charAt(i);
if(c=='M'){
}
}
return minNeededOperationsCase1;
}
else{
return totalNeededOperationsCase2;
}
}
}
Code: 12:00:00 UTC,
java,
autosave
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768
// 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(String S, int K) {
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=3
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=7
//1,-1,3,-3,1,-1,1,-1,2,-3,5,-1,1,-1,1,-2,2
//-> Case1: Alle Ms < K
//Alle Substrings der länge K ansehen und die Ls zählen (+1 pro M an der Grenze)
//-> Case2: Es gibt Ms >= K
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
//Algorithmus vorschlag:
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
//2.Ggfls nochmal durchiterieren und Case 1 fixen
//Optimierung kommt später
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
boolean isCase2 = false;
int totalNeededOperationsCase2=0;
int minNeededOperationsCase1=0;
int lastMLength=0;
for(int i=0;i<S.length();i++){
char c = S.charAt(i);
if(c=='M'){
lastMLength++;
}
else{ //Can only be L
if(lastMLength >= K){
isCase2 = true;
}
if(isCase2){
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
totalNeededOperationsCase2+=Math.floor(lastMLength/K+0.5)-1;
}
}
}
if(!isCase2){
int lCounter=0;
for(int i=0;i<k;i++){
if(c!='M'){
lCounter++;
}
}
minNeededOperationsCase1 = lCounter;
if(k==N)
for(int i=0;i<S.length();i++){
char c = S.charAt(i);
if(c=='M'){
}
}
return minNeededOperationsCase1;
}
else{
return totalNeededOperationsCase2;
}
}
}
Code: 12:00:11 UTC,
java,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869
// 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(String S, int K) {
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=3
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=7
//1,-1,3,-3,1,-1,1,-1,2,-3,5,-1,1,-1,1,-2,2
//-> Case1: Alle Ms < K
//Alle Substrings der länge K ansehen und die Ls zählen (+1 pro M an der Grenze)
//-> Case2: Es gibt Ms >= K
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
//Algorithmus vorschlag:
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
//2.Ggfls nochmal durchiterieren und Case 1 fixen
//Optimierung kommt später
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
boolean isCase2 = false;
int totalNeededOperationsCase2=0;
int minNeededOperationsCase1=0;
int lastMLength=0;
for(int i=0;i<S.length();i++){
char c = S.charAt(i);
if(c=='M'){
lastMLength++;
}
else{ //Can only be L
if(lastMLength >= K){
isCase2 = true;
}
if(isCase2){
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
totalNeededOperationsCase2+=Math.floor(lastMLength/K+0.5)-1;
}
}
}
if(!isCase2){
int lCounter=0;
for(int i=0;i<k;i++){
if(c!='M'){
lCounter++;
}
}
minNeededOperationsCase1 = lCounter;
if(k==N) return minNeededOperationsCase1;
for(int i=0;i<S.length();i++){
char c = S.charAt(i);
if(c=='M'){
}
}
return minNeededOperationsCase1;
}
else{
return totalNeededOperationsCase2;
}
}
}
Code: 12:00:22 UTC,
java,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970
// 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(String S, int K) {
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=3
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=7
//1,-1,3,-3,1,-1,1,-1,2,-3,5,-1,1,-1,1,-2,2
//-> Case1: Alle Ms < K
//Alle Substrings der länge K ansehen und die Ls zählen (+1 pro M an der Grenze)
//-> Case2: Es gibt Ms >= K
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
//Algorithmus vorschlag:
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
//2.Ggfls nochmal durchiterieren und Case 1 fixen
//Optimierung kommt später
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
boolean isCase2 = false;
int totalNeededOperationsCase2=0;
int minNeededOperationsCase1=0;
int lastMLength=0;
for(int i=0;i<S.length();i++){
char c = S.charAt(i);
if(c=='M'){
lastMLength++;
}
else{ //Can only be L
if(lastMLength >= K){
isCase2 = true;
}
if(isCase2){
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
totalNeededOperationsCase2+=Math.floor(lastMLength/K+0.5)-1;
}
}
}
if(!isCase2){
int lCounter=0;
for(int i=0;i<k;i++){
if(c!='M'){
lCounter++;
}
}
minNeededOperationsCase1 = lCounter;
//because then
if(k==N) return minNeededOperationsCase1;
for(int i=0;i<S.length();i++){
char c = S.charAt(i);
if(c=='M'){
}
}
return minNeededOperationsCase1;
}
else{
return totalNeededOperationsCase2;
}
}
}
Code: 12:00:33 UTC,
java,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970
// 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(String S, int K) {
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=3
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=7
//1,-1,3,-3,1,-1,1,-1,2,-3,5,-1,1,-1,1,-2,2
//-> Case1: Alle Ms < K
//Alle Substrings der länge K ansehen und die Ls zählen (+1 pro M an der Grenze)
//-> Case2: Es gibt Ms >= K
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
//Algorithmus vorschlag:
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
//2.Ggfls nochmal durchiterieren und Case 1 fixen
//Optimierung kommt später
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
boolean isCase2 = false;
int totalNeededOperationsCase2=0;
int minNeededOperationsCase1=0;
int lastMLength=0;
for(int i=0;i<S.length();i++){
char c = S.charAt(i);
if(c=='M'){
lastMLength++;
}
else{ //Can only be L
if(lastMLength >= K){
isCase2 = true;
}
if(isCase2){
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
totalNeededOperationsCase2+=Math.floor(lastMLength/K+0.5)-1;
}
}
}
if(!isCase2){
int lCounter=0;
for(int i=0;i<k;i++){
if(c!='M'){
lCounter++;
}
}
minNeededOperationsCase1 = lCounter;
//because then this is the only case
if(k==N) return minNeededOperationsCase1;
for(int i=0;i<S.length();i++){
char c = S.charAt(i);
if(c=='M'){
}
}
return minNeededOperationsCase1;
}
else{
return totalNeededOperationsCase2;
}
}
}
Code: 12:00:44 UTC,
java,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970
// 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(String S, int K) {
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=3
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=7
//1,-1,3,-3,1,-1,1,-1,2,-3,5,-1,1,-1,1,-2,2
//-> Case1: Alle Ms < K
//Alle Substrings der länge K ansehen und die Ls zählen (+1 pro M an der Grenze)
//-> Case2: Es gibt Ms >= K
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
//Algorithmus vorschlag:
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
//2.Ggfls nochmal durchiterieren und Case 1 fixen
//Optimierung kommt später
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
boolean isCase2 = false;
int totalNeededOperationsCase2=0;
int minNeededOperationsCase1=0;
int lastMLength=0;
for(int i=0;i<S.length();i++){
char c = S.charAt(i);
if(c=='M'){
lastMLength++;
}
else{ //Can only be L
if(lastMLength >= K){
isCase2 = true;
}
if(isCase2){
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
totalNeededOperationsCase2+=Math.floor(lastMLength/K+0.5)-1;
}
}
}
if(!isCase2){
int lCounter=0;
for(int i=0;i<k;i++){
if(c!='M'){
lCounter++;
}
}
minNeededOperationsCase1 = lCounter;
//because then this is the only case
if(k==N) return minNeededOperationsCase1;
if()
for(int i=0;i<S.length();i++){
char c = S.charAt(i);
if(c=='M'){
}
}
return minNeededOperationsCase1;
}
else{
return totalNeededOperationsCase2;
}
}
}
Code: 12:01:14 UTC,
java,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172
// 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(String S, int K) {
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=3
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=7
//1,-1,3,-3,1,-1,1,-1,2,-3,5,-1,1,-1,1,-2,2
//-> Case1: Alle Ms < K
//Alle Substrings der länge K ansehen und die Ls zählen (+1 pro M an der Grenze)
//-> Case2: Es gibt Ms >= K
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
//Algorithmus vorschlag:
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
//2.Ggfls nochmal durchiterieren und Case 1 fixen
//Optimierung kommt später
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
boolean isCase2 = false;
int totalNeededOperationsCase2=0;
int minNeededOperationsCase1=0;
int lastMLength=0;
for(int i=0;i<S.length();i++){
char c = S.charAt(i);
if(c=='M'){
lastMLength++;
}
else{ //Can only be L
if(lastMLength >= K){
isCase2 = true;
}
if(isCase2){
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
totalNeededOperationsCase2+=Math.floor(lastMLength/K+0.5)-1;
}
}
}
if(!isCase2){
int lCounter=0;
for(int i=0;i<k;i++){
char c = S.charAt(i);
if(c!='M'){
lCounter++;
}
}
minNeededOperationsCase1 = lCounter;
//because then this is the only case
if(k==N) return minNeededOperationsCase1;
if(S.charAt(k)=='M') minNeededOperationsCase1++;
for(int i=0;i<S.length();i++){
char c = S.charAt(i);
if(c=='M'){
}
}
return minNeededOperationsCase1;
}
else{
return totalNeededOperationsCase2;
}
}
}
Code: 12:01:37 UTC,
java,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273
// 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(String S, int K) {
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=3
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=7
//1,-1,3,-3,1,-1,1,-1,2,-3,5,-1,1,-1,1,-2,2
//-> Case1: Alle Ms < K
//Alle Substrings der länge K ansehen und die Ls zählen (+1 pro M an der Grenze)
//-> Case2: Es gibt Ms >= K
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
//Algorithmus vorschlag:
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
//2.Ggfls nochmal durchiterieren und Case 1 fixen
//Optimierung kommt später
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
boolean isCase2 = false;
int totalNeededOperationsCase2=0;
int minNeededOperationsCase1=0;
int lastMLength=0;
for(int i=0;i<S.length();i++){
char c = S.charAt(i);
if(c=='M'){
lastMLength++;
}
else{ //Can only be L
if(lastMLength >= K){
isCase2 = true;
}
if(isCase2){
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
totalNeededOperationsCase2+=Math.floor(lastMLength/K+0.5)-1;
}
}
}
if(!isCase2){
int lCounter=0;
for(int i=0;i<k;i++){
char c = S.charAt(i);
if(c!='M'){
lCounter++;
}
}
minNeededOperationsCase1 = lCounter;
//because then this is the only case
if(k==N) return minNeededOperationsCase1;
//In this case the M train has become too big
if(S.charAt(k)=='M') minNeededOperationsCase1++;
for(int i=k;i<S.length();i++){
char c = S.charAt(i);
if(c=='M'){
}
}
return minNeededOperationsCase1;
}
else{
return totalNeededOperationsCase2;
}
}
}
Code: 12:01:56 UTC,
java,
autosave
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374
// 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(String S, int K) {
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=3
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=7
//1,-1,3,-3,1,-1,1,-1,2,-3,5,-1,1,-1,1,-2,2
//-> Case1: Alle Ms < K
//Alle Substrings der länge K ansehen und die Ls zählen (+1 pro M an der Grenze)
//-> Case2: Es gibt Ms >= K
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
//Algorithmus vorschlag:
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
//2.Ggfls nochmal durchiterieren und Case 1 fixen
//Optimierung kommt später
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
boolean isCase2 = false;
int totalNeededOperationsCase2=0;
int minNeededOperationsCase1=0;
int lastMLength=0;
for(int i=0;i<S.length();i++){
char c = S.charAt(i);
if(c=='M'){
lastMLength++;
}
else{ //Can only be L
if(lastMLength >= K){
isCase2 = true;
}
if(isCase2){
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
totalNeededOperationsCase2+=Math.floor(lastMLength/K+0.5)-1;
}
}
}
if(!isCase2){
int lCounter=0;
for(int i=0;i<k;i++){
char c = S.charAt(i);
if(c!='M'){
lCounter++;
}
}
minNeededOperationsCase1 = lCounter;
//because then this is the only case
if(k==N) return minNeededOperationsCase1;
//In this case the M train has become too big
if(S.charAt(k)=='M') minNeededOperationsCase1++;
for(int i=k;i<S.length();i++){
char c = S.charAt(i);
char firstChar =
if(c=='M'){
}
}
return minNeededOperationsCase1;
}
else{
return totalNeededOperationsCase2;
}
}
}
Code: 12:02:18 UTC,
java,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475
// 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(String S, int K) {
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=3
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=7
//1,-1,3,-3,1,-1,1,-1,2,-3,5,-1,1,-1,1,-2,2
//-> Case1: Alle Ms < K
//Alle Substrings der länge K ansehen und die Ls zählen (+1 pro M an der Grenze)
//-> Case2: Es gibt Ms >= K
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
//Algorithmus vorschlag:
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
//2.Ggfls nochmal durchiterieren und Case 1 fixen
//Optimierung kommt später
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
boolean isCase2 = false;
int totalNeededOperationsCase2=0;
int minNeededOperationsCase1=0;
int lastMLength=0;
for(int i=0;i<S.length();i++){
char c = S.charAt(i);
if(c=='M'){
lastMLength++;
}
else{ //Can only be L
if(lastMLength >= K){
isCase2 = true;
}
if(isCase2){
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
totalNeededOperationsCase2+=Math.floor(lastMLength/K+0.5)-1;
}
}
}
if(!isCase2){
int lCounter=0;
for(int i=0;i<k;i++){
char c = S.charAt(i);
if(c!='M'){
lCounter++;
}
}
minNeededOperationsCase1 = lCounter;
//because then this is the only case
if(k==N) return minNeededOperationsCase1;
//In this case the M train has become too big
if(S.charAt(k)=='M') minNeededOperationsCase1++;
for(int i=k;i<S.length();i++){
char c = S.charAt(i);
char firstChar = S.charAt(i-k);
//adapt current operationsneeded
if(c=='M'){
}
}
return minNeededOperationsCase1;
}
else{
return totalNeededOperationsCase2;
}
}
}
Code: 12:02:34 UTC,
java,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576
// 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(String S, int K) {
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=3
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=7
//1,-1,3,-3,1,-1,1,-1,2,-3,5,-1,1,-1,1,-2,2
//-> Case1: Alle Ms < K
//Alle Substrings der länge K ansehen und die Ls zählen (+1 pro M an der Grenze)
//-> Case2: Es gibt Ms >= K
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
//Algorithmus vorschlag:
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
//2.Ggfls nochmal durchiterieren und Case 1 fixen
//Optimierung kommt später
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
boolean isCase2 = false;
int totalNeededOperationsCase2=0;
int minNeededOperationsCase1=0;
int lastMLength=0;
for(int i=0;i<S.length();i++){
char c = S.charAt(i);
if(c=='M'){
lastMLength++;
}
else{ //Can only be L
if(lastMLength >= K){
isCase2 = true;
}
if(isCase2){
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
totalNeededOperationsCase2+=Math.floor(lastMLength/K+0.5)-1;
}
}
}
if(!isCase2){
int lCounter=0;
for(int i=0;i<k;i++){
char c = S.charAt(i);
if(c!='M'){
lCounter++;
}
}
minNeededOperationsCase1 = lCounter;
//because then this is the only case
if(k==N) return minNeededOperationsCase1;
//In this case the M train has become too big
if(S.charAt(k)=='M') minNeededOperationsCase1++;
for(int i=k;i<S.length();i++){
char c = S.charAt(i);
char firstChar = S.charAt(i-k);
//adapt current operationsneeded
//
if(c=='M'){
}
}
return minNeededOperationsCase1;
}
else{
return totalNeededOperationsCase2;
}
}
}
Code: 12:02:52 UTC,
java,
autosave
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677
// 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(String S, int K) {
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=3
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=7
//1,-1,3,-3,1,-1,1,-1,2,-3,5,-1,1,-1,1,-2,2
//-> Case1: Alle Ms < K
//Alle Substrings der länge K ansehen und die Ls zählen (+1 pro M an der Grenze)
//-> Case2: Es gibt Ms >= K
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
//Algorithmus vorschlag:
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
//2.Ggfls nochmal durchiterieren und Case 1 fixen
//Optimierung kommt später
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
boolean isCase2 = false;
int totalNeededOperationsCase2=0;
int minNeededOperationsCase1=0;
int lastMLength=0;
for(int i=0;i<S.length();i++){
char c = S.charAt(i);
if(c=='M'){
lastMLength++;
}
else{ //Can only be L
if(lastMLength >= K){
isCase2 = true;
}
if(isCase2){
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
totalNeededOperationsCase2+=Math.floor(lastMLength/K+0.5)-1;
}
}
}
if(!isCase2){
int lCounter=0;
for(int i=0;i<k;i++){
char c = S.charAt(i);
if(c!='M'){
lCounter++;
}
}
minNeededOperationsCase1 = lCounter;
//because then this is the only case
if(k==N) return minNeededOperationsCase1;
//In this case the M train has become too big
if(S.charAt(k)=='M') minNeededOperationsCase1++;
for(int i=k;i<S.length();i++){
char c = S.charAt(i);
char firstChar = S.charAt(i-k);
//adapt current operations needed value
//compare to current minimum
if(c=='M'){
}
}
return minNeededOperationsCase1;
}
else{
return totalNeededOperationsCase2;
}
}
}
Code: 12:03:13 UTC,
java,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778
// 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(String S, int K) {
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=3
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=7
//1,-1,3,-3,1,-1,1,-1,2,-3,5,-1,1,-1,1,-2,2
//-> Case1: Alle Ms < K
//Alle Substrings der länge K ansehen und die Ls zählen (+1 pro M an der Grenze)
//-> Case2: Es gibt Ms >= K
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
//Algorithmus vorschlag:
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
//2.Ggfls nochmal durchiterieren und Case 1 fixen
//Optimierung kommt später
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
boolean isCase2 = false;
int totalNeededOperationsCase2=0;
int minNeededOperationsCase1=0;
int lastMLength=0;
for(int i=0;i<S.length();i++){
char c = S.charAt(i);
if(c=='M'){
lastMLength++;
}
else{ //Can only be L
if(lastMLength >= K){
isCase2 = true;
}
if(isCase2){
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
totalNeededOperationsCase2+=Math.floor(lastMLength/K+0.5)-1;
}
}
}
if(!isCase2){
int lCounter=0;
for(int i=0;i<k;i++){
char c = S.charAt(i);
if(c!='M'){
lCounter++;
}
}
minNeededOperationsCase1 = lCounter;
//because then this is the only case
if(k==N) return minNeededOperationsCase1;
//In this case the M train has become too big
if(S.charAt(k)=='M') minNeededOperationsCase1++;
int currentOpsNeeded=minNeededOperationsCase1;
for(int i=k;i<S.length();i++){
char c = S.charAt(i);
char firstChar = S.charAt(i-k);
//adapt current operations needed value
//compare to current minimum
if(c=='M'){
}
}
return minNeededOperationsCase1;
}
else{
return totalNeededOperationsCase2;
}
}
}
Code: 12:03:24 UTC,
java,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778
// 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(String S, int K) {
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=3
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=7
//1,-1,3,-3,1,-1,1,-1,2,-3,5,-1,1,-1,1,-2,2
//-> Case1: Alle Ms < K
//Alle Substrings der länge K ansehen und die Ls zählen (+1 pro M an der Grenze)
//-> Case2: Es gibt Ms >= K
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
//Algorithmus vorschlag:
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
//2.Ggfls nochmal durchiterieren und Case 1 fixen
//Optimierung kommt später
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
boolean isCase2 = false;
int totalNeededOperationsCase2=0;
int minNeededOperationsCase1=0;
int lastMLength=0;
for(int i=0;i<S.length();i++){
char c = S.charAt(i);
if(c=='M'){
lastMLength++;
}
else{ //Can only be L
if(lastMLength >= K){
isCase2 = true;
}
if(isCase2){
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
totalNeededOperationsCase2+=Math.floor(lastMLength/K+0.5)-1;
}
}
}
if(!isCase2){
int lCounter=0;
for(int i=0;i<k;i++){
char c = S.charAt(i);
if(c!='M'){
lCounter++;
}
}
minNeededOperationsCase1 = lCounter;
//because then this is the only case
if(k==N) return minNeededOperationsCase1;
//In this case the M train has become too big
if(S.charAt(k)=='M') minNeededOperationsCase1++;
int currentOpsNeeded=minNeededOperationsCase1 - 1;
for(int i=k;i<S.length();i++){
char c = S.charAt(i);
char firstChar = S.charAt(i-k);
//adapt current operations needed value
//compare to current minimum
if(c=='M'){
}
}
return minNeededOperationsCase1;
}
else{
return totalNeededOperationsCase2;
}
}
}
Code: 12:03:54 UTC,
java,
autosave
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980
// 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(String S, int K) {
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=3
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=7
//1,-1,3,-3,1,-1,1,-1,2,-3,5,-1,1,-1,1,-2,2
//-> Case1: Alle Ms < K
//Alle Substrings der länge K ansehen und die Ls zählen (+1 pro M an der Grenze)
//-> Case2: Es gibt Ms >= K
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
//Algorithmus vorschlag:
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
//2.Ggfls nochmal durchiterieren und Case 1 fixen
//Optimierung kommt später
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
boolean isCase2 = false;
int totalNeededOperationsCase2=0;
int minNeededOperationsCase1=0;
int lastMLength=0;
for(int i=0;i<S.length();i++){
char c = S.charAt(i);
if(c=='M'){
lastMLength++;
}
else{ //Can only be L
if(lastMLength >= K){
isCase2 = true;
}
if(isCase2){
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
totalNeededOperationsCase2+=Math.floor(lastMLength/K+0.5)-1;
}
}
}
if(!isCase2){
int lCounter=0;
for(int i=0;i<k;i++){
char c = S.charAt(i);
if(c!='M'){
lCounter++;
}
}
minNeededOperationsCase1 = lCounter;
//because then this is the only case
if(k==N) return minNeededOperationsCase1;
//This needs to happen before in case the value is incremented (we dont know)
int currentOpsNeeded=minNeededOperationsCase1;
//In this case the M train has become too big
if(S.charAt(k)=='M') minNeededOperationsCase1++;
for(int i=k;i<S.length();i++){
char c = S.charAt(i);
char firstChar = S.charAt(i-k);
//adapt current operations needed value
//compare to current minimum
if(c=='M'){
}
}
return minNeededOperationsCase1;
}
else{
return totalNeededOperationsCase2;
}
}
}
Code: 12:04:12 UTC,
java,
autosave
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980
// 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(String S, int K) {
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=3
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=7
//1,-1,3,-3,1,-1,1,-1,2,-3,5,-1,1,-1,1,-2,2
//-> Case1: Alle Ms < K
//Alle Substrings der länge K ansehen und die Ls zählen (+1 pro M an der Grenze)
//-> Case2: Es gibt Ms >= K
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
//Algorithmus vorschlag:
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
//2.Ggfls nochmal durchiterieren und Case 1 fixen
//Optimierung kommt später
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
boolean isCase2 = false;
int totalNeededOperationsCase2=0;
int minNeededOperationsCase1=0;
int lastMLength=0;
for(int i=0;i<S.length();i++){
char c = S.charAt(i);
if(c=='M'){
lastMLength++;
}
else{ //Can only be L
if(lastMLength >= K){
isCase2 = true;
}
if(isCase2){
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
totalNeededOperationsCase2+=Math.floor(lastMLength/K+0.5)-1;
}
}
}
if(!isCase2){
int lCounter=0;
for(int i=0;i<k;i++){
char c = S.charAt(i);
if(c!='M'){
lCounter++;
}
}
minNeededOperationsCase1 = lCounter;
//because then this is the only case
if(k==N) return minNeededOperationsCase1;
//This needs to happen before in case the value is incremented (we dont know)
int currentOpsNeeded=minNeededOperationsCase1;
//In this case the M train has become too big
if(S.charAt(k)=='M') minNeededOperationsCase1++;
for(int i=k;i<S.length();i++){
char c = S.charAt(i);
char firstChar = S.charAt(i-k);
//adapt current operations needed value
if(c=='L'){
}
//compare to current minimum
}
return minNeededOperationsCase1;
}
else{
return totalNeededOperationsCase2;
}
}
}
Code: 12:04:22 UTC,
java,
autosave
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980
// 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(String S, int K) {
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=3
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=7
//1,-1,3,-3,1,-1,1,-1,2,-3,5,-1,1,-1,1,-2,2
//-> Case1: Alle Ms < K
//Alle Substrings der länge K ansehen und die Ls zählen (+1 pro M an der Grenze)
//-> Case2: Es gibt Ms >= K
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
//Algorithmus vorschlag:
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
//2.Ggfls nochmal durchiterieren und Case 1 fixen
//Optimierung kommt später
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
boolean isCase2 = false;
int totalNeededOperationsCase2=0;
int minNeededOperationsCase1=0;
int lastMLength=0;
for(int i=0;i<S.length();i++){
char c = S.charAt(i);
if(c=='M'){
lastMLength++;
}
else{ //Can only be L
if(lastMLength >= K){
isCase2 = true;
}
if(isCase2){
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
totalNeededOperationsCase2+=Math.floor(lastMLength/K+0.5)-1;
}
}
}
if(!isCase2){
int lCounter=0;
for(int i=0;i<k;i++){
char c = S.charAt(i);
if(c!='M'){
lCounter++;
}
}
minNeededOperationsCase1 = lCounter;
//because then this is the only case
if(k==N) return minNeededOperationsCase1;
//This needs to happen before in case the value is incremented (we dont know)
int currentOpsNeeded=minNeededOperationsCase1;
//In this case the M train has become too big
if(S.charAt(k)=='M') minNeededOperationsCase1++;
for(int i=k;i<S.length();i++){
char c = S.charAt(i);
char firstChar = S.charAt(i-k);
//adapt current operations needed value
if(c=='L'){
currentOpsNeeded++;
}
//compare to current minimum
}
return minNeededOperationsCase1;
}
else{
return totalNeededOperationsCase2;
}
}
}
Code: 12:04:40 UTC,
java,
autosave
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283
// 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(String S, int K) {
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=3
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=7
//1,-1,3,-3,1,-1,1,-1,2,-3,5,-1,1,-1,1,-2,2
//-> Case1: Alle Ms < K
//Alle Substrings der länge K ansehen und die Ls zählen (+1 pro M an der Grenze)
//-> Case2: Es gibt Ms >= K
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
//Algorithmus vorschlag:
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
//2.Ggfls nochmal durchiterieren und Case 1 fixen
//Optimierung kommt später
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
boolean isCase2 = false;
int totalNeededOperationsCase2=0;
int minNeededOperationsCase1=0;
int lastMLength=0;
for(int i=0;i<S.length();i++){
char c = S.charAt(i);
if(c=='M'){
lastMLength++;
}
else{ //Can only be L
if(lastMLength >= K){
isCase2 = true;
}
if(isCase2){
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
totalNeededOperationsCase2+=Math.floor(lastMLength/K+0.5)-1;
}
}
}
if(!isCase2){
int lCounter=0;
for(int i=0;i<k;i++){
char c = S.charAt(i);
if(c!='M'){
lCounter++;
}
}
minNeededOperationsCase1 = lCounter;
//because then this is the only case
if(k==N) return minNeededOperationsCase1;
//This needs to happen before in case the value is incremented (we dont know)
int currentOpsNeeded=minNeededOperationsCase1;
//In this case the M train has become too big
if(S.charAt(k)=='M') minNeededOperationsCase1++;
for(int i=k;i<S.length();i++){
char c = S.charAt(i);
char firstChar = S.charAt(i-k);
//adapt current operations needed value
if(c=='L'){
currentOpsNeeded++;
}
if(firstChar=='L'){
currentOpsNeeded--;
}
//compare to current minimum
}
return minNeededOperationsCase1;
}
else{
return totalNeededOperationsCase2;
}
}
}
Code: 12:05:38 UTC,
java,
autosave
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283
// 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(String S, int K) {
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=3
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=7
//1,-1,3,-3,1,-1,1,-1,2,-3,5,-1,1,-1,1,-2,2
//-> Case1: Alle Ms < K
//Alle Substrings der länge K ansehen und die Ls zählen (+1 pro M an der Grenze)
//-> Case2: Es gibt Ms >= K
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
//Algorithmus vorschlag:
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
//2.Ggfls nochmal durchiterieren und Case 1 fixen
//Optimierung kommt später
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
boolean isCase2 = false;
int totalNeededOperationsCase2=0;
int minNeededOperationsCase1=0;
int lastMLength=0;
for(int i=0;i<S.length();i++){
char c = S.charAt(i);
if(c=='M'){
lastMLength++;
}
else{ //Can only be L
if(lastMLength >= K){
isCase2 = true;
}
if(isCase2){
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
totalNeededOperationsCase2+=Math.floor(lastMLength/K+0.5)-1;
}
}
}
if(!isCase2){
int lCounter=0;
for(int i=0;i<k;i++){
char c = S.charAt(i);
if(c!='M'){
lCounter++;
}
}
minNeededOperationsCase1 = lCounter;
//because then this is the only case
if(k==N) return minNeededOperationsCase1;
//This needs to happen before in case the value is incremented (we dont know)
int currentOpsNeeded=minNeededOperationsCase1;
//In this case the M train has become too big
if(S.charAt(k)=='M') minNeededOperationsCase1++;
for(int i=k;i<S.length();i++){
char c = S.charAt(i);
char firstChar = S.charAt(i-k);
//adapt current operations needed value
if(c=='L'){
currentOpsNeeded++;
}
if(firstChar=='L'){
currentOpsNeeded--;
}
//compare to current minimum
int
}
return minNeededOperationsCase1;
}
else{
return totalNeededOperationsCase2;
}
}
}
Code: 12:05:49 UTC,
java,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384
// 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(String S, int K) {
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=3
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=7
//1,-1,3,-3,1,-1,1,-1,2,-3,5,-1,1,-1,1,-2,2
//-> Case1: Alle Ms < K
//Alle Substrings der länge K ansehen und die Ls zählen (+1 pro M an der Grenze)
//-> Case2: Es gibt Ms >= K
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
//Algorithmus vorschlag:
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
//2.Ggfls nochmal durchiterieren und Case 1 fixen
//Optimierung kommt später
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
boolean isCase2 = false;
int totalNeededOperationsCase2=0;
int minNeededOperationsCase1=0;
int lastMLength=0;
for(int i=0;i<S.length();i++){
char c = S.charAt(i);
if(c=='M'){
lastMLength++;
}
else{ //Can only be L
if(lastMLength >= K){
isCase2 = true;
}
if(isCase2){
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
totalNeededOperationsCase2+=Math.floor(lastMLength/K+0.5)-1;
}
}
}
if(!isCase2){
int lCounter=0;
for(int i=0;i<k;i++){
char c = S.charAt(i);
if(c!='M'){
lCounter++;
}
}
minNeededOperationsCase1 = lCounter;
//because then this is the only case
if(k==N) return minNeededOperationsCase1;
//This needs to happen before in case the value is incremented (we dont know)
int currentOpsNeeded=minNeededOperationsCase1;
//In this case the M train has become too big
if(S.charAt(k)=='M') minNeededOperationsCase1++;
for(int i=k;i<S.length();i++){
char c = S.charAt(i);
char firstChar = S.charAt(i-k);
//adapt current operations needed value
if(c=='L'){
currentOpsNeeded++;
}
if(firstChar=='L'){
currentOpsNeeded--;
}
//compare to current minimum
int additionForComparison = 0;
}
return minNeededOperationsCase1;
}
else{
return totalNeededOperationsCase2;
}
}
}
Code: 12:06:01 UTC,
java,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384
// 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(String S, int K) {
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=3
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=7
//1,-1,3,-3,1,-1,1,-1,2,-3,5,-1,1,-1,1,-2,2
//-> Case1: Alle Ms < K
//Alle Substrings der länge K ansehen und die Ls zählen (+1 pro M an der Grenze)
//-> Case2: Es gibt Ms >= K
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
//Algorithmus vorschlag:
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
//2.Ggfls nochmal durchiterieren und Case 1 fixen
//Optimierung kommt später
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
boolean isCase2 = false;
int totalNeededOperationsCase2=0;
int minNeededOperationsCase1=0;
int lastMLength=0;
for(int i=0;i<S.length();i++){
char c = S.charAt(i);
if(c=='M'){
lastMLength++;
}
else{ //Can only be L
if(lastMLength >= K){
isCase2 = true;
}
if(isCase2){
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
totalNeededOperationsCase2+=Math.floor(lastMLength/K+0.5)-1;
}
}
}
if(!isCase2){
int lCounter=0;
for(int i=0;i<k;i++){
char c = S.charAt(i);
if(c!='M'){
lCounter++;
}
}
minNeededOperationsCase1 = lCounter;
//because then this is the only case
if(k==N) return minNeededOperationsCase1;
//This needs to happen before in case the value is incremented (we dont know)
int currentOpsNeeded=minNeededOperationsCase1;
//In this case the M train has become too big
if(S.charAt(k)=='M') minNeededOperationsCase1++;
for(int i=k;i<S.length();i++){
char c = S.charAt(i);
char firstChar = S.charAt(i-k);
//adapt current operations needed value
if(c=='L'){
currentOpsNeeded++;
}
if(firstChar=='L'){
currentOpsNeeded--;
}
//compare to current minimum
int additionForComparison = 0;
if(firstChar)
}
return minNeededOperationsCase1;
}
else{
return totalNeededOperationsCase2;
}
}
}
Code: 12:06:31 UTC,
java,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687
// 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(String S, int K) {
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=3
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=7
//1,-1,3,-3,1,-1,1,-1,2,-3,5,-1,1,-1,1,-2,2
//-> Case1: Alle Ms < K
//Alle Substrings der länge K ansehen und die Ls zählen (+1 pro M an der Grenze)
//-> Case2: Es gibt Ms >= K
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
//Algorithmus vorschlag:
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
//2.Ggfls nochmal durchiterieren und Case 1 fixen
//Optimierung kommt später
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
boolean isCase2 = false;
int totalNeededOperationsCase2=0;
int minNeededOperationsCase1=0;
int lastMLength=0;
for(int i=0;i<S.length();i++){
char c = S.charAt(i);
if(c=='M'){
lastMLength++;
}
else{ //Can only be L
if(lastMLength >= K){
isCase2 = true;
}
if(isCase2){
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
totalNeededOperationsCase2+=Math.floor(lastMLength/K+0.5)-1;
}
}
}
if(!isCase2){
int lCounter=0;
for(int i=0;i<k;i++){
char c = S.charAt(i);
if(c!='M'){
lCounter++;
}
}
minNeededOperationsCase1 = lCounter;
//because then this is the only case
if(k==N) return minNeededOperationsCase1;
//This needs to happen before in case the value is incremented (we dont know)
int currentOpsNeeded=minNeededOperationsCase1;
//In this case the M train has become too big
if(S.charAt(k)=='M') minNeededOperationsCase1++;
for(int i=k;i<S.length();i++){
char c = S.charAt(i);
char firstChar = S.charAt(i-k);
//adapt current operations needed value
if(c=='L'){
currentOpsNeeded++;
}
if(firstChar=='L'){
currentOpsNeeded--;
}
//compare to current minimum
int additionForComparison = 0;
if(firstChar == 'M'){
additionForComparison++;
}
if(i)
}
return minNeededOperationsCase1;
}
else{
return totalNeededOperationsCase2;
}
}
}
Code: 12:06:45 UTC,
java,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687
// 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(String S, int K) {
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=3
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=7
//1,-1,3,-3,1,-1,1,-1,2,-3,5,-1,1,-1,1,-2,2
//-> Case1: Alle Ms < K
//Alle Substrings der länge K ansehen und die Ls zählen (+1 pro M an der Grenze)
//-> Case2: Es gibt Ms >= K
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
//Algorithmus vorschlag:
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
//2.Ggfls nochmal durchiterieren und Case 1 fixen
//Optimierung kommt später
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
boolean isCase2 = false;
int totalNeededOperationsCase2=0;
int minNeededOperationsCase1=0;
int lastMLength=0;
for(int i=0;i<S.length();i++){
char c = S.charAt(i);
if(c=='M'){
lastMLength++;
}
else{ //Can only be L
if(lastMLength >= K){
isCase2 = true;
}
if(isCase2){
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
totalNeededOperationsCase2+=Math.floor(lastMLength/K+0.5)-1;
}
}
}
if(!isCase2){
int lCounter=0;
for(int i=0;i<k;i++){
char c = S.charAt(i);
if(c!='M'){
lCounter++;
}
}
minNeededOperationsCase1 = lCounter;
//because then this is the only case
if(k==N) return minNeededOperationsCase1;
//This needs to happen before in case the value is incremented (we dont know)
int currentOpsNeeded=minNeededOperationsCase1;
//In this case the M train has become too big
if(S.charAt(k)=='M') minNeededOperationsCase1++;
for(int i=k;i<S.length();i++){
char c = S.charAt(i);
char firstChar = S.charAt(i-k);
//adapt current operations needed value
if(c=='L'){
currentOpsNeeded++;
}
if(firstChar=='L'){
currentOpsNeeded--;
}
//compare to current minimum
int additionForComparison = 0;
if(firstChar == 'M'){
additionForComparison++;
}
if(i<S.length()-1 && )
}
return minNeededOperationsCase1;
}
else{
return totalNeededOperationsCase2;
}
}
}
Code: 12:07:12 UTC,
java,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990
// 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(String S, int K) {
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=3
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=7
//1,-1,3,-3,1,-1,1,-1,2,-3,5,-1,1,-1,1,-2,2
//-> Case1: Alle Ms < K
//Alle Substrings der länge K ansehen und die Ls zählen (+1 pro M an der Grenze)
//-> Case2: Es gibt Ms >= K
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
//Algorithmus vorschlag:
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
//2.Ggfls nochmal durchiterieren und Case 1 fixen
//Optimierung kommt später
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
boolean isCase2 = false;
int totalNeededOperationsCase2=0;
int minNeededOperationsCase1=0;
int lastMLength=0;
for(int i=0;i<S.length();i++){
char c = S.charAt(i);
if(c=='M'){
lastMLength++;
}
else{ //Can only be L
if(lastMLength >= K){
isCase2 = true;
}
if(isCase2){
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
totalNeededOperationsCase2+=Math.floor(lastMLength/K+0.5)-1;
}
}
}
if(!isCase2){
int lCounter=0;
for(int i=0;i<k;i++){
char c = S.charAt(i);
if(c!='M'){
lCounter++;
}
}
minNeededOperationsCase1 = lCounter;
//because then this is the only case
if(k==N) return minNeededOperationsCase1;
//This needs to happen before in case the value is incremented (we dont know)
int currentOpsNeeded=minNeededOperationsCase1;
//In this case the M train has become too big
if(S.charAt(k)=='M') minNeededOperationsCase1++;
for(int i=k;i<S.length();i++){
char c = S.charAt(i);
char firstChar = S.charAt(i-k);
//adapt current operations needed value
if(c=='L'){
currentOpsNeeded++;
}
if(firstChar=='L'){
currentOpsNeeded--;
}
//compare to current minimum
int additionForComparison = 0;
if(firstChar == 'M'){
additionForComparison++;
}
if(i<S.length()-1 && S.charAt(i+1)=='M'){
additionForComparison++;
}
if()
}
return minNeededOperationsCase1;
}
else{
return totalNeededOperationsCase2;
}
}
}
Code: 12:07:40 UTC,
java,
autosave
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192
// 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(String S, int K) {
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=3
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=7
//1,-1,3,-3,1,-1,1,-1,2,-3,5,-1,1,-1,1,-2,2
//-> Case1: Alle Ms < K
//Alle Substrings der länge K ansehen und die Ls zählen (+1 pro M an der Grenze)
//-> Case2: Es gibt Ms >= K
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
//Algorithmus vorschlag:
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
//2.Ggfls nochmal durchiterieren und Case 1 fixen
//Optimierung kommt später
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
boolean isCase2 = false;
int totalNeededOperationsCase2=0;
int minNeededOperationsCase1=0;
int lastMLength=0;
for(int i=0;i<S.length();i++){
char c = S.charAt(i);
if(c=='M'){
lastMLength++;
}
else{ //Can only be L
if(lastMLength >= K){
isCase2 = true;
}
if(isCase2){
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
totalNeededOperationsCase2+=Math.floor(lastMLength/K+0.5)-1;
}
}
}
if(!isCase2){
int lCounter=0;
for(int i=0;i<k;i++){
char c = S.charAt(i);
if(c!='M'){
lCounter++;
}
}
minNeededOperationsCase1 = lCounter;
//because then this is the only case
if(k==N) return minNeededOperationsCase1;
//This needs to happen before in case the value is incremented (we dont know)
int currentOpsNeeded=minNeededOperationsCase1;
//In this case the M train has become too big
if(S.charAt(k)=='M') minNeededOperationsCase1++;
for(int i=k;i<S.length();i++){
char c = S.charAt(i);
char firstChar = S.charAt(i-k);
//adapt current operations needed value
if(c=='L'){
currentOpsNeeded++;
}
if(firstChar=='L'){
currentOpsNeeded--;
}
//compare to current minimum
int additionForComparison = 0;
if(firstChar == 'M'){
additionForComparison++;
}
if(i<S.length()-1 && S.charAt(i+1)=='M'){
additionForComparison++;
}
if(currentOpsNeeded+additionForComparison < minNeededOperationsCase1){
minNeededOperationsCase1 =
}
}
return minNeededOperationsCase1;
}
else{
return totalNeededOperationsCase2;
}
}
}
Code: 12:07:50 UTC,
java,
autosave
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192
// 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(String S, int K) {
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=3
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=7
//1,-1,3,-3,1,-1,1,-1,2,-3,5,-1,1,-1,1,-2,2
//-> Case1: Alle Ms < K
//Alle Substrings der länge K ansehen und die Ls zählen (+1 pro M an der Grenze)
//-> Case2: Es gibt Ms >= K
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
//Algorithmus vorschlag:
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
//2.Ggfls nochmal durchiterieren und Case 1 fixen
//Optimierung kommt später
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
boolean isCase2 = false;
int totalNeededOperationsCase2=0;
int minNeededOperationsCase1=0;
int lastMLength=0;
for(int i=0;i<S.length();i++){
char c = S.charAt(i);
if(c=='M'){
lastMLength++;
}
else{ //Can only be L
if(lastMLength >= K){
isCase2 = true;
}
if(isCase2){
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
totalNeededOperationsCase2+=Math.floor(lastMLength/K+0.5)-1;
}
}
}
if(!isCase2){
int lCounter=0;
for(int i=0;i<k;i++){
char c = S.charAt(i);
if(c!='M'){
lCounter++;
}
}
minNeededOperationsCase1 = lCounter;
//because then this is the only case
if(k==N) return minNeededOperationsCase1;
//This needs to happen before in case the value is incremented (we dont know)
int currentOpsNeeded=minNeededOperationsCase1;
//In this case the M train has become too big
if(S.charAt(k)=='M') minNeededOperationsCase1++;
for(int i=k;i<S.length();i++){
char c = S.charAt(i);
char firstChar = S.charAt(i-k);
//adapt current operations needed value
if(c=='L'){
currentOpsNeeded++;
}
if(firstChar=='L'){
currentOpsNeeded--;
}
//compare to current minimum
int additionForComparison = 0;
if(firstChar == 'M'){
additionForComparison++;
}
if(i<S.length()-1 && S.charAt(i+1)=='M'){
additionForComparison++;
}
if(currentOpsNeeded+additionForComparison < minNeededOperationsCase1){
minNeededOperationsCase1 = currentOpsNeeded+additionForComparison;
}
}
return minNeededOperationsCase1;
}
else{
return totalNeededOperationsCase2;
}
}
}
Code: 12:07:58 UTC,
java,
verify,
result: Failed
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192
// 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(String S, int K) {
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=3
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=7
//1,-1,3,-3,1,-1,1,-1,2,-3,5,-1,1,-1,1,-2,2
//-> Case1: Alle Ms < K
//Alle Substrings der länge K ansehen und die Ls zählen (+1 pro M an der Grenze)
//-> Case2: Es gibt Ms >= K
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
//Algorithmus vorschlag:
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
//2.Ggfls nochmal durchiterieren und Case 1 fixen
//Optimierung kommt später
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
boolean isCase2 = false;
int totalNeededOperationsCase2=0;
int minNeededOperationsCase1=0;
int lastMLength=0;
for(int i=0;i<S.length();i++){
char c = S.charAt(i);
if(c=='M'){
lastMLength++;
}
else{ //Can only be L
if(lastMLength >= K){
isCase2 = true;
}
if(isCase2){
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
totalNeededOperationsCase2+=Math.floor(lastMLength/K+0.5)-1;
}
}
}
if(!isCase2){
int lCounter=0;
for(int i=0;i<k;i++){
char c = S.charAt(i);
if(c!='M'){
lCounter++;
}
}
minNeededOperationsCase1 = lCounter;
//because then this is the only case
if(k==N) return minNeededOperationsCase1;
//This needs to happen before in case the value is incremented (we dont know)
int currentOpsNeeded=minNeededOperationsCase1;
//In this case the M train has become too big
if(S.charAt(k)=='M') minNeededOperationsCase1++;
for(int i=k;i<S.length();i++){
char c = S.charAt(i);
char firstChar = S.charAt(i-k);
//adapt current operations needed value
if(c=='L'){
currentOpsNeeded++;
}
if(firstChar=='L'){
currentOpsNeeded--;
}
//compare to current minimum
int additionForComparison = 0;
if(firstChar == 'M'){
additionForComparison++;
}
if(i<S.length()-1 && S.charAt(i+1)=='M'){
additionForComparison++;
}
if(currentOpsNeeded+additionForComparison < minNeededOperationsCase1){
minNeededOperationsCase1 = currentOpsNeeded+additionForComparison;
}
}
return minNeededOperationsCase1;
}
else{
return totalNeededOperationsCase2;
}
}
}
Analysis
Compile error
Solution.java:47: error: cannot find symbol
for(int i=0;i<k;i++){
^
symbol: variable k
location: class Solution
Solution.java:55: error: cannot find symbol
if(k==N) return minNeededOperationsCase1;
^
symbol: variable k
location: class Solution
Solution.java:55: error: cannot find symbol
if(k==N) return minNeededOperationsCase1;
^
symbol: variable N
location: class Solution
Solution.java:60: error: cannot find symbol
if(S.charAt(k)=='M') minNeededOperationsCase1++;
^
symbol: variable k
location: class Solution
Solution.java:62: error: cannot find symbol
for(int i=k;i<S.length();i++){
^
symbol: variable k
location: class Solution
Solution.java:64: error: cannot find symbol
char firstChar = S.charAt(i-k);
^
symbol: variable k
location: class Solution
6 errors
Code: 12:08:20 UTC,
java,
autosave
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192
// 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(String S, int K) {
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=3
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=7
//1,-1,3,-3,1,-1,1,-1,2,-3,5,-1,1,-1,1,-2,2
//-> Case1: Alle Ms < K
//Alle Substrings der länge K ansehen und die Ls zählen (+1 pro M an der Grenze)
//-> Case2: Es gibt Ms >= K
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
//Algorithmus vorschlag:
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
//2.Ggfls nochmal durchiterieren und Case 1 fixen
//Optimierung kommt später
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
boolean isCase2 = false;
int totalNeededOperationsCase2=0;
int minNeededOperationsCase1=0;
int lastMLength=0;
for(int i=0;i<S.length();i++){
char c = S.charAt(i);
if(c=='M'){
lastMLength++;
}
else{ //Can only be L
if(lastMLength >= K){
isCase2 = true;
}
if(isCase2){
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
totalNeededOperationsCase2+=Math.floor(lastMLength/K+0.5)-1;
}
}
}
if(!isCase2){
int lCounter=0;
for(int i=0;i<K;i++){
char c = S.charAt(i);
if(c!='M'){
lCounter++;
}
}
minNeededOperationsCase1 = lCounter;
//because then this is the only case
if(k==N) return minNeededOperationsCase1;
//This needs to happen before in case the value is incremented (we dont know)
int currentOpsNeeded=minNeededOperationsCase1;
//In this case the M train has become too big
if(S.charAt(k)=='M') minNeededOperationsCase1++;
for(int i=k;i<S.length();i++){
char c = S.charAt(i);
char firstChar = S.charAt(i-k);
//adapt current operations needed value
if(c=='L'){
currentOpsNeeded++;
}
if(firstChar=='L'){
currentOpsNeeded--;
}
//compare to current minimum
int additionForComparison = 0;
if(firstChar == 'M'){
additionForComparison++;
}
if(i<S.length()-1 && S.charAt(i+1)=='M'){
additionForComparison++;
}
if(currentOpsNeeded+additionForComparison < minNeededOperationsCase1){
minNeededOperationsCase1 = currentOpsNeeded+additionForComparison;
}
}
return minNeededOperationsCase1;
}
else{
return totalNeededOperationsCase2;
}
}
}
Code: 12:08:31 UTC,
java,
verify,
result: Failed
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192
// 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(String S, int K) {
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=3
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=7
//1,-1,3,-3,1,-1,1,-1,2,-3,5,-1,1,-1,1,-2,2
//-> Case1: Alle Ms < K
//Alle Substrings der länge K ansehen und die Ls zählen (+1 pro M an der Grenze)
//-> Case2: Es gibt Ms >= K
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
//Algorithmus vorschlag:
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
//2.Ggfls nochmal durchiterieren und Case 1 fixen
//Optimierung kommt später
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
boolean isCase2 = false;
int totalNeededOperationsCase2=0;
int minNeededOperationsCase1=0;
int lastMLength=0;
for(int i=0;i<S.length();i++){
char c = S.charAt(i);
if(c=='M'){
lastMLength++;
}
else{ //Can only be L
if(lastMLength >= K){
isCase2 = true;
}
if(isCase2){
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
totalNeededOperationsCase2+=Math.floor(lastMLength/K+0.5)-1;
}
}
}
if(!isCase2){
int lCounter=0;
for(int i=0;i<K;i++){
char c = S.charAt(i);
if(c!='M'){
lCounter++;
}
}
minNeededOperationsCase1 = lCounter;
//because then this is the only case
if(K==N) return minNeededOperationsCase1;
//This needs to happen before in case the value is incremented (we dont know)
int currentOpsNeeded=minNeededOperationsCase1;
//In this case the M train has become too big
if(S.charAt(K)=='M') minNeededOperationsCase1++;
for(int i=K;i<S.length();i++){
char c = S.charAt(i);
char firstChar = S.charAt(i-K);
//adapt current operations needed value
if(c=='L'){
currentOpsNeeded++;
}
if(firstChar=='L'){
currentOpsNeeded--;
}
//compare to current minimum
int additionForComparison = 0;
if(firstChar == 'M'){
additionForComparison++;
}
if(i<S.length()-1 && S.charAt(i+1)=='M'){
additionForComparison++;
}
if(currentOpsNeeded+additionForComparison < minNeededOperationsCase1){
minNeededOperationsCase1 = currentOpsNeeded+additionForComparison;
}
}
return minNeededOperationsCase1;
}
else{
return totalNeededOperationsCase2;
}
}
}
Analysis
Compile error
Solution.java:55: error: cannot find symbol
if(K==N) return minNeededOperationsCase1;
^
symbol: variable N
location: class Solution
1 error
Code: 12:08:51 UTC,
java,
autosave
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192
// 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(String S, int K) {
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=3
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=7
//1,-1,3,-3,1,-1,1,-1,2,-3,5,-1,1,-1,1,-2,2
//-> Case1: Alle Ms < K
//Alle Substrings der länge K ansehen und die Ls zählen (+1 pro M an der Grenze)
//-> Case2: Es gibt Ms >= K
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
//Algorithmus vorschlag:
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
//2.Ggfls nochmal durchiterieren und Case 1 fixen
//Optimierung kommt später
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
boolean isCase2 = false;
int totalNeededOperationsCase2=0;
int minNeededOperationsCase1=0;
int lastMLength=0;
for(int i=0;i<S.length();i++){
char c = S.charAt(i);
if(c=='M'){
lastMLength++;
}
else{ //Can only be L
if(lastMLength >= K){
isCase2 = true;
}
if(isCase2){
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
totalNeededOperationsCase2+=Math.floor(lastMLength/K+0.5)-1;
}
}
}
if(!isCase2){
int lCounter=0;
for(int i=0;i<K;i++){
char c = S.charAt(i);
if(c!='M'){
lCounter++;
}
}
minNeededOperationsCase1 = lCounter;
//because then this is the only case
if(K==S.length()) return minNeededOperationsCase1;
//This needs to happen before in case the value is incremented (we dont know)
int currentOpsNeeded=minNeededOperationsCase1;
//In this case the M train has become too big
if(S.charAt(K)=='M') minNeededOperationsCase1++;
for(int i=K;i<S.length();i++){
char c = S.charAt(i);
char firstChar = S.charAt(i-K);
//adapt current operations needed value
if(c=='L'){
currentOpsNeeded++;
}
if(firstChar=='L'){
currentOpsNeeded--;
}
//compare to current minimum
int additionForComparison = 0;
if(firstChar == 'M'){
additionForComparison++;
}
if(i<S.length()-1 && S.charAt(i+1)=='M'){
additionForComparison++;
}
if(currentOpsNeeded+additionForComparison < minNeededOperationsCase1){
minNeededOperationsCase1 = currentOpsNeeded+additionForComparison;
}
}
return minNeededOperationsCase1;
}
else{
return totalNeededOperationsCase2;
}
}
}
Code: 12:08:55 UTC,
java,
verify,
result: Failed
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192
// 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(String S, int K) {
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=3
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=7
//1,-1,3,-3,1,-1,1,-1,2,-3,5,-1,1,-1,1,-2,2
//-> Case1: Alle Ms < K
//Alle Substrings der länge K ansehen und die Ls zählen (+1 pro M an der Grenze)
//-> Case2: Es gibt Ms >= K
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
//Algorithmus vorschlag:
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
//2.Ggfls nochmal durchiterieren und Case 1 fixen
//Optimierung kommt später
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
boolean isCase2 = false;
int totalNeededOperationsCase2=0;
int minNeededOperationsCase1=0;
int lastMLength=0;
for(int i=0;i<S.length();i++){
char c = S.charAt(i);
if(c=='M'){
lastMLength++;
}
else{ //Can only be L
if(lastMLength >= K){
isCase2 = true;
}
if(isCase2){
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
totalNeededOperationsCase2+=Math.floor(lastMLength/K+0.5)-1;
}
}
}
if(!isCase2){
int lCounter=0;
for(int i=0;i<K;i++){
char c = S.charAt(i);
if(c!='M'){
lCounter++;
}
}
minNeededOperationsCase1 = lCounter;
//because then this is the only case
if(K==S.length()) return minNeededOperationsCase1;
//This needs to happen before in case the value is incremented (we dont know)
int currentOpsNeeded=minNeededOperationsCase1;
//In this case the M train has become too big
if(S.charAt(K)=='M') minNeededOperationsCase1++;
for(int i=K;i<S.length();i++){
char c = S.charAt(i);
char firstChar = S.charAt(i-K);
//adapt current operations needed value
if(c=='L'){
currentOpsNeeded++;
}
if(firstChar=='L'){
currentOpsNeeded--;
}
//compare to current minimum
int additionForComparison = 0;
if(firstChar == 'M'){
additionForComparison++;
}
if(i<S.length()-1 && S.charAt(i+1)=='M'){
additionForComparison++;
}
if(currentOpsNeeded+additionForComparison < minNeededOperationsCase1){
minNeededOperationsCase1 = currentOpsNeeded+additionForComparison;
}
}
return minNeededOperationsCase1;
}
else{
return totalNeededOperationsCase2;
}
}
}
Analysis
expand all
Example tests
1.
0.008 s
WRONG ANSWER,
got 0 expected 1
1.
0.008 s
WRONG ANSWER,
got 1 expected 2
User test case 1:
['MMLMMLMMLMMLMM', 3]
Code: 12:11:45 UTC,
java,
autosave
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192
// 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(String S, int K) {
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=3
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=7
//1,-1,3,-3,1,-1,1,-1,2,-3,5,-1,1,-1,1,-2,2
//-> Case1: Alle Ms < K
//Alle Substrings der länge K ansehen und die Ls zählen (+1 pro M an der Grenze)
//-> Case2: Es gibt Ms >= K
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
//Algorithmus vorschlag:
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
//2.Ggfls nochmal durchiterieren und Case 1 fixen
//Optimierung kommt später
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
boolean isCase2 = false;
int totalNeededOperationsCase2=0;
int minNeededOperationsCase1=;
int lastMLength=0;
for(int i=0;i<S.length();i++){
char c = S.charAt(i);
if(c=='M'){
lastMLength++;
}
else{ //Can only be L
if(lastMLength >= K){
isCase2 = true;
}
if(isCase2){
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
totalNeededOperationsCase2+=Math.floor(lastMLength/K+0.5)-1;
}
}
}
if(!isCase2){
int lCounter=0;
for(int i=0;i<K;i++){
char c = S.charAt(i);
if(c!='M'){
lCounter++;
}
}
minNeededOperationsCase1 = lCounter;
//because then this is the only case
if(K==S.length()) return minNeededOperationsCase1;
//This needs to happen before in case the value is incremented (we dont know)
int currentOpsNeeded=minNeededOperationsCase1;
//In this case the M train has become too big
if(S.charAt(K)=='M') minNeededOperationsCase1++;
for(int i=K;i<S.length();i++){
char c = S.charAt(i);
char firstChar = S.charAt(i-K);
//adapt current operations needed value
if(c=='L'){
currentOpsNeeded++;
}
if(firstChar=='L'){
currentOpsNeeded--;
}
//compare to current minimum
int additionForComparison = 0;
if(firstChar == 'M'){
additionForComparison++;
}
if(i<S.length()-1 && S.charAt(i+1)=='M'){
additionForComparison++;
}
if(currentOpsNeeded+additionForComparison < minNeededOperationsCase1){
minNeededOperationsCase1 = currentOpsNeeded+additionForComparison;
}
}
return minNeededOperationsCase1;
}
else{
return totalNeededOperationsCase2;
}
}
}
Code: 12:11:58 UTC,
java,
autosave
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192
// 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(String S, int K) {
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=3
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=7
//1,-1,3,-3,1,-1,1,-1,2,-3,5,-1,1,-1,1,-2,2
//-> Case1: Alle Ms < K
//Alle Substrings der länge K ansehen und die Ls zählen (+1 pro M an der Grenze)
//-> Case2: Es gibt Ms >= K
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
//Algorithmus vorschlag:
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
//2.Ggfls nochmal durchiterieren und Case 1 fixen
//Optimierung kommt später
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
boolean isCase2 = false;
int totalNeededOperationsCase2=0;
int minNeededOperationsCase1=Integer.M;
int lastMLength=0;
for(int i=0;i<S.length();i++){
char c = S.charAt(i);
if(c=='M'){
lastMLength++;
}
else{ //Can only be L
if(lastMLength >= K){
isCase2 = true;
}
if(isCase2){
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
totalNeededOperationsCase2+=Math.floor(lastMLength/K+0.5)-1;
}
}
}
if(!isCase2){
int lCounter=0;
for(int i=0;i<K;i++){
char c = S.charAt(i);
if(c!='M'){
lCounter++;
}
}
minNeededOperationsCase1 = lCounter;
//because then this is the only case
if(K==S.length()) return minNeededOperationsCase1;
//This needs to happen before in case the value is incremented (we dont know)
int currentOpsNeeded=minNeededOperationsCase1;
//In this case the M train has become too big
if(S.charAt(K)=='M') minNeededOperationsCase1++;
for(int i=K;i<S.length();i++){
char c = S.charAt(i);
char firstChar = S.charAt(i-K);
//adapt current operations needed value
if(c=='L'){
currentOpsNeeded++;
}
if(firstChar=='L'){
currentOpsNeeded--;
}
//compare to current minimum
int additionForComparison = 0;
if(firstChar == 'M'){
additionForComparison++;
}
if(i<S.length()-1 && S.charAt(i+1)=='M'){
additionForComparison++;
}
if(currentOpsNeeded+additionForComparison < minNeededOperationsCase1){
minNeededOperationsCase1 = currentOpsNeeded+additionForComparison;
}
}
return minNeededOperationsCase1;
}
else{
return totalNeededOperationsCase2;
}
}
}
Code: 12:12:11 UTC,
java,
verify,
result: Failed
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192
// 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(String S, int K) {
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=3
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=7
//1,-1,3,-3,1,-1,1,-1,2,-3,5,-1,1,-1,1,-2,2
//-> Case1: Alle Ms < K
//Alle Substrings der länge K ansehen und die Ls zählen (+1 pro M an der Grenze)
//-> Case2: Es gibt Ms >= K
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
//Algorithmus vorschlag:
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
//2.Ggfls nochmal durchiterieren und Case 1 fixen
//Optimierung kommt später
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
boolean isCase2 = false;
int totalNeededOperationsCase2=0;
int minNeededOperationsCase1=Integer.MAX_VALUE;
int lastMLength=0;
for(int i=0;i<S.length();i++){
char c = S.charAt(i);
if(c=='M'){
lastMLength++;
}
else{ //Can only be L
if(lastMLength >= K){
isCase2 = true;
}
if(isCase2){
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
totalNeededOperationsCase2+=Math.floor(lastMLength/K+0.5)-1;
}
}
}
if(!isCase2){
int lCounter=0;
for(int i=0;i<K;i++){
char c = S.charAt(i);
if(c!='M'){
lCounter++;
}
}
minNeededOperationsCase1 = lCounter;
//because then this is the only case
if(K==S.length()) return minNeededOperationsCase1;
//This needs to happen before in case the value is incremented (we dont know)
int currentOpsNeeded=minNeededOperationsCase1;
//In this case the M train has become too big
if(S.charAt(K)=='M') minNeededOperationsCase1++;
for(int i=K;i<S.length();i++){
char c = S.charAt(i);
char firstChar = S.charAt(i-K);
//adapt current operations needed value
if(c=='L'){
currentOpsNeeded++;
}
if(firstChar=='L'){
currentOpsNeeded--;
}
//compare to current minimum
int additionForComparison = 0;
if(firstChar == 'M'){
additionForComparison++;
}
if(i<S.length()-1 && S.charAt(i+1)=='M'){
additionForComparison++;
}
if(currentOpsNeeded+additionForComparison < minNeededOperationsCase1){
minNeededOperationsCase1 = currentOpsNeeded+additionForComparison;
}
}
return minNeededOperationsCase1;
}
else{
return totalNeededOperationsCase2;
}
}
}
Analysis
expand all
Example tests
1.
0.004 s
WRONG ANSWER,
got 0 expected 1
1.
0.004 s
WRONG ANSWER,
got 1 expected 2
expand all
User tests
1.
0.004 s
OK
function result: 2
function result: 2
1.
0.008 s
OK
function result: 3
function result: 3
1.
0.008 s
OK
function result: 9
function result: 9
User test case 1:
['MMLMMLMMLMMLMM', 3]
User test case 2:
['MMMLMMMMMLMM', 2]
User test case 3:
['MMMLMMMMMLMM', 1]
Code: 12:12:55 UTC,
java,
autosave
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192
// 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(String S, int K) {
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=3
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=7
//1,-1,3,-3,1,-1,1,-1,2,-3,5,-1,1,-1,1,-2,2
//-> Case1: Alle Ms < K
//Alle Substrings der länge K ansehen und die Ls zählen (+1 pro M an der Grenze)
//-> Case2: Es gibt Ms >= K
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
//Algorithmus vorschlag:
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
//2.Ggfls nochmal durchiterieren und Case 1 fixen
//Optimierung kommt später
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
boolean isCase2 = false;
int totalNeededOperationsCase2=0;
int minNeededOperationsCase1=Integer.MAX_VALUE;
int lastMLength=0;
for(int i=0;i<S.length();i++){
char c = S.charAt(i);
if(c=='M'){
lastMLength++;
}
else{ //Can only be L
if(lastMLength >= K){
isCase2 = true;
}
if(isCase2){
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
totalNeededOperationsCase2+=Math.rio(lastMLength/K+0.5)-1;
}
}
}
if(!isCase2){
int lCounter=0;
for(int i=0;i<K;i++){
char c = S.charAt(i);
if(c!='M'){
lCounter++;
}
}
minNeededOperationsCase1 = lCounter;
//because then this is the only case
if(K==S.length()) return minNeededOperationsCase1;
//This needs to happen before in case the value is incremented (we dont know)
int currentOpsNeeded=minNeededOperationsCase1;
//In this case the M train has become too big
if(S.charAt(K)=='M') minNeededOperationsCase1++;
for(int i=K;i<S.length();i++){
char c = S.charAt(i);
char firstChar = S.charAt(i-K);
//adapt current operations needed value
if(c=='L'){
currentOpsNeeded++;
}
if(firstChar=='L'){
currentOpsNeeded--;
}
//compare to current minimum
int additionForComparison = 0;
if(firstChar == 'M'){
additionForComparison++;
}
if(i<S.length()-1 && S.charAt(i+1)=='M'){
additionForComparison++;
}
if(currentOpsNeeded+additionForComparison < minNeededOperationsCase1){
minNeededOperationsCase1 = currentOpsNeeded+additionForComparison;
}
}
return minNeededOperationsCase1;
}
else{
return totalNeededOperationsCase2;
}
}
}
Code: 12:13:01 UTC,
java,
verify,
result: Failed
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192
// 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(String S, int K) {
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=3
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=7
//1,-1,3,-3,1,-1,1,-1,2,-3,5,-1,1,-1,1,-2,2
//-> Case1: Alle Ms < K
//Alle Substrings der länge K ansehen und die Ls zählen (+1 pro M an der Grenze)
//-> Case2: Es gibt Ms >= K
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
//Algorithmus vorschlag:
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
//2.Ggfls nochmal durchiterieren und Case 1 fixen
//Optimierung kommt später
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
boolean isCase2 = false;
int totalNeededOperationsCase2=0;
int minNeededOperationsCase1=Integer.MAX_VALUE;
int lastMLength=0;
for(int i=0;i<S.length();i++){
char c = S.charAt(i);
if(c=='M'){
lastMLength++;
}
else{ //Can only be L
if(lastMLength >= K){
isCase2 = true;
}
if(isCase2){
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
totalNeededOperationsCase2+=Math.round(lastMLength/K)-1;
}
}
}
if(!isCase2){
int lCounter=0;
for(int i=0;i<K;i++){
char c = S.charAt(i);
if(c!='M'){
lCounter++;
}
}
minNeededOperationsCase1 = lCounter;
//because then this is the only case
if(K==S.length()) return minNeededOperationsCase1;
//This needs to happen before in case the value is incremented (we dont know)
int currentOpsNeeded=minNeededOperationsCase1;
//In this case the M train has become too big
if(S.charAt(K)=='M') minNeededOperationsCase1++;
for(int i=K;i<S.length();i++){
char c = S.charAt(i);
char firstChar = S.charAt(i-K);
//adapt current operations needed value
if(c=='L'){
currentOpsNeeded++;
}
if(firstChar=='L'){
currentOpsNeeded--;
}
//compare to current minimum
int additionForComparison = 0;
if(firstChar == 'M'){
additionForComparison++;
}
if(i<S.length()-1 && S.charAt(i+1)=='M'){
additionForComparison++;
}
if(currentOpsNeeded+additionForComparison < minNeededOperationsCase1){
minNeededOperationsCase1 = currentOpsNeeded+additionForComparison;
}
}
return minNeededOperationsCase1;
}
else{
return totalNeededOperationsCase2;
}
}
}
Analysis
expand all
Example tests
1.
0.004 s
WRONG ANSWER,
got 0 expected 1
1.
0.008 s
WRONG ANSWER,
got 1 expected 2
expand all
User tests
1.
0.004 s
OK
function result: 2
function result: 2
1.
0.008 s
OK
function result: 3
function result: 3
1.
0.004 s
OK
function result: 9
function result: 9
User test case 1:
['MMLMMLMMLMMLMM', 3]
User test case 2:
['MMMLMMMMMLMM', 2]
User test case 3:
['MMMLMMMMMLMM', 1]
Code: 12:13:35 UTC,
java,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293
// 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(String S, int K) {
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=3
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=7
//1,-1,3,-3,1,-1,1,-1,2,-3,5,-1,1,-1,1,-2,2
//-> Case1: Alle Ms < K
//Alle Substrings der länge K ansehen und die Ls zählen (+1 pro M an der Grenze)
//-> Case2: Es gibt Ms >= K
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
//Algorithmus vorschlag:
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
//2.Ggfls nochmal durchiterieren und Case 1 fixen
//Optimierung kommt später
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
boolean isCase2 = false;
int totalNeededOperationsCase2=0;
int minNeededOperationsCase1=Integer.MAX_VALUE;
int lastMLength=0;
for(int i=0;i<S.length();i++){
char c = S.charAt(i);
if(c=='M'){
lastMLength++;
}
else{ //Can only be L
if(lastMLength >= K){
isCase2 = true;
}
if(isCase2){
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
totalNeededOperationsCase2+=Math.round(lastMLength/K)-1;
}
lastMLength=0;
}
}
if(!isCase2){
int lCounter=0;
for(int i=0;i<K;i++){
char c = S.charAt(i);
if(c!='M'){
lCounter++;
}
}
minNeededOperationsCase1 = lCounter;
//because then this is the only case
if(K==S.length()) return minNeededOperationsCase1;
//This needs to happen before in case the value is incremented (we dont know)
int currentOpsNeeded=minNeededOperationsCase1;
//In this case the M train has become too big
if(S.charAt(K)=='M') minNeededOperationsCase1++;
for(int i=K;i<S.length();i++){
char c = S.charAt(i);
char firstChar = S.charAt(i-K);
//adapt current operations needed value
if(c=='L'){
currentOpsNeeded++;
}
if(firstChar=='L'){
currentOpsNeeded--;
}
//compare to current minimum
int additionForComparison = 0;
if(firstChar == 'M'){
additionForComparison++;
}
if(i<S.length()-1 && S.charAt(i+1)=='M'){
additionForComparison++;
}
if(currentOpsNeeded+additionForComparison < minNeededOperationsCase1){
minNeededOperationsCase1 = currentOpsNeeded+additionForComparison;
}
}
return minNeededOperationsCase1;
}
else{
return totalNeededOperationsCase2;
}
}
}
Code: 12:13:37 UTC,
java,
verify,
result: Failed
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293
// 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(String S, int K) {
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=3
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=7
//1,-1,3,-3,1,-1,1,-1,2,-3,5,-1,1,-1,1,-2,2
//-> Case1: Alle Ms < K
//Alle Substrings der länge K ansehen und die Ls zählen (+1 pro M an der Grenze)
//-> Case2: Es gibt Ms >= K
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
//Algorithmus vorschlag:
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
//2.Ggfls nochmal durchiterieren und Case 1 fixen
//Optimierung kommt später
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
boolean isCase2 = false;
int totalNeededOperationsCase2=0;
int minNeededOperationsCase1=Integer.MAX_VALUE;
int lastMLength=0;
for(int i=0;i<S.length();i++){
char c = S.charAt(i);
if(c=='M'){
lastMLength++;
}
else{ //Can only be L
if(lastMLength >= K){
isCase2 = true;
}
if(isCase2){
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
totalNeededOperationsCase2+=Math.round(lastMLength/K)-1;
}
lastMLength=0;
}
}
if(!isCase2){
int lCounter=0;
for(int i=0;i<K;i++){
char c = S.charAt(i);
if(c!='M'){
lCounter++;
}
}
minNeededOperationsCase1 = lCounter;
//because then this is the only case
if(K==S.length()) return minNeededOperationsCase1;
//This needs to happen before in case the value is incremented (we dont know)
int currentOpsNeeded=minNeededOperationsCase1;
//In this case the M train has become too big
if(S.charAt(K)=='M') minNeededOperationsCase1++;
for(int i=K;i<S.length();i++){
char c = S.charAt(i);
char firstChar = S.charAt(i-K);
//adapt current operations needed value
if(c=='L'){
currentOpsNeeded++;
}
if(firstChar=='L'){
currentOpsNeeded--;
}
//compare to current minimum
int additionForComparison = 0;
if(firstChar == 'M'){
additionForComparison++;
}
if(i<S.length()-1 && S.charAt(i+1)=='M'){
additionForComparison++;
}
if(currentOpsNeeded+additionForComparison < minNeededOperationsCase1){
minNeededOperationsCase1 = currentOpsNeeded+additionForComparison;
}
}
return minNeededOperationsCase1;
}
else{
return totalNeededOperationsCase2;
}
}
}
Analysis
expand all
User tests
1.
0.008 s
OK
function result: 2
function result: 2
1.
0.004 s
OK
function result: 1
function result: 1
1.
0.004 s
OK
function result: 6
function result: 6
User test case 1:
['MMLMMLMMLMMLMM', 3]
User test case 2:
['MMMLMMMMMLMM', 2]
User test case 3:
['MMMLMMMMMLMM', 1]
Code: 12:17:41 UTC,
java,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394
// 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(String S, int K) {
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=3
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=7
//1,-1,3,-3,1,-1,1,-1,2,-3,5,-1,1,-1,1,-2,2
//-> Case1: Alle Ms < K
//Alle Substrings der länge K ansehen und die Ls zählen (+1 pro M an der Grenze)
//-> Case2: Es gibt Ms >= K
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
//Algorithmus vorschlag:
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
//2.Ggfls nochmal durchiterieren und Case 1 fixen
//Optimierung kommt später
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
boolean isCase2 = false;
int totalNeededOperationsCase2=0;
int minNeededOperationsCase1=Integer.MAX_VALUE;
int lastMLength=0;
for(int i=0;i<S.length();i++){
char c = S.charAt(i);
if(c=='M'){
lastMLength++;
}
else{ //Can only be L
if(lastMLength >= K){
isCase2 = true;
}
if(isCase2){
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
totalNeededOperationsCase2+=Math.round(lastMLength/K)-1;
}
lastMLength=0;
}
}
if(!isCase2){
int lCounter=0;
for(int i=0;i<K;i++){
char c = S.charAt(i);
if(c!='M'){
lCounter++;
}
}
minNeededOperationsCase1 = lCounter;
//because then this is the only case
if(K==S.length()) return minNeededOperationsCase1;
//This needs to happen before in case the value is incremented (we dont know)
int currentOpsNeeded=minNeededOperationsCase1;
//In this case the M train has become too big
if(S.charAt(K)=='M') minNeededOperationsCase1++;
for(int i=K;i<S.length();i++){
char c = S.charAt(i);
char firstChar = S.charAt(i-K);
//adapt current operations needed value
if(c=='L'){
currentOpsNeeded++;
}
if(firstChar=='L'){
currentOpsNeeded--;
}
//compare to current minimum
int additionForComparison = 0;
if(firstChar == 'M'){
additionForComparison++;
}
if(i<S.length()-1 && S.charAt(i+1)=='M'){
additionForComparison++;
}
if(currentOpsNeeded+additionForComparison < minNeededOperationsCase1){
minNeededOperationsCase1 = currentOpsNeeded+additionForComparison;
}
}
return minNeededOperationsCase1;
}
else{
return totalNeededOperationsCase2;
}
}
}
Code: 12:18:04 UTC,
java,
autosave
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495
// 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(String S, int K) {
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=3
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=7
//1,-1,3,-3,1,-1,1,-1,2,-3,5,-1,1,-1,1,-2,2
//-> Case1: Alle Ms < K
//Alle Substrings der länge K ansehen und die Ls zählen (+1 pro M an der Grenze)
//-> Case2: Es gibt Ms >= K
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
//Algorithmus vorschlag:
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
//2.Ggfls nochmal durchiterieren und Case 1 fixen
//Optimierung kommt später
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
boolean isCase2 = false;
int totalNeededOperationsCase2=0;
int minNeededOperationsCase1=Integer.MAX_VALUE;
int lastMLength=0;
for(int i=0;i<S.length();i++){
char c = S.charAt(i);
if(c=='M'){
lastMLength++;
}
else{ //Can only be L
if(lastMLength >= K){
isCase2 = true;
totalNeededOperationsCase2++;
lastMLength
}
if(isCase2){
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
totalNeededOperationsCase2+=Math.round(lastMLength/K)-1;
}
lastMLength=0;
}
}
if(!isCase2){
int lCounter=0;
for(int i=0;i<K;i++){
char c = S.charAt(i);
if(c!='M'){
lCounter++;
}
}
minNeededOperationsCase1 = lCounter;
//because then this is the only case
if(K==S.length()) return minNeededOperationsCase1;
//This needs to happen before in case the value is incremented (we dont know)
int currentOpsNeeded=minNeededOperationsCase1;
//In this case the M train has become too big
if(S.charAt(K)=='M') minNeededOperationsCase1++;
for(int i=K;i<S.length();i++){
char c = S.charAt(i);
char firstChar = S.charAt(i-K);
//adapt current operations needed value
if(c=='L'){
currentOpsNeeded++;
}
if(firstChar=='L'){
currentOpsNeeded--;
}
//compare to current minimum
int additionForComparison = 0;
if(firstChar == 'M'){
additionForComparison++;
}
if(i<S.length()-1 && S.charAt(i+1)=='M'){
additionForComparison++;
}
if(currentOpsNeeded+additionForComparison < minNeededOperationsCase1){
minNeededOperationsCase1 = currentOpsNeeded+additionForComparison;
}
}
return minNeededOperationsCase1;
}
else{
return totalNeededOperationsCase2;
}
}
}
Code: 12:18:15 UTC,
java,
autosave
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495
// 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(String S, int K) {
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=3
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=7
//1,-1,3,-3,1,-1,1,-1,2,-3,5,-1,1,-1,1,-2,2
//-> Case1: Alle Ms < K
//Alle Substrings der länge K ansehen und die Ls zählen (+1 pro M an der Grenze)
//-> Case2: Es gibt Ms >= K
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
//Algorithmus vorschlag:
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
//2.Ggfls nochmal durchiterieren und Case 1 fixen
//Optimierung kommt später
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
boolean isCase2 = false;
int totalNeededOperationsCase2=0;
int minNeededOperationsCase1=Integer.MAX_VALUE;
int lastMLength=0;
for(int i=0;i<S.length();i++){
char c = S.charAt(i);
if(c=='M'){
lastMLength++;
}
else{ //Can only be L
if(lastMLength >= K){
isCase2 = true;
totalNeededOperationsCase2++;
lastMLength=0;
}
if(isCase2){
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
totalNeededOperationsCase2+=Math.round(lastMLength/K)-1;
}
lastMLength=0;
}
}
if(!isCase2){
int lCounter=0;
for(int i=0;i<K;i++){
char c = S.charAt(i);
if(c!='M'){
lCounter++;
}
}
minNeededOperationsCase1 = lCounter;
//because then this is the only case
if(K==S.length()) return minNeededOperationsCase1;
//This needs to happen before in case the value is incremented (we dont know)
int currentOpsNeeded=minNeededOperationsCase1;
//In this case the M train has become too big
if(S.charAt(K)=='M') minNeededOperationsCase1++;
for(int i=K;i<S.length();i++){
char c = S.charAt(i);
char firstChar = S.charAt(i-K);
//adapt current operations needed value
if(c=='L'){
currentOpsNeeded++;
}
if(firstChar=='L'){
currentOpsNeeded--;
}
//compare to current minimum
int additionForComparison = 0;
if(firstChar == 'M'){
additionForComparison++;
}
if(i<S.length()-1 && S.charAt(i+1)=='M'){
additionForComparison++;
}
if(currentOpsNeeded+additionForComparison < minNeededOperationsCase1){
minNeededOperationsCase1 = currentOpsNeeded+additionForComparison;
}
}
return minNeededOperationsCase1;
}
else{
return totalNeededOperationsCase2;
}
}
}
Code: 12:18:28 UTC,
java,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990
// 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(String S, int K) {
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=3
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=7
//1,-1,3,-3,1,-1,1,-1,2,-3,5,-1,1,-1,1,-2,2
//-> Case1: Alle Ms < K
//Alle Substrings der länge K ansehen und die Ls zählen (+1 pro M an der Grenze)
//-> Case2: Es gibt Ms >= K
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
//Algorithmus vorschlag:
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
//2.Ggfls nochmal durchiterieren und Case 1 fixen
//Optimierung kommt später
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
boolean isCase2 = false;
int totalNeededOperationsCase2=0;
int minNeededOperationsCase1=Integer.MAX_VALUE;
int lastMLength=0;
for(int i=0;i<S.length();i++){
char c = S.charAt(i);
if(c=='M'){
lastMLength++;
if(lastMLength >= K){
isCase2 = true;
totalNeededOperationsCase2++;
lastMLength=0;
}
}
else{ //Can only be L
lastMLength=0;
}
}
if(!isCase2){
int lCounter=0;
for(int i=0;i<K;i++){
char c = S.charAt(i);
if(c!='M'){
lCounter++;
}
}
minNeededOperationsCase1 = lCounter;
//because then this is the only case
if(K==S.length()) return minNeededOperationsCase1;
//This needs to happen before in case the value is incremented (we dont know)
int currentOpsNeeded=minNeededOperationsCase1;
//In this case the M train has become too big
if(S.charAt(K)=='M') minNeededOperationsCase1++;
for(int i=K;i<S.length();i++){
char c = S.charAt(i);
char firstChar = S.charAt(i-K);
//adapt current operations needed value
if(c=='L'){
currentOpsNeeded++;
}
if(firstChar=='L'){
currentOpsNeeded--;
}
//compare to current minimum
int additionForComparison = 0;
if(firstChar == 'M'){
additionForComparison++;
}
if(i<S.length()-1 && S.charAt(i+1)=='M'){
additionForComparison++;
}
if(currentOpsNeeded+additionForComparison < minNeededOperationsCase1){
minNeededOperationsCase1 = currentOpsNeeded+additionForComparison;
}
}
return minNeededOperationsCase1;
}
else{
return totalNeededOperationsCase2;
}
}
}
Code: 12:18:58 UTC,
java,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091
// 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(String S, int K) {
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=3
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=7
//1,-1,3,-3,1,-1,1,-1,2,-3,5,-1,1,-1,1,-2,2
//-> Case1: Alle Ms < K
//Alle Substrings der länge K ansehen und die Ls zählen (+1 pro M an der Grenze)
//-> Case2: Es gibt Ms >= K
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
//Algorithmus vorschlag:
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
//2.Ggfls nochmal durchiterieren und Case 1 fixen
//Optimierung kommt später
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
boolean isCase2 = false;
int totalNeededOperationsCase2=0;
int minNeededOperationsCase1=Integer.MAX_VALUE;
int lastMLength=0;
for(int i=0;i<S.length();i++){
char c = S.charAt(i);
if(c=='M'){
lastMLength++;
if(lastMLength >=
K){
isCase2 = true;
totalNeededOperationsCase2++;
lastMLength=0;
}
}
else{ //Can only be L
lastMLength=0;
}
}
if(!isCase2){
int lCounter=0;
for(int i=0;i<K;i++){
char c = S.charAt(i);
if(c!='M'){
lCounter++;
}
}
minNeededOperationsCase1 = lCounter;
//because then this is the only case
if(K==S.length()) return minNeededOperationsCase1;
//This needs to happen before in case the value is incremented (we dont know)
int currentOpsNeeded=minNeededOperationsCase1;
//In this case the M train has become too big
if(S.charAt(K)=='M') minNeededOperationsCase1++;
for(int i=K;i<S.length();i++){
char c = S.charAt(i);
char firstChar = S.charAt(i-K);
//adapt current operations needed value
if(c=='L'){
currentOpsNeeded++;
}
if(firstChar=='L'){
currentOpsNeeded--;
}
//compare to current minimum
int additionForComparison = 0;
if(firstChar == 'M'){
additionForComparison++;
}
if(i<S.length()-1 && S.charAt(i+1)=='M'){
additionForComparison++;
}
if(currentOpsNeeded+additionForComparison < minNeededOperationsCase1){
minNeededOperationsCase1 = currentOpsNeeded+additionForComparison;
}
}
return minNeededOperationsCase1;
}
else{
return totalNeededOperationsCase2;
}
}
}
Code: 12:19:08 UTC,
java,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990
// 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(String S, int K) {
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=3
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=7
//1,-1,3,-3,1,-1,1,-1,2,-3,5,-1,1,-1,1,-2,2
//-> Case1: Alle Ms < K
//Alle Substrings der länge K ansehen und die Ls zählen (+1 pro M an der Grenze)
//-> Case2: Es gibt Ms >= K
//Um die langen Ms zu verkürzen muss ich ihre länge durch K teilen, runden und 1 abziehen
//-> MMMMMMMM 8/3=2.6 2.6~= 3 , 3-1=2 -> 2 changes
//Algorithmus vorschlag:
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
//2.Ggfls nochmal durchiterieren und Case 1 fixen
//Optimierung kommt später
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
boolean isCase2 = false;
int totalNeededOperationsCase2=0;
int minNeededOperationsCase1=Integer.MAX_VALUE;
int lastMLength=0;
for(int i=0;i<S.length();i++){
char c = S.charAt(i);
if(c=='M'){
lastMLength++;
if(lastMLength > K){
isCase2 = true;
totalNeededOperationsCase2++;
lastMLength=0;
}
}
else{ //Can only be L
lastMLength=0;
}
}
if(!isCase2){
int lCounter=0;
for(int i=0;i<K;i++){
char c = S.charAt(i);
if(c!='M'){
lCounter++;
}
}
minNeededOperationsCase1 = lCounter;
//because then this is the only case
if(K==S.length()) return minNeededOperationsCase1;
//This needs to happen before in case the value is incremented (we dont know)
int currentOpsNeeded=minNeededOperationsCase1;
//In this case the M train has become too big
if(S.charAt(K)=='M') minNeededOperationsCase1++;
for(int i=K;i<S.length();i++){
char c = S.charAt(i);
char firstChar = S.charAt(i-K);
//adapt current operations needed value
if(c=='L'){
currentOpsNeeded++;
}
if(firstChar=='L'){
currentOpsNeeded--;
}
//compare to current minimum
int additionForComparison = 0;
if(firstChar == 'M'){
additionForComparison++;
}
if(i<S.length()-1 && S.charAt(i+1)=='M'){
additionForComparison++;
}
if(currentOpsNeeded+additionForComparison < minNeededOperationsCase1){
minNeededOperationsCase1 = currentOpsNeeded+additionForComparison;
}
}
return minNeededOperationsCase1;
}
else{
return totalNeededOperationsCase2;
}
}
}
Code: 12:19:39 UTC,
java,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788
// 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(String S, int K) {
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=3
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=7
//1,-1,3,-3,1,-1,1,-1,2,-3,5,-1,1,-1,1,-2,2
//-> Case1: Alle Ms < K
//Alle Substrings der länge K ansehen und die Ls zählen (+1 pro M an der Grenze)
//-> Case2: Es gibt Ms >= K
//Algorithmus vorschlag:
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
//2.Ggfls nochmal durchiterieren und Case 1 fixen
//Optimierung kommt später
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
boolean isCase2 = false;
int totalNeededOperationsCase2=0;
int minNeededOperationsCase1=Integer.MAX_VALUE;
int lastMLength=0;
for(int i=0;i<S.length();i++){
char c = S.charAt(i);
if(c=='M'){
lastMLength++;
if(lastMLength > K){
isCase2 = true;
totalNeededOperationsCase2++;
lastMLength=0;
}
}
else{ //Can only be L
lastMLength=0;
}
}
if(!isCase2){
int lCounter=0;
for(int i=0;i<K;i++){
char c = S.charAt(i);
if(c!='M'){
lCounter++;
}
}
minNeededOperationsCase1 = lCounter;
//because then this is the only case
if(K==S.length()) return minNeededOperationsCase1;
//This needs to happen before in case the value is incremented (we dont know)
int currentOpsNeeded=minNeededOperationsCase1;
//In this case the M train has become too big
if(S.charAt(K)=='M') minNeededOperationsCase1++;
for(int i=K;i<S.length();i++){
char c = S.charAt(i);
char firstChar = S.charAt(i-K);
//adapt current operations needed value
if(c=='L'){
currentOpsNeeded++;
}
if(firstChar=='L'){
currentOpsNeeded--;
}
//compare to current minimum
int additionForComparison = 0;
if(firstChar == 'M'){
additionForComparison++;
}
if(i<S.length()-1 && S.charAt(i+1)=='M'){
additionForComparison++;
}
if(currentOpsNeeded+additionForComparison < minNeededOperationsCase1){
minNeededOperationsCase1 = currentOpsNeeded+additionForComparison;
}
}
return minNeededOperationsCase1;
}
else{
return totalNeededOperationsCase2;
}
}
}
Code: 12:20:09 UTC,
java,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990
// 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(String S, int K) {
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=3
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=7
//1,-1,3,-3,1,-1,1,-1,2,-3,5,-1,1,-1,1,-2,2
//-> Case1: Alle Ms < K
//Alle Substrings der länge K ansehen und die Ls zählen (+1 pro M an der Grenze)
//-> Case2: Es gibt Ms >= K
//Algorithmus vorschlag:
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
//2.Ggfls nochmal durchiterieren und Case 1 fixen
//Optimierung kommt später
//TODO put all in one
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
boolean isCase2 = false;
int totalNeededOperationsCase2=0;
int minNeededOperationsCase1=Integer.MAX_VALUE;
int lastMLength=0;
for(int i=0;i<S.length();i++){
char c = S.charAt(i);
if(c=='M'){
lastMLength++;
if(lastMLength > K){
isCase2 = true;
totalNeededOperationsCase2++;
lastMLength=0;
}
}
else{ //Can only be L
lastMLength=0;
}
}
if(!isCase2){
int lCounter=0;
for(int i=0;i<K;i++){
char c = S.charAt(i);
if(c!='M'){
lCounter++;
}
}
minNeededOperationsCase1 = lCounter;
//because then this is the only case
if(K==S.length()) return minNeededOperationsCase1;
//This needs to happen before in case the value is incremented (we dont know)
int currentOpsNeeded=minNeededOperationsCase1;
//In this case the M train has become too big
if(S.charAt(K)=='M') minNeededOperationsCase1++;
for(int i=K;i<S.length();i++){
char c = S.charAt(i);
char firstChar = S.charAt(i-K);
//adapt current operations needed value
if(c=='L'){
currentOpsNeeded++;
}
if(firstChar=='L'){
currentOpsNeeded--;
}
//compare to current minimum
int additionForComparison = 0;
if(firstChar == 'M'){
additionForComparison++;
}
if(i<S.length()-1 && S.charAt(i+1)=='M'){
additionForComparison++;
}
if(currentOpsNeeded+additionForComparison < minNeededOperationsCase1){
minNeededOperationsCase1 = currentOpsNeeded+additionForComparison;
}
}
return minNeededOperationsCase1;
}
else{
return totalNeededOperationsCase2;
}
}
}
Code: 12:20:11 UTC,
java,
verify,
result: Passed
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990
// 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(String S, int K) {
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=3
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=7
//1,-1,3,-3,1,-1,1,-1,2,-3,5,-1,1,-1,1,-2,2
//-> Case1: Alle Ms < K
//Alle Substrings der länge K ansehen und die Ls zählen (+1 pro M an der Grenze)
//-> Case2: Es gibt Ms >= K
//Algorithmus vorschlag:
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
//2.Ggfls nochmal durchiterieren und Case 1 fixen
//Optimierung kommt später
//TODO put all in one loop
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
boolean isCase2 = false;
int totalNeededOperationsCase2=0;
int minNeededOperationsCase1=Integer.MAX_VALUE;
int lastMLength=0;
for(int i=0;i<S.length();i++){
char c = S.charAt(i);
if(c=='M'){
lastMLength++;
if(lastMLength > K){
isCase2 = true;
totalNeededOperationsCase2++;
lastMLength=0;
}
}
else{ //Can only be L
lastMLength=0;
}
}
if(!isCase2){
int lCounter=0;
for(int i=0;i<K;i++){
char c = S.charAt(i);
if(c!='M'){
lCounter++;
}
}
minNeededOperationsCase1 = lCounter;
//because then this is the only case
if(K==S.length()) return minNeededOperationsCase1;
//This needs to happen before in case the value is incremented (we dont know)
int currentOpsNeeded=minNeededOperationsCase1;
//In this case the M train has become too big
if(S.charAt(K)=='M') minNeededOperationsCase1++;
for(int i=K;i<S.length();i++){
char c = S.charAt(i);
char firstChar = S.charAt(i-K);
//adapt current operations needed value
if(c=='L'){
currentOpsNeeded++;
}
if(firstChar=='L'){
currentOpsNeeded--;
}
//compare to current minimum
int additionForComparison = 0;
if(firstChar == 'M'){
additionForComparison++;
}
if(i<S.length()-1 && S.charAt(i+1)=='M'){
additionForComparison++;
}
if(currentOpsNeeded+additionForComparison < minNeededOperationsCase1){
minNeededOperationsCase1 = currentOpsNeeded+additionForComparison;
}
}
return minNeededOperationsCase1;
}
else{
return totalNeededOperationsCase2;
}
}
}
Analysis
expand all
User tests
1.
0.004 s
OK
function result: 2
function result: 2
1.
0.008 s
OK
function result: 2
function result: 2
1.
0.004 s
OK
function result: 4
function result: 4
User test case 1:
['MMLMMLMMLMMLMM', 3]
User test case 2:
['MMMLMMMMMLMM', 2]
User test case 3:
['MMMLMMMMMLMM', 1]
Code: 12:21:37 UTC,
java,
verify,
result: Passed
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990
// 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(String S, int K) {
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=3
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=7
//1,-1,3,-3,1,-1,1,-1,2,-3,5,-1,1,-1,1,-2,2
//-> Case1: Alle Ms < K
//Alle Substrings der länge K ansehen und die Ls zählen (+1 pro M an der Grenze)
//-> Case2: Es gibt Ms >= K
//Algorithmus vorschlag:
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
//2.Ggfls nochmal durchiterieren und Case 1 fixen
//Optimierung kommt später
//TODO put all in one loop
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
boolean isCase2 = false;
int totalNeededOperationsCase2=0;
int minNeededOperationsCase1=Integer.MAX_VALUE;
int lastMLength=0;
for(int i=0;i<S.length();i++){
char c = S.charAt(i);
if(c=='M'){
lastMLength++;
if(lastMLength > K){
isCase2 = true;
totalNeededOperationsCase2++;
lastMLength=0;
}
}
else{ //Can only be L
lastMLength=0;
}
}
if(!isCase2){
int lCounter=0;
for(int i=0;i<K;i++){
char c = S.charAt(i);
if(c!='M'){
lCounter++;
}
}
minNeededOperationsCase1 = lCounter;
//because then this is the only case
if(K==S.length()) return minNeededOperationsCase1;
//This needs to happen before in case the value is incremented (we dont know)
int currentOpsNeeded=minNeededOperationsCase1;
//In this case the M train has become too big
if(S.charAt(K)=='M') minNeededOperationsCase1++;
for(int i=K;i<S.length();i++){
char c = S.charAt(i);
char firstChar = S.charAt(i-K);
//adapt current operations needed value
if(c=='L'){
currentOpsNeeded++;
}
if(firstChar=='L'){
currentOpsNeeded--;
}
//compare to current minimum
int additionForComparison = 0;
if(firstChar == 'M'){
additionForComparison++;
}
if(i<S.length()-1 && S.charAt(i+1)=='M'){
additionForComparison++;
}
if(currentOpsNeeded+additionForComparison < minNeededOperationsCase1){
minNeededOperationsCase1 = currentOpsNeeded+additionForComparison;
}
}
return minNeededOperationsCase1;
}
else{
return totalNeededOperationsCase2;
}
}
}
Analysis
expand all
User tests
1.
0.004 s
OK
function result: 2
function result: 2
1.
0.004 s
OK
function result: 2
function result: 2
1.
0.008 s
OK
function result: 4
function result: 4
1.
0.008 s
OK
function result: 4
function result: 4
1.
0.004 s
OK
function result: 3
function result: 3
1.
0.004 s
OK
function result: 8
function result: 8
User test case 1:
['MMLMMLMMLMMLMM', 3]
User test case 2:
['MMMLMMMMMLMM', 2]
User test case 3:
['MMMLMMMMMLMM', 1]
User test case 4:
['LLLLLLLLLLLLLLLL', 4]
User test case 5:
['MMMMMMMMMMMMMMMM', 4]
User test case 6:
['MLMLLLMMMLMMM', 0]
Code: 12:22:15 UTC,
java,
autosave
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192
// 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(String S, int K) {
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=3
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=7
//1,-1,3,-3,1,-1,1,-1,2,-3,5,-1,1,-1,1,-2,2
//-> Case1: Alle Ms < K
//Alle Substrings der länge K ansehen und die Ls zählen (+1 pro M an der Grenze)
//-> Case2: Es gibt Ms >= K
//Algorithmus vorschlag:
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
//2.Ggfls nochmal durchiterieren und Case 1 fixen
//Optimierung kommt später
//TODO put all in one loop
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
boolean isCase2 = false;
int totalNeededOperationsCase2=0;
int minNeededOperationsCase1=Integer.MAX_VALUE;
int lastMLength=0;
for(int i=0;i<S.length();i++){
char c = S.charAt(i);
if(c=='M'){
lastMLength++;
if(lastMLength > K){
isCase2 = true;
totalNeededOperationsCase2++;
lastMLength=0;
}
}
else{ //Can only be L
lastMLength=0;
}
}
if(!isCase2){
int lCounter=0;
for(int i=0;i<K;i++){
char c = S.charAt(i);
if(c!='M'){
lCounter++;
}
}
minNeededOperationsCase1 = lCounter;
//because then this is the only case
if(K==S.length()) return minNeededOperationsCase1;
//This needs to happen before in case the value is incremented (we dont know)
int currentOpsNeeded=minNeededOperationsCase1;
//In this case the M train has become too big
if(S.charAt(K)=='M') minNeededOperationsCase1++;
for(int i=K;i<S.length();i++){
char c = S.charAt(i);
char firstChar = S.charAt(i-K);
//adapt current operations needed value
if(c=='L'){
currentOpsNeeded++;
}
if(firstChar=='L'){
currentOpsNeeded--;
}
//compare to current minimum
int additionForComparison = 0;
if(firstChar == 'M'){
additionForComparison++;
}
if(i<S.length()-1 && S.charAt(i+1)=='M'){
additionForComparison++;
}
if(currentOpsNeeded+additionForComparison < minNeededOperationsCase1){
minNeededOperationsCase1 = currentOpsNeeded+additionForComparison;
}
}
return minNeededOperationsCase1;
}
else{
return totalNeededOperationsCase2;
}
}
//
}
Code: 12:22:32 UTC,
java,
autosave
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192
// 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(String S, int K) {
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=3
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=7
//1,-1,3,-3,1,-1,1,-1,2,-3,5,-1,1,-1,1,-2,2
//-> Case1: Alle Ms < K
//Alle Substrings der länge K ansehen und die Ls zählen (+1 pro M an der Grenze)
//-> Case2: Es gibt Ms >= K
//Algorithmus vorschlag:
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
//2.Ggfls nochmal durchiterieren und Case 1 fixen
//Optimierung kommt später
//TODO put all in one loop
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
boolean isCase2 = false;
int totalNeededOperationsCase2=0;
int minNeededOperationsCase1=Integer.MAX_VALUE;
int lastMLength=0;
for(int i=0;i<S.length();i++){
char c = S.charAt(i);
if(c=='M'){
lastMLength++;
if(lastMLength > K){
isCase2 = true;
totalNeededOperationsCase2++;
lastMLength=0;
}
}
else{ //Can only be L
lastMLength=0;
}
}
if(!isCase2){
int lCounter=0;
for(int i=0;i<K;i++){
char c = S.charAt(i);
if(c!='M'){
lCounter++;
}
}
minNeededOperationsCase1 = lCounter;
//because then this is the only case
if(K==S.length()) return minNeededOperationsCase1;
//This needs to happen before in case the value is incremented (we dont know)
int currentOpsNeeded=minNeededOperationsCase1;
//In this case the M train has become too big
if(S.charAt(K)=='M') minNeededOperationsCase1++;
for(int i=K;i<S.length();i++){
char c = S.charAt(i);
char firstChar = S.charAt(i-K);
//adapt current operations needed value
if(c=='L'){
currentOpsNeeded++;
}
if(firstChar=='L'){
currentOpsNeeded--;
}
//compare to current minimum
int additionForComparison = 0;
if(firstChar == 'M'){
additionForComparison++;
}
if(i<S.length()-1 && S.charAt(i+1)=='M'){
additionForComparison++;
}
if(currentOpsNeeded+additionForComparison < minNeededOperationsCase1){
minNeededOperationsCase1 = currentOpsNeeded+additionForComparison;
}
}
return minNeededOperationsCase1;
}
else{
return totalNeededOperationsCase2;
}
}
//Tests 2,2,4,4,3,8
}
Code: 12:23:12 UTC,
java,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697
// 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(String S, int K) {
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=3
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=7
//1,-1,3,-3,1,-1,1,-1,2,-3,5,-1,1,-1,1,-2,2
//-> Case1: Alle Ms < K
//Alle Substrings der länge K ansehen und die Ls zählen (+1 pro M an der Grenze)
//-> Case2: Es gibt Ms >= K
//Algorithmus vorschlag:
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
//2.Ggfls nochmal durchiterieren und Case 1 fixen
//Optimierung kommt später
//TODO put all in one loop
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
boolean isCase2 = false;
int totalNeededOperationsCase2=0;
int minNeededOperationsCase1=Integer.MAX_VALUE;
int lastMLength=0;
for(int i=0;i<S.length();i++){
char c = S.charAt(i);
if(c=='M'){
lastMLength++;
if(lastMLength > K){
isCase2 = true;
totalNeededOperationsCase2++;
lastMLength=0;
}
}
else{ //Can only be L
lastMLength=0;
}
}
if(!isCase2){
int lCounter=0;
for(int i=0;i<K;i++){
char c = S.charAt(i);
if(c!='M'){
lCounter++;
}
}
minNeededOperationsCase1 = lCounter;
//because then this is the only case
if(K==S.length()) return minNeededOperationsCase1;
//This needs to happen before in case the value is incremented (we dont know)
int currentOpsNeeded=minNeededOperationsCase1;
//In this case the M train has become too big
if(S.charAt(K)=='M') minNeededOperationsCase1++;
for(int i=K;i<S.length();i++){
char c = S.charAt(i);
char firstChar = S.charAt(i-K);
//adapt current operations needed value
if(c=='L'){
currentOpsNeeded++;
}
if(firstChar=='L'){
currentOpsNeeded--;
}
//compare to current minimum
int additionForComparison = 0;
if(firstChar == 'M'){
additionForComparison++;
}
if(i<S.length()-1 && S.charAt(i+1)=='M'){
additionForComparison++;
}
if(currentOpsNeeded+additionForComparison < minNeededOperationsCase1){
minNeededOperationsCase1 = currentOpsNeeded+additionForComparison;
}
}
return minNeededOperationsCase1;
}
else{
return totalNeededOperationsCase2;
}
}
//Tests 2,2,4,4,3,8
}
Code: 12:23:29 UTC,
java,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104
// 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(String S, int K) {
/* OLD SOLUTION
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=3
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=7
//1,-1,3,-3,1,-1,1,-1,2,-3,5,-1,1,-1,1,-2,2
//-> Case1: Alle Ms < K
//Alle Substrings der länge K ansehen und die Ls zählen (+1 pro M an der Grenze)
//-> Case2: Es gibt Ms >= K
//Algorithmus vorschlag:
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
//2.Ggfls nochmal durchiterieren und Case 1 fixen
//Optimierung kommt später
//TODO put all in one loop
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
boolean isCase2 = false;
int totalNeededOperationsCase2=0;
int minNeededOperationsCase1=Integer.MAX_VALUE;
int lastMLength=0;
for(int i=0;i<S.length();i++){
char c = S.charAt(i);
if(c=='M'){
lastMLength++;
if(lastMLength > K){
isCase2 = true;
totalNeededOperationsCase2++;
lastMLength=0;
}
}
else{ //Can only be L
lastMLength=0;
}
}
if(!isCase2){
int lCounter=0;
for(int i=0;i<K;i++){
char c = S.charAt(i);
if(c!='M'){
lCounter++;
}
}
minNeededOperationsCase1 = lCounter;
//because then this is the only case
if(K==S.length()) return minNeededOperationsCase1;
//This needs to happen before in case the value is incremented (we dont know)
int currentOpsNeeded=minNeededOperationsCase1;
//In this case the M train has become too big
if(S.charAt(K)=='M') minNeededOperationsCase1++;
for(int i=K;i<S.length();i++){
char c = S.charAt(i);
char firstChar = S.charAt(i-K);
//adapt current operations needed value
if(c=='L'){
currentOpsNeeded++;
}
if(firstChar=='L'){
currentOpsNeeded--;
}
//compare to current minimum
int additionForComparison = 0;
if(firstChar == 'M'){
additionForComparison++;
}
if(i<S.length()-1 && S.charAt(i+1)=='M'){
additionForComparison++;
}
if(currentOpsNeeded+additionForComparison < minNeededOperationsCase1){
minNeededOperationsCase1 = currentOpsNeeded+additionForComparison;
}
}
return minNeededOperationsCase1;
}
else{
return totalNeededOperationsCase2;
}
*/
}
//Tests 2,2,4,4,3,8
}
Code: 12:23:48 UTC,
java,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166
// 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(String S, int K) {
boolean isCase2 = false;
int totalNeededOperationsCase2=0;
int minNeededOperationsCase1=Integer.MAX_VALUE;
int lastMLength=0;
for(int i=0;i<S.length();i++){
char c = S.charAt(i);
if(c=='M'){
lastMLength++;
if(lastMLength > K){
isCase2 = true;
totalNeededOperationsCase2++;
lastMLength=0;
}
}
else{ //Can only be L
lastMLength=0;
}
}
if(!isCase2){
int lCounter=0;
for(int i=0;i<K;i++){
char c = S.charAt(i);
if(c!='M'){
lCounter++;
}
}
minNeededOperationsCase1 = lCounter;
//because then this is the only case
if(K==S.length()) return minNeededOperationsCase1;
//This needs to happen before in case the value is incremented (we dont know)
int currentOpsNeeded=minNeededOperationsCase1;
//In this case the M train has become too big
if(S.charAt(K)=='M') minNeededOperationsCase1++;
for(int i=K;i<S.length();i++){
char c = S.charAt(i);
char firstChar = S.charAt(i-K);
//adapt current operations needed value
if(c=='L'){
currentOpsNeeded++;
}
if(firstChar=='L'){
currentOpsNeeded--;
}
//compare to current minimum
int additionForComparison = 0;
if(firstChar == 'M'){
additionForComparison++;
}
if(i<S.length()-1 && S.charAt(i+1)=='M'){
additionForComparison++;
}
if(currentOpsNeeded+additionForComparison < minNeededOperationsCase1){
minNeededOperationsCase1 = currentOpsNeeded+additionForComparison;
}
}
return minNeededOperationsCase1;
}
else{
return totalNeededOperationsCase2;
}
/* OLD SOLUTION
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=3
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=7
//1,-1,3,-3,1,-1,1,-1,2,-3,5,-1,1,-1,1,-2,2
//-> Case1: Alle Ms < K
//Alle Substrings der länge K ansehen und die Ls zählen (+1 pro M an der Grenze)
//-> Case2: Es gibt Ms >= K
//Algorithmus vorschlag:
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
//2.Ggfls nochmal durchiterieren und Case 1 fixen
//Optimierung kommt später
//TODO put all in one loop
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
boolean isCase2 = false;
int totalNeededOperationsCase2=0;
int minNeededOperationsCase1=Integer.MAX_VALUE;
int lastMLength=0;
for(int i=0;i<S.length();i++){
char c = S.charAt(i);
if(c=='M'){
lastMLength++;
if(lastMLength > K){
isCase2 = true;
totalNeededOperationsCase2++;
lastMLength=0;
}
}
else{ //Can only be L
lastMLength=0;
}
}
if(!isCase2){
int lCounter=0;
for(int i=0;i<K;i++){
char c = S.charAt(i);
if(c!='M'){
lCounter++;
}
}
minNeededOperationsCase1 = lCounter;
//because then this is the only case
if(K==S.length()) return minNeededOperationsCase1;
//This needs to happen before in case the value is incremented (we dont know)
int currentOpsNeeded=minNeededOperationsCase1;
//In this case the M train has become too big
if(S.charAt(K)=='M') minNeededOperationsCase1++;
for(int i=K;i<S.length();i++){
char c = S.charAt(i);
char firstChar = S.charAt(i-K);
//adapt current operations needed value
if(c=='L'){
currentOpsNeeded++;
}
if(firstChar=='L'){
currentOpsNeeded--;
}
//compare to current minimum
int additionForComparison = 0;
if(firstChar == 'M'){
additionForComparison++;
}
if(i<S.length()-1 && S.charAt(i+1)=='M'){
additionForComparison++;
}
if(currentOpsNeeded+additionForComparison < minNeededOperationsCase1){
minNeededOperationsCase1 = currentOpsNeeded+additionForComparison;
}
}
return minNeededOperationsCase1;
}
else{
return totalNeededOperationsCase2;
}
*/
}
//Tests 2,2,4,4,3,8
}
Code: 12:23:58 UTC,
java,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164
// 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(String S, int K) {
boolean isCase2 = false;
int totalNeededOperationsCase2=0;
int minNeededOperationsCase1=Integer.MAX_VALUE;
int lastMLength=0;
for(int i=0;i<S.length();i++){
char c = S.charAt(i);
if(c=='M'){
lastMLength++;
if(lastMLength > K){
isCase2 = true;
totalNeededOperationsCase2++;
lastMLength=0;
}
}
else{ //Can only be L
lastMLength=0;
}
}
if(!isCase2){
int lCounter=0;
for(int i=0;i<K;i++){
char c = S.charAt(i);
if(c!='M'){
lCounter++;
}
}
minNeededOperationsCase1 = lCounter;
//because then this is the only case
if(K==S.length()) return minNeededOperationsCase1;
//This needs to happen before in case the value is incremented (we dont know)
int currentOpsNeeded=minNeededOperationsCase1;
//In this case the M train has become too big
if(S.charAt(K)=='M') minNeededOperationsCase1++;
for(int i=K;i<S.length();i++){
char c = S.charAt(i);
char firstChar = S.charAt(i-K);
//adapt current operations needed value
if(c=='L'){
currentOpsNeeded++;
}
if(firstChar=='L'){
currentOpsNeeded--;
}
//compare to current minimum
int additionForComparison = 0;
if(firstChar == 'M'){
additionForComparison++;
}
if(i<S.length()-1 && S.charAt(i+1)=='M'){
additionForComparison++;
}
if(currentOpsNeeded+additionForComparison < minNeededOperationsCase1){
minNeededOperationsCase1 = currentOpsNeeded+additionForComparison;
}
}
return minNeededOperationsCase1;
}
else{
return totalNeededOperationsCase2;
}
/* OLD SOLUTION
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=3
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=7
//1,-1,3,-3,1,-1,1,-1,2,-3,5,-1,1,-1,1,-2,2
//-> Case1: Alle Ms < K
//Alle Substrings der länge K ansehen und die Ls zählen (+1 pro M an der Grenze)
//-> Case2: Es gibt Ms >= K
//Algorithmus vorschlag:
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
//2.Ggfls nochmal durchiterieren und Case 1 fixen
//Optimierung kommt später
//TODO put all in one loop
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
boolean isCase2 = false;
int totalNeededOperationsCase2=0;
int minNeededOperationsCase1=Integer.MAX_VALUE;
int lastMLength=0;
for(int i=0;i<S.length();i++){
char c = S.charAt(i);
if(c=='M'){
lastMLength++;
if(lastMLength > K){
isCase2 = true;
totalNeededOperationsCase2++;
lastMLength=0;
}
}
else{ //Can only be L
lastMLength=0;
}
}
if(!isCase2){
int lCounter=0;
for(int i=0;i<K;i++){
char c = S.charAt(i);
if(c!='M'){
lCounter++;
}
}
minNeededOperationsCase1 = lCounter;
//because then this is the only case
if(K==S.length()) return minNeededOperationsCase1;
//This needs to happen before in case the value is incremented (we dont know)
int currentOpsNeeded=minNeededOperationsCase1;
//In this case the M train has become too big
if(S.charAt(K)=='M') minNeededOperationsCase1++;
for(int i=K;i<S.length();i++){
char c = S.charAt(i);
char firstChar = S.charAt(i-K);
//adapt current operations needed value
if(c=='L'){
currentOpsNeeded++;
}
if(firstChar=='L'){
currentOpsNeeded--;
}
//compare to current minimum
int additionForComparison = 0;
if(firstChar == 'M'){
additionForComparison++;
}
if(i<S.length()-1 && S.charAt(i+1)=='M'){
additionForComparison++;
}
if(currentOpsNeeded+additionForComparison < minNeededOperationsCase1){
minNeededOperationsCase1 = currentOpsNeeded+additionForComparison;
}
}
return minNeededOperationsCase1;
}
else{
return totalNeededOperationsCase2;
}
*/
}
//Tests 2,2,4,4,3,8
}
Code: 12:25:20 UTC,
java,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104
// 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(String S, int K) {
/* OLD SOLUTION
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=3
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=7
//1,-1,3,-3,1,-1,1,-1,2,-3,5,-1,1,-1,1,-2,2
//-> Case1: Alle Ms < K
//Alle Substrings der länge K ansehen und die Ls zählen (+1 pro M an der Grenze)
//-> Case2: Es gibt Ms >= K
//Algorithmus vorschlag:
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
//2.Ggfls nochmal durchiterieren und Case 1 fixen
//Optimierung kommt später
//TODO put all in one loop
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
boolean isCase2 = false;
int totalNeededOperationsCase2=0;
int minNeededOperationsCase1=Integer.MAX_VALUE;
int lastMLength=0;
for(int i=0;i<S.length();i++){
char c = S.charAt(i);
if(c=='M'){
lastMLength++;
if(lastMLength > K){
isCase2 = true;
totalNeededOperationsCase2++;
lastMLength=0;
}
}
else{ //Can only be L
lastMLength=0;
}
}
if(!isCase2){
int lCounter=0;
for(int i=0;i<K;i++){
char c = S.charAt(i);
if(c!='M'){
lCounter++;
}
}
minNeededOperationsCase1 = lCounter;
//because then this is the only case
if(K==S.length()) return minNeededOperationsCase1;
//This needs to happen before in case the value is incremented (we dont know)
int currentOpsNeeded=minNeededOperationsCase1;
//In this case the M train has become too big
if(S.charAt(K)=='M') minNeededOperationsCase1++;
for(int i=K;i<S.length();i++){
char c = S.charAt(i);
char firstChar = S.charAt(i-K);
//adapt current operations needed value
if(c=='L'){
currentOpsNeeded++;
}
if(firstChar=='L'){
currentOpsNeeded--;
}
//compare to current minimum
int additionForComparison = 0;
if(firstChar == 'M'){
additionForComparison++;
}
if(i<S.length()-1 && S.charAt(i+1)=='M'){
additionForComparison++;
}
if(currentOpsNeeded+additionForComparison < minNeededOperationsCase1){
minNeededOperationsCase1 = currentOpsNeeded+additionForComparison;
}
}
return minNeededOperationsCase1;
}
else{
return totalNeededOperationsCase2;
}
*/
}
//Tests 2,2,4,4,3,8
}
Code: 12:25:30 UTC,
java,
autosave
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192
// 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(String S, int K) {
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=3
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=7
//1,-1,3,-3,1,-1,1,-1,2,-3,5,-1,1,-1,1,-2,2
//-> Case1: Alle Ms < K
//Alle Substrings der länge K ansehen und die Ls zählen (+1 pro M an der Grenze)
//-> Case2: Es gibt Ms >= K
//Algorithmus vorschlag:
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
//2.Ggfls nochmal durchiterieren und Case 1 fixen
//Optimierung kommt später
//TODO put all in one loop
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
boolean isCase2 = false;
int totalNeededOperationsCase2=0;
int minNeededOperationsCase1=Integer.MAX_VALUE;
int lastMLength=0;
for(int i=0;i<S.length();i++){
char c = S.charAt(i);
if(c=='M'){
lastMLength++;
if(lastMLength > K){
isCase2 = true;
totalNeededOperationsCase2++;
lastMLength=0;
}
}
else{ //Can only be L
lastMLength=0;
}
}
if(!isCase2){
int lCounter=0;
for(int i=0;i<K;i++){
char c = S.charAt(i);
if(c!='M'){
lCounter++;
}
}
minNeededOperationsCase1 = lCounter;
//because then this is the only case
if(K==S.length()) return minNeededOperationsCase1;
//This needs to happen before in case the value is incremented (we dont know)
int currentOpsNeeded=minNeededOperationsCase1;
//In this case the M train has become too big
if(S.charAt(K)=='M') minNeededOperationsCase1++;
for(int i=K;i<S.length();i++){
char c = S.charAt(i);
char firstChar = S.charAt(i-K);
//adapt current operations needed value
if(c=='L'){
currentOpsNeeded++;
}
if(firstChar=='L'){
currentOpsNeeded--;
}
//compare to current minimum
int additionForComparison = 0;
if(firstChar == 'M'){
additionForComparison++;
}
if(i<S.length()-1 && S.charAt(i+1)=='M'){
additionForComparison++;
}
if(currentOpsNeeded+additionForComparison < minNeededOperationsCase1){
minNeededOperationsCase1 = currentOpsNeeded+additionForComparison;
}
}
return minNeededOperationsCase1;
}
else{
return totalNeededOperationsCase2;
}
}
//Tests 2,2,4,4,3,8
}
Code: 12:26:32 UTC,
java,
verify,
result: Passed
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192
// 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(String S, int K) {
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=3
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=7
//1,-1,3,-3,1,-1,1,-1,2,-3,5,-1,1,-1,1,-2,2
//-> Case1: Alle Ms < K
//Alle Substrings der länge K ansehen und die Ls zählen (+1 pro M an der Grenze)
//-> Case2: Es gibt Ms >= K
//Algorithmus vorschlag:
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
//2.Ggfls nochmal durchiterieren und Case 1 fixen
//Optimierung kommt später
//TODO put all in one loop
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
boolean isCase2 = false;
int totalNeededOperationsCase2=0;
int minNeededOperationsCase1=Integer.MAX_VALUE;
int lastMLength=0;
for(int i=0;i<S.length();i++){
char c = S.charAt(i);
if(c=='M'){
lastMLength++;
if(lastMLength > K){
isCase2 = true;
totalNeededOperationsCase2++;
lastMLength=0;
}
}
else{ //Can only be L
lastMLength=0;
}
}
if(!isCase2){
int lCounter=0;
for(int i=0;i<K;i++){
char c = S.charAt(i);
if(c!='M'){
lCounter++;
}
}
minNeededOperationsCase1 = lCounter;
//because then this is the only case
if(K==S.length()) return minNeededOperationsCase1;
//This needs to happen before in case the value is incremented (we dont know)
int currentOpsNeeded=minNeededOperationsCase1;
//In this case the M train has become too big
if(S.charAt(K)=='M') minNeededOperationsCase1++;
for(int i=K;i<S.length();i++){
char c = S.charAt(i);
char firstChar = S.charAt(i-K);
//adapt current operations needed value
if(c=='L'){
currentOpsNeeded++;
}
if(firstChar=='L'){
currentOpsNeeded--;
}
//compare to current minimum
int additionForComparison = 0;
if(firstChar == 'M'){
additionForComparison++;
}
if(i<S.length()-1 && S.charAt(i+1)=='M'){
additionForComparison++;
}
if(currentOpsNeeded+additionForComparison < minNeededOperationsCase1){
minNeededOperationsCase1 = currentOpsNeeded+additionForComparison;
}
}
return minNeededOperationsCase1;
}
else{
return totalNeededOperationsCase2;
}
}
//Tests 2,2,4,4,3,8
}
Analysis
expand all
User tests
1.
0.004 s
OK
function result: 2
function result: 2
1.
0.004 s
OK
function result: 2
function result: 2
1.
0.008 s
OK
function result: 4
function result: 4
1.
0.004 s
OK
function result: 4
function result: 4
1.
0.008 s
OK
function result: 3
function result: 3
1.
0.004 s
OK
function result: 8
function result: 8
1.
0.008 s
OK
function result: 2
function result: 2
User test case 1:
['MMLMMLMMLMMLMM', 3]
User test case 2:
['MMMLMMMMMLMM', 2]
User test case 3:
['MMMLMMMMMLMM', 1]
User test case 4:
['LLLLLLLLLLLLLLLL', 4]
User test case 5:
['MMMMMMMMMMMMMMMM', 4]
User test case 6:
['MLMLLLMMMLMMM', 0]
User test case 7:
['MLMMMMLMMLLLL', 8]
Code: 12:26:42 UTC,
java,
verify,
result: Passed
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192
// 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(String S, int K) {
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=3
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=7
//1,-1,3,-3,1,-1,1,-1,2,-3,5,-1,1,-1,1,-2,2
//-> Case1: Alle Ms < K
//Alle Substrings der länge K ansehen und die Ls zählen (+1 pro M an der Grenze)
//-> Case2: Es gibt Ms >= K
//Algorithmus vorschlag:
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
//2.Ggfls nochmal durchiterieren und Case 1 fixen
//Optimierung kommt später
//TODO put all in one loop
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
boolean isCase2 = false;
int totalNeededOperationsCase2=0;
int minNeededOperationsCase1=Integer.MAX_VALUE;
int lastMLength=0;
for(int i=0;i<S.length();i++){
char c = S.charAt(i);
if(c=='M'){
lastMLength++;
if(lastMLength > K){
isCase2 = true;
totalNeededOperationsCase2++;
lastMLength=0;
}
}
else{ //Can only be L
lastMLength=0;
}
}
if(!isCase2){
int lCounter=0;
for(int i=0;i<K;i++){
char c = S.charAt(i);
if(c!='M'){
lCounter++;
}
}
minNeededOperationsCase1 = lCounter;
//because then this is the only case
if(K==S.length()) return minNeededOperationsCase1;
//This needs to happen before in case the value is incremented (we dont know)
int currentOpsNeeded=minNeededOperationsCase1;
//In this case the M train has become too big
if(S.charAt(K)=='M') minNeededOperationsCase1++;
for(int i=K;i<S.length();i++){
char c = S.charAt(i);
char firstChar = S.charAt(i-K);
//adapt current operations needed value
if(c=='L'){
currentOpsNeeded++;
}
if(firstChar=='L'){
currentOpsNeeded--;
}
//compare to current minimum
int additionForComparison = 0;
if(firstChar == 'M'){
additionForComparison++;
}
if(i<S.length()-1 && S.charAt(i+1)=='M'){
additionForComparison++;
}
if(currentOpsNeeded+additionForComparison < minNeededOperationsCase1){
minNeededOperationsCase1 = currentOpsNeeded+additionForComparison;
}
}
return minNeededOperationsCase1;
}
else{
return totalNeededOperationsCase2;
}
}
//Tests 2,2,4,4,3,8
}
Analysis
expand all
User tests
1.
0.004 s
OK
function result: 2
function result: 2
1.
0.004 s
OK
function result: 2
function result: 2
1.
0.004 s
OK
function result: 4
function result: 4
1.
0.004 s
OK
function result: 4
function result: 4
1.
0.004 s
OK
function result: 3
function result: 3
1.
0.004 s
OK
function result: 8
function result: 8
1.
0.008 s
OK
function result: 2
function result: 2
User test case 1:
['MMLMMLMMLMMLMM', 3]
User test case 2:
['MMMLMMMMMLMM', 2]
User test case 3:
['MMMLMMMMMLMM', 1]
User test case 4:
['LLLLLLLLLLLLLLLL', 4]
User test case 5:
['MMMMMMMMMMMMMMMM', 4]
User test case 6:
['MLMLLLMMMLMMM', 0]
User test case 7:
['MLMMMMLMMLLLL', 8]
Code: 12:26:47 UTC,
java,
final,
score:
100
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192
// 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(String S, int K) {
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=3
//MLMMMLLLMLMLMMLLLMMMMMLMLMLLMM K=7
//1,-1,3,-3,1,-1,1,-1,2,-3,5,-1,1,-1,1,-2,2
//-> Case1: Alle Ms < K
//Alle Substrings der länge K ansehen und die Ls zählen (+1 pro M an der Grenze)
//-> Case2: Es gibt Ms >= K
//Algorithmus vorschlag:
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
//2.Ggfls nochmal durchiterieren und Case 1 fixen
//Optimierung kommt später
//TODO put all in one loop
//1.Einmal durchiterieren und schauen ob es Case 2 ist. (Und gleich solven)
boolean isCase2 = false;
int totalNeededOperationsCase2=0;
int minNeededOperationsCase1=Integer.MAX_VALUE;
int lastMLength=0;
for(int i=0;i<S.length();i++){
char c = S.charAt(i);
if(c=='M'){
lastMLength++;
if(lastMLength > K){
isCase2 = true;
totalNeededOperationsCase2++;
lastMLength=0;
}
}
else{ //Can only be L
lastMLength=0;
}
}
if(!isCase2){
int lCounter=0;
for(int i=0;i<K;i++){
char c = S.charAt(i);
if(c!='M'){
lCounter++;
}
}
minNeededOperationsCase1 = lCounter;
//because then this is the only case
if(K==S.length()) return minNeededOperationsCase1;
//This needs to happen before in case the value is incremented (we dont know)
int currentOpsNeeded=minNeededOperationsCase1;
//In this case the M train has become too big
if(S.charAt(K)=='M') minNeededOperationsCase1++;
for(int i=K;i<S.length();i++){
char c = S.charAt(i);
char firstChar = S.charAt(i-K);
//adapt current operations needed value
if(c=='L'){
currentOpsNeeded++;
}
if(firstChar=='L'){
currentOpsNeeded--;
}
//compare to current minimum
int additionForComparison = 0;
if(firstChar == 'M'){
additionForComparison++;
}
if(i<S.length()-1 && S.charAt(i+1)=='M'){
additionForComparison++;
}
if(currentOpsNeeded+additionForComparison < minNeededOperationsCase1){
minNeededOperationsCase1 = currentOpsNeeded+additionForComparison;
}
}
return minNeededOperationsCase1;
}
else{
return totalNeededOperationsCase2;
}
}
//Tests 2,2,4,4,3,8
}Analysis summary
The solution obtained perfect score.
Analysis
Detected time complexity:
O(N)
expand all
Correctness tests
1.
0.004 s
OK
2.
0.004 s
OK
3.
0.004 s
OK
4.
0.004 s
OK
1.
0.008 s
OK
2.
0.004 s
OK
3.
0.008 s
OK
4.
0.004 s
OK
5.
0.008 s
OK
1.
0.004 s
OK
2.
0.004 s
OK
3.
0.008 s
OK
1.
0.004 s
OK
2.
0.004 s
OK
3.
0.004 s
OK
4.
0.004 s
OK
1.
0.004 s
OK
2.
0.008 s
OK
3.
0.008 s
OK
1.
0.008 s
OK
2.
0.004 s
OK
3.
0.008 s
OK
4.
0.008 s
OK
5.
0.008 s
OK
expand all
Performance tests
1.
0.016 s
OK
2.
0.024 s
OK
3.
0.024 s
OK
1.
0.016 s
OK
2.
0.024 s
OK
3.
0.024 s
OK
1.
0.108 s
OK
2.
0.112 s
OK
3.
0.092 s
OK
4.
0.108 s
OK
5.
0.104 s
OK
1.
0.068 s
OK
2.
0.076 s
OK
3.
0.108 s
OK
4.
0.076 s
OK