Sudoku is a game played on a 9×9 grid. The goal of the game is to fill all cells of the grid with digits from 1 to 9, so that each column, each row, and each of the nine 3×3 sub-grids (also known as blocks) contain all of the digits from 1 to 9.
(More info at: http://en.wikipedia.org/wiki/Sudoku)

Sudoku Solution Validator

Write a function validSolution/ValidateSolution/valid_solution() that accepts a 2D array representing a Sudoku board, and returns true if it is a valid solution, or false otherwise. The cells of the sudoku board may also contain 0’s, which will represent empty cells. Boards containing one or more zeroes are considered to be invalid solutions.

The board is always 9 cells by 9 cells, and every cell only contains integers from 0 to 9.

Examples

validSolution([
  [5, 3, 4, 6, 7, 8, 9, 1, 2],
  [6, 7, 2, 1, 9, 5, 3, 4, 8],
  [1, 9, 8, 3, 4, 2, 5, 6, 7],
  [8, 5, 9, 7, 6, 1, 4, 2, 3],
  [4, 2, 6, 8, 5, 3, 7, 9, 1],
  [7, 1, 3, 9, 2, 4, 8, 5, 6],
  [9, 6, 1, 5, 3, 7, 2, 8, 4],
  [2, 8, 7, 4, 1, 9, 6, 3, 5],
  [3, 4, 5, 2, 8, 6, 1, 7, 9]
]); // => true

validSolution([
  [5, 3, 4, 6, 7, 8, 9, 1, 2], 
  [6, 7, 2, 1, 9, 0, 3, 4, 8],
  [1, 0, 0, 3, 4, 2, 5, 6, 0],
  [8, 5, 9, 7, 6, 1, 0, 2, 0],
  [4, 2, 6, 8, 5, 3, 7, 9, 1],
  [7, 1, 3, 9, 2, 4, 8, 5, 6],
  [9, 0, 1, 5, 3, 7, 2, 1, 4],
  [2, 8, 7, 4, 1, 9, 6, 3, 5],
  [3, 0, 0, 4, 8, 1, 1, 7, 9]
]); // => false

Solution

#include <stdbool.h>

bool validSolution(unsigned int board[9][9])
{
  /* Write your code here */
  int b, k, ko, bb, kk, jum, cek = 1;

  for (b = 0; b < 9; b++)
  {
    jum = 0;
    for (k = 0; k < 9; k++)
    {
      jum = jum + board[b][k];
    }
    if (jum != 45)
    {
      cek = 0;
    }
  }

  for (b = 0; b < 9; b++)
  {
    jum = 0;
    for (k = 0; k < 9; k++)
    {
      jum = jum + board[k][b];
    }
    if (jum != 45)
    {
      cek = 0;
    }
  }

  for (ko = 0; ko < 9; ko++)
  {
    bb = (ko / 3) * 3;
    kk = (ko % 3) * 3;
    jum = 0;
    for (b = bb; b < bb + 3; b++)
    {
      for (k = kk; k < kk + 3; k++)
      {
        jum = jum + board[b][k];
      }
    }
    if (jum != 45)
    {
      cek = 0;
    }
  }
  return cek;
}

The post Belajar Bahasa C – Sudoku Solution Validator appeared first on Onestring Lab.

I found this joke on USENET, but the punchline is scrambled. Maybe you can decipher it? According to Wikipedia, ROT13 (http://en.wikipedia.org/wiki/ROT13) is frequently used to obfuscate jokes on USENET.

Hint: For this task you’re only supposed to substitute characters. Not spaces, punctuation, numbers etc.

Test examples:

"EBG13 rknzcyr." -->
 "ROT13 example."

"This is my first ROT13 excercise!" -->
 "Guvf vf zl svefg EBG13 rkprepvfr!"

Solution:

#include <string.h>

char *rot13(char *str_out, const char *str_in)
{
  // write to str_out and return it
  *str_out = '\0';

  char b;
  unsigned long i;
  for (i = 0; i < strlen(str_in); i++)
  {
    b = str_in[i];
    if ((b >= 'A' && b <= 'M') || (b >= 'a' && b <= 'm'))
      b += 13;
    else if ((b >= 'N' && b <= 'Z') || (b >= 'n' && b <= 'z'))
      b -= 13;
    strncat(str_out, &b, 1);
  }
  return str_out;
}

The post Belajar Bahasa C – ROT13 appeared first on Onestring Lab.

Your task is to write a function maskify, which changes all but the last four characters into '#'.

The problem link is here.

Examples

"4556364607935616" --> "############5616"
     "64607935616" -->      "#######5616"
               "1" -->                "1"
                "" -->                 ""

// "What was the name of your first pet?"

"Skippy" --> "##ippy"

"Nananananananananananananananana Batman!"
-->
"####################################man!"

Solution

#include <string.h>
char *maskify(char *masked, const char *string)
{
  unsigned long i, slen = strlen(string);
  strcpy(masked, string);
  if (slen > 4)
    for (i = 0; i < slen - 4; i++)
      masked[i] = '#';
  return masked; // return it
}

The post Belajar Bahasa C – Credit Card Mask appeared first on Onestring Lab.

The wave (known as the Mexican wave in the English-speaking world outside North America) is an example of metachronal rhythm achieved in a packed stadium when successive groups of spectators briefly stand, yell, and raise their arms. Immediately upon stretching to full height, the spectator returns to the usual seated position.

The result is a wave of standing spectators that travels through the crowd, even though individual spectators never move away from their seats. In many large arenas the crowd is seated in a contiguous circuit all the way around the sport field, and so the wave is able to travel continuously around the arena; in discontinuous seating arrangements, the wave can instead reflect back and forth through the crowd. When the gap in seating is narrow, the wave can sometimes pass through it. Usually only one wave crest will be present at any given time in an arena, although simultaneous, counter-rotating waves have been produced. (Source Wikipedia)

Task

In this simple Kata your task is to create a function that turns a string into a Mexican Wave. You will be passed a string and you must return that string in an array where an uppercase letter is a person standing up. The problem link is here.

Rules

• The input string will always be lower case but maybe empty.
• If the character in the string is whitespace then pass over it as if it was an empty seat

Example

wave("hello") => {"Hello", "hEllo", "heLlo", "helLo", "hellO"}

Solution

void wave(const char *y, char **target)
{
  /* you don't have to allocate memory, use target */
  /* y string is always null terminated */
  /* each string in target has length strlen(y) + 1 */

  int i, k;
  char temp;
  int slen = strlen(y);
  char *c = (char *)calloc((slen + 1), sizeof(char));

  for (i = 0; i < slen; i++)
  {
    strcpy(c, "");
    for (k = 0; k < slen; k++)
    {
      temp = (k == i && y[k] != 32) ? toupper(y[k]) : y[k];
      strncat(c, &temp, 1);
    }
    if (y[i] != 32)
      strcpy(*target++, c);
  }
}

The post Belajar Bahasa C – Mexican Wave appeared first on Onestring Lab.

He drops the ball out of the window. The ball bounces (for example), to two-thirds of its height (a bounce of 0.66).

His mother looks out of a window 1.5 meters from the ground.

How many times will the mother see the ball pass in front of her window (including when it’s falling and bouncing?

The problem link is here.

Three conditions must be met for a valid experiment:

• Float parameter “h” in meters must be greater than 0
• Float parameter “bounce” must be greater than 0 and less than 1
• Float parameter “window” must be less than h.

If all three conditions above are fulfilled, return a positive integer, otherwise return -1.

Note:
The ball can only be seen if the height of the rebounding ball is strictly greater than the window parameter.

Examples:

- h = 3, bounce = 0.66, window = 1.5, result is 3

- h = 3, bounce = 1, window = 1.5, result is -1 

(Condition 2) not fulfilled).

Sample Test:

#include <criterion/criterion.h>

extern int bouncingBall (double h, double bounce, double window);
static void testequal(double h, double bounce, double window, int expected);

Test(bouncingBall, sampleTests) {       
    testequal(2, 0.5, 1.0, 1);
    testequal(3, 0.66, 1.5, 3);
    testequal(30, 0.66, 1.5, 15);
    testequal(30, 0.75, 1.5, 21);
    testequal(30, 0.4, 10, 3);
    testequal(40, 0.4, 10, 3);
    testequal(10, 0.6, 10, -1);
    testequal(40, 1, 10, -1);
    testequal(-5, 0.66, 1.5, -1);
    testequal(5, -1, 1.5, -1);
    testequal(4, 0.25, 1.0, 1);
}

static void testequal(double h, double bounce, double window, int expected) {
    int actual = bouncingBall(h, bounce, window);
    cr_assert_eq(actual, expected,
		"for h = %f, bounce = %f, window = %f\n"
		"expected %d, but got %d",
		h, bounce, window,
		expected, actual
	);
}

Solution

int bouncingBall(double h, double bounce, double window)
{
  // your code;
  int s = 1;
  if (h <= window || h < 0 || bounce < 0 || bounce >= 1)
    s = -1;
  else
  {
    h = h * bounce;
    while (h > window)
    {
      s += 2;
      h = h * bounce;
    }
  }

  return s;
}

The post Belajar Bahasa C – Bouncing Balls appeared first on Onestring Lab.

Per Wikipedia, a prime number ( or a prime ) is a natural number greater than 1 that has no positive divisors other than 1 and itself.

The problem link is here

Requirements

• You can assume you will be given an integer input.
• You can not assume that the integer will be only positive. You may be given negative numbers as well ( or 0 ).
• NOTE on performance: There are no fancy optimizations required, but still the most trivial solutions might time out. Numbers go up to 2^31 ( or similar, depending on language ). Looping all the way up to n, or n/2, will be too slow.

Example

is_prime(1)  /* false */
is_prime(2)  /* true  */
is_prime(-1) /* false */

Sample Tests

#include <criterion/criterion.h>
#include <stdbool.h>

bool is_prime(int num);

Test(Sample_Test, basic_test)
{
    cr_assert_not(is_prime(0), "Your solution returned that 0 is prime, but it's not");
    cr_assert_not(is_prime(1), "Your solution returned that 1 is prime, but it's not");
    cr_assert(is_prime(2), "Your solution returned that 2 is not prime, but it is");
    cr_assert(is_prime(73), "Your solution returned that 73 is not prime, but it is");
    cr_assert_not(is_prime(75), "Your solution returned that 75 is prime, but it's not");
    cr_assert_not(is_prime(-1), "Your solution returned that -1 is prime, but it's not");
}

Test(Sample_Test, test_prime)
{
    cr_assert(is_prime(3), "Your solution returned that 3 is not prime, but it is");
    cr_assert(is_prime(5), "Your solution returned that 5 is not prime, but it is");
    cr_assert(is_prime(7), "Your solution returned that 7 is not prime, but it is");
    cr_assert(is_prime(41), "Your solution returned that 41 is not prime, but it is");
    cr_assert(is_prime(5099), "Your solution returned that 5099 is not prime, but it is");
}

Test(Sample_Test, test_not_prime)
{
    cr_assert_not(is_prime(4), "Your solution returned that 4 is prime, but it's not");
    cr_assert_not(is_prime(6), "Your solution returned that 6 is prime, but it's not");
    cr_assert_not(is_prime(8), "Your solution returned that 8 is prime, but it's not");
    cr_assert_not(is_prime(9), "Your solution returned that 9 is prime, but it's not");
    cr_assert_not(is_prime(45), "Your solution returned that 45 is prime, but it's not");
    cr_assert_not(is_prime(-5), "Your solution returned that -5 is prime, but it's not");
    cr_assert_not(is_prime(-8), "Your solution returned that -8 is prime, but it's not");
    cr_assert_not(is_prime(-41), "Your solution returned that -41 is prime, but it's not");
}

Test(Sample_Test, test_large)
{
    cr_assert_not(is_prime(247464361), "Your solution returned that 247464361 is prime, but it's not");
    cr_assert(is_prime(1634300119), "Your solution returned that 1634300119 is not prime, but it is");
}

Solution

#include <stdbool.h>

bool is_prime(int num)
{
  bool prime = true;
  int i, k;

  if (num <= 1 || (num % 2 == 0 && num != 2))
    prime = false;
  k = floor(sqrt(num));
  for (i = 3; i <= k; i++)
    if (num % i == 0)
      prime = false;
  return prime;
}

The post Belajar Bahasa C – Is a number prime? appeared first on Onestring Lab.

Examples:

move_zeros(10, int [] {1, 2, 0, 1, 0, 1, 0, 3, 0, 1}); // -> int [] {1, 2, 1, 1, 3, 1, 0, 0, 0, 0}

Sample Tests:

Test(move_zeros, sample_tests) {
    do_test(8, ((int []) {0, 1, 0, 2, 0, 3, 4, 5}), ((int []) {1, 2, 3, 4, 5, 0, 0, 0}));
    do_test(20, ((int []) {9, 0, 0, 9, 1, 2, 0, 1, 0, 1, 0, 3, 0, 1, 9, 0, 0, 0, 0, 9}), ((int []) {9, 9, 1, 2, 1, 1, 3, 1, 9, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}));
    do_test(2, ((int []) {0, 0}), ((int []) {0, 0}));
    do_test(1, ((int []) {0}), ((int []) {0}));
    do_test(0, ((int []) {}), ((int []) {}));
}

Solution:

#include <stddef.h>

void move_zeros(size_t len, int arr[len])
{
  // mutate arr in place
  size_t i, j, k, temp;
  for (i = 0; i < len; i++)
  {
    if (arr[i] == 0)
    {
      k = i;
      for (j = i + 1; j < len; j++)
      {
        if (arr[j] != 0)
        {
          temp = arr[j];
          arr[j] = 0;
          arr[k] = temp;
          k = j;
        }
      }
    }
  }
}

The post Belajar Bahasa C – Moving Zeros To The End appeared first on Onestring Lab.

Modern Roman numerals are written by expressing each decimal digit of the number to be encoded separately, starting with the leftmost digit and skipping any 0s. So 1990 is rendered “MCMXC” (1000 = M, 900 = CM, 90 = XC) and 2008 is rendered “MMVIII” (2000 = MM, 8 = VIII). The Roman numeral for 1666, “MDCLXVI”, uses each letter in descending order.

Example:

solution('XXI'); // should return 21

The problem link is here.

Solution:

#include <string.h>

int roman_val(char roman)
{
  int val = 0;

  switch (roman)
  {
  case 'I':
    return val = 1;
    break;
  case 'V':
    return val = 5;
    break;
  case 'X':
    return val = 10;
    break;
  case 'L':
    return val = 50;
    break;
  case 'C':
    return val = 100;
    break;
  case 'D':
    return val = 500;
    break;
  case 'M':
    return val = 1000;
    break;
  }
  return val;
}

unsigned decode_roman(const char *roman_number)
{
  unsigned long len = strlen(roman_number);
  unsigned i, n, m, value = 0;

  for (i = 0; i < len; i++)
  {
    n = roman_val(roman_number[i]);
    m = roman_val(roman_number[i + 1]);

    if (n >= m)
      value += n;
    else if (n < m)
      value += (m - n), i++;
  }
  return value;
}

The post Belajar Bahasa C – Roman Numerals Decoder appeared first on Onestring Lab.

If you want to know more: http://en.wikipedia.org/wiki/DNA

In DNA strings, symbols “A” and “T” are complements of each other, as “C” and “G”. Your function receives one side of the DNA (string, except for Haskell); you need to return the other complementary side. DNA strand is never empty or there is no DNA at all (again, except for Haskell).

More similar exercise are found here: http://rosalind.info/problems/list-view/ (source)

Example: (input –> output)

"ATTGC" --> "TAACG"
"GTAT" --> "CATA"

The problem link is here.

Solution:

#include <string.h>

char *dna_strand(const char *dna)
{

  int len = strlen(dna);
  int i;
  char *cdna = calloc(len + 1, sizeof(char));
  char temp;

  strcpy(cdna, "");

  for (i = 0; i < len; i++)
  {
    if (dna[i] == 'A')
    {
      temp = 'T';
      strncat(cdna, &temp, 1);
    }
    else if (dna[i] == 'T')
    {
      temp = 'A';
      strncat(cdna, &temp, 1);
    }
    else if (dna[i] == 'C')
    {
      temp = 'G';
      strncat(cdna, &temp, 1);
    }
    else if (dna[i] == 'G')
    {
      temp = 'C';
      strncat(cdna, &temp, 1);
    }
  }
  return cdna;
}

The post Belajar Bahasa C – Complementary DNA appeared first on Onestring Lab.

For example (Input –> Output):

39 --> 3 (because 3*9 = 27, 2*7 = 14, 1*4 = 4 and 4 has only one digit)
999 --> 4 (because 9*9*9 = 729, 7*2*9 = 126, 1*2*6 = 12, and finally 1*2 = 2)
4 --> 0 (because 4 is already a one-digit number)

The problem link is here.

Solution:

int persistence(int n)
{
  int x = 0;
  while (n > 9)
  {
    int m = 1;
    while (n)
    {
      m = m * (n % 10);
      n = n / 10;
    }
    n = m;
    x++;
  }
  return x;
}

The post Belajar Bahasa C – Persistent Bugger appeared first on Onestring Lab.

Examples:

accum("abcd") -> "A-Bb-Ccc-Dddd"
accum("RqaEzty") -> "R-Qq-Aaa-Eeee-Zzzzz-Tttttt-Yyyyyyy"
accum("cwAt") -> "C-Ww-Aaa-Tttt"

The problem link is here.

Solution:

char *accum(const char *source)
{
  char temp;
  unsigned long i, j, mem;
  unsigned long length = strlen(source);

  mem = strlen(source);
  for (i = 0; i <= length; i++)
  {
    mem += i;
  }

  char *mumbling = calloc(mem + 1, sizeof(char));

  for (i = 0; i < length; i++)
  {
    for (j = 0; j < i + 1; j++)
    {

      temp = (j == 0) ? toupper(source[i]) : tolower(source[i]);
      strncat(mumbling, &temp, 1);
    }

    (i < length - 1) ? strncat(mumbling, "-", 1) : "";
  }
  return mumbling;
}

The post Belajar Bahasa C – Mumbling appeared first on Onestring Lab.

You will always get an valid array. And it will be always exactly one letter be missing. The length of the array will always be at least 2. The array will always contain letters in only one case.

Example:

['a','b','c','d','f'] -> 'e'
['O','Q','R','S'] -> 'P'

(Use the English alphabet with 26 letters!) Have fun coding it and please don’t forget to vote and rank this kata! :-). I have also created other katas. Take a look if you enjoyed this kata!

The link problem is here.

Solution:

char findMissingLetter(char array[], int arrayLength)
{
  char miss, start;
  int i;

  start = array[0];
  for (i = 0; i < arrayLength; i++)
  {
    if (start != array[i])
    {
      miss = start;
      break;
    }
    start = start + 1;
  }
  return miss;
}

The post Belajar Bahasa C – Find the missing letter appeared first on Onestring Lab.