C#

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Expression_Evaluator
{
    class Program
    {
   	static int[] ReadInput(out int value)
        {
            Console.Write("Enter integer numbers to use (space-separated): ");
            string s = Console.ReadLine();
            string[] parts = s.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);

            int[] a = new int[parts.Length];
            for (int i = 0; i < a.Length; i++)
                a[i] = int.Parse(parts[i]);

            Console.Write("Enter integer value to calculate: ");
            value = int.Parse(Console.ReadLine());

            return a;

        }
        static void SolveAndPrint(int[] numbers, int targetValue)
        {

            int targetKey = (targetValue << numbers.Length) + (1 << numbers.Length) - 1;

            HashSet<int> solvedKeys = new HashSet<int>();
            Dictionary<int, int> keyToLeftParent = new Dictionary<int, int>();
            Dictionary<int, int> keyToRightParent = new Dictionary<int, int>();
            Dictionary<int, char> keyToOperator = new Dictionary<int, char>();
            Queue<int> queue = new Queue<int>();

            for (int i = 0; i < numbers.Length; i++)
            {
                
                int key = (numbers[i] << numbers.Length) + (1 << i);

                solvedKeys.Add(key);
                queue.Enqueue(key);

            }

            while (queue.Count > 0 && !solvedKeys.Contains(targetKey))
            {

                int curKey = queue.Dequeue();

                int curMask = curKey & ((1 << numbers.Length) - 1);
                int curValue = curKey >> numbers.Length;

                int[] keys = new int[solvedKeys.Count];
                solvedKeys.CopyTo(keys);

                for (int i = 0; i < keys.Length; i++)
                {
                    
                    int mask = keys[i] & ((1 << numbers.Length) - 1);
                    int value = keys[i] >> numbers.Length;

                    if ((mask & curMask) == 0)
                    {
                        for (int op = 0; op < 6; op++)
                        {

                            char opSign = '\0';
                            int newValue = 0;

                            switch (op)
                            {
                                case 0: // Addition
                                    newValue = curValue + value;
                                    opSign = '+';
                                    break;
                                case 1: // Subtraction - another value subtracted from current
                                    newValue = curValue - value;
                                    opSign = '-';
                                    break;
                                case 2: // Subtraction - current value subtracted from another
                                    newValue = value - curValue;
                                    opSign = '-';
                                    break;
                                case 3: // Multiplication
                                    newValue = curValue * value;
                                    opSign = '*';
                                    break;
                                case 4: // Division - current divided by another
                                    newValue = -1;  // Indicates failure to divide
                                    if (value != 0 && curValue % value == 0)
                                        newValue = curValue / value;
                                    opSign = ' ';
                                    break;
                                case 5: // Division - other value divided by current
                                    newValue = -1;  // Indicates failure to divide
                                    if (curValue != 0 && value % curValue == 0)
                                        newValue = value / curValue;
                                    opSign = ' ';
                                    break;
                            }

                            if (newValue >= 0)
                            {   
                                int newMask = (curMask | mask);
                                
                                int newKey = (newValue << numbers.Length) + newMask;

                                if (!solvedKeys.Contains(newKey))
                                {    
                                    solvedKeys.Add(newKey);
                                    
                                    if (op == 2 || op == 5)
                                    {   
                                        keyToLeftParent.Add(newKey, keys[i]);
                                        keyToRightParent.Add(newKey, curKey);
                                    }
                                    else
                                    {
                                        keyToLeftParent.Add(newKey, curKey);
                                        keyToRightParent.Add(newKey, keys[i]);
                                    }

                                    keyToOperator.Add(newKey, opSign);
                                    solvedKeys.Add(newKey);
                                    queue.Enqueue(newKey);
                                    
                                }

                            }

                        }
                    }
                }

            }

            if (!solvedKeys.Contains(targetKey))
                Console.WriteLine("Solution has not been found.");
            else
            {
                PrintExpression(keyToLeftParent, keyToRightParent, keyToOperator, targetKey, numbers.Length);
                Console.WriteLine("={0}", targetValue);
            }
        }

        static void PrintExpression(Dictionary<int, int> keyToLeftParent, Dictionary<int, int> keyToRightParent, Dictionary<int, char> keyToOperator,
                                    int key, int numbersCount)
        {
            if (!keyToOperator.ContainsKey(key))
                Console.Write("{0}", key >> numbersCount);
            else
            {
                Console.Write("(");

                PrintExpression(keyToLeftParent, keyToRightParent, keyToOperator,
                                keyToLeftParent[key], numbersCount);

                Console.Write(keyToOperator[key]);

                PrintExpression(keyToLeftParent, keyToRightParent, keyToOperator,
                                keyToRightParent[key], numbersCount);
                Console.Write(")");
            }
        }
       static void Main(string[] args)
        {
            while (true)
            {

                int value;
                int[] numbers = ReadInput(out value);

                SolveAndPrint(numbers, value);

                Console.Write("More? (y/n) ");
                if (Console.ReadLine().ToLower() != "y")
                    break;

            }
        }
    }
}

Pavlex4 wrote:

how to not use all values to make expression

CREATE TABLE table1
(
Reci nvarchar(13)
);

INSERT INTO table1 VALUES ('заступниство');
INSERT INTO table1 VALUES ('затровавање');
INSERT INTO table1 VALUES ('заустављати');
INSERT INTO table1 VALUES ('заварљивост');
INSERT INTO table1 VALUES ('земљорадник');
INSERT INTO table1 VALUES ('земљорадња');
INSERT INTO table1 VALUES ('згњецавање');
INSERT INTO table1 VALUES ('згусњавање');
INSERT INTO table1 VALUES ('злонамерност');
INSERT INTO table1 VALUES ('злостављати');
INSERT INTO table1 VALUES ('зверокрадица');
.........

string cs= @"Data Source=(LocalDB)\MSSQLLocalDB;AttachDbFilename=C:\Users\Pavle\Documents\Visual Studio 2015\Projects\Test slagalica\Test slagalica\Slagalica-DB-Cirilica.mdf;Integrated Security=True";
        string queryString = "SELECT * FROM table1 WHERE LEN(Reci) >=10 AND LEN(Reci) <=12 ORDER BY NEWID()";
using (SqlConnection connection = new SqlConnection(cs))
            {
                SqlCommand mycommand = new SqlCommand(queryString, connection);
                try
                {
                    connection.Open();
                    string word = (string)mycommand.ExecuteScalar();
                    label14.Text = word;
                    promesana_rec = new string(word.ToUpper().OrderBy(r => random.Next()).ToArray());
                    textBox2.Text = promesana_rec.ToUpper();
                }
                catch (Exception ex)
                {
                    MessageBox.Show(ex.Message);
                }
            }

INSERT INTO table1 (Reci) VALUES (N'заступниство');

CREATE TABLE table1
(
ID [INT] IDENTITY(1,1) NOT NULL,
Reci nvarchar(13) NOT NULL,
WordLen INT NOT NULL
);

SELECT TOP 1 Reci FROM Table1 ...

using (SqlConnection connection = new SqlConnection(cs))
                {
                    SqlCommand cmd = new SqlCommand("SELECT * FROM table1 WHERE Reci='" + textBox1.Text + "'", connection);
                    try
                    {
                        connection.Open();
                        SqlDataAdapter da = new SqlDataAdapter(cmd);
                        DataSet ds = new DataSet();
                        da.Fill(ds);
                        int j = ds.Tables[0].Rows.Count;
                        if (j == 0)
                        {
                            MessageBox.Show("word" + textBox1.Text + "already exists!");
                            ds.Clear();
                        }
                    }
                    catch (Exception ex)
                    {
                        MessageBox.Show(ex.Message);
                    }
                }

private void uxRunCount_PreviewKeyDown( object sender, System.Windows.Input.KeyEventArgs e ) {

   bool ok = IsNumeric( e.Key );

   if ( !ok ) {
      e.Handled = true;    // Reject change.
   }
}

private bool IsNumeric( Key key ) {

   if ( key == Key.Back || key == Key.Delete ) { return true; }
   if ( key == Key.Tab || key == Key.Return ) { return true; }

   if ( key >= Key.D0 && key <= Key.D9 ) { return true; }
   if ( key >= Key.NumPad0 && key <= Key.NumPad9 ) { return true; }

   return false;
}

private void myTextBox_KeyPress(object sender, KeyPressEventArgs e)

char keyPressedByUser = e.KeyChar;

var allowedKeys = promesana_rec.Select(ch => (Keys)Convert.ToInt32(char.ToUpper(ch)));

e.SuppressKeyPress = !allowedKeys.Contains(e.KeyCode) && new[] { Keys.None, Keys.Shift }.Contains(e.Modifiers);