Примеры реализации сортировки перемешиванием

Pascal

k:= 25; {Индекс последнего изменения}
s:= 1; {Первый элемент массива}
e:= 25; {Последний элемент массива}
while e > s do
begin
   for i:= e downto s+1 do if Arr[i] < Arr[i-1] then
   begin
      tmp := Arr[i];
      Arr[i] := Arr[i-1];
      Arr[i-1] := tmp;
      k := i;
   end;
   s:=k;
   for i:= s to e-1 do if Arr[i]>Arr[i+1] then
   begin
      tmp := Arr[i];
      Arr[i] := Arr[i+1];
      Arr[i+1] := tmp;
      k := i;
   end;
   e:=k;   
end;

Для варианта С++ и С пример не совсем соответствуют.

C++
  #include <algorithm>
 
  template< typename Iterator >
  void cocktail_sort( Iterator first, Iterator last )
  {
      for( --last; first < last; --last, ++first )
      {
          for( Iterator i = first; i < last; ++i )
              if ( *(i + 1) < *i )
                  std::iter_swap( i, i + 1 );
 
          for( Iterator i = last - 1; i > first; --i )
              if ( *i < *(i - 1) )
                  std::iter_swap( i, i - 1 );
      }
  }

C
#define SWAP(A,B) {(A)=(A)^(B); (B)=(A)^(B); (A)=(A)^(B);}
 
void m_sheker(int mas[], int n)
{
        int last = n-1, left = 1, right = n-1, j;
 
        do
        {
                for(j = right; j >= left; j--)
                {
                        if(mas[j-1] > mas[j])
                        {
                                SWAP(mas[j-1], mas[j]);
                                last = j;
                        }
                }
 
                left = last + 1;
 
                for(j = left; j <= right; j++)
                {
                        if(mas[j-1] > mas[j])
                        {
                                SWAP(mas[j-1], mas[j]);
                                last = j;
                        }
                }
 
                right = last-1;
 
        } while(left < right);
}

C#
 public static void ArrSort(int[] name)
        {
            int b = 0;
            int left = 0;//Левая граница
            int right = name.Length - 1;//Правая граница
            while(left<right) 
            { 
                for (int i = left; i < right; i++)//Слева направо...
                {
                   if (name[i] > name[i + 1])
                        {
                            b = name[i];
                            name[i] = name[i + 1];
                            name[i + 1] = b;
                            b= i;
                        }
                }
                right = b;//Сохраним последнюю перестановку как границу
                if (left >= right) break;//Если границы сошлись выходим
                for (int i = right; i > left; i--)//Справа налево...
                {
                   if (name[i-1] > name[i])
                        {
                            b = name[i];
                            name[i] = name[i-1];
                            name[i -1] = b;
                            b = i;
                        }
                }
                left = b;//Сохраним последнюю перестановку как границу
            }
        }

Fortran
program cocktailsort
 
integer A(17)
integer i,t
logical::sort=.true.
open(1,file='massiv.txt',status='old')
        read(1,*) A
                do i=1,17
                        write(*,*) A(i)
                enddo
do while(sort)
sort=.false.
        do i=1, 16
                if(A(i)>A(i+1)) then
                        t=A(i)
                        A(i)=A(i+1)
                        A(i+1)=t
                        sort=.true.
                endif
        enddo
sort=.false.
 
        do i=16, 1, -1
                if(A(i)>A(i+1)) then
                        t=A(i)
                        A(i)=A(i+1)
                        A(i+1)=t
                        sort=.true.
                endif
        enddo
enddo
write(*,*) '---'
do i=1,17
        write(*,*) A(i)
enddo
pause
end

Perl
while ( $left < $right ) { 
        for ( my $j = $right; $j >= $left; $j-- ) { 
                if ( $array_for_sort[$j-1] > $array_for_sort[$j] ) { 
                        ( $array_for_sort[$j-1],$array_for_sort[$j]) = ( $array_for_sort[$j],$array_for_sort[$j-1] );
                        $last = $j;
                }
        }
        $left = $last + 1;
        for( my $j = $left; $j <= $right; $j++ ) {
                if ( $array_for_sort[$j-1] > $array_for_sort[$j] ) { 
                        ( $array_for_sort[$j-1],$array_for_sort[$j] ) = ( $array_for_sort[$j],$array_for_sort[$j-1] );
                        $last = $j;
                }
        }  
        $right = $last - 1;
}

Добавлено: 09 Мая 2018 17:55:46 Добавил: Андрей Ковальчук

C# WinAPI - получить список открытых окон

C#

Данный код позволяет получить словарь со списками открытых окон и их handler'ом:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Security.Cryptography;
using System.Management;
using System.Runtime.InteropServices;
using Microsoft.Win32;
using System.Xml;
using System.Drawing;

namespace GalaxyDesktop
{
    using HWND = IntPtr;
    public static class OpenWindowGetter
    {
        /// <summary>Returns a dictionary that contains the handle and title of all the open windows.</summary>
        /// <returns>A dictionary that contains the handle and title of all the open windows.</returns>

        public static IDictionary<HWND, string> GetOpenWindows()
        {
            HWND lShellWindow = GetShellWindow();
            Dictionary<HWND, string> lWindows = new Dictionary<HWND, string>();

            EnumWindows(delegate(HWND hWnd, int lParam)
            {
                if (hWnd == lShellWindow) return true;
                if (!IsWindowVisible(hWnd)) return true;

                int lLength = GetWindowTextLength(hWnd);
                if (lLength == 0) return true;

                StringBuilder lBuilder = new StringBuilder(lLength);
                GetWindowText(hWnd, lBuilder, lLength + 1);

                lWindows[hWnd] = lBuilder.ToString();
                return true;

            }, 0);

            return lWindows;
        }

        delegate bool EnumWindowsProc(HWND hWnd, int lParam);

        [DllImport("USER32.DLL")]
        static extern bool EnumWindows(EnumWindowsProc enumFunc, int lParam);

        [DllImport("USER32.DLL")]
        static extern int GetWindowText(HWND hWnd, StringBuilder lpString, int nMaxCount);

        [DllImport("USER32.DLL")]
        static extern int GetWindowTextLength(HWND hWnd);

        [DllImport("USER32.DLL")]
        static extern bool IsWindowVisible(HWND hWnd);

        [DllImport("USER32.DLL")]
        static extern IntPtr GetShellWindow();
    }
}

Добавлено: 19 Декабря 2014 08:20:41 Добавил: Андрей Ковальчук

C# WinAPI - Смена UserAgent в WebBrowser

C#

Данный код позволяет поменять UserAgent контрола WebBrowser в Windows Forms.


1. Импортируем функцию из WinAPI

 [DllImport("urlmon.dll", CharSet = CharSet.Ansi)]
        private static extern int UrlMkSetSessionOption(int dwOption, string pBuffer, int dwBufferLength, int dwReserved);
        const int URLMON_OPTION_USERAGENT = 0x10000001;


2. Создаем метод для смены UserAgent:
public void ChangeUserAgent(string Agent)
{
 UrlMkSetSessionOption(URLMON_OPTION_USERAGENT, Agent, Agent.Length, 0);
}


3. Применяем при загрузке формы
public void form1_Load()
{
ChangeUserAgent("Mozilla/5.0 (compatible; MSIE 10.0; Windows Phone 7.0; Trident/6.0; IEMobile/10.0; ARM; Touch; NOKIA; Lumia 820)");
}

Добавлено: 19 Декабря 2014 08:16:09 Добавил: Андрей Ковальчук

C# WinAPI - AppBar, Регистрируем форму как оболочку и фиксируем.

C#

Данный код применялся мной для создания своей оболочки для Windows (аналог explorer)

Данный код регистрирует форму как Appbar и фиксирует ее над всеми окнами.

[StructLayout(LayoutKind.Sequential)]
        struct RECT
        {
            public int left;
            public int top;
            public int right;
            public int bottom;
        }

        [StructLayout(LayoutKind.Sequential)]
        struct APPBARDATA
        {
            public int cbSize;
            public IntPtr hWnd;
            public int uCallbackMessage;
            public int uEdge;
            public RECT rc;
            public IntPtr lParam;
        }

        enum ABMsg : int
        {
            ABM_NEW = 0,
            ABM_REMOVE = 1,
            ABM_QUERYPOS = 2,
            ABM_SETPOS = 3,
            ABM_GETSTATE = 4,
            ABM_GETTASKBARPOS = 5,
            ABM_ACTIVATE = 6,
            ABM_GETAUTOHIDEBAR = 7,
            ABM_SETAUTOHIDEBAR = 8,
            ABM_WINDOWPOSCHANGED = 9,
            ABM_SETSTATE = 10
        }

        enum ABNotify : int
        {
            ABN_STATECHANGE = 0,
            ABN_POSCHANGED,
            ABN_FULLSCREENAPP,
            ABN_WINDOWARRANGE
        }

        enum ABEdge : int
        {
            ABE_LEFT = 0,
            ABE_TOP,
            ABE_RIGHT,
            ABE_BOTTOM
        }

        private bool fBarRegistered = false;

        [DllImport("SHELL32", CallingConvention = CallingConvention.StdCall)]
        static extern uint SHAppBarMessage(int dwMessage, ref APPBARDATA pData);
        [DllImport("USER32")]
        static extern int GetSystemMetrics(int Index);
        [DllImport("User32.dll", ExactSpelling = true,
            CharSet = System.Runtime.InteropServices.CharSet.Auto)]
        private static extern bool MoveWindow
            (IntPtr hWnd, int x, int y, int cx, int cy, bool repaint);
        [DllImport("User32.dll", CharSet = CharSet.Auto)]
        private static extern int RegisterWindowMessage(string msg);
        private int uCallBack;

        private void RegisterBar()
        {
            APPBARDATA abd = new APPBARDATA();
            abd.cbSize = Marshal.SizeOf(abd);
            abd.hWnd = this.Handle;
            if (!fBarRegistered)
            {
                uCallBack = RegisterWindowMessage("AppBarMessage");
                abd.uCallbackMessage = uCallBack;

                uint ret = SHAppBarMessage((int)ABMsg.ABM_NEW, ref abd);
                fBarRegistered = true;

                ABSetPos();
            }
            else
            {
                SHAppBarMessage((int)ABMsg.ABM_REMOVE, ref abd);
                fBarRegistered = false;
            }
        }

        private void ABSetPos()
        {
            APPBARDATA abd = new APPBARDATA();
            abd.cbSize = Marshal.SizeOf(abd);
            abd.hWnd = this.Handle;
            abd.uEdge = (int)ABEdge.ABE_TOP;

            if (abd.uEdge == (int)ABEdge.ABE_LEFT || abd.uEdge == (int)ABEdge.ABE_RIGHT)
            {
                abd.rc.top = 0;
                abd.rc.bottom = SystemInformation.PrimaryMonitorSize.Height;
                if (abd.uEdge == (int)ABEdge.ABE_LEFT)
                {
                    abd.rc.left = 0;
                    abd.rc.right = Size.Width;
                }
                else
                {
                    abd.rc.right = SystemInformation.PrimaryMonitorSize.Width;
                    abd.rc.left = abd.rc.right - Size.Width;
                }

            }
            else
            {
                abd.rc.left = 0;
                abd.rc.right = SystemInformation.PrimaryMonitorSize.Width;
                if (abd.uEdge == (int)ABEdge.ABE_TOP)
                {
                    abd.rc.top = 0;
                    abd.rc.bottom = Size.Height;
                }
                else
                {
                    abd.rc.bottom = SystemInformation.PrimaryMonitorSize.Height;
                    abd.rc.top = abd.rc.bottom - Size.Height;
                }
            }

            // Query the system for an approved size and position. 
            SHAppBarMessage((int)ABMsg.ABM_QUERYPOS, ref abd);

            // Adjust the rectangle, depending on the edge to which the 
            // appbar is anchored. 
            switch (abd.uEdge)
            {
                case (int)ABEdge.ABE_LEFT:
                    abd.rc.right = abd.rc.left + Size.Width;
                    break;
                case (int)ABEdge.ABE_RIGHT:
                    abd.rc.left = abd.rc.right - Size.Width;
                    break;
                case (int)ABEdge.ABE_TOP:
                    abd.rc.bottom = abd.rc.top + Size.Height;
                    break;
                case (int)ABEdge.ABE_BOTTOM:
                    abd.rc.top = abd.rc.bottom - Size.Height;
                    break;
            }

            // Pass the final bounding rectangle to the system. 
            SHAppBarMessage((int)ABMsg.ABM_SETPOS, ref abd);

            // Move and size the appbar so that it conforms to the 
            // bounding rectangle passed to the system. 
            MoveWindow(abd.hWnd, abd.rc.left, abd.rc.top,
                abd.rc.right - abd.rc.left, abd.rc.bottom - abd.rc.top, true);
        }

        protected override void WndProc(ref System.Windows.Forms.Message m)
        {
            if (m.Msg == uCallBack)
            {
                switch (m.WParam.ToInt32())
                {
                    case (int)ABNotify.ABN_POSCHANGED:
                        ABSetPos();
                        break;
                }
            }

            base.WndProc(ref m);
        }

        protected override System.Windows.Forms.CreateParams CreateParams
        {
            get
            {
                CreateParams cp = base.CreateParams;
                cp.Style &= (~0x00C00000); // WS_CAPTION
                cp.Style &= (~0x00800000); // WS_BORDER
                cp.ExStyle = 0x00000080 | 0x00000008; // WS_EX_TOOLWINDOW | WS_EX_TOPMOST
                return cp;
            }
        }

Добавлено: 19 Декабря 2014 08:11:02 Добавил: Андрей Ковальчук

Sound

C#

Сам использовал XNA. Только тут требование, что звук должен быть в wav формате.
var stream = TitleContainer.OpenStream("Путь к файлу");
if (stream != null)
{
    var effect = SoundEffect.FromStream(stream);
    FrameworkDispatcher.Update();
    effect.Play();
}

Можно зациклить звуковой эффект добавив пару строк.
var stream = TitleContainer.OpenStream("Путь к файлу");
if (stream != null)
{
    var effect = SoundEffect.FromStream(stream);
    FrameworkDispatcher.Update();
    var instance = effect.CreateInstance();
    instance.IsLooped = true;
    instance.Play();

Добавлено: 21 Июля 2014 09:44:42 Добавил: Андрей Ковальчук

Переклад зі 100 бальної системи в 5 бальну.

C#

#include<stdio.h>
int main(){
printf("Вітаю Вас в мою програму!\n");
printf("Програма призначена за для перекладу зі 100\n");
printf("бальною шкалу в 5 бальну шкалу.\n");
printf("При наступних умовах:\n");
puts("30>=1"); 
puts("31-50>=2");
puts("51-72>=3");
puts("73-86>=4");
puts("87-100>=5");
printf("Ведіть оцінку:\n");
int otsinka;
scanf("%d",&otsinka);
printf("Ви ввели оцінку %i\n",otsinka);

if((otsinka>=1)==(otsinka<=30)){printf("Ваш результат: 1 бал\n");}
if((otsinka<=50)==(otsinka>=31)){printf("Ваш результат: 2 бала\n");}
if((otsinka<=72)==(otsinka>=51)){printf("Ваш результат: 3 бала\n");}
if((otsinka<=86)==(otsinka>=73)){printf("Ваш результат: 4 бала\n");}
if((otsinka<=100)==(otsinka>=87)){printf("Ваш результат: 5 балів\n");}

return 0;
}

Добавлено: 11 Июля 2014 10:09:56 Добавил: Андрей Ковальчук

Правый край максимального ряда

C#

#pragma warning(disable : 4996)
#include <stdio.h>
#include <conio.h>
#include <stdlib.h>
#include <string.h>

int MaxString(FILE *fp) //Поиск максимально длинной строки 
{
	int i=0,tmp=0;
	int size=1;
	int max=0;
	char *str=(char*)calloc(1,sizeof(char));
	while(!feof(fp))
	{	
		str[size-1] = fgetc(fp);
		str[size]='\0';
			if(str[size-1]!='\n')
			{
				tmp++;
				if (str[size]=='\0')
				str=(char*)realloc(str,++size);
			}
			else
			{
				if(max<=tmp)
				{
					max=tmp;
					tmp=0;
					size=1;
				}
				else
				{
					tmp=0;
					size=1;
				}
		}
	}
	if (max<=tmp)
		max=tmp;
	free(str);
	rewind(fp);
	return max;
}
void RightString(FILE *fp, int max,char nF[])
{
	char *str=(char*)calloc(1,sizeof(char));
	char *tmpStr=(char*)calloc(max,sizeof(char));
	int size =1;
	int tmp=0,i=0;
	int j=0;
	FILE *fget;
	fget=fopen("tmp.txt","a+");

	while(!feof(fp))
	{	
		str[size-1] = fgetc(fp);
		str[size]='\0';
			if(str[size-1]!='\n'&&!feof(fp))
			{
				if (str[size]=='\0')
				str=(char*)realloc(str,++size);
			}
			else
			{
				char *tmpStr=(char*)calloc(max,sizeof(char));
				while(i<max)
				{

					if ((max-size-1-i)>0)
					{
						tmpStr[i]=' ';
						i++;
					}
					else 
					{
						strcat(tmpStr,str);
						printf(tmpStr);
						i=max;
						fputs(tmpStr,fget);
					}
				}
				i=0;
				size=1;
				tmpStr="  ";
			}
			
	}
	fclose(fget);
}
int main(int argc, char *argv[])
{
	FILE *fp;
	int max;
	char nameFile[]={"text.txt"};
	if((fp=fopen(nameFile, "r"))==NULL)
		return 0;

	max = MaxString(fp);
	RightString(fp, max,nameFile);
	getch();
	return 0;
}

Добавлено: 15 Июня 2014 11:14:04 Добавил: Андрей Ковальчук

Сериализация любого объекта в байтовый массив и обратно

C#

using System.IO;
using System.Runtime.Serialization.Formatters.Binary;


public static byte[] ObjectToByteArray(object obj) //Переводим объект в массив
        {
            if (obj == null)
            {
                return null; //если объект пустой
            }
            BinaryFormatter BF = new BinaryFormatter(); 

            MemoryStream MS = new MemoryStream();

            BF.Serialize(MS, obj);

            return MS.ToArray();
        }

        public static object ByteArrayToObject(byte[] array) //Переводим массив в объект
        {
            if (array == null)
            {
                return null; //если объект пустой
            }
            MemoryStream MS = new MemoryStream();
            BinaryFormatter BF = new BinaryFormatter();
            MS.Write(array, 0, array.Length);
            MS.Seek(0, SeekOrigin.Begin);
            object obj = (object)BF.Deserialize(MS);
            return obj;
        }


Пример на заранее заданном массиве Data:
byte[] Data;
Dictionary<string,string> DickTator = (Dicktionary<string,string>)ByteArrayToObject(Data);


Честно спёр откуда-то :)

Добавлено: 10 Июня 2014 12:21:34 Добавил: Андрей Ковальчук

Сериализация любого объекта в байтовый массив и обратно

C#

using System.IO;
using System.Runtime.Serialization.Formatters.Binary;


public static byte[] ObjectToByteArray(object obj) //Переводим объект в массив
        {
            if (obj == null)
            {
                return null;
            }
            BinaryFormatter BF = new BinaryFormatter();
            MemoryStream MS = new MemoryStream();
            BF.Serialize(MS, obj);
            return MS.ToArray();
        }

        public static object ByteArrayToObject(byte[] array) //Переводим массив в объект
        {
            if (array == null)
            {
                return null;
            }
            MemoryStream MS = new MemoryStream();
            BinaryFormatter BF = new BinaryFormatter();
            MS.Write(array, 0, array.Length);
            MS.Seek(0, SeekOrigin.Begin);
            object obj = (object)BF.Deserialize(MS);
            return obj;
        }


Пример на заранее заданном массиве Data:
byte[] Data;
Dictionary<string,string> DickTator = (Dicktionary<string,string>)ByteArrayToObject(Data);


Добавлено: 10 Июня 2014 12:18:56 Добавил: Андрей Ковальчук

Мини игра на c#(тест моих знаний как начинающего)

C#

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace WindowsFormsApplication1
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        private void pictureBox2_Click(object sender, EventArgs e)
        {
            
        }

        private void timer1_Tick(object sender, EventArgs e) // При включении таймера происходит передвижение объекта 
        {
            pictureBox2.Left = pictureBox2.Left + 1;

        }

        private void button1_Click(object sender, EventArgs e)//включение таймера №1
        {
            timer1.Enabled = true;

        }

        private void button2_Click(object sender, EventArgs e)//при нажатии на кнопку butten2 происходит выключение всех таймеров 
        {
            timer1.Enabled = false;
            timer2.Enabled = false;
            timer3.Enabled = false;
            timer4.Enabled = false;
            timer5.Enabled = false;
            timer6.Enabled = false;
            timer7.Enabled = false;
            timer8.Enabled = false;
        }

        private void button3_Click(object sender, EventArgs e)//включение таймера 2
        {
            timer2.Enabled = true;
            
        }

        private void button4_Click(object sender, EventArgs e)//включение таймера 3
        {
            timer3.Enabled = true;
            
        }

        private void timer2_Tick(object sender, EventArgs e)//при включение таймера 2 происходит движение вверх
        {
            pictureBox2.Top = pictureBox2.Top - 10;
        }

        private void label3_Click(object sender, EventArgs e)// при нажатии на лаэйбл номер 3 происходить выклчение таймера 1 и вкл 4 и так ниже 
        {
            
            timer4.Enabled = true;
            timer1.Enabled = false;
 
        }

        private void label4_Click(object sender, EventArgs e)
        {
            timer4.Enabled = false;
            timer1.Enabled = false;
            timer5.Enabled = true;
           
            
        }

        private void label5_Click(object sender, EventArgs e)
        {
            timer4.Enabled = false;
            timer6.Enabled = true;
            timer1.Enabled = false;
            timer5.Enabled = false;
           
        }

        private void label6_Click(object sender, EventArgs e)
        {
            timer7.Enabled = true;
            timer4.Enabled = false;
            timer6.Enabled = false;
            timer1.Enabled = false;
            timer5.Enabled = false;
        }

        private void timer3_Tick(object sender, EventArgs e)
        {
            pictureBox2.Top = pictureBox2.Top + 10;
        }

        private void timer4_Tick(object sender, EventArgs e)
        {
            
            pictureBox2.Left = pictureBox2.Left + 2;
        }

        private void button5_Click(object sender, EventArgs e)
        {
            timer4.Enabled = true;
            timer1.Enabled = false;
        }

        private void Form1_Load(object sender, EventArgs e)
        {

        }

        private void timer5_Tick(object sender, EventArgs e)
        {
            pictureBox2.Left = pictureBox2.Left + 5;
        }

        private void timer6_Tick(object sender, EventArgs e)
        {
            pictureBox2.Left = pictureBox2.Left + 7;
        }

        private void timer7_Tick(object sender, EventArgs e)
        {
            pictureBox2.Left = pictureBox2.Left + 10;
        }

        private void button5_Click_1(object sender, EventArgs e)
        {
            
           
        }

        private void button6_Click(object sender, EventArgs e)
        {
            
            Close();

        }

        private void radioButton1_CheckedChanged(object sender, EventArgs e) // выбор машины 1
        {
            pictureBox1.Visible = true;
            pictureBox2.Visible = false;
            
            label1.Visible = false;
            label2.Visible = false;
            label3.Visible = false;
            label4.Visible = false;
            label5.Visible = false;
            label6.Visible = false;
            button1.Visible = false;
            button2.Visible = false;
            button3.Visible = false;
            button4.Visible = false;
        }

        private void radioButton2_CheckedChanged(object sender, EventArgs e)//выбор машины 2
        {
            pictureBox1.Visible = false;
            pictureBox2.Visible = true;


            label1.Visible = true;
            label2.Visible = true;
            label3.Visible = true;
            label4.Visible = true;
            label5.Visible = true;
            label6.Visible = true;
            button1.Visible = true;
            button2.Visible = true;
            button3.Visible = true;
            button4.Visible = true;
           
            
        }

        private void radioButton3_CheckedChanged(object sender, EventArgs e)
        {

        }

        private void checkBox1_CheckedChanged(object sender, EventArgs e)
        {
            
        }
    }
}


Добавлено: 09 Апреля 2014 06:09:51 Добавил: Андрей Ковальчук

Cript (шифрование файлов)

C#

С твоего кода даже обфускатор офигеет. (С) _не_помню_кто_сказал_


Сначала у меня была идея побаловаться с ООП на Си. И я решил сделать небольшую программку для шифрования файлов. Ниже привожу сорцы.

typedefs.h - В файле основные дефайны, инклуды и макрос __PRINT_DBG(), который я использовал для дебага. Этот файл подключается ко всем остальным файлам.
#ifndef TYPEDEFS_H_INCLUDED
#define TYPEDEFS_H_INCLUDED

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>

#if SYSTEM == MSDOS
	#define WIN_OS
#elif SYSTEM == LINUX
	#define LIN_OS
#endif

#define DEBUG_MOD
#undef DEBUG_MOD

#ifdef DEBUG_MOD
	#define __PRINT_DBG( x )\
		printf ( (x) )
#else
	#define __PRINT_DBG(x)\
		printf ("")
#endif

#define NOOB_CRIPT_ALGORITHM 0
typedef int bool;
enum BOOL {FALSE, TRUE};
#define class typedef struct
#define sub  void

#endif



Дальше идет код, отвечающий за хранение и изменение настроек. Может это не очень хорошая идея, но я ничего другого не придумал.
settings_class.h
#ifndef SETTINGS_CLASS_H_INCLUDED
#define SETTINGS_CLASS_H_INCLUDED



class {
// public:
//	Settings();

//	bool isRemove();
//	bool isSettingTypeOfCript();
//	int  getCriptAlgorithm();
//	int  getCriptBufSize();
//	FILE *getInputFile();
//	FILE *getOutputFile();

//	void setCript (bool val);
//	void setRemove (bool val);
//	void setSettingsTypeOfCript (bool val);
//	void setCriptAlgorithm (int val);
//	void setCriptBufSize (int val);
//	void setInputFile (FILE *inputfile);
//	void setOutputFile (FILE *outputfile);

//	~Settings();

// private:
	bool remove;
	bool reverse;
	int  criptAlgorithm;
	int criptBufSize;
	bool settedInputFile;
	char* inputfilename;
	FILE *inputfile;
	bool settedOutputFile;
	char* outputfilename;
	FILE *outputfile;
} Settings;

#endif


settings.h
#ifndef SETTINGS_H_INCLUDED
#define SETTINGS_H_INCLUDED



#include "typedefs.h"
#include "settings_class.h"


sub Settings_constructor (Settings *this);

bool Settings_isRemove (Settings *this);
bool Settings_isReverse (Settings *this);
int Settings_getCriptAlgorithm (Settings *this);
int Settings_getCriptBufSize (Settings *this);
bool Settings_isSettedInputFile (Settings *this);
char* Settings_getInputFileName (Settings *this);
FILE *Settings_getInputFile (Settings *this);
bool Settings_isSettedOutputFile (Settings *this);
char* Settings_getOutputFileName (Settings *this);
FILE *Settings_getOutputFile (Settings *this);

sub Settings_setRemove (Settings *this, bool val);
sub Settings_setReverse (Settings *this, bool val);
sub Settings_setCriptAlgorithm (Settings *this, int val);
sub Settings_setCriptBufSize (Settings *this, int val);
sub Settings_setSettedInputFile (Settings *this, bool val);
sub Settings_setInputFileName (Settings *this, char* path);
sub Settings_setInputFile (Settings *this, FILE *inputfile);
sub Settings_setSettedOutputFile (Settings *this, bool val);
sub Settings_setOutputFileName (Settings *this, char* path);
sub Settings_setOutputFile (Settings *this, FILE *outputfile);

sub Settings_destructor (Settings *this);

#endif


settings.c
#include "typedefs.h"
#include "settings.h"



sub Settings_constructor (Settings *this) {
	this->remove = FALSE;
	this->reverse = FALSE;
	this->criptAlgorithm = 0;
	this->criptBufSize = 1024 * 1024;
	this->settedInputFile = FALSE;
	this->inputfile = NULL;
	this->inputfilename = NULL;
	this->settedOutputFile = FALSE;
	this->outputfile = NULL;
	this->outputfilename = NULL;
}



bool Settings_isRemove (Settings *this) {
	return this->remove;
}



bool Settings_isReverse (Settings *this) {
	return this->reverse;
}



int Settings_getCriptAlgorithm (Settings *this) {
	return this->criptAlgorithm;
}



int Settings_getCriptBufSize (Settings *this) {
	return this->criptBufSize;
}



bool Settings_isSettedInputFile (Settings *this) {
	return this->settedInputFile;
}



char* Settings_getInputFileName (Settings *this) {
	return this->inputfilename;
}



FILE *Settings_getInputFile (Settings *this) {
	return this->inputfile;
}



bool Settings_isSettedOutputFile (Settings *this) {
	return this->settedOutputFile;
}



char* Settings_getOutputFileName (Settings *this) {
	return this->outputfilename;
}



FILE *Settings_getOutputFile (Settings *this) {
	return this->outputfile;
}



sub Settings_setRemove (Settings *this, bool val) {
	this->remove = val;
}



sub Settings_setReverse (Settings *this, bool val) {
	this->reverse = val;
}



sub Settings_setCriptAlgorithm (Settings *this, int val) {
	this->criptAlgorithm = val;
}




sub Settings_setCriptBufSize (Settings *this, int val) {
	this->criptBufSize = val;
}



sub Settings_setSettedInputFile (Settings *this, bool val) {
	this->settedInputFile = val;
}



sub Settings_setInputFileName (Settings *this, char* path) {
	this->inputfilename = path;
}



sub Settings_setInputFile (Settings *this, FILE *inputfile) {
	this->inputfile = inputfile;
}



sub Settings_setSettedOutputFile (Settings *this, bool val) {
	this->settedOutputFile = val;
}



sub Settings_setOutputFileName (Settings *this, char* path) {
	this->outputfilename = path;
}



sub Settings_setOutputFile (Settings *this, FILE *outputfile) {
	this->outputfile = outputfile;
}



sub Settings_destructor (Settings *this) {
	this->inputfile = NULL;
	this->inputfilename = NULL;
	this->outputfile = NULL;
	this->outputfilename = NULL;
}



Настройки частично могут поменяться, если вызывать программу с параметрами. За их парсинг отвечает следующий код.

arg_class.h
#ifndef ARG_CLASS_H_DEFINED
#define ARG_CLASS_H_DEFINED



class {
// public:
//	void argPars (int argc, char **argv);
//	void srgSet (char *arg);
//	void setTypeOfCript (char *type);
//	void setInputFile (char *path);
//	void setOutputFile (char *path);

// private:
	Settings *setups;
} Arg;



#endif


arg.h
#ifndef ARG_H_INCLUDED
#define ARG_H_INCLUDED



#include "typedefs.h"
#include "arg_class.h"
#include "settings_class.h"



// From 'main.c'.
sub showUsage (void);



sub Arg_constructor (Arg *this, Settings *setups);

sub Arg_argPars (Arg *this, int argc, char **argv);
sub Arg_argSet (Arg *this, char *arg);
sub Arg_flagSet (Arg *this, char *arg);
sub Arg_setTypeOfCript (Arg *this, char *type);
sub Arg_setInputFile (Arg *this, char *path);
sub Arg_setOutputFile (Arg * this, char *path);

sub Arg_destructor (Arg *this);



#endif


arg.c
#include "settings.h"
#include "arg.h"
#include "main.h"



sub Arg_constructor (Arg *this, Settings *setups) {
	__PRINT_DBG("__FUNC: Arg_constructor\n");
	this->setups = setups;
}



sub Arg_argPars (Arg *this, int argc, char **argv) {
	__PRINT_DBG("__FUNC: Arg_argPars\n");
	for (int i = 1; i < argc; i++) {
		       if (argv[i][0] == '-' && argv[i][1] != '-') {
			Arg_argSet (this, argv[i]);
		} else if (argv[i][0] == '-' && argv[i][1] == '-') {
			Arg_flagSet (this, argv[i]);
		} else if (Settings_isSettedInputFile (this->setups) == FALSE) {
			Arg_setInputFile (this, argv[i]);
		} else if (Settings_isSettedOutputFile (this->setups) == FALSE) {
			Arg_setOutputFile (this, argv[i]);
		} else {
			printf ("Invalide argument \'%s\'!\n", argv[i]);
			exit (1);
		}
	}

	if (Settings_getInputFile (this->setups) != NULL && Settings_getOutputFile (this->setups) == NULL) {
		Arg_setOutputFile (this, strcat (Settings_getInputFileName (this->setups), ".cript"));
	}

	if (Settings_getInputFile (this->setups) == NULL) {
		printf ("Missed a input file!\n");
		exit (1);
	}
}



sub Arg_argSet (Arg *this, char *arg) {
	__PRINT_DBG("__FUNC: Arg_argSet\n");
	for (int i = 1; arg[i] != '{EDIT_TEXT}'; i++) {
		#define param arg[i]
		       if (param == 'R') {
			Settings_setReverse (this->setups, 1);
		} else if (param == 'r') {
			Settings_setRemove (this->setups, 1);
		} else {
			printf ("Invalid arguments!\n");
			showUsage();
			exit (1);
		}
		#undef param
	}
}



/* If str1 == str2 then return 1. */
bool Arg_mystrcmp (char* str1, char *str2) {
	while (*str1 == *str2 && *str1 != '=') {
		str1++; str2++;
	}

	if (*str1 == *str2 && *str1 == '=') {
		return 1;
	} else {
		return 0;
	}
}



char *Arg_getParam (char *arg) {
	while (*arg != '=' && *arg != '{EDIT_TEXT}') {
		arg++;
	}
	if (*arg == '=') {
		arg++;
		return arg;
	} else {
		return NULL;
	}
}



sub Arg_flagSet (Arg *this, char *arg) {
	__PRINT_DBG("__FUNC: Arg_flagSet\n");
	char *param;

	       if (Arg_mystrcmp (arg, "--cript-met=")) {
		param = Arg_getParam (arg);

		       if (!strcmp (param, "noob")) {
			/***/printf ("noob\n");
			Settings_setCriptAlgorithm (this->setups, NOOB_CRIPT_ALGORITHM);
		} else {
			printf ("Invalide parametr of \'--cript-met=\'!\n");
			showUsage();
			exit (1);
		}
	} else if (!strcmp (arg, "--reverse")) {
		Settings_setReverse (this->setups, TRUE);
	} else if (!strcmp (arg, "--remove")) {
		Settings_setRemove (this->setups, TRUE);
	} else if (!strcmp (arg, "--help")) {
		showUsage();
	} else {
		printf ("Invalide argument \'%s\'!\n", arg);
		showUsage();
		exit (1);
	}
}



sub Arg_setTypeOfCript (Arg *this, char *type) {
	//
}



sub Arg_setInputFile (Arg *this, char *path) {
	__PRINT_DBG("__FUNC: Arg_setInputFile\n");
	FILE *file;
	if ((file = fopen (path, "rb")) != NULL) {
		Settings_setSettedInputFile (this->setups, TRUE);
		Settings_setInputFileName (this->setups, path);
		Settings_setInputFile (this->setups, file);
	} else {
		printf ("File \'%s\' not exist!\n", path);
		exit (1);
	}
}



sub Arg_setOutputFile (Arg * this, char *path) {
	__PRINT_DBG("__FUNC: Arg_setOutputFile\n");
	FILE *file;

// Cleaning file.
	if ((file = fopen (path, "w")) == NULL) {
		printf ("Can\'t create a file \'%s\'!\n", path);
		exit (1);
	} else {
		fclose (file);
	}

	if ((file = fopen (path, "ab")) != NULL) {
		Settings_setSettedOutputFile (this->setups, TRUE);
		Settings_setOutputFileName (this->setups, path);
		Settings_setOutputFile (this->setups, file);
	} else {
		printf ("Can\'t create a file \'%s\'!\n", path);
		exit (1);
	}
}



sub Arg_destructor (Arg *this) {
	__PRINT_DBG("__FUNC: Arg_destructor\n");
	this->setups = NULL;
}


Возможно, я не правильно понимаю наследование или не правильно его применяю (что, в общем-то, одно и то же), но решил я сделать так.

criptbuf_class.h
#ifndef CRIPTBUF_CLASS_H_INCLUDED
#define CRIPTBUF_CLASS_H_INCLUDED



class {
// public:
//	CriptBuf();
//	~CriptBuf();

// protected:
	char *buf;
} CriptBuf;



#endif


criptbuf.h
#ifndef CRIPT_BUF_H_INCLUDED
#define CRIPT_BUF_H_INCLUDED



#include "typedefs.h"
#include "criptbuf_class.h"



sub CriptBuf_constructor (CriptBuf *this, int bufSize);

char CriptBuf_getBit (CriptBuf *this, int num);
void CriptBuf_setBit (CriptBuf *this, int num, char val);

sub CriptBuf_destructor (CriptBuf *this);



#endif


criptbuf.c
#include "criptbuf.h"



sub CriptBuf_constructor (CriptBuf *this, int bufSize) {
	__PRINT_DBG("__FUNC: CriptBuf_constructor\n");
	this->buf = (char *) calloc (bufSize, sizeof (char));
}



char CriptBuf_getBit (CriptBuf *this, int num) {
	return this->buf[num];
}



void CriptBuf_setBit (CriptBuf *this, int num, char val) {
	this->buf[num] = val;
}



sub CriptBuf_destructor (CriptBuf *this) {
	__PRINT_DBG("__FUNC: CriptBuf_destructor\n");
	free (this->buf);
}



Предыдущий класс "наследуется" следующим (который и отвечает за шифрование).

cript_class.h
#ifndef CRIPT_CLASS_H_INCLUDED
#define CRIPT_CLASS_H_INCLUDED


#include "settings_class.h"
#include "criptbuf_class.h"


class /* protected: CriptBuf, protected: CriptAlgorithm */ {
// public:
//	Cript();
//	void setCriptAlgorithm();
//	void setPreCriptBuf();
//	void writeCript();
//	virtual void doCripting() = 0;
//	~Cript();

// private:
	Settings *setups;

// parents:
	CriptBuf *CriptBuf;
} Cript;



#endif


cript.h
#ifndef CRIPT_H_INCLUDED
#define CRIPT_H_INCLUDED



#include "typedefs.h"
#include "settings.h"
#include "cript_class.h"



sub Cript_constructor (Cript *this, Settings *setups);

sub Cript_setPreCriptBuf (Cript *this);
sub Cript_writeCript (Cript *this);
sub Cript_criptFile (Cript *this);

sub Cript_destructor (Cript *this);



#endif


cript.c
#include "cript.h"
#include "cript_001.h"
#include "criptbuf.h"



sub Cript_constructor (Cript *this, Settings *setups) {
	__PRINT_DBG("__FUNC: Cript_constructor\n");
	this->setups = setups;

	this->CriptBuf = (CriptBuf *) calloc (1, sizeof (CriptBuf));
	CriptBuf_constructor (this->CriptBuf, Settings_getCriptBufSize (this->setups));
}



void (*Cript_doCripting[][2]) (Cript *this) = {
	{Cript_cript_001, Cript_recript_001}
};



sub Cript_criptFile (Cript *this) {
	__PRINT_DBG("__FUNC: Cript_criptFile\n");
	while (!feof (Settings_getInputFile (this->setups))) {
		Cript_setPreCriptBuf (this);
		(*Cript_doCripting[Settings_getCriptAlgorithm (this->setups)][Settings_isReverse (this->setups)]) (this);
		Cript_writeCript (this);
	}
}



sub Cript_setPreCriptBuf (Cript *this) {
	__PRINT_DBG(("__FUNC: Cript_setPreCriptBuf\n"));
	int i;
	bool flag;

	for (i = 0; i < Settings_getCriptBufSize (this->setups) && (flag = !feof (Settings_getInputFile (this->setups))); i++) {
		CriptBuf_setBit (this->CriptBuf, i, getc (Settings_getInputFile (this->setups)));
		/***/printf (" _ %d: %c\n", i, CriptBuf_getBit (this->CriptBuf, i));
	}
	if (!flag) { /** Ugly style, imho. */
		i--;
	}

	Settings_setCriptBufSize (this->setups, i);
}



sub Cript_writeCript (Cript *this) {
	__PRINT_DBG(("__FUNC: Cript_writeCript\n"));
	for (int i = 0; i < Settings_getCriptBufSize (this->setups); i++) {
		putc (CriptBuf_getBit (this->CriptBuf, i), Settings_getOutputFile (this->setups));
	}
}



sub Cript_destructor (Cript *this) {
	__PRINT_DBG("__FUNC: Cript_destructor\n");
	CriptBuf_destructor (this->CriptBuf);
	this->setups = NULL;
}


В коде выше используется двумерный массив указателей на функции. Двумерный, чтобы можно было легко вызвать алгоритм расшифровки для несимметричного алгоритма шифрования. Я посчитал, что так проще будет добавлять новые алгоритмы шифрования.
В общем, вот тот алгоритм, что используется сейчас.

cript_001.h
#ifndef CRIPT_001_H_INCLUDED
#define CRIPT_001_H_INCLUDED



#include "typedefs.h"
#include "cript_class.h"



#define CRIPT_BLOCK_SIZE 4



sub Cript_cript_001 (Cript *this);
sub Cript_recript_001 (Cript *this);



#endif


cript_001.c
#include "cript_001.h"
#include "settings.h"
#include "criptbuf.h"




char reverseBit (char bite) {
	__PRINT_DBG("__FUNC: reverseBit\n");

	char temp = 0;

	// ...
	#define CHAR_SIZE 8
	for (int i = 0; i < CHAR_SIZE; i++) {
		temp |= ((bite >> i) & 1) << (CHAR_SIZE - 1 - i);
	}
	bite = temp;

	return bite;
}



void Cript_cript_001 (Cript *this) {
	/*
	 * Reverse beat from boundary to center.
	 */

	__PRINT_DBG("__FUNC: Cript_cript_001\n");
	int temp;

	for (int i = 0; i < Settings_getCriptBufSize (this->setups); i += CRIPT_BLOCK_SIZE) {
		if (i + CRIPT_BLOCK_SIZE <= Settings_getCriptBufSize (this->setups)) {
			for (int j = 0; j < CRIPT_BLOCK_SIZE / 2; j++) {
				temp = CriptBuf_getBit (this->CriptBuf, i + j);
				CriptBuf_setBit (this->CriptBuf, i + j, reverseBit (CriptBuf_getBit (this->CriptBuf, i + CRIPT_BLOCK_SIZE - j - 1)));
				CriptBuf_setBit (this->CriptBuf, i + CRIPT_BLOCK_SIZE - j - 1, reverseBit (temp));
			}
		} else {
			for (int j = 0; i + j < Settings_getCriptBufSize (this->setups); j++) {
				CriptBuf_setBit (this->CriptBuf, i + j, reverseBit (CriptBuf_getBit (this->CriptBuf, i + j)));
			}
		}
	}
}



void Cript_recript_001 (Cript *this) {
	__PRINT_DBG("__FUNC: Cript_recript_001\n");
	Cript_cript_001 (this);
}


Из недостатков алгоритма можно выделить очень медленную работу. На 1МБ может уйти около минуты. После выполнения алгоритма каждый блок 4 байта будет побитово развернут. Если последний блок меньше 4 байт, будет побитово разворачиваться каждый байт.

Назначение файлов main.h и main.c должно быть понятно любому.
Я решил не делать "объекты классов", которые описал выше, глобальными, а создавать их в теле функции, передав по ссылке.

main.h
#ifndef MAIN_H_INCLUDED
#define MAIN_H_INCLUDED

#include "typedefs.h"
#include "settings_class.h"

sub showUsage (void);
sub deliteSorceFile (Settings *setups);
sub closeFiles (Settings *setups);

#endif


main.c
#include "typedefs.h"
#include "main.h"
#include "arg.h"
#include "cript.h"



sub showUsage (void) {
	printf (
"Usage:\n\
cript [param] (options) [path to file] [output file name]\n\
\n\
param:\n\
\t-R, --reverse\n\
\t\t> Reverse cript (encript).\n\
\t-r, --remove\n\
\t\t> remove source file.\n\
options:\n\
\t--cript-met=method\n\
\t\t> method={noob}\n\
\n"
	);
}



sub deliteSorceFile (Settings *setups) {
	remove (Settings_getInputFileName (setups));
}



sub closeFiles (Settings *setups) {
	fclose (Settings_getInputFile (setups));
	fclose (Settings_getOutputFile (setups));
}



int main (int argc, char **argv) {
	if (argc == 1) {
		showUsage();
		return 0;
	}

	Settings setups;
	Settings_constructor (&setups);

	Arg arg; Arg_constructor (&arg, &setups);
	Arg_argPars (&arg, argc, argv);

	Cript cript;
	Cript_constructor (&cript, &setups);

	Cript_criptFile (&cript);
	Cript_destructor (&cript);

	closeFiles (&setups);

	if (Settings_isRemove (&setups) == 1) {
		deliteSorceFile (&setups);
	}

	Settings_destructor (&setups);

	return 0;
}


Чтобы не собирать отдельно каждый файл ручками, сделаем Makefile (на виндовс make не завелся, придется собирать от руки).

Makefile
# Make 4.0

CC=gcc

CFLAGS=-c -Os --std=c99


all: cript

cript: main.o settings.o arg.o criptbuf.o cript.o cript_001.o
	$(CC) main.o settings.o arg.o criptbuf.o cript.o cript_001.o -o cript

main.o: main.c
	$(CC) $(CFLAGS) main.c

settings.o: settings.c
	$(CC) $(CFLAGS) settings.c

arg.o: arg.c
	$(CC) $(CFLAGS) arg.c

criptbuf.o: criptbuf.c
	$(CC) $(CFLAGS) criptbuf.c

cript.o: cript.c
	$(CC) $(CFLAGS) cript.c

cript_001.o: cript_001.c
	$(CC) $(CFLAGS) cript_001.c


clean:
	rm -rf *.o cript

clean_o:
	rm -rf *.o

cleancripted:
	rm -rf *.cript

fun:
	rm -rf *


Потом может добавлю графический интерфейс на питоне. Если кому интересно, ссылка на гитхаб. Обновления кидать туда буду.
https://github.com/npcipav/cript

Добавлено: 25 Марта 2014 01:47:42 Добавил: Андрей Ковальчук

chess.c

C#

#include <stdio.h>
#include <stdlib.h>


#define SCREEN_SIZE  25
#define MAX_LEN      15
#define STEP_CODE     2
#define CHEAT_CODE    1

/* Code of chessman. */
enum CM     {NULL_CM, KING, QUEEN, PAWN, ROOK, ELEPHANT, HORSE};
/* Цвет фигуры. */
enum Color  {BLACK_C = -1, NULL_C, WHITE_C};
/* 0 - Мат, 1 - Шах. */
enum Status {MATE_G, CHECK_G, GAME_G};
/* Странно, что в Си нет bool. -_- */
enum bool   {FALSE, TRUE};

struct Game {
    struct Game_T {
        int cm [8] [8];
        struct k {int x, y;} w, b;       /* Белый король и черный. */
    } n,                  /* Настоящее положение фигур. */
      f;                  /* Промежуточное положение. Выполняется проверка. */
    int status;           /* (Status). */
    int color;            /* Цвет активного игрока (Color). */
} g;

void startGame (void);
void execLine  (const char line[MAX_LEN]);
void showBoard (void);
void showMan   (const int i);

int  checkValide    (const char line[MAX_LEN]);
void setCoordinates (char line [MAX_LEN]);
void getCoordinates (char line [MAX_LEN]);

       int  isPosible         (int x1, int y1, int x2, int y2);
inline void isPosibleKing     (int x1, int y1, int x2, int y2, int *valide);
inline void isPosibleRook     (int x1, int y1, int x2, int y2, int *valide);
inline void isPosibleElephant (int x1, int y1, int x2, int y2, int *valide);
inline void isPosibleHorse    (int x1, int y1, int x2, int y2, int *valide);
inline void isPosiblePawn     (int x1, int y1, int x2, int y2, int *valide);

       int  isCheck             (void);
inline void isCheckFromElephant (int x, int y, int *valide);
inline void isCheckFromRook     (int x, int y, int *valide);
inline void isCheckFromHorse    (int x, int y, int *valide);
inline void isCheckFromPawn     (int x, int y, int *valide);

/*//////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////*/
int
main(void) {
    char line [MAX_LEN];
    int valide;

    scanf ("%s", line);
/* Обработка настроек. */
    execLine (line);

    while (g.status != MATE_G) {
        scanf ("%s", line);
        if ( (valide = checkValide (line)) == STEP_CODE) {
            setCoordinates (line);
        } else if ( valide == CHEAT_CODE) {
            execLine (line);
        } /* else doNothing(); */
    }

    return 0;
}



void showBoard (void) {
    register int i, j;
/* Оистка экрана. */
    for (i = 0; i < SCREEN_SIZE; i++) printf ("\n");

    printf ("\tA\tB\tC\tD\tE\tF\tG\tH");
    for (i = 0; i < 8; i++) {
        printf ("%d\t", i);
        for (j = 0; j < 8; j++) {
            showMan (g.n.cm [i] [j]);
        }
        printf ("%d", i);
    }
    printf ("\tA\tB\tC\tD\tE\tF\tG\tH");
}


/* Печатает букву с именем фигуры вместо ее номера. */
void showMan (const int i) {
    switch (i) {
        case KING : printf ("K");
        break;
        case QUEEN : printf ("Q");
        break;
        case ROOK : printf ("R");
        break;
        case ELEPHANT : printf ("E");
        break;
        case HORSE : printf ("H");
        break;
        case PAWN : printf ("P");
        break;
        case -KING : printf ("k");
        break;
        case -QUEEN : printf ("q");
        break;
        case -ROOK : printf ("r");
        break;
        case -ELEPHANT : printf ("e");
        break;
        case -HORSE : printf ("h");
        break;
        case -PAWN : printf ("p");
        break;
    }
}



void execLine (const char line[MAX_LEN]) {
    startGame ();
/** Запуск чит-кода. */
}



void startGame (void) {
    int i;
/* Расстановка ладьей. */
    g.n.cm [0] [0] = g.n.cm [0] [7] =  ROOK + 10;
    g.n.cm [7] [0] = g.n.cm [7] [7] = -ROOK - 10;
/* Расстановка коней. */
    g.n.cm [0] [1] = g.n.cm [0] [6] =  HORSE + 10;
    g.n.cm [7] [1] = g.n.cm [7] [6] = -HORSE - 10;
/* Расстановка слонов. */
    g.n.cm [0] [2] = g.n.cm [0] [5] =  ELEPHANT + 10;
    g.n.cm [7] [2] = g.n.cm [7] [5] = -ELEPHANT - 10;
/* Расстановка ферзей. */
    g.n.cm [0] [3] =  QUEEN + 10;
    g.n.cm [7] [3] = -QUEEN - 10;
/* Установка королей. */
    g.n.cm [0] [4] =  KING + 10;
    g.n.cm [7] [4] = -KING - 10;
    g.n.w.x = g.n.b.x = 4; g.n.w.y = 0; g.n.b.y = 7;
/* Пешки. */
    for (i = 0; i < 7; i++) {
        g.n.cm [1] [i] =  PAWN + 10; /* Белые. */
        g.n.cm [6] [i] = -PAWN - 10; /* Черные. */
    }

    g.status = GAME_G;
    g.color = WHITE_C;
}



int checkValide (const char line[MAX_LEN]) {
    int valide = TRUE;
    int i;

/* Если элементы массива не содержат соответствующих символов, valide = 0. */
    for (i = 0; i < 5; i += 3) {
        if ( !strcpm (line [i], "12345678")) {
            valide = FALSE;
        }
    }
    for (i = 1; i < 5; i += 3) {
        if ( !strcpm (line [i], "aAbBcCdDeEfFgGhH")) {
            valide = FALSE;
        }
    }
    if ( valide) {
        return STEP_CODE;
    } else {
        return CHEAT_CODE;
    }
}



void setCoordinates (char line [MAX_LEN]) {
    getCoordinates (line);
        const int x1 = line [0];
        const int y1 = line [1] - 1;
        const int x2 = line [3];
        const int y2 = line [4] - 1;

/* Установка фигуры в промежуточное положение. */
    g.f.cm [y2] [x2] = g.f.cm [y1] [x1];
    g.f.cm [y1] [x1] = NULL_CM;
    if ( isPosible (x1, y1, x2, y2) && !isCheck()) {
/* Запись положения короля. */
        if ( abs (g.n.cm [y1] [x1] % 10) == KING) {
            if ( g.n.cm [y1] [x1] / 10 == WHITE_C) {
                g.n.w.x = x2;
                g.n.w.y = y2;
            } else {
                g.n.b.x = x2;
                g.n.b.y = y2;
            }
        } else {
/* Установка фигуры. */
            g.n.cm [y2] [x2] = g.n.cm [y1] [x1];
            g.n.cm [y1] [x1] = NULL_CM;
        }
    }
}


/* Перевод координат из текста в цифры. */
void getCoordinates (char line [MAX_LEN]) {
    int i, j; char c, C;

    for (i = 0; i < 4; i += 3) {
        for (c = 'a', C = 'A', j = 1; c <= 'h' && C <= 'H' && j
             <= 8; c++, C++, j++) {
            if ( line [i] == c || line [i] == C) {
                line [i] = j;
            }
        }
    }

    line [1] = atoi (line [1]);
    line [4] = atoi (line [4]);
}



int isPosible (int x1, int y1, int x2, int y2) {
    int valide = FALSE;

    switch (abs (g.n.cm [y1] [x1] % 10)) {
    case KING : isPosibleKing(x1, y1, x2, y2, &valide);
    break;

    case QUEEN : isPosibleRook(x1, y1, x2, y2, &valide);
                 isPosibleElephant(x1, y1, x2, y2, &valide);
    break;

    case PAWN : isPosiblePawn(x1, y1, x2, y2, &valide);
    break;

    case ROOK : isPosibleKing(x1, y1, x2, y2, &valide);
    break;

    case ELEPHANT : isPosibleElephant(x1, y1, x2, y2, &valide);
    break;

    case HORSE : isPosibleHorse(x1, y1, x2, y2, &valide);
    break;
    }

    return valide;
}



inline void isPosibleKing (int x1, int y1, int x2, int y2, int *valide) {
    valide = abs((x2 - x1) * (y2 - y1)) < 1 && g.n.cm [y2] [x2] / 10 != g.color;
}



inline void isPosibleRook (int x1, int y1, int x2, int y2, int *valide) {
    int i, j;

    for (i = y1 + 1, j = x2 + 1; i < 8 && j < 8 && !g.n.cm [y1] [i]; i++, j++) {
        if ( y1 == y2 && x2 - x1 && i == x2) {
            valide = 1;
        }
    }
    if ( i < 7 && j < 7 && g.n.cm [i + 1] [j + 1] == -g.color) {
        valide = 1;
    }

    for (i = y1 + 1, j = x2 - 1; i < 8 && j >= 0 && !g.n.cm [y1] [i]; i++, j--) {
        if ( y1 == y2 && x2 - x1 && i == x2) {
            valide = 1;
        }
    }
    if ( i < 7 && j > 0 && g.n.cm [i + 1] [j - 1] == -g.color) {
        valide = 1;
    }

    for (i = y1 - 1, j = x2 + 1; i >= 0 && j < 8 && !g.n.cm [y1] [i]; i--, j++) {
        if ( y1 == y2 && x2 - x1 && i == x2) {
            valide = 1;
        }
    }
    if ( i > 0 && j < 7 && g.n.cm [i - 1] [j + 1] == -g.color) {
        valide = 1;
    }

    for (i = y1 - 1, j = x2 - 1; i >= 0 && j >= 0 && !g.n.cm [y1] [i]; i--, j--) {
        if ( y1 == y2 && x2 - x1 && i == x2) {
            valide = 1;
        }
    }
    if ( i > 0 && j > 0 && g.n.cm [i - 1] [j - 1] == -g.color) {
        valide = 1;
    }
}


inline void isPosibleElephant (int x1, int y1, int x2, int y2, int *valide) {
    int i, j;

    for (i = y1 + 1, j = x1 + 1; i < 8 && j < 8 && !g.n.cm [i] [j]; i++, j++) {
        if ( i == y2 && j == x2) {
            valide = 1;
        }
    }
    if ( i < 7 && j < 7 && g.n.cm [i + 1] [j + 1] == -g.color) {
        valide = 1;
    }

    for (i = y1 + 1, j = x1 - 1; i < 8 && j >= 0 && !g.n.cm [i] [j]; i++, j--) {
        if ( i == y2 && j == x2) {
            valide = 1;
        }
    }
    if ( i < 7 && j > 0 && g.n.cm [i + 1] [j - 1] == -g.color) {
        valide = 1;
    }

    for (i = y1 - 1, j = x1 + 1; i >= 0 && j < 8 && !g.n.cm [i] [j]; i--, j++) {
        if ( i == y2 && j == x2) {
            valide = 1;
        }
    }
    if ( i > 0 && j < 7 && g.n.cm [i - 1] [j + 1] == -g.color) {
        valide = 1;
    }

    for (i = y1 - 1, j = x1 - 1; i >= 0 && j >= 0 && !g.n.cm [i] [j]; i--, j--) {
        if ( i == y2 && j == x2) {
            valide = 1;
        }
    }
    if ( i > 0 && j > 0 && g.n.cm [i - 1] [j - 1] == -g.color) {
        valide = 1;
    }
}


inline void isPosibleHorse (int x1, int y1, int x2, int y2, int *valide) {
    valide = (x2 == x1 + 2 && y2 == x1 + 3 || x2 == x1 + 3 && y2 == y1 + 2
           || x2 == x1 - 2 && y2 == y1 - 3 || x2 == x1 - 3 && y2 == y1 - 2
           || x2 == x1 + 2 && y2 == y1 - 3 || x2 == x1 + 3 && y2 == y1 - 2
           || x2 == x1 - 2 && y2 == y1 + 3 || x2 == x1 - 3 && y2 == y1 + 2)
           && g.n.cm [y2] [x2] / 10 != g.color;
}



inline void isPosiblePawn (int x1, int y1, int x2, int y2, int *valide) {
/* Если осуществляется попытка сделать ход на клетку вперед, ИЛИ если
 * осуществляется попытка сделать ход на клетку по диагонали, И если там есть
 * фигура противоположного цвета. */
    valide = y2 - y1 == 1 && !(x2 - x1) && !g.n.cm [y2] [x2]
           || abs ((x2 - x1) * (y2 - y1)) == 1 && g.n.cm [y2] [x2] / 10
           == -g.color;
}



int isCheck (void) {
    int x, y;
    int valide = FALSE;

    if ( g.color == WHITE_C) {x = g.f.w.x; y = g.f.w.y;}
                        else {x = g.f.b.x; y = g.f.b.y;}

/* Проверка битых полей от слона или ферзя. */
    isCheckFromElephant (x, y, &valide);

/* Проверка битых полей от ладьи или ферзя. */
    isCheckFromRook (x, y, &valide);

/* Проверка битых полей от коня. */
    isCheckFromHorse (x, y, &valide);

/* Проверка битых полей от пешки. */
    isCheckFromPawn (x, y, &valide);

    return valide;
}

inline void isCheckFromElephant (int x, int y, int *valide) {
    int i, j;

    for (i = y + 1, j = x + 1; i < 7 && j < 7 && !g.n.cm [i] [j]; i++, j++);
    valide = g.n.cm [i] [j] == -g.color && (abs (g.f.cm [j] [i] % 10)
           == ELEPHANT || abs (g.f.cm [j] [i] % 10) == QUEEN);

    for (i = y + 1, j = x - 1; i < 7 && j > 0 && !g.n.cm [i] [j]; i++, j--);
    valide = g.n.cm [i] [j] == -g.color && (abs (g.f.cm [j] [i] % 10)
           == ELEPHANT || abs (g.f.cm [j] [i] % 10) == QUEEN);

    for (i = y - 1, j = x + 1; i > 0 && j < 7 && !g.n.cm [i] [j]; i--, j++);
    valide = g.n.cm [i] [j] == -g.color && (abs (g.f.cm [j] [i] % 10)
           == ELEPHANT || abs (g.f.cm [j] [i] % 10) == QUEEN);

    for (i = y - 1, j = x - 1; i > 0 && j > 0 && !g.n.cm [i] [j]; i--, j--);
    valide = g.n.cm [i] [j] == -g.color && (abs (g.f.cm [j] [i] % 10)
           == ELEPHANT || abs (g.f.cm [j] [i] % 10) == QUEEN);
}

inline void isCheckFromRook (int x, int y, int *valide) {
    int i;

    for (i = x + 1; && i < 7 && !g.n.cm [y] [i]; i++);
    valide = abs (g.f.cm [y] [i] % 10) == ROOK
           || abs (g.f.cm [y] [i] % 10) == QUEEN;

    for (i = x - 1; i > 0 && !g.n.cm [y] [i]; i--);
    valide = abs (g.f.cm [y] [i] % 10) == ROOK
           || abs (g.f.cm [y] [i] % 10) == QUEEN;

    for (i = y + 1; i < 7 && !g.n.cm [y] [i]; i++);
    valide = abs (g.f.cm [i] [x] % 10) == ROOK
           || abs (g.f.cm [i] [x] % 10) == QUEEN;

    for (i = y - 1; i > 0 && !g.n.cm [y] [i]; i--);
    valide = abs (g.f.cm [i] [x] % 10) == ROOK
           || abs (g.f.cm [i] [x] % 10) == QUEEN;
}

inline void isCheckFromHorse (int x, int y, int *valide) {
    valide =       g.n.cm [y + 2] [x + 3] / 10 == -g.color
           && abs (g.n.cm [y + 2] [x + 3])     == HORSE
           ||      g.n.cm [y + 2] [x - 3] / 10 == -g.color
           && abs (g.n.cm [y + 2] [x - 3])     == HORSE
           ||      g.n.cm [y - 2] [x + 3] / 10 == -g.color
           && abs (g.n.cm [y - 2] [x + 3])     == HORSE
           ||      g.n.cm [y - 2] [x - 3] / 10 == -g.color
           && abs (g.n.cm [y - 2] [x - 3])     == HORSE
           ||      g.n.cm [y + 3] [x + 2] / 10 == -g.color
           && abs (g.n.cm [y + 3] [x + 2])     == HORSE
           ||      g.n.cm [y + 3] [x - 2] / 10 == -g.color
           && abs (g.n.cm [y + 3] [x - 2])     == HORSE
           ||      g.n.cm [y - 3] [x + 2] / 10 == -g.color
           && abs (g.n.cm [y - 3] [x + 2])     == HORSE
           ||      g.n.cm [y - 3] [x - 2] / 10 == -g.color
           && abs (g.n.cm [y - 3] [x - 2])     == HORSE;
}

inline void isCheckFromPawn (int x, int y, int *valide) {
    valide =  abs (g.n.cm [y + g.color] [x + 1]) == PAWN
           || abs (g.n.cm [y + g.color] [x - 1]) == PAWN;
}

Добавлено: 01 Декабря 2013 09:57:15 Добавил: Андрей Ковальчук

Самый быстрый алгоритм Евклида вычисления НОД

C#

Заинтересовал вопрос о различных реализациях алгоритма Евклида для неотрицательных целых чисел. Ниже привожу алгоритмы, собственноручно написанные, исходя из теоретического материала. Каждый алгоритм можно модифицировать в ту или иную сторону.

Считается, что бинарный алгоритм работает быстрее, но мои тесты показывают, что два первых алгоритма работают быстрее бинарного. Может ли кто перепроверить на скорость на своих компиляторах, а то очень интересно и не видится никаких преимуществ бинарного алгоритма.

Код C

//обычный алгоритм Евклида через остатки
long Nod(long a, long b)
{
    while (a && b)
        if (a >= b)
           a %= b;
        else
           b %= a;
    return a | b;
}


Код C
// Алгоритм Евклида через разности
long Nod(long a, long b)
{
    while (a && b)
        if (a >= b)
           a -= b;
        else
           b -= a;
    return a | b;
}

Код C
// Бинарный алгоритм Евклида
long Nod(long a, long b)
{
    long deg = 0;
    if (a == 0 || b == 0)
        return a | b;
    while (((a | b) & 1) == 0)
    {
        deg++;
        a >>= 1;
        b >>= 1;
    }
    while (a && b)
    {
        if (b & 1)
            while ((a & 1) == 0)
                a >>= 1;
        else
            while ((b & 1) == 0)
                b >>= 1;
        if (a >= b)
            a = (a - b) >> 1;
        else
            b = (b - a) >> 1;
    }
    return ((a | b) << deg);
}

Еще один бинарный алгоритм, но он самый медленный из всех предыдущих.
Код C
long Nod(long a, long b)
{
    long buf, deg = 0;
    if (a == 0 || b == 0)
        return a | b;
    while (((a | b) & 1) == 0)
    {
        deg++;
        a >>= 1;
        b >>= 1;
    }
    if (a)
        while ((a & 1) == 0)
            a >>= 1;
    while (b)
    {
        while ((b & 1) == 0)
            b >>= 1;
        if (a < b)
            b -= a;
        else
        {
            buf = a - b;
            a = b;
            b = buf;
        }
        b >>= 1;
    }
    return (a << deg);
}

Добавлено: 26 Сентября 2013 12:51:14 Добавил: Андрей Ковальчук

Задание 2

C#

using System;

namespace zadanie_2._1
{
	/// <summary>
	/// Извлечение корня n-ой степени: ввод исходных данных, проверка, вывод результата
	/// </summary>

	public class Program
	{
		public static void Main(string[] args)
		{
			string x, n;
			double number, exp;

			//Проверка на соответствие типу: До тех пор, пока число не будет типа double, повторять приглашение для ввода чисел
			do
			{
				System.Console.WriteLine("Извлечение корня n-ой степени");
				Console.Write("Введите подкоренное выражение:");
				x = Console.ReadLine();
				Console.Write("Введите степень корня:");
				n = Console.ReadLine();

				if (!double.TryParse(x, out number))
				{
					Console.WriteLine("Ошибка!");
				}

				if (!double.TryParse(n, out exp))
				{
					Console.WriteLine("Ошибка!");
				}

			}

			while (!double.TryParse(x, out number) || (!double.TryParse(n, out exp)));


			NewtonsMethod sqr = new NewtonsMethod();

			//Вывод результатов
			double x2 = sqr.sqrt(number, exp);
			Console.WriteLine("Результат (Метод Ньютона): " + x2.ToString());
			double x3 = Math.Pow(number, 1.0 / exp);
			Console.WriteLine("Результат (Метод MathPow): " + x3.ToString());
			Console.ReadKey();
		}
	}

	/// <summary>
	///  Метод Ньютона (метод касательных) для любых целых положительных степеней
	/// </summary>
	/// <param name="number">Число под корнем</param>
	/// <param name="exp">Степень корня</param>
	/// <param name="eps">Заданная точность</param>

	public class NewtonsMethod
	{
		public double sqrt(double number, double exp, double eps = 1e-15)
		{
			//Нулевая степень корня = 1
			if (number == 0) return 1;
			//Корень из нуля = 0
			else if (exp == 0) return number;

			double x0 = 1e-16; //начальное приближение

			while (true) //бесконечный цикл
			{
				double x1 = 1.0 / exp * ((exp - 1.0) * x0 + number / Math.Pow(x0, exp - 1));

				if (Math.Abs(x1 - x0) > eps) x0 = x1; //условия окончания вычислений
				else return x1;
			}
		}
	}
}

Добавлено: 22 Сентября 2013 09:56:16 Добавил: Андрей Ковальчук

Задание 1

C#

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO;
using System.Globalization;

namespace ConsoleApplication1
{
	/// <summary>
	/// Класс,который содержит функцию для работы с массивом строк
	/// </summary>

	public class stroki
	{
		/// <summary>
		/// Функция для работы со строками: считывание текстового файла, разбиение и форматирование строк
		/// </summary>
		/// <param name="args"></param>

		static void Main(string[] args)
		{
			decimal x, y;
			string line;

			System.IO.StreamReader file = new System.IO.StreamReader("1.txt");

			try
			{
				while ((line = file.ReadLine()) != null)
				{
					char[] seps = { ',' };
					string[] parts = line.Split(seps);

					if (decimal.TryParse(parts[0], out x))

						Console.Write("X:" + x.ToString("##.####", CultureInfo.CreateSpecificCulture("ru-RU")) + " ");

					else System.Console.WriteLine("Not decimal");

					if (decimal.TryParse(parts[1], out y))

						Console.WriteLine("Y:" + y.ToString("##.####", CultureInfo.CreateSpecificCulture("ru-RU")) + " ");

					else System.Console.Write("Not decimal");
				}
			}
			catch (IndexOutOfRangeException)
			{
				Console.WriteLine("Тип строки неправильный!");
			}

		}
	}
}



Добавлено: 22 Сентября 2013 09:55:15 Добавил: Андрей Ковальчук