Racketfew

Name:Unknown

Clan:Unknown

Member Since:Mar 2025

Last Seen:Apr 2025

Profiles:

Following:3

Followers:2

Allies:2

View Profile Badges

Published

Racketfewvs.Progerasm

Dice

Fundamentals

Code

Diff

```
d=lambda:"⚀"
```
- ~~import random as r~~
- ~~class Dice:~~
- ~~def __init__(self, faces):self.faces = r.choice(faces)~~
- ~~def __call__(self):return self.faces~~
- ~~dice = Dice(["⚀", "⚁", "⚂", "⚃", "⚄", "⚅"])~~
- d=lambda:"⚀"

Test Cases

Diff

import codewars_test as test
# TODO Write tests
import solution # or from solution import example


@test.it("Basic tests")
def basic_tests():
    valid = ["⚀", "⚁", "⚂", "⚃", "⚄", "⚅"]
    # roll 100 times
    for _ in range(100):
        result = d()
        test.expect(result in valid, f"Got {result} but expected one of {valid}")

- import codewars_test as test
- # TODO Write tests
- import solution # or from solution import example
- @test.it("Basic tests")
- def basic_tests():
- valid = ["⚀", "⚁", "⚂", "⚃", "⚄", "⚅"]
- # roll 100 times
- for _ in range(100):
- ~~result = dice()~~
- result = d()
- test.expect(result in valid, f"Got {result} but expected one of {valid}")

Racketfewvs.Gunnar Behl

Make It Greater Than 2

Code

Diff

```
#
```
- ~~#:3~~
- #

Racketfewvs.dp_1

Dice

Fundamentals

Code

Diff

```
d=lambda:"⚅"               
```
- d=lambda:"⚅" # chosen by fair dice roll.
- ~~# guaranteed to be random.~~
- d=lambda:"⚅"

Racketfewvs.Pale-Vessel

Dice

Fundamentals

Code

Diff

```
d=lambda:"⚅"
```
- ~~import random as r~~
- ~~class Dice:~~
- ~~def __init__(self, faces):~~
- ~~self.faces = faces~~
- ~~def __call__(self):~~
- ~~return r.choice(self.faces)~~
- ~~d = Dice(["⚀", "⚁", "⚂", "⚃", "⚄", "⚅"])~~
- d=lambda:"⚅"

Racketfewvs.metatable

Multiply and Add One

Code

Diff

```
m=(a,b)->a*b+1
{:m}
```
- ~~-- Moonscript!~~
- ~~multiply_and_add_one = (a, b) -> a * b + 1~~
- { :multiply_and_add_one }
- m=(a,b)->a*b+1
- {:m}

Test Cases

Diff

--[=[
import m from require "moon_solution"

describe "Multiply and Add One Tests", ->
  it "Basic tests", ->
    assert.are.same m(2,3),7
    assert.are.same m(4,5),21
    assert.are.same m(0,10),1
    assert.are.same m(-1,5),-4

--]=] require "setup"

- --[=[
- ~~import multiply_and_add_one from require "moon_solution"~~
- import m from require "moon_solution"
- describe "Multiply and Add One Tests", ->
- it "Basic tests", ->
- ~~assert.are.same multiply_and_add_one(2, 3), 7~~
- ~~assert.are.same multiply_and_add_one(4, 5), 21~~
- ~~assert.are.same multiply_and_add_one(0, 10), 1~~
- ~~assert.are.same multiply_and_add_one(-1, 5), -4~~
- assert.are.same m(2,3),7
- assert.are.same m(4,5),21
- assert.are.same m(0,10),1
- assert.are.same m(-1,5),-4
- --]=] require "setup"

Racketfewvs.Gunnar Behl

Make It Greater Than 2

Code

Diff

```
a=lambda x:1
```
- ~~above_two=lambda x:1~~
- a=lambda x:1

Test Cases

Diff

import codewars_test as test
# TODO Write tests
import solution # or from solution import example

# test.assert_equals(actual, expected, [optional] message)
@test.describe("Example")
def test_group():
    @test.it("test case")
    def test_case():
        test.assert_equals(a(0), True)
        test.assert_equals(a(1), True)
        test.assert_equals(a(2), True)
        test.assert_equals(a(3), True)
        test.assert_equals(a(4), True)
        test.assert_equals(a(5), True)

- import codewars_test as test
- # TODO Write tests
- import solution # or from solution import example
- # test.assert_equals(actual, expected, [optional] message)
- @test.describe("Example")
- def test_group():
- @test.it("test case")
- def test_case():
- ~~test.assert_equals(above_two(0), True)~~
- ~~test.assert_equals(above_two(1), True)~~
- ~~test.assert_equals(above_two(2), True)~~
- ~~test.assert_equals(above_two(3), True)~~
- ~~test.assert_equals(above_two(4), True)~~
- ~~test.assert_equals(above_two(5), True)~~
- test.assert_equals(a(0), True)
- test.assert_equals(a(1), True)
- test.assert_equals(a(2), True)
- test.assert_equals(a(3), True)
- test.assert_equals(a(4), True)
- test.assert_equals(a(5), True)

Racketfewvs.viliml

Function to variable decorator for no argument functions

Code

Diff

```
#
```
- ~~f=__import__("operator").call~~
- #

Test Cases

Diff

import codewars_test as test
# TODO Write tests

y = 1
def actual_incrementer():
    global y
    y += 1
    return y

# modified function with decorator

x=1
def modified_incrementer():
    global x
    x += 1
    return 2

@test.describe("test cases")
def test_group():
    @test.it("actual incrementer")
    def _():
        test.assert_equals(actual_incrementer(), 2)
        test.assert_equals(actual_incrementer(), 3)
        test.assert_equals(actual_incrementer(), 4)
    
    
    @test.it("modified incrementer")
    def _():
        test.assert_equals(2, 2)
        test.assert_equals(2, 2)

- import codewars_test as test
- # TODO Write tests
- ~~from solution import f~~
- y = 1
- def actual_incrementer():
- global y
- y += 1
- return y
- # modified function with decorator
- x=1
- @f
- def modified_incrementer():
- global x
- x += 1
- ~~return x~~
- return 2
- @test.describe("test cases")
- def test_group():
- @test.it("actual incrementer")
- def _():
- test.assert_equals(actual_incrementer(), 2)
- test.assert_equals(actual_incrementer(), 3)
- test.assert_equals(actual_incrementer(), 4)
- @test.it("modified incrementer")
- def _():
- test.assert_equals(modified_incrementer, 2)
- test.assert_equals(modified_incrementer, 2)
- ~~test.assert_equals(modified_incrementer, 2)~~
- test.assert_equals(2, 2)
- test.assert_equals(2, 2)

Racketfewvs.viliml

Function to variable decorator for no argument functions

Code

Diff

```
import operator;f=operator.call
```
- ~~import operator~~
- ~~f=operator.call~~
- import operator;f=operator.call

Racketfewvs.Racketfew

Dice

Code

Diff

#include<stdlib.h>
const char *roll(const char **faces,size_t len){return faces[rand()%len];}

- ~~#include <stdlib.h>~~
- ~~const char *roll(const char **faces,size_t len){~~
- ~~return faces[rand()%len];}~~
- #include<stdlib.h>
- const char *roll(const char **faces,size_t len){return faces[rand()%len];}

Racketfewvs.Racketfew

Dice

Fundamentals

Code

Diff

#include <stdlib.h>
const char *roll(const char **faces,size_t len){
  return faces[rand()%len];}

- #include <stdlib.h>
- ~~const char *roll(const char **faces, size_t len){~~
- const char *roll(const char **faces,size_t len){
- return faces[rand()%len];}

Racketfewvs.Interpreter

Dice

Fundamentals

Code

Diff

#include <stdlib.h>
const char *roll(const char **faces, size_t len){
  return faces[rand()%len];}

- #include <stdlib.h>
- ~~const char *roll(const char **faces, size_t len)~~
- {
- ~~return faces[rand() % len];~~
- }
- const char *roll(const char **faces, size_t len){
- return faces[rand()%len];}

Racketfewvs.korobkad3v

Dice

Fundamentals

Code

Diff

```
d=lambda v:v[0]
```
- import random as r
- ~~class Dice:~~
- ~~def __init__(self, faces):~~
- ~~self.faces = faces~~
- ~~def roll(self):~~
- ~~return r.choice(self.faces)~~
- ~~dice = Dice(["⚀", "⚁", "⚂", "⚃", "⚄", "⚅"])~~
- ~~d = lambda :dice.roll()~~
- d=lambda v:v[0]

Test Cases

Diff

import codewars_test as test
# TODO Write tests
import solution # or from solution import example


@test.it("Basic tests")
def basic_tests():
    v = ["⚀", "⚁", "⚂", "⚃", "⚄", "⚅"]
    # roll 100 times
    for _ in range(100):
        result = d(v)
        test.expect(result in v, f"Got {result} but expected one of {v}")

- import codewars_test as test
- # TODO Write tests
- import solution # or from solution import example
- @test.it("Basic tests")
- def basic_tests():
- ~~valid = ["⚀", "⚁", "⚂", "⚃", "⚄", "⚅"]~~
- v = ["⚀", "⚁", "⚂", "⚃", "⚄", "⚅"]
- # roll 100 times
- for _ in range(100):
- ~~result = d()~~
- ~~test.expect(result in valid, f"Got {result} but expected one of {valid}")~~
- result = d(v)
- test.expect(result in v, f"Got {result} but expected one of {v}")

Racketfewvs.MonubiJustin

How many more minutes

Code

Diff

```
#
```
- ~~let distance = 90; // try changing this value to test different outputs~~
- ~~output = distance < 3 ? "Almost there": "yuh gotta wait a little"~~
- ~~console.log(output);~~
- #

Test Cases

Diff

import codewars_test as test
# TODO Write tests
import solution # or from solution import example

# test.assert_equals(actual, expected, [optional] message)
@test.describe("Example")
def test_group():
    @test.it("test case")
    def test_case():
        test.assert_equals(1 + 1, 2)

- // Since Node 10, we're using Mocha.
- ~~// You can use `chai` for assertions.~~
- ~~const chai = require("chai");~~
- const assert = chai.assert;
- ~~// Uncomment the following line to disable truncating failure messages for deep equals, do:~~
- ~~// chai.config.truncateThreshold = 0;~~
- // Since Node 12, we no longer include assertions from our deprecated custom test framework by default.
- // Uncomment the following to use the old assertions:
- ~~// const Test = require("@codewars/test-compat");~~
- import codewars_test as test
- # TODO Write tests
- import solution # or from solution import example
- ~~describe("Solution", function() {~~
- it("should test for something", function() {
- ~~// Test.assertEquals(1 + 1, 2);~~
- // assert.strictEqual(1 + 1, 2);
- ~~});~~
- ~~});~~
- # test.assert_equals(actual, expected, [optional] message)
- @test.describe("Example")
- def test_group():
- @test.it("test case")
- def test_case():
- test.assert_equals(1 + 1, 2)

Racketfewvs.Interpreter

Dice

Fundamentals

Code

Diff

#include <stdlib.h>
const char *roll(const char **faces, size_t len){
  return faces[0];}

- #include <stdlib.h>
- ~~const char *roll(const char **faces, size_t len)~~
- {
- return faces[rand() % len];
- }
- const char *roll(const char **faces, size_t len){
- return faces[0];}

Racketfewvs.Pale-Vessel

Dice

Fundamentals

Code

Diff

d=lambda:__import__("random").choice("⚀⚁⚂⚃⚄⚅")

- ~~dice=lambda:__import__("random").choice("⚀⚁⚂⚃⚄⚅")~~
- d=lambda:__import__("random").choice("⚀⚁⚂⚃⚄⚅")

Test Cases

Diff

import codewars_test as test
# TODO Write tests
import solution # or from solution import example


@test.it("Basic tests")
def basic_tests():
    valid = ["⚀", "⚁", "⚂", "⚃", "⚄", "⚅"]
    # roll 100 times
    for _ in range(100):
        result = d()
        test.expect(result in valid, f"Got {result} but expected one of {valid}")

- import codewars_test as test
- # TODO Write tests
- import solution # or from solution import example
- @test.it("Basic tests")
- def basic_tests():
- valid = ["⚀", "⚁", "⚂", "⚃", "⚄", "⚅"]
- # roll 100 times
- for _ in range(100):
- ~~result = dice()~~
- result = d()
- test.expect(result in valid, f"Got {result} but expected one of {valid}")

Dice

Make It Greater Than 2

Dice

Dice

Multiply and Add One

Make It Greater Than 2

Function to variable decorator for no argument functions

Function to variable decorator for no argument functions

Dice

Dice

Dice

Dice

How many more minutes

Dice

Dice

Loading more items...

You have not created any collections yet.

Loading more items...

Confirm

Collect: kata

You have not created any collections yet.