[Fork] [Fork] C# Class To Javascript Object | C# Online Compiler

[Fork] [Fork] C# Class To Javascript Object by mrdilbaz

using System.Collections.Generic;
using System;

public class CrosswordsAlgorithm
{

	public void Main(){
		
	}

	public List<CrossedWord> CrToShow = new List<CrossedWord>();
	float crosswordLength = float.MaxValue;
	int WordsPlaced = 0, crosswordMinX = 0, crosswordMinY = 0;
	Random random = new Random();
	public void GenerateCrossWords(List<string> words)
	{
		List<CrossedWord> fixedwordsList = new List<CrossedWord>();


 		foreach (string word in words)
		{
			fixedwordsList.Add(new CrossedWord(word, "0"));
		}


		// bulmacanin en son hali

		List<CrossedWord> CrossWordsToKeep = new List<CrossedWord>();

		 crosswordLength = float.MaxValue;
		 WordsPlaced = 0;
		 crosswordMinX = 0;
		 crosswordMinY = 0;

		// En iyi crosswordu belirleme dongusu

		for (int gen = 0; gen < fixedwordsList.Count; gen++)
		{
			// temel listeye dokunmuyoruz
			List<CrossedWord> allWords = new List<CrossedWord>(fixedwordsList);

			if (gen % 2 == 1)
			{
				// kelime listesini karistiriyoruz en dogru ve unique sonuclar olussun diye
				for (int j = allWords.Count - 1; j > 0; j--)
				{
					int r = random.Next(0, j + 1);
					CrossedWord tmp = allWords[r];
					allWords[r] = allWords[j];
					allWords[j] = tmp;
				}
			}
			else
			{
				allWords.Sort();
				allWords.Reverse();
			}

			// Son kelime bulmacasini yeniliyoruz
			List<CrossedWord> finalWords = new List<CrossedWord>();

			//bulunan ilk kelimeyi ekliyoruz
			finalWords.Add(new CrossedWord(allWords[0]));
			//bunu listeden siliyoruz
			allWords.RemoveAt(0);

			//ilk kelimenin yatay oldugunu farz edersek
			int minX = 0, maxX = finalWords[0].Size - 1, minY = 0, maxY = 0;

			// tum kelimeler icin bu donguyu kullanmaya devam ediyoruz
			int maxLoop = (int)(allWords.Count * allWords.Count);

			int z = 0;
			int i = 0;
			for (; 0 != allWords.Count && z < maxLoop; z++)
			{

				// yerlestirmek istedigimiz mevcut kelime
				CrossedWord currentWordToPlace = new CrossedWord(allWords[i]);


				// Yerlestirmeyi basardigimizi gosterdik
				bool bIsPlaced = false;

				//her zaman en iyi konumu bulmaya calisacagiz baslangic pozisyonumuzu seciyoruz
				Tile BestStartingPosition = new Tile(0, 0);
				CrossedWord.Direction BestDirection = CrossedWord.Direction.Horizontal;

				// hangi bulmacanin en iyi oldugunu bulmak icin buldugumuz tum bulmacalara skor veriyoruz
				float score = float.MaxValue;

				// bulmacadaki mevcut tum kelimeleri donguye aliyoruz
				for (int j = 0; j < finalWords.Count; j++)
				{
					//Yeni kelimeyi yerlestirmek icin kullanacagımız halihazırda yerlestirilmiş olan kelime
					CrossedWord currentWordPlaced = finalWords[j];

					// yeni kelimeyi mevcut olana gore yerlestireceksek,yenisi diger yone eklenecek
					currentWordToPlace.WordDirection = currentWordPlaced.WordDirection == CrossedWord.Direction.Horizontal ? CrossedWord.Direction.Vertical : CrossedWord.Direction.Horizontal;

					//Bize her harf icin (İlk harf icin dizi [0]) o anda yerlestirilen kelimenin aynı harfe sahip oldugu karoları veren bir dizi
					List<Tile>[] intersectionForEachLetter = currentWordPlaced.SimilarLetterTiles(currentWordToPlace);

					// tum harfler icin bu donguyu devam ettiriyoruz
					for (int k = 0; k < intersectionForEachLetter.Length; k++)
					{
						// Bir harf için tum tileleri ariyorum
						for (int l = 0; l < intersectionForEachLetter[k].Count; l++)
						{
							// tile aliyoruz
							Tile currentCommonTile = intersectionForEachLetter[k][l];

							// Yerlestirilen kelimenin yönü ve kesisme karosu göz önüne alındıgında, yeni kelime potansiyel başlangıç konumunu hesaplıyoruz
							if (currentWordPlaced.WordDirection == CrossedWord.Direction.Horizontal)
							{
								currentWordToPlace.StartingPosition = new Tile(currentCommonTile.X, currentCommonTile.Y - k);
							}
							else
							{
								currentWordToPlace.StartingPosition = new Tile(currentCommonTile.X - k, currentCommonTile.Y);
							}

							//Yeni kelimeyi istedigimiz yerin ,var olan kelimelerle celisip celismedigini kontrol etmek icin bulmacadaki
							// tum kelimelerin uzerinde bir dongu yapin int bize kac tane dogru kesisimimiz oldugunu soyler
							int iCanBePlaced = 0;
							//celiski olup olmagini gosterir
							bool bCanBePlaced = true;
							for (int m = 0; m < finalWords.Count && bCanBePlaced; m++)
							{
								// ca = 0, cakisma olmadigi anlamina gelir, -1 bir cakisma anlamina gelir, 1 iyi bir kesisim anlamina gelir
								int ca = finalWords[m].CanAccept(currentWordToPlace);
								if (ca > 0)
									iCanBePlaced += ca;
								if (ca == -1)
									bCanBePlaced = false;
							}

							// Yer iyi ve en az bir iyi donuse  sahip
							if (bCanBePlaced && iCanBePlaced > 0)
							{
								// En iyi yeri bulmak icin bir puan hesaplariz

								// ne kadar kesişme ama tam tersi değer
								int crossedNumber = (0 - iCanBePlaced);

								// ne kadar az olursa o kadar iyi olması gerekiyor
								float tmpScore = random.Next(0, 10) + crossedNumber * 100;

								// eger bu puan bir oncekinden daha iyi ise, bu pozisyonu koruruz ve bu kelimeyi en az bir kez yerlestirmeyi basardigimizi söyleriz.
								if (tmpScore < score)
								{
									bIsPlaced = true;

									// Yeni puani guncelleriz
									score = tmpScore;
									BestStartingPosition = currentWordToPlace.StartingPosition;
									BestDirection = currentWordToPlace.WordDirection;
								}
							}
						}
					}
				}
				// Bu yeni kelimeyi yerleştirmek için en az bir pozisyonumuz var
				if (bIsPlaced)
				{
					// bu kaydedilmis pozisyonu aliriz
					currentWordToPlace.StartingPosition = BestStartingPosition;
					currentWordToPlace.WordDirection = BestDirection;
					// bu kelimeyi crossworde ekleriz
					finalWords.Add(currentWordToPlace);

					// Izgara olusturmada daha rastgele faktorlere sahip olmak icin capraz bulmaca dizisini karistirmak (gercekten onemli degil, dogrusal islem bu yuzden sorun degil)
					for (int j = finalWords.Count - 1; j > 0; j--)
					{
						int r = random.Next(0, j + 1);
						CrossedWord tmp = finalWords[r];
						finalWords[r] = finalWords[j];
						finalWords[j] = tmp;
					}

					// Gerekirse izgara dikdörtgenini güncelleme
					minX = Math.Min(minX, currentWordToPlace.StartingPosition.X);
					minY = Math.Min(minY, currentWordToPlace.StartingPosition.Y);

					maxX = Math.Max(maxX, currentWordToPlace.WordDirection == CrossedWord.Direction.Horizontal ? currentWordToPlace.StartingPosition.X + currentWordToPlace.Size - 1 : currentWordToPlace.StartingPosition.X);
					maxY = Math.Max(maxY, currentWordToPlace.WordDirection == CrossedWord.Direction.Vertical ? currentWordToPlace.StartingPosition.Y + currentWordToPlace.Size - 1 : currentWordToPlace.StartingPosition.Y);

					allWords.RemoveAt(i);
					if (allWords.Count > 0)
						i = i % allWords.Count;
				}
				else
				{
					i = (i + 1) % allWords.Count;
				}
			}

			// Izgaranin son yeni uzunlugu
			float newLength = (float)Math.Sqrt((maxX - minX) * (maxX - minX) + (maxY - minY) * (maxY - minY));
			// Izgaraya koymayi basardigimiz son yeni kelime sayisi
			int currentWordsPlaced = finalWords.Count;

			// daha iyi bir izgaraysa (daha kucuk ve daha fazla kelime). Aslinda, icerdigi daha fazla kelime ile orantili olarak daha buyuk bir bulmacaya izin veriyoruz
			if (newLength - (currentWordsPlaced - WordsPlaced) * 4 < crosswordLength && WordsPlaced < currentWordsPlaced)
			{
				// bu gridi hafizada tutuyoruz
				CrossWordsToKeep = finalWords;
				// en iyi gridi hafizada tutuyoruz
				crosswordLength = newLength;
				WordsPlaced = currentWordsPlaced;

				crosswordMinX = minX;
				crosswordMinY = minY;
			}

		}

		for (int r = 0; r < CrossWordsToKeep.Count; r++)
		{
			CrossWordsToKeep[r].StartingPosition.X += Math.Abs(crosswordMinX);
			CrossWordsToKeep[r].StartingPosition.Y += Math.Abs(crosswordMinY);
		}

		CrToShow = CrossWordsToKeep;

	}

}

public class Tile {
	private int _x;
	private int _y;

	public int X {
		get {
			return this._x;
		}
		set {
			this._x = value;
		}
	}

	public int Y {
		get {
			return this._y;
		}
		set {
			this._y = value;
		}
	}

	public Tile(int x, int y) {
		this.X = x;
		this.Y = y;
	}

	public override bool Equals(Object obj) {
		if (obj == null) return false;

		Tile otherTile = obj as Tile;
		if (otherTile == null) {
			return false;
		} else {
			return this.X == otherTile.X && this.Y == otherTile.Y;
		}
	}

	public override int GetHashCode() {
		return this.X ^ this.Y;
	}

	public bool Equals(Tile t) {
		if (t == null) {
			return false;
		} else {
			return this.X == t.X && this.Y == t.Y;
		}
	}

}


public class CrossedWord : IComparable
{
	public enum Direction
	{
		Horizontal,
		Vertical
	}

	private string _word;
	private string _clue;

	private Tile _startingPosition;
	private Direction _wordDirection;


	public string Word
	{
		get {return this._word;}
		set {this._word = value;}
	}

	public string Clue
	{
		get {return this._clue;}
		set {this._clue = value;}
	}

	public int Size
	{
		get{return this._word.Length;}
	}

	public Tile StartingPosition
	{
		get{return this._startingPosition;}
		set{this._startingPosition = value;}
	}

	public Direction WordDirection
	{
		get{return this._wordDirection;}
		set{this._wordDirection = value;}
	}

	public CrossedWord(string word, string clue){
		this.Word = word;
		this.Clue = clue;
		this.WordDirection = Direction.Horizontal;
		this.StartingPosition = new Tile(0,0);
	}

	public CrossedWord(CrossedWord previous){
		this.Word = previous.Word;
		this.Clue = previous.Clue;
		this.WordDirection = previous.WordDirection;
		this.StartingPosition = new Tile(previous.StartingPosition.X, previous.StartingPosition.Y);
	}

	public int CompareTo(object obj)
	{
		if(obj == null) return 1;

		CrossedWord otherCrossWord = obj as CrossedWord;
		if(otherCrossWord != null)
		{
			return this.Size.CompareTo(otherCrossWord.Size);
		}
		else
		{
			throw new ArgumentException("Object is not a CrossedWord");
		}
	}

	//Eğer tile karo uzerinde degilse 0 dondur
	public char LetterOnTile(Tile t)
	{
		if(isWordOverTile(t))
		{
			switch(this.WordDirection)
			{
				case Direction.Horizontal : return this.Word[t.X - this.StartingPosition.X];
				case Direction.Vertical : return this.Word[t.Y - this.StartingPosition.Y];
				default : return '0';
			}
		}
		else
		{
			return '0';
		}
	}

	// kutucugu pozisyonun altına yerlestirme bolumu
	public Tile TileAtWordPosition(int pos)
	{
		if(pos >= 0 && pos < this.Size)
		{
			switch(this.WordDirection)
			{
				case Direction.Horizontal : return new Tile(this.StartingPosition.X + pos, this.StartingPosition.Y);
				case Direction.Vertical : return new Tile(this.StartingPosition.X, this.StartingPosition.Y + pos);
				default : throw new MissingMemberException("This Word has no direction");
			}
		}
		else
		{
			throw new ArgumentOutOfRangeException();
		}
	}

	// Kelimenin harflerinden birinin karoda olup olmadigini ogrenme bolumu
	public bool isWordOverTile(Tile t)
	{
		return (this.WordDirection == Direction.Horizontal && t.Y == this.StartingPosition.Y && t.X >= this.StartingPosition.X && t.X < this.StartingPosition.X + this.Size)
			|| (this.WordDirection == Direction.Vertical && t.X == this.StartingPosition.X && t.Y >= this.StartingPosition.Y && t.Y < this.StartingPosition.Y + this.Size) ;
	}

	// Array uzerine eklemeler yaptigimiz kisim (ayni harflerin kesistigi kisim)
	public List<Tile>[] SimilarLetterTiles(CrossedWord c)
	{
		List<Tile>[] tilesForEachLetter = new List<Tile>[c.Size];
		for(int i = 0; i< c.Size ; i++)
		{
			List<Tile> TilesForCurrentLetter = new List<Tile>();
			for(int j = 0; j<this.Size; j++)
			{
				if(c.Word[i] == this.Word[j])
					TilesForCurrentLetter.Add(this.TileAtWordPosition(j));
			}
			tilesForEachLetter[i] = TilesForCurrentLetter;
		}
		return tilesForEachLetter;
	}

	// Bulmaca kabul ediliyor mu kismidir bu kisim - ayni harfler vs.
	public int CanAccept(CrossedWord c)
	{
		// ikisi de HORIZONTAL
		if(this.WordDirection == Direction.Horizontal && c.WordDirection == Direction.Horizontal )

			// Aralarinda birden fazla bosluk ya da kutu varsa
			if( Math.Abs(c.StartingPosition.Y - this.StartingPosition.Y) > 1 )
				return 0;

		// Aralarinda birden fazla bosluk var ama bir baglantilari mevcut degilse
		if( Math.Abs(c.StartingPosition.Y - this.StartingPosition.Y) <= 1 && (this.StartingPosition.X > c.StartingPosition.X + c.Size || this.StartingPosition.X + this.Size < c.StartingPosition.X))
			return 2;

		// ikisi de  VERTICAL
		if(this.WordDirection == Direction.Vertical && c.WordDirection == Direction.Vertical )

			// Aralarinda birden fazla satir bosluk varsa
			if( Math.Abs(c.StartingPosition.X - this.StartingPosition.X) > 1  )
				return 0;

		// 1 satirdan az bosluk varsa ama herhangi bir baglantilari yoksa
		if ( Math.Abs(c.StartingPosition.X - this.StartingPosition.X)  <= 1  && (this.StartingPosition.Y > c.StartingPosition.Y + c.Size || this.StartingPosition.Y + this.Size < c.StartingPosition.Y))
			return 2;

		// INSTANCE HORIZONTAL ve digeri  VERTICAL
		if(this.WordDirection == Direction.Horizontal && c.WordDirection == Direction.Vertical)
		{
			Tile potentialIntersection = new Tile(c.StartingPosition.X, this.StartingPosition.Y);

			char instanceChar = this.LetterOnTile(potentialIntersection);
			char otherChar = c.LetterOnTile(potentialIntersection);
			// Eger benzer harf varsa
			if(this.isWordOverTile(potentialIntersection) && c.isWordOverTile(potentialIntersection) && instanceChar == otherChar)
			{
				if(instanceChar != '0')
					return 1;
				else
					return 0;
			}
			else if(instanceChar == '0' && (potentialIntersection.X < this.StartingPosition.X - 1 || potentialIntersection.X > this.StartingPosition.X + this.Size))
			{
				return 0;
			}
		}

		// INSTANCE VERTICAL ve digeri HORIZONTAL
		if(this.WordDirection == Direction.Vertical && c.WordDirection == Direction.Horizontal)
		{
			Tile potentialIntersection = new Tile(this.StartingPosition.X, c.StartingPosition.Y);

			char instanceChar = this.LetterOnTile(potentialIntersection);
			char otherChar = c.LetterOnTile(potentialIntersection);
			// Eger benzer harf varsa
			if(this.isWordOverTile(potentialIntersection) && c.isWordOverTile(potentialIntersection) && instanceChar == otherChar)
			{
				if(instanceChar != '0')
					return 1;
				else
					return 0;
			}
			else if(instanceChar == '0' && (potentialIntersection.Y < this.StartingPosition.Y - 1 || potentialIntersection.Y > this.StartingPosition.Y + this.Size))
			{
				return 0;
			}
		}


		return -1;
	}
}

​x
 
using System.Collections.Generic;
using System;
​
public class CrosswordsAlgorithm
{
​
    public void Main(){
        
    }
​
    public List<CrossedWord> CrToShow = new List<CrossedWord>();
    float crosswordLength = float.MaxValue;
    int WordsPlaced = 0, crosswordMinX = 0, crosswordMinY = 0;
    Random random = new Random();
    public void GenerateCrossWords(List<string> words)
    {
        List<CrossedWord> fixedwordsList = new List<CrossedWord>();
​
​
        foreach (string word in words)
        {
            fixedwordsList.Add(new CrossedWord(word, "0"));
        }
​
​
        // bulmacanin en son hali
​
        List<CrossedWord> CrossWordsToKeep = new List<CrossedWord>();
​
         crosswordLength = float.MaxValue;
         WordsPlaced = 0;
         crosswordMinX = 0;
         crosswordMinY = 0;
​
        // En iyi crosswordu belirleme dongusu
​
        for (int gen = 0; gen < fixedwordsList.Count; gen++)
        {
            // temel listeye dokunmuyoruz
            List<CrossedWord> allWords = new List<CrossedWord>(fixedwordsList);
​
            if (gen % 2 == 1)
            {
                // kelime listesini karistiriyoruz en dogru ve unique sonuclar olussun diye
                for (int j = allWords.Count - 1; j > 0; j--)
                {
                    int r = random.Next(0, j + 1);
                    CrossedWord tmp = allWords[r];
                    allWords[r] = allWords[j];
                    allWords[j] = tmp;
                }
            }
            else
            {
                allWords.Sort();
                allWords.Reverse();
            }
​
            // Son kelime bulmacasini yeniliyoruz
            List<CrossedWord> finalWords = new List<CrossedWord>();
​
            //bulunan ilk kelimeyi ekliyoruz
            finalWords.Add(new CrossedWord(allWords[0]));
            //bunu listeden siliyoruz
            allWords.RemoveAt(0);
​
            //ilk kelimenin yatay oldugunu farz edersek
            int minX = 0, maxX = finalWords[0].Size - 1, minY = 0, maxY = 0;
​
            // tum kelimeler icin bu donguyu kullanmaya devam ediyoruz
            int maxLoop = (int)(allWords.Count * allWords.Count);
​
            int z = 0;
            int i = 0;
            for (; 0 != allWords.Count && z < maxLoop; z++)
            {
​
                // yerlestirmek istedigimiz mevcut kelime
                CrossedWord currentWordToPlace = new CrossedWord(allWords[i]);
​
​
                // Yerlestirmeyi basardigimizi gosterdik
                bool bIsPlaced = false;
​
                //her zaman en iyi konumu bulmaya calisacagiz baslangic pozisyonumuzu seciyoruz
                Tile BestStartingPosition = new Tile(0, 0);
                CrossedWord.Direction BestDirection = CrossedWord.Direction.Horizontal;
​
                // hangi bulmacanin en iyi oldugunu bulmak icin buldugumuz tum bulmacalara skor veriyoruz
                float score = float.MaxValue;
​
                // bulmacadaki mevcut tum kelimeleri donguye aliyoruz
                for (int j = 0; j < finalWords.Count; j++)
                {
                    //Yeni kelimeyi yerlestirmek icin kullanacagımız halihazırda yerlestirilmiş olan kelime
                    CrossedWord currentWordPlaced = finalWords[j];
​
                    // yeni kelimeyi mevcut olana gore yerlestireceksek,yenisi diger yone eklenecek
                    currentWordToPlace.WordDirection = currentWordPlaced.WordDirection == CrossedWord.Direction.Horizontal ? CrossedWord.Direction.Vertical : CrossedWord.Direction.Horizontal;
​
                    //Bize her harf icin (İlk harf icin dizi [0]) o anda yerlestirilen kelimenin aynı harfe sahip oldugu karoları veren bir dizi
                    List<Tile>[] intersectionForEachLetter = currentWordPlaced.SimilarLetterTiles(currentWordToPlace);
​
                    // tum harfler icin bu donguyu devam ettiriyoruz
                    for (int k = 0; k < intersectionForEachLetter.Length; k++)
                    {
                        // Bir harf için tum tileleri ariyorum
                        for (int l = 0; l < intersectionForEachLetter[k].Count; l++)
                        {
                            // tile aliyoruz
                            Tile currentCommonTile = intersectionForEachLetter[k][l];
​
                            // Yerlestirilen kelimenin yönü ve kesisme karosu göz önüne alındıgında, yeni kelime potansiyel başlangıç konumunu hesaplıyoruz
                            if (currentWordPlaced.WordDirection == CrossedWord.Direction.Horizontal)
                            {
                                currentWordToPlace.StartingPosition = new Tile(currentCommonTile.X, currentCommonTile.Y - k);
                            }
                            else
                            {
                                currentWordToPlace.StartingPosition = new Tile(currentCommonTile.X - k, currentCommonTile.Y);
                            }
​
                            //Yeni kelimeyi istedigimiz yerin ,var olan kelimelerle celisip celismedigini kontrol etmek icin bulmacadaki
                            // tum kelimelerin uzerinde bir dongu yapin int bize kac tane dogru kesisimimiz oldugunu soyler
                            int iCanBePlaced = 0;
                            //celiski olup olmagini gosterir
                            bool bCanBePlaced = true;
                            for (int m = 0; m < finalWords.Count && bCanBePlaced; m++)
                            {
                                // ca = 0, cakisma olmadigi anlamina gelir, -1 bir cakisma anlamina gelir, 1 iyi bir kesisim anlamina gelir
                                int ca = finalWords[m].CanAccept(currentWordToPlace);
                                if (ca > 0)
                                    iCanBePlaced += ca;
                                if (ca == -1)
                                    bCanBePlaced = false;
                            }
​
                            // Yer iyi ve en az bir iyi donuse  sahip
                            if (bCanBePlaced && iCanBePlaced > 0)
                            {
                                // En iyi yeri bulmak icin bir puan hesaplariz
​
                                // ne kadar kesişme ama tam tersi değer
                                int crossedNumber = (0 - iCanBePlaced);
​
                                // ne kadar az olursa o kadar iyi olması gerekiyor
                                float tmpScore = random.Next(0, 10) + crossedNumber * 100;
​
                                // eger bu puan bir oncekinden daha iyi ise, bu pozisyonu koruruz ve bu kelimeyi en az bir kez yerlestirmeyi basardigimizi söyleriz.
                                if (tmpScore < score)
                                {
                                    bIsPlaced = true;
​
                                    // Yeni puani guncelleriz
                                    score = tmpScore;
                                    BestStartingPosition = currentWordToPlace.StartingPosition;
                                    BestDirection = currentWordToPlace.WordDirection;
                                }
                            }
                        }
                    }
                }
                // Bu yeni kelimeyi yerleştirmek için en az bir pozisyonumuz var
                if (bIsPlaced)
                {
                    // bu kaydedilmis pozisyonu aliriz
                    currentWordToPlace.StartingPosition = BestStartingPosition;
                    currentWordToPlace.WordDirection = BestDirection;
                    // bu kelimeyi crossworde ekleriz
                    finalWords.Add(currentWordToPlace);
​
                    // Izgara olusturmada daha rastgele faktorlere sahip olmak icin capraz bulmaca dizisini karistirmak (gercekten onemli degil, dogrusal islem bu yuzden sorun degil)
                    for (int j = finalWords.Count - 1; j > 0; j--)
                    {
                        int r = random.Next(0, j + 1);
                        CrossedWord tmp = finalWords[r];
                        finalWords[r] = finalWords[j];
                        finalWords[j] = tmp;
                    }
​
                    // Gerekirse izgara dikdörtgenini güncelleme
                    minX = Math.Min(minX, currentWordToPlace.StartingPosition.X);
                    minY = Math.Min(minY, currentWordToPlace.StartingPosition.Y);
​
                    maxX = Math.Max(maxX, currentWordToPlace.WordDirection == CrossedWord.Direction.Horizontal ? currentWordToPlace.StartingPosition.X + currentWordToPlace.Size - 1 : currentWordToPlace.StartingPosition.X);
                    maxY = Math.Max(maxY, currentWordToPlace.WordDirection == CrossedWord.Direction.Vertical ? currentWordToPlace.StartingPosition.Y + currentWordToPlace.Size - 1 : currentWordToPlace.StartingPosition.Y);
​
                    allWords.RemoveAt(i);
                    if (allWords.Count > 0)
                        i = i % allWords.Count;
                }
                else
                {
                    i = (i + 1) % allWords.Count;
                }
            }
​
            // Izgaranin son yeni uzunlugu
            float newLength = (float)Math.Sqrt((maxX - minX) * (maxX - minX) + (maxY - minY) * (maxY - minY));
            // Izgaraya koymayi basardigimiz son yeni kelime sayisi
            int currentWordsPlaced = finalWords.Count;
​
            // daha iyi bir izgaraysa (daha kucuk ve daha fazla kelime). Aslinda, icerdigi daha fazla kelime ile orantili olarak daha buyuk bir bulmacaya izin veriyoruz
            if (newLength - (currentWordsPlaced - WordsPlaced) * 4 < crosswordLength && WordsPlaced < currentWordsPlaced)
            {
                // bu gridi hafizada tutuyoruz
                CrossWordsToKeep = finalWords;
                // en iyi gridi hafizada tutuyoruz
                crosswordLength = newLength;
                WordsPlaced = currentWordsPlaced;
​
                crosswordMinX = minX;
                crosswordMinY = minY;
            }
​
        }
​
        for (int r = 0; r < CrossWordsToKeep.Count; r++)
        {
            CrossWordsToKeep[r].StartingPosition.X += Math.Abs(crosswordMinX);
            CrossWordsToKeep[r].StartingPosition.Y += Math.Abs(crosswordMinY);
        }
​
        CrToShow = CrossWordsToKeep;
​
    }
​
}
​
public class Tile {
    private int _x;
    private int _y;
​
    public int X {
        get {
            return this._x;
        }
        set {
            this._x = value;
        }
    }
​
    public int Y {
        get {
            return this._y;
        }
        set {
            this._y = value;
        }
    }
​
    public Tile(int x, int y) {
        this.X = x;
        this.Y = y;
    }
​
    public override bool Equals(Object obj) {
        if (obj == null) return false;
​
        Tile otherTile = obj as Tile;
        if (otherTile == null) {
            return false;
        } else {
            return this.X == otherTile.X && this.Y == otherTile.Y;
        }
    }
​
    public override int GetHashCode() {
        return this.X ^ this.Y;
    }
​
    public bool Equals(Tile t) {
        if (t == null) {
            return false;
        } else {
            return this.X == t.X && this.Y == t.Y;
        }
    }
​
}
​
​
public class CrossedWord : IComparable
{
    public enum Direction
    {
        Horizontal,
        Vertical
    }
​
    private string _word;
    private string _clue;
​
    private Tile _startingPosition;
    private Direction _wordDirection;
​
​
    public string Word
    {
        get {return this._word;}
        set {this._word = value;}
    }
​
    public string Clue
    {
        get {return this._clue;}
        set {this._clue = value;}
    }
​
    public int Size
    {
        get{return this._word.Length;}
    }
​
    public Tile StartingPosition
    {
        get{return this._startingPosition;}
        set{this._startingPosition = value;}
    }
​
    public Direction WordDirection
    {
        get{return this._wordDirection;}
        set{this._wordDirection = value;}
    }
​
    public CrossedWord(string word, string clue){
        this.Word = word;
        this.Clue = clue;
        this.WordDirection = Direction.Horizontal;
        this.StartingPosition = new Tile(0,0);
    }
​
    public CrossedWord(CrossedWord previous){
        this.Word = previous.Word;
        this.Clue = previous.Clue;
        this.WordDirection = previous.WordDirection;
        this.StartingPosition = new Tile(previous.StartingPosition.X, previous.StartingPosition.Y);
    }
​
    public int CompareTo(object obj)
    {
        if(obj == null) return 1;
​
        CrossedWord otherCrossWord = obj as CrossedWord;
        if(otherCrossWord != null)
        {
            return this.Size.CompareTo(otherCrossWord.Size);
        }
        else
        {
            throw new ArgumentException("Object is not a CrossedWord");
        }
    }
​
    //Eğer tile karo uzerinde degilse 0 dondur
    public char LetterOnTile(Tile t)
    {
        if(isWordOverTile(t))
        {
            switch(this.WordDirection)
            {
                case Direction.Horizontal : return this.Word[t.X - this.StartingPosition.X];
                case Direction.Vertical : return this.Word[t.Y - this.StartingPosition.Y];
                default : return '0';
            }
        }
        else
        {
            return '0';
        }
    }
​
    // kutucugu pozisyonun altına yerlestirme bolumu
    public Tile TileAtWordPosition(int pos)
    {
        if(pos >= 0 && pos < this.Size)
        {
            switch(this.WordDirection)
            {
                case Direction.Horizontal : return new Tile(this.StartingPosition.X + pos, this.StartingPosition.Y);
                case Direction.Vertical : return new Tile(this.StartingPosition.X, this.StartingPosition.Y + pos);
                default : throw new MissingMemberException("This Word has no direction");
            }
        }
        else
        {
            throw new ArgumentOutOfRangeException();
        }
    }
​
    // Kelimenin harflerinden birinin karoda olup olmadigini ogrenme bolumu
    public bool isWordOverTile(Tile t)
    {
        return (this.WordDirection == Direction.Horizontal && t.Y == this.StartingPosition.Y && t.X >= this.StartingPosition.X && t.X < this.StartingPosition.X + this.Size)
            || (this.WordDirection == Direction.Vertical && t.X == this.StartingPosition.X && t.Y >= this.StartingPosition.Y && t.Y < this.StartingPosition.Y + this.Size) ;
    }
​
    // Array uzerine eklemeler yaptigimiz kisim (ayni harflerin kesistigi kisim)
    public List<Tile>[] SimilarLetterTiles(CrossedWord c)
    {
        List<Tile>[] tilesForEachLetter = new List<Tile>[c.Size];
        for(int i = 0; i< c.Size ; i++)
        {
            List<Tile> TilesForCurrentLetter = new List<Tile>();
            for(int j = 0; j<this.Size; j++)
            {
                if(c.Word[i] == this.Word[j])
                    TilesForCurrentLetter.Add(this.TileAtWordPosition(j));
            }
            tilesForEachLetter[i] = TilesForCurrentLetter;
        }
        return tilesForEachLetter;
    }
​
    // Bulmaca kabul ediliyor mu kismidir bu kisim - ayni harfler vs.
    public int CanAccept(CrossedWord c)
    {
        // ikisi de HORIZONTAL
        if(this.WordDirection == Direction.Horizontal && c.WordDirection == Direction.Horizontal )
​
            // Aralarinda birden fazla bosluk ya da kutu varsa
            if( Math.Abs(c.StartingPosition.Y - this.StartingPosition.Y) > 1 )
                return 0;
​
        // Aralarinda birden fazla bosluk var ama bir baglantilari mevcut degilse
        if( Math.Abs(c.StartingPosition.Y - this.StartingPosition.Y) <= 1 && (this.StartingPosition.X > c.StartingPosition.X + c.Size || this.StartingPosition.X + this.Size < c.StartingPosition.X))
            return 2;
​
        // ikisi de  VERTICAL
        if(this.WordDirection == Direction.Vertical && c.WordDirection == Direction.Vertical )
​
            // Aralarinda birden fazla satir bosluk varsa
            if( Math.Abs(c.StartingPosition.X - this.StartingPosition.X) > 1  )
                return 0;
​
        // 1 satirdan az bosluk varsa ama herhangi bir baglantilari yoksa
        if ( Math.Abs(c.StartingPosition.X - this.StartingPosition.X)  <= 1  && (this.StartingPosition.Y > c.StartingPosition.Y + c.Size || this.StartingPosition.Y + this.Size < c.StartingPosition.Y))
            return 2;
​
        // INSTANCE HORIZONTAL ve digeri  VERTICAL
        if(this.WordDirection == Direction.Horizontal && c.WordDirection == Direction.Vertical)
        {
            Tile potentialIntersection = new Tile(c.StartingPosition.X, this.StartingPosition.Y);
​
            char instanceChar = this.LetterOnTile(potentialIntersection);
            char otherChar = c.LetterOnTile(potentialIntersection);
            // Eger benzer harf varsa
            if(this.isWordOverTile(potentialIntersection) && c.isWordOverTile(potentialIntersection) && instanceChar == otherChar)
            {
                if(instanceChar != '0')
                    return 1;
                else
                    return 0;
            }
            else if(instanceChar == '0' && (potentialIntersection.X < this.StartingPosition.X - 1 || potentialIntersection.X > this.StartingPosition.X + this.Size))
            {
                return 0;
            }
        }
​
        // INSTANCE VERTICAL ve digeri HORIZONTAL
        if(this.WordDirection == Direction.Vertical && c.WordDirection == Direction.Horizontal)
        {
            Tile potentialIntersection = new Tile(this.StartingPosition.X, c.StartingPosition.Y);
​
            char instanceChar = this.LetterOnTile(potentialIntersection);
            char otherChar = c.LetterOnTile(potentialIntersection);
            // Eger benzer harf varsa
            if(this.isWordOverTile(potentialIntersection) && c.isWordOverTile(potentialIntersection) && instanceChar == otherChar)
            {
                if(instanceChar != '0')
                    return 1;
                else
                    return 0;
            }
            else if(instanceChar == '0' && (potentialIntersection.Y < this.StartingPosition.Y - 1 || potentialIntersection.Y > this.StartingPosition.Y + this.Size))
            {
                return 0;
            }
        }
​
​
        return -1;
    }
}

Enter number to test

Cached Result
Last Run:	10:18:13 am
Compile:	0.401s
Execute:	0s
Memory:	32kb
CPU:	0.016s

View IL Code