Start a new Kumite
AllAgda (Beta)BF (Beta)CCFML (Beta)ClojureCOBOL (Beta)CoffeeScriptCommonLisp (Beta)CoqC++CrystalC#D (Beta)DartElixirElm (Beta)Erlang (Beta)Factor (Beta)Forth (Beta)Fortran (Beta)F#GoGroovyHaskellHaxe (Beta)Idris (Beta)JavaJavaScriptJulia (Beta)Kotlinλ Calculus (Beta)LeanLuaNASMNim (Beta)Objective-C (Beta)OCaml (Beta)Pascal (Beta)Perl (Beta)PHPPowerShell (Beta)Prolog (Beta)PureScript (Beta)PythonR (Beta)RacketRaku (Beta)Reason (Beta)RISC-V (Beta)RubyRustScalaShellSolidity (Beta)SQLSwiftTypeScriptVB (Beta)
Show only mine

Kumite (ko͞omiˌtā) is the practice of taking techniques learned from Kata and applying them through the act of freestyle sparring.

You can create a new kumite by providing some initial code and optionally some test cases. From there other warriors can spar with you, by enhancing, refactoring and translating your code. There is no limit to how many warriors you can spar with.

A great use for kumite is to begin an idea for a kata as one. You can collaborate with other code warriors until you have it right, then you can convert it to a kata.

Ad
Ad
jorge.nmvs.daniel.em

Trains & Railways (RENFE)

Code
Diff
  • import java.util.List;
import java.util.Map;

public class TrainsAndRailwaysv2 {

	public static Map<Character, List<Character>> travel(char[][] tracks) {
    //suerte
    return null;  
  }
}
    • import java.util.List;
    • import java.util.Map;
    • public class TrainsAndRailwaysv2 {
    • public static Map<Character, List<Character>> travel(char[][] tracks) {
    • //suerte
    • return null;
    • }
    • }
metatablevs.Kache

Make It Greater Than 2

Code
Diff
  • -- Moonscript!
above_two: -> true
    • def above_two(_):
    • return True
    • -- Moonscript!
    • above_two: -> true
alvaro..buvs.omar.bt

Driving Test Evaluator

You work as a driving test examiner in an alien planet. Your task is to evaluate whether an examinee has passed the exam based on the exam data you receive and the rules described below.

You receive the exam data in two Strings, the first one represents all the indications the driver has received during the exam, from road signals and the examiner. The second String represents the actions of the examinee which are registered every second from the start to the end of the exam.

The format of the strings is the following:

indications: String of symbols separated by " " which represent one indication each following the following legend.

Indication Symbol Expected Behaviour
STOP STOP -> No cars passing by
STOP3 -> 3 cars passing by		 Stop at least 3 seconds + 2 seconds for each passing car
YIELD YIELD -> No cars passing by
YIELD2 -> 2 cars passing by		 Stop ONLY if there are cars passing by (2 seconds/car)
SPEED LIMIT SL50_100 -> Sets a speed limit of 50 for the next 100 seconds
SL35_60 -> Sets a speed limit of 35 for the next 60 seconds		 Don't go over the set speed limit
TURN TURNL -> Turn left
TURNR -> Turn right		 Turn as indicated
Red light R3 -> Red light for 3 seconds
R20 -> Red light for 20 seconds		 Stop for the given amount of time

actions: String of symbols separated by " " which contain the speed of the vehicle and the turn, if any, taken each second of the exam. Turns are represented with "<" (left) and ">" (right).

Input example:

indications = "SL30_5 YIELD2 SL25_40 R8 YIELD TURNR STOP "
actions = "29 15 0 0 0 0 25 28 35 24 0 0 0 0 0 0 0 0 13 24 35 38> 35 37 36 24 12 0 0 0"

The Rules

  • There are minor and eliminatory infractions. Three minor infractions or one eliminatory infraction will disqualify the examinee.
  • As the information you received is incomplete (there is no way to know when each of the indications were encountered) you must assume the examinee does the correct thing UNLESS there is no other possibility. For example:
    Infractions
    | Minor Infraction | Description |
    |---|---|
    | Speed limit | Examinee drives over the speed limit for three consecutive seconds. |
    | Insufficient stop time (no cars) | Examinee stops at STOP signal but does so for less than three seconds (no cars passing by). |
    | Insufficient stop time (cars) | Examinee waits the necessary time for all cars to pass by but does not wait or waits partially the mandatory 3 seconds. |
    | Not turning | Examinee does not turn when indicated. |
Eliminatory Infraction Description
Unnecessary stopping Examinee stops for no reason at all.
Running a red light Examinee doesn't stop or starts moving before a red light turns green.
Ignoring STOP Examinee doesn't stop at all at a STOP sign.
Running into traffic. Examinee doesn't wait the necessary time at a STOP or yield sign for other cars to pass by.
Reckless driving Examinee goes over the speed limit for over 10 speed units at any given time.

All inputs will be valid so no validation is required.
You must return true if the examinee has passed the exam and false if they haven't.

Code
Diff
  • import java.util.Arrays;
import java.util.List;

public class DrivingTestEvaluator {
    static int knockoutFoul;
    static int mildFoul;
    static List<String> actions;
    static int currentIndex;

    public static boolean evaluate(String exam, String road) {
        knockoutFoul = 0;
        mildFoul = 0;
        currentIndex = 0;

        // Corrige el orden: exam contiene las indicaciones, road contiene las acciones
        List<String> rules = Arrays.asList(exam.trim().split("\\s+"));
        actions = Arrays.asList(road.trim().split("\\s+"));

        for (String rule : rules) {
            if (rule.startsWith("SL")) {
                comprobateSpeedLimit(rule);
            } else if (rule.startsWith("STOP")) {
                comprobateStop(rule);
            } else if (rule.startsWith("YIELD")) {
                comprobateYield(rule);
            } else if (rule.startsWith("TURN")) {
                comprobateTurn(rule);
            } else if (rule.startsWith("R")) {
                comprobateRedLight(rule);
            }

            if (knockoutFoul > 0) return false;
        }

        return mildFoul < 3;
    }

    public static void comprobateSpeedLimit(String rule) {
        String[] parts = rule.substring(2).split("_");
        int speedLimit = Integer.parseInt(parts[0]);
        int duration = Integer.parseInt(parts[1]);

        int overLimitCounter = 0;
        boolean minorCounted = false;

        for (int i = 0; i < duration && currentIndex + i < actions.size(); i++) {
            int speed = extractSpeed(actions.get(currentIndex + i));

            if (speed > speedLimit + 10) {
                knockoutFoul++;
                return;
            }

            if (speed > speedLimit) {
                overLimitCounter++;
            } else {
                overLimitCounter = 0;
            }

            if (overLimitCounter >= 3 && !minorCounted) {
                mildFoul++;
                minorCounted = true;
            }
        }

        currentIndex += Math.min(duration, actions.size() - currentIndex);
    }

    public static void comprobateStop(String rule) {
        int cars = rule.length() > 4 ? Integer.parseInt(rule.substring(4)) : 0;
        int requiredStop = 3 + (2 * cars);

        int count = 0;
        int i = currentIndex;

        while (i < actions.size() && extractSpeed(actions.get(i)) == 0) {
            count++;
            i++;
        }

        if (count != requiredStop) {
            knockoutFoul++;
        }
        
        currentIndex = i;
    }

    public static void comprobateYield(String rule) {
        int cars = rule.length() > 5 ? Integer.parseInt(rule.substring(5)) : 0;
        int requiredStop = 2 * cars;

        int stopCount = 0;
        int i = currentIndex;
        
        while (i < actions.size() && extractSpeed(actions.get(i)) == 0) {
            stopCount++;
            i++;
        }
        
        if (cars == 0) {
            if (stopCount > 0) {
                knockoutFoul++;
            }
        } else {
            if (stopCount < requiredStop) {
                knockoutFoul++;
            }
        }
        
        currentIndex = i;
    }

    public static void comprobateTurn(String rule) {
        String requiredDirection = rule.equals("TURNR") ? ">" : "<";
        boolean turned = false;
        int i = currentIndex;
        
        while (i < actions.size()) {
            String action = actions.get(i);
            if (action.endsWith(requiredDirection)) {
                turned = true;
                currentIndex = i + 1;
                break;
            }
            if ((requiredDirection.equals(">") && action.endsWith("<")) || 
                (requiredDirection.equals("<") && action.endsWith(">"))) {
                mildFoul++;
                currentIndex = i + 1;
                return;
            }
            i++;
        }

        if (!turned) {
            mildFoul++;
        }
    }

    public static void comprobateRedLight(String rule) {
        int duration = rule.length() > 1 ? Integer.parseInt(rule.substring(1)) : 1;
        
        for (int i = 0; i < duration && currentIndex + i < actions.size(); i++) {
            if (extractSpeed(actions.get(currentIndex + i)) != 0) {
                knockoutFoul++;
                currentIndex += i + 1;
                return;
            }
        }
        
        currentIndex += Math.min(duration, actions.size() - currentIndex);
    }

    public static int extractSpeed(String action) {
        if (action.endsWith("<") || action.endsWith(">")) {
            return Integer.parseInt(action.substring(0, action.length() - 1));
        }
        return Integer.parseInt(action);
    }
}
    • import java.util.Arrays;
    • import java.util.List;
    • public class DrivingTestEvaluator {
    • static int knockoutFoul;
    • static int mildFoul;
    • static List<String> actions;
    • static int currentIndex;
    • public static boolean evaluate(String exam, String road) {
    • knockoutFoul = 0;
    • mildFoul = 0;
    • currentIndex = 0;
    • actions = Arrays.asList(exam.trim().split("\\s+"));
    • List<String> rules = Arrays.asList(road.trim().split("\\s+"));
    • // Corrige el orden: exam contiene las indicaciones, road contiene las acciones
    • List<String> rules = Arrays.asList(exam.trim().split("\\s+"));
    • actions = Arrays.asList(road.trim().split("\\s+"));
    • for (String rule : rules) {
    • if (rule.startsWith("SL")) {
    • comprobateSpeedLimit(rule);
    • } else if (rule.startsWith("STOP")) {
    • comprobateStop(rule);
    • } else if (rule.startsWith("YIELD")) {
    • comprobateYield(rule);
    • } else if (rule.startsWith("TURN")) {
    • comprobateTurn(rule);
    • } else if (rule.startsWith("R")) {
    • comprobateRedLight(rule);
    • }
    • if (knockoutFoul > 0) return false;
    • }
    • return mildFoul < 3;
    • }
    • public static void comprobateSpeedLimit(String rule) {
    • String[] parts = rule.substring(2).split("_");
    • int speedLimit = Integer.parseInt(parts[0]);
    • int duration = Integer.parseInt(parts[1]);
    • int overLimitCounter = 0;
    • boolean minorCounted = false;
    • for (int i = 0; i < duration && currentIndex + i < actions.size(); i++) {
    • int speed = extractSpeed(actions.get(currentIndex + i));
    • if (speed > speedLimit + 10) {
    • knockoutFoul++;
    • return;
    • }
    • if (speed > speedLimit) {
    • overLimitCounter++;
    • } else {
    • overLimitCounter = 0;
    • }
    • if (overLimitCounter >= 3 && !minorCounted) {
    • mildFoul++;
    • minorCounted = true;
    • }
    • }
    • currentIndex += Math.min(duration, actions.size() - currentIndex);
    • }
    • public static void comprobateStop(String rule) {
    • int cars = rule.length() > 4 ? Integer.parseInt(rule.substring(4)) : 0;
    • int requiredStop = 3 + (2 * cars);
    • int stopCount = 0;
    • while (currentIndex < actions.size() && extractSpeed(actions.get(currentIndex)) == 0) {
    • stopCount++;
    • currentIndex++;
    • int count = 0;
    • int i = currentIndex;
    • while (i < actions.size() && extractSpeed(actions.get(i)) == 0) {
    • count++;
    • i++;
    • }
    • if (stopCount == 0) {
    • if (count != requiredStop) {
    • knockoutFoul++;
    • } else if (stopCount < requiredStop) {
    • if (stopCount >= 2 * cars) mildFoul++;
    • else knockoutFoul++;
    • }
    • currentIndex = i;
    • }
    • public static void comprobateYield(String rule) {
    • int cars = rule.length() > 5 ? Integer.parseInt(rule.substring(5)) : 0;
    • int requiredStop = 2 * cars;
    • int stopCount = 0;
    • while (currentIndex < actions.size() && extractSpeed(actions.get(currentIndex)) == 0) {
    • int i = currentIndex;
    • while (i < actions.size() && extractSpeed(actions.get(i)) == 0) {
    • stopCount++;
    • currentIndex++;
    • i++;
    • }
    • if (cars == 0) {
    • if (stopCount >= 2) knockoutFoul++;
    • if (stopCount > 0) {
    • knockoutFoul++;
    • }
    • } else {
    • if (stopCount < requiredStop) {
    • knockoutFoul++;
    • } else if (stopCount < requiredStop + 3) {
    • mildFoul++;
    • }
    • }
    • currentIndex = i;
    • }
    • public static void comprobateTurn(String rule) {
    • String requiredDirection = rule.equals("TURNR") ? ">" : "<";
    • boolean turned = false;
    • for (int i = currentIndex; i < actions.size(); i++) {
    • if (actions.get(i).endsWith(requiredDirection)) {
    • int i = currentIndex;
    • while (i < actions.size()) {
    • String action = actions.get(i);
    • if (action.endsWith(requiredDirection)) {
    • turned = true;
    • currentIndex = i + 1;
    • break;
    • }
    • if ((requiredDirection.equals(">") && action.endsWith("<")) ||
    • (requiredDirection.equals("<") && action.endsWith(">"))) {
    • mildFoul++;
    • currentIndex = i + 1;
    • return;
    • }
    • i++;
    • }
    • if (!turned) {
    • mildFoul++;
    • }
    • }
    • public static void comprobateRedLight(String rule) {
    • int duration = Integer.parseInt(rule.substring(1));
    • boolean failed = false;
    • int duration = rule.length() > 1 ? Integer.parseInt(rule.substring(1)) : 1;
    • for (int i = 0; i < duration && currentIndex + i < actions.size(); i++) {
    • if (extractSpeed(actions.get(currentIndex + i)) != 0) {
    • failed = true;
    • knockoutFoul++;
    • currentIndex += i + 1;
    • return;
    • }
    • }
    • if (failed) {
    • knockoutFoul++;
    • }
    • currentIndex += Math.min(duration, actions.size() - currentIndex);
    • }
    • public static int extractSpeed(String action) {
    • if (action.endsWith("<") || action.endsWith(">")) {
    • return Integer.parseInt(action.substring(0, action.length() - 1));
    • }
    • return Integer.parseInt(action);
    • }
    • }
Javier.dCdNvs.pedro.dp0

Cross Math