# Check if N indices of given Array can be colored by M colors using one color at most K times

Find an arrangement of **M** colors for **N** indices such that no two adjacent indices have same color and each color can be used at most** K** times. If no such arrangement exists, output -1.

**Examples:**

Input: N = 6, M = 4, K = 2

Output: 1 2 3 4 1 2

Explanation: Color 1 is assigned to the 1-st index.

Color 2 is assigned to the 2-nd index, color 3 to the 3-rd index,

color 4 to the 4-th index.

Again, color 1 is assigned to 5-th index and color 2 to 6-th index.Input: N = 20, M = 6, K = 3

Output: -1

Explanation: No such arrangement exists in which 6 colors may be assigned to at most 3 indices.

**Approach:** Observe the following points:

- If the number of colors is only 1 and the number of indices is greater than 1, then no such assignment can exist.
- If the total number of indices is greater than what can be colored by the colors available (
**M*****K**), then no such assignment exists.

Follow the steps below to solve the above problem:

- If the number of colors is 1 and the number of indices is greater than 1, then output -1.
- If the total number of colors is greater than what can be colored by the available colors (
**M*****K**), then output -1. - If both of the above conditions do not meet, then:
- Initialize variable
**x**with 1. - Run a loop till
**N**and within the loop, output**x**. Increment**x**and check if**x**is greater than**M**. If**x**becomes greater than**M**, set**x**= 1. - When
**x**is set to 1, the loop again starts printing the number of colors from 1.

- Initialize variable

Below is the implementation of the above approach:

## C++

`// C++ program for the above approach` `#include <iostream>` `using` `namespace` `std;` `// Function to find the required` `// arrangement of colors to indices` `void` `findAssignment(` `int` `N, ` `int` `M, ` `int` `K)` `{` ` ` `// If number of colors is 1` ` ` `// and number of indices is more than 1` ` ` `if` `(M == 1 && N > 1) {` ` ` `// Output -1` ` ` `cout << -1;` ` ` `}` ` ` `// If number of indices is more than` ` ` `// what can be colored` ` ` `// by the available colors` ` ` `else` `if` `(N > M * K) {` ` ` `// Output -1` ` ` `cout << -1;` ` ` `}` ` ` `else` `{` ` ` `// Initialize x with 1` ` ` `int` `x = 1;` ` ` `// Loop to print` ` ` `// the required arrangement` ` ` `for` `(` `int` `i = 0; i < N; ++i) {` ` ` `// Output the number of colors` ` ` `cout << x << ` `" "` `;` ` ` `// Increment the number of colors` ` ` `x++;` ` ` `// If x exceeds the total number` ` ` `// of available colors` ` ` `if` `(x > M) {` ` ` `// Set x to 1` ` ` `x = 1;` ` ` `}` ` ` `}` ` ` `}` `}` `// Driver Code` `int` `main()` `{` ` ` `// Given input` ` ` `int` `N = 6, M = 4, K = 2;` ` ` `// Function Call` ` ` `findAssignment(N, M, K);` ` ` `return` `0;` `}` |

## Java

`// Java program for the above approach` `import` `java.io.*;` `import` `java.lang.*;` `import` `java.util.*;` `class` `GFG {` ` ` `// Function to find the required` ` ` `// arrangement of colors to indices` ` ` `static` `void` `findAssignment(` `int` `N, ` `int` `M, ` `int` `K)` ` ` `{` ` ` `// If number of colors is 1` ` ` `// and number of indices is more than 1` ` ` `if` `(M == ` `1` `&& N > ` `1` `) {` ` ` `// Output -1` ` ` `System.out.print(` `"-1"` `);` ` ` `}` ` ` `// If number of indices is more than` ` ` `// what can be colored` ` ` `// by the available colors` ` ` `else` `if` `(N > M * K) {` ` ` `// Output -1` ` ` `System.out.print(` `"-1"` `);` ` ` `}` ` ` `else` `{` ` ` `// Initialize x with 1` ` ` `int` `x = ` `1` `;` ` ` `// Loop to print` ` ` `// the required arrangement` ` ` `for` `(` `int` `i = ` `0` `; i < N; ++i) {` ` ` `// Output the number of colors` ` ` `System.out.print(x + ` `" "` `);` ` ` `// Increment the number of colors` ` ` `x++;` ` ` `// If x exceeds the total number` ` ` `// of available colors` ` ` `if` `(x > M) {` ` ` `// Set x to 1` ` ` `x = ` `1` `;` ` ` `}` ` ` `}` ` ` `}` ` ` `}` ` ` `// Driver Code` ` ` `public` `static` `void` `main (String[] args)` ` ` `{` ` ` `// Given input` ` ` `int` `N = ` `6` `, M = ` `4` `, K = ` `2` `;` ` ` `// Function Call` ` ` `findAssignment(N, M, K);` ` ` `}` `}` `// This code is contributed by hrithikgarg03188` |

## Python3

`# Python code for the above approach` `# Function to find the required` `# arrangement of colors to indices` `def` `findAssignment(N, M, K):` ` ` `# If number of colors is 1` ` ` `# and number of indices is more than 1` ` ` `if` `(M ` `=` `=` `1` `and` `N > ` `1` `):` ` ` `# Output -1` ` ` `print` `(` `-` `1` `)` ` ` ` ` `# If number of indices is more than` ` ` `# what can be colored` ` ` `# by the available colors` ` ` `elif` `(N > M ` `*` `K) :` ` ` `# Output -1` ` ` `print` `(` `-` `1` `)` ` ` ` ` `else` `:` ` ` `# Initialize x with 1` ` ` `x ` `=` `1` `;` ` ` `# Loop to print` ` ` `# the required arrangement` ` ` `for` `i ` `in` `range` `(N):` ` ` `# Output the number of colors` ` ` `print` `(x, end` `=` `" "` `);` ` ` `# Increment the number of colors` ` ` `x ` `+` `=` `1` ` ` `# If x exceeds the total number` ` ` `# of available colors` ` ` `if` `(x > M):` ` ` `# Set x to 1` ` ` `x ` `=` `1` `;` `# Driver Code` `# Given input` `N ` `=` `6` `M ` `=` `4` `K ` `=` `2` `# Function Call` `findAssignment(N, M, K);` `# This code is contributed by gfgking` |

## C#

`// C# program for the above approach` `using` `System;` `class` `GFG` `{` ` ` `// Function to find the required` `// arrangement of colors to indices` `static` `void` `findAssignment(` `int` `N, ` `int` `M, ` `int` `K)` `{` ` ` ` ` `// If number of colors is 1` ` ` `// and number of indices is more than 1` ` ` `if` `(M == 1 && N > 1) {` ` ` `// Output -1` ` ` `Console.Write(-1);` ` ` `}` ` ` `// If number of indices is more than` ` ` `// what can be colored` ` ` `// by the available colors` ` ` `else` `if` `(N > M * K) {` ` ` `// Output -1` ` ` `Console.Write(-1);` ` ` `}` ` ` `else` `{` ` ` `// Initialize x with 1` ` ` `int` `x = 1;` ` ` `// Loop to print` ` ` `// the required arrangement` ` ` `for` `(` `int` `i = 0; i < N; ++i) {` ` ` `// Output the number of colors` ` ` `Console.Write(x + ` `" "` `);` ` ` `// Increment the number of colors` ` ` `x++;` ` ` `// If x exceeds the total number` ` ` `// of available colors` ` ` `if` `(x > M) {` ` ` `// Set x to 1` ` ` `x = 1;` ` ` `}` ` ` `}` ` ` `}` `}` `// Driver Code` `public` `static` `void` `Main()` `{` ` ` ` ` `// Given input` ` ` `int` `N = 6, M = 4, K = 2;` ` ` `// Function Call` ` ` `findAssignment(N, M, K);` `}` `}` `// This code is contributed by Samim Hossain Mondal.` |

## Javascript

`<script>` ` ` `// JavaScript code for the above approach` ` ` `// Function to find the required` ` ` `// arrangement of colors to indices` ` ` `function` `findAssignment(N, M, K)` ` ` `{` ` ` ` ` `// If number of colors is 1` ` ` `// and number of indices is more than 1` ` ` `if` `(M == 1 && N > 1) {` ` ` `// Output -1` ` ` `document.write(-1)` ` ` `}` ` ` `// If number of indices is more than` ` ` `// what can be colored` ` ` `// by the available colors` ` ` `else` `if` `(N > M * K) {` ` ` `// Output -1` ` ` `document.write(-1)` ` ` `}` ` ` `else` `{` ` ` `// Initialize x with 1` ` ` `let x = 1;` ` ` `// Loop to print` ` ` `// the required arrangement` ` ` `for` `(let i = 0; i < N; ++i) {` ` ` `// Output the number of colors` ` ` `document.write(x + ` `" "` `);` ` ` `// Increment the number of colors` ` ` `x++;` ` ` `// If x exceeds the total number` ` ` `// of available colors` ` ` `if` `(x > M) {` ` ` `// Set x to 1` ` ` `x = 1;` ` ` `}` ` ` `}` ` ` `}` ` ` `}` ` ` `// Driver Code` ` ` `// Given input` ` ` `let N = 6, M = 4, K = 2;` ` ` `// Function Call` ` ` `findAssignment(N, M, K);` ` ` `// This code is contributed by Potta Lokesh` ` ` `</script>` |

**Output**

1 2 3 4 1 2

**Time Complexity:**** **O(N)* Auxiliary Space:* O(1)