Ad
Interpretervs.Dark_Ughh

Alfonso's Code Wars - Writing a check amount (REVISED)

Code
Diff
  • #include <stdio.h>
#include <stdlib.h>

char *
checkAmount (double amount)
{
  if (amount >= 100.00)
    return 0;

  static const char *u[11]
      = { "ZERO", "ONE",   "TWO",   "THREE", "FOUR", "FIVE",
          "SIX",  "SEVEN", "EIGHT", "NINE",  "TEN" };
  static const char *s[9]
      = { "ELEVEN",  "TWELVE",    "THIRTEEN", "FOURTEEN", "FIFTEEN",
          "SIXTEEN", "SEVENTEEN", "EIGHTEEN", "NINETEEN" };
  static const char *t[8]
      = { "TWENTY", "THIRTY",  "FORTY",  "FIFTY",
          "SIXTY",  "SEVENTY", "EIGHTY", "NINETY" };
  
  char *res = malloc (32);
  int w = amount, c = (int)(amount * 100) % 100;

  _Bool r = w >= 20 && w % 10;
  sprintf (res, "%s%s%s and %d/100",
           w < 11   ? u[w]
           : w < 20 ? s[w - 11]
                    : t[w / 10 - 2],
           r ? " " : "", r ? u[w % 10] : "", c);

  return res;
}
    • #include <string.h>
    • #include <stdio.h>
    • #include <stdlib.h>
    • char *checkAmount(double amount) {
    • char * return_val = NULL;
    • // Your code here!
    • char *
    • checkAmount (double amount)
    • {
    • if (amount >= 100.00)
    • return 0;
    • static const char *u[11]
    • = { "ZERO", "ONE", "TWO", "THREE", "FOUR", "FIVE",
    • "SIX", "SEVEN", "EIGHT", "NINE", "TEN" };
    • static const char *s[9]
    • = { "ELEVEN", "TWELVE", "THIRTEEN", "FOURTEEN", "FIFTEEN",
    • "SIXTEEN", "SEVENTEEN", "EIGHTEEN", "NINETEEN" };
    • static const char *t[8]
    • = { "TWENTY", "THIRTY", "FORTY", "FIFTY",
    • "SIXTY", "SEVENTY", "EIGHTY", "NINETY" };
    • return return_val;
    • char *res = malloc (32);
    • int w = amount, c = (int)(amount * 100) % 100;
    • _Bool r = w >= 20 && w % 10;
    • sprintf (res, "%s%s%s and %d/100",
    • w < 11 ? u[w]
    • : w < 20 ? s[w - 11]
    • : t[w / 10 - 2],
    • r ? " " : "", r ? u[w % 10] : "", c);
    • return res;
    • }
Interpretervs.pearcebasmanm

Twin Sum Solutions

Code
Diff
  • #include <stddef.h>
#include <stdlib.h>

int *
twin_sum_solutions (int *input, size_t input_len, size_t *output_len)
{
  int *res = malloc (input_len * sizeof (int));
  for (size_t i = *output_len = 0; i < input_len - 1; i++)
    if (input[i] == input[i + 1])
      res[(*output_len)++] = input[i] * 2, i++;
  return realloc (res, *output_len * sizeof (int));
}
    • fn twin_sum_solutions(array: &[i32]) -> Vec<i32> {
    • array
    • .windows(2)
    • .filter(|w| w[0] == w[1])
    • .map(|w| w[0] + w[1])
    • .collect()
    • #include <stddef.h>
    • #include <stdlib.h>
    • int *
    • twin_sum_solutions (int *input, size_t input_len, size_t *output_len)
    • {
    • int *res = malloc (input_len * sizeof (int));
    • for (size_t i = *output_len = 0; i < input_len - 1; i++)
    • if (input[i] == input[i + 1])
    • res[(*output_len)++] = input[i] * 2, i++;
    • return realloc (res, *output_len * sizeof (int));
    • }
Interpretervs.seraph776

Proche de 0: (Close to 0)

Code
Diff
  • #include <math.h>
#include <stdlib.h>

int
closest_to_zero (int nums[/* len */], size_t len)
{
  if (len == 0)
    return 0;

  int r = nums[0], ar = abs (r);
  for (size_t i = 1; i < len; i++)
    {
      int n = nums[i], an = abs (n);
      if (an < ar || (an == ar && n > r))
        r = n, ar = abs (r);
    }
  return r;
}
    • def closest_to_zero(nums):
    • if not nums:
    • return 0
    • n = min(nums, key=abs)
    • if n < 0 and abs(n) in nums:
    • return abs(n)
    • return n
    • #include <math.h>
    • #include <stdlib.h>
    • int
    • closest_to_zero (int nums[/* len */], size_t len)
    • {
    • if (len == 0)
    • return 0;
    • int r = nums[0], ar = abs (r);
    • for (size_t i = 1; i < len; i++)
    • {
    • int n = nums[i], an = abs (n);
    • if (an < ar || (an == ar && n > r))
    • r = n, ar = abs (r);
    • }
    • return r;
    • }
Interpretervs.The-Wolfson

Caesar Cypher

Ciphers
Fundamentals
Code
Diff
  • #include <ctype.h>
#include <stdbool.h>
#include <stdlib.h>
#include <string.h>

char *
caesar_cypher (const char *input, int amount, bool reversed, bool encode,
               bool ignore_special_chars, bool match_case)
{
  char *res = malloc (strlen(input) + 1);
  char *p   = res;
  amount    = (amount % 26) * (2 * (encode ^ reversed) - 1);
  
  for (; *input; input++)
    {
      char c = *input;
      if (!isalpha (c))
        {
          if (!ignore_special_chars)
            *p++ = c;
          continue;
        }
      char s = ((toupper (c) + amount - 39) % 26) + 65;
      *p++ = match_case && islower (c) ? tolower (s) : s;
    }
  
  return *p = '\0', res;
}
    • func caesarCypher(
    • _ input: String,
    • amount: Int,
    • reversed: Bool = false,
    • encode: Bool = true,
    • ignoreSpecialChars: Bool = false,
    • matchCase: Bool = true
    • ) -> String {
    • let alphabet = Array("ABCDEFGHIJKLMNOPQRSTUVWXYZ")
    • return input.map { character in
    • let char = Character(character.uppercased())
    • guard alphabet.contains(char) else {
    • return ignoreSpecialChars ? "" : String(char)
    • }
    • var newIndex = alphabet.firstIndex(of: char)!
    • switch encode {
    • case true:
    • newIndex += (reversed ? -amount : amount)
    • case false:
    • newIndex += (reversed ? amount : -amount)
    • #include <ctype.h>
    • #include <stdbool.h>
    • #include <stdlib.h>
    • #include <string.h>
    • char *
    • caesar_cypher (const char *input, int amount, bool reversed, bool encode,
    • bool ignore_special_chars, bool match_case)
    • {
    • char *res = malloc (strlen(input) + 1);
    • char *p = res;
    • amount = (amount % 26) * (2 * (encode ^ reversed) - 1);
    • for (; *input; input++)
    • {
    • char c = *input;
    • if (!isalpha (c))
    • {
    • if (!ignore_special_chars)
    • *p++ = c;
    • continue;
    • }
    • (newIndex < 0) ? (newIndex += 26) : ()
    • (newIndex >= 26) ? (newIndex -= 26) : ()
    • return (char.isLowercase && matchCase)
    • ? alphabet[newIndex].lowercased() : alphabet[newIndex].uppercased()
    • }.joined()
    • char s = ((toupper (c) + amount - 39) % 26) + 65;
    • *p++ = match_case && islower (c) ? tolower (s) : s;
    • }
    • return *p = '\0', res;
    • }
Interpretervs.Saillou

Arrange list of integer

Lists
Code
Diff
  • #include <stdlib.h>

int cmp(const void *a, const void *b) { return *(int *)a - *(int *)b; }

void re_arrange(int data[/* len */], size_t len)
{
  size_t e = 0;
  for (size_t i = 0; i < len; i++)
  {
    if (!(data[i] & 1))
    {
      int t     = data[i];
      data[i]   = data[e];
      data[e++] = t;
    }
  }
  qsort(data,     e,       sizeof(int), cmp);
  qsort(&data[e], len - e, sizeof(int), cmp);
}
    • #include <vector>
    • #include <stdlib.h>
    • void re_arrange(std::vector<int>& data) {
    • std::vector<int> even, odd;
    • std::copy_if (data.cbegin(), data.cend(), std::back_inserter(even), [](int num){
    • return num%2 == 0;
    • });
    • std::copy_if (data.cbegin(), data.cend(), std::back_inserter(odd), [](int num){
    • return num%2 == 1;
    • });
    • sort(even.begin(), even.end());
    • sort(odd.begin(), odd.end());
    • std::vector<int> result = even;
    • result.insert(result.cend(), odd.cbegin(), odd.cend());
    • data = result;
    • int cmp(const void *a, const void *b) { return *(int *)a - *(int *)b; }
    • void re_arrange(int data[/* len */], size_t len)
    • {
    • size_t e = 0;
    • for (size_t i = 0; i < len; i++)
    • {
    • if (!(data[i] & 1))
    • {
    • int t = data[i];
    • data[i] = data[e];
    • data[e++] = t;
    • }
    • }
    • qsort(data, e, sizeof(int), cmp);
    • qsort(&data[e], len - e, sizeof(int), cmp);
    • }
Interpretervs.Racketfew

Dice

Fundamentals

Due to the great demand (joking) for a better test case to detect foul play, I've implemented just that.

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[0];}
    • const char *roll(const char **faces, size_t len)
    • {
    • return faces[rand() % len];
    • }
Interpretervs.korobkad3v

Dice

Fundamentals

Written in C.

Code
Diff
  • #include <stdlib.h>

const char *roll(const char **faces, size_t len)
{
  return faces[rand() % len];
}
    • import random
    • dice=lambda:random.choice("⚀⚁⚂⚃⚄⚅")
    • #include <stdlib.h>
    • const char *roll(const char **faces, size_t len)
    • {
    • return faces[rand() % len];
    • }
Interpretervs.Hypnoshroom333

ohaegbua3615's Kumite #2

no need to assign strlen to a seperate variable, saved some cycles.

Code
Diff
  • #include <stdlib.h>
#include <string.h>
#include <ctype.h>

char *fun(const char *input)
{
  char *result = malloc(strlen(input) + 1);
  char *p      = result;
  while (*p++ = toupper(*input++));
  return result;
}
    • #include <stdlib.h>
    • #include <string.h>
    • #include <ctype.h>
    • char *fun(const char *input) {
    • size_t len = strlen(input);
    • char *result = malloc(len + 1);
    • char *p = result;
    • while ((*p++ = toupper(*input++)));
    • return result;
    • char *fun(const char *input)
    • {
    • char *result = malloc(strlen(input) + 1);
    • char *p = result;
    • while (*p++ = toupper(*input++));
    • return result;
    • }
Interpretervs.tykbry

Make It Greater Than 2

Code
Diff
  • _Bool above_two(int *arg)
{
  return *arg > 2 ? 1 : (*arg = 3, 0);
}
    • template<typename T>
    • bool above_two(T& arg){
    • static_assert(std::is_arithmetic<T>::value, "arg must be a arithmetic type");
    • if(arg <= T(2)){
    • arg = T(3);
    • }
    • return true;
    • _Bool above_two(int *arg)
    • {
    • return *arg > 2 ? 1 : (*arg = 3, 0);
    • }
Interpretervs.leehunt

ohaegbua3615's Kumite #2

  • Eliminated unnecessary variable allocation (i inside the for loop).
  • Moved null terminator assignment into the loop, removing the need for an external assignment.
Code
Diff
  • #include <stdlib.h>
#include <string.h>
#include <ctype.h>

char *fun(const char *input)
{
  size_t  len    = strlen(input);
  char   *result = malloc(++len), *p = result;
  
  while (len--)
    *p++ = toupper(*input++);

  return result;
}
    • #include <stdlib.h>
    • #include <string.h>
    • #include <ctype.h>
    • char *fun(const char *input)
    • {
    • size_t len = strlen(input);
    • char *result = malloc(len + 1), *p = result;
    • for (size_t i = 0; i < len; i++)
    • char *result = malloc(++len), *p = result;
    • while (len--)
    • *p++ = toupper(*input++);
    • *p = '\0';
    • return result;
    • }
Interpretervs.MXT1GA

ohaegbua3615's Kumite #2

Code
Diff
  • #include <stdlib.h>
#include <string.h>
#include <ctype.h>

char *fun(const char *input)
{
  size_t  len    = strlen(input);
  char   *result = malloc(len + 1);
  for (size_t i = 0; input[i]; i++)
    result[i] = toupper(input[i]);
  return result[len] = '\0', result;
}
    • def fun(s): return s.upper()
    • #include <stdlib.h>
    • #include <string.h>
    • #include <ctype.h>
    • char *fun(const char *input)
    • {
    • size_t len = strlen(input);
    • char *result = malloc(len + 1);
    • for (size_t i = 0; input[i]; i++)
    • result[i] = toupper(input[i]);
    • return result[len] = '\0', result;
    • }
Interpretervs.mudassir920

Reverse the letters in a String

Code
Diff
  • #include <stdlib.h>
#include <string.h>

char *reverse_string(char *word)
{
  size_t  len = strlen(word);
  char   *res = malloc(len + 1);
  for (size_t i = 0; i < len; i++)
    res[i] = word[len - i - 1];
  return res[len] = '\0', res;
}
    • #include <string>
    • std::string reverse_string(std::string_view word){
    • return {word.rbegin(), word.rend()};
    • #include <stdlib.h>
    • #include <string.h>
    • char *reverse_string(char *word)
    • {
    • size_t len = strlen(word);
    • char *res = malloc(len + 1);
    • for (size_t i = 0; i < len; i++)
    • res[i] = word[len - i - 1];
    • return res[len] = '\0', res;
    • }
Interpretervs.Harlow743

Joker_04's Kumite #2

Code
Diff
  • int sum_of_numbers(int a, int b)
{
  return a + b;
}
    • sum_of_numbers = lambda a, b: a + b
    • int sum_of_numbers(int a, int b)
    • {
    • return a + b;
    • }
Interpretervs.user3525445

Multiply and Add One

someone had to do it

Code
Diff
  • int multiply_and_add_one(int a, int b)
{
  int res;
  __asm__
  (
    "imul %1, %2;"
    "add $1, %2;"
    "mov %2, %0;"
    : "=r" (res)
    : "r" (a), "r" (b)
    :
  );
  return res;
}
    • def multiply_and_add_one(a, b):
    • return a * b + 1
    • int multiply_and_add_one(int a, int b)
    • {
    • int res;
    • __asm__
    • (
    • "imul %1, %2;"
    • "add $1, %2;"
    • "mov %2, %0;"
    • : "=r" (res)
    • : "r" (a), "r" (b)
    • :
    • );
    • return res;
    • }
Interpretervs.123456777890-r

The sum of the unique numbers

Arrays

I was bored.

Code
Diff
  • #include <stdlib.h>

int cmp(const void *a, const void *b)
{ 
  return *(int *)a - *(int *)b;
}

int unique_sum(const int arr[/*size*/], size_t size)
{
  int r = 0;
  qsort(arr, size, sizeof(int), cmp);
  for (size_t i = 0; i < size; )
  {
    if ((i == 0        || arr[i] != arr[i - 1]) &&
        (i == size - 1 || arr[i] != arr[i + 1]))
      r += arr[i];
    for (int v = arr[i]; i < size && arr[i] == v; i++);
  }
  return r;
}
    • #include <bits/stdc++.h>
    • using namespace std;
    • int unique_sum(const vector<int>& n) {
    • auto nums = n;
    • sort(nums.begin(), nums.end(), [](int a, int b) {
    • return a < b;
    • });
    • int sum = 0;
    • for(size_t i = 0; i < nums.size(); i++) {
    • if(nums[i] == nums[i+1] || nums[i] == nums[i-1]) {
    • continue;
    • } else {
    • sum += nums[i];
    • }
    • #include <stdlib.h>
    • int cmp(const void *a, const void *b)
    • {
    • return *(int *)a - *(int *)b;
    • }
    • int unique_sum(const int arr[/*size*/], size_t size)
    • {
    • int r = 0;
    • qsort(arr, size, sizeof(int), cmp);
    • for (size_t i = 0; i < size; )
    • {
    • if ((i == 0 || arr[i] != arr[i - 1]) &&
    • (i == size - 1 || arr[i] != arr[i + 1]))
    • r += arr[i];
    • for (int v = arr[i]; i < size && arr[i] == v; i++);
    • }
    • return sum;
    • return r;
    • }
Loading more items...