示例#1
0
        } // End main()

        /*-----------------------------------------------------------------------
        *   Greedy Algorithm (Non-optimal i.e. approximate or heuristic solution)
        *  -----------------------------------------------------------------------*/

        /**
         *  As an example only, write out the file directly to the output with _simple_ wrapping,
         *  i.e. adding spaces between words and moving to the next line if a word would go past the
         *  indicated column number C.  This will fail if any word length exceeds the column limit C,
         *  but it still goes ahead and just puts one word on that line.
         */
        private static int WrapSimply(IQueueInterface <String> words, int columnLength, String outputFilename)
        {
            StreamWriter sw              = null;
            int          col             = 1;
            int          spacesRemaining = 0;



            try
            {
                sw = new StreamWriter(outputFilename);
            }
            catch (FileNotFoundException)
            {
                Console.WriteLine("Cannot create or open " + outputFilename +
                                  " for writing.  Using standard output instead.");
                sw = new StreamWriter(Console.OpenStandardOutput());
            }

            // Running count of spaces left at the end of lines
            while (!words.IsEmpty())
            {
                String str = words.Peek();
                int    len = str.Length;
                // See if we need to wrap to the next line
                if (col == 1)
                {
                    sw.Write(str);
                    col += len;
                    words.Pop();
                }
                else if ((col + len) >= columnLength)
                {
                    // go to the next line
                    sw.WriteLine();
                    spacesRemaining += (columnLength - col) + 1;
                    col              = 1;
                }
                else
                {   // Typical case of printing the next word on the same line
                    sw.Write(" ");
                    sw.Write(str);
                    col += (len + 1);
                    words.Pop();
                }
            }
            sw.WriteLine();

            sw.Flush();
            sw.Close();
            return(spacesRemaining);

            Console.ReadKey();
        } // end wrapSimply
示例#2
0
        } // End main()

        /*-----------------------------------------------------------------------
        *   Greedy Algorithm (Non-optimal i.e. approximate or heuristic solution)
        *  -----------------------------------------------------------------------*/
        private static int WrapSimply(IQueueInterface <String> Words, int ColumnLength, String OutputFilename)
        {
            StreamWriter Outp;

            Outp = null;
            try
            {
                Outp = new StreamWriter(OutputFilename);
            }
            catch (FileNotFoundException)
            {
                System.Console.WriteLine("Cannot create or " +
                                         "open " + OutputFilename +
                                         " for writing.  Using standard output instead.");
            }

            int Col             = 1;
            int spacesRemaining = 0;            // Running count of spaces left at the end of lines

            while (!Words.IsEmpty())
            {
                String str = Words.Peek();
                int    Len = str.Length;
                // See if we need to wrap to the next line
                if (Col == 1)
                {
                    Outp.Write(str);
                    Col += Len;
                    Words.Pop();
                }
                else if ((Col + Len) >= ColumnLength)
                {
                    // go to the next line
                    Outp.WriteLine();
                    spacesRemaining += (ColumnLength - Col) + 1;
                    Col              = 1;
                }
                else
                {   // Typical case of printing the next word on the same line
                    Outp.Write(" ");
                    Outp.Write(str);
                    Col += (Len + 1);
                    Words.Pop();
                }
            }
            Outp.WriteLine();
            Outp.Close();
            return(spacesRemaining);
        } // end wrapSimply
        } // End main()

        /*-----------------------------------------------------------------------
        *   Greedy Algorithm (Non-optimal i.e. approximate or heuristic solution)
        *  -----------------------------------------------------------------------*/

        /**
         *  As an example only, write out the file directly to the output with _simple_ wrapping,
         *  i.e. adding spaces between words and moving to the next line if a word would go past the
         *  indicated column number C.  This will fail if any word length exceeds the column limit C,
         *  but it still goes ahead and just puts one word on that line.
         */
        private static int wrapSimply(IQueueInterface <String> words, int columnLength, String outputFilename)
        {
            //Writing into file, setting writeFile to null
            System.IO.TextWriter writeFile = null;
            //Testing for errors
            try
            {
                writeFile = new StreamWriter(outputFilename);
            }
            catch (FileNotFoundException e)
            {
                Console.Write("Cannot create or open " + outputFilename +
                              " for writing.  Using standard output instead.");
            }

            int col             = 1;
            int spacesRemaining = 0;            // Running count of spaces left at the end of lines

            while (!words.IsEmpty())
            {
                string str = words.Peek();
                int    len = str.Length;
                // See if we need to wrap to the next line
                if (col == 1)
                {
                    writeFile.Write(str);
                    col += len;
                    words.Pop();
                }
                else if ((col + len) >= columnLength)
                {
                    // go to the next line
                    writeFile.Write(Environment.NewLine);
                    spacesRemaining += (columnLength - col) + 1;
                    col              = 1;
                }
                else
                {   // Typical case of printing the next word on the same line
                    writeFile.Write(" ");
                    writeFile.Write(str);
                    col += (len + 1);
                    words.Pop();
                }
            }
            writeFile.Write(Environment.NewLine);
            writeFile.Flush();
            writeFile.Close();
            return(spacesRemaining);
        } // end wrapSimply
示例#4
0
        private static int WrapSimply(IQueueInterface <string> words, int columnLength, string outputFilename)
        {
            StreamWriter writerOut = new StreamWriter(outputFilename);

            try
            {
                writerOut.Flush();
                writerOut.Close();
                StreamWriter streamWriter = writerOut = new StreamWriter(outputFilename);
            }
            catch (FileNotFoundException)
            {
                Console.WriteLine("Cannon create or open " + outputFilename + " for writing. Using standard output instead.");
            }

            int col             = 1;
            int spacesRemaining = 0;

            while (!words.IsEmpty())
            {
                String str = words.Peek();
                int    len = str.Length;
                //Console.WriteLine(len);
                if (col == 1)
                {
                    writerOut.Write(str);
                    col += len;
                    words.Pop();
                }
                else if ((col + len) >= columnLength)
                {
                    writerOut.WriteLine();
                    spacesRemaining += (columnLength - col + 1);
                    col              = 1;
                }
                else
                {
                    writerOut.Write(" ");
                    writerOut.Write(str);
                    col += (len + 1);
                    words.Pop();
                }
            }
            writerOut.WriteLine();
            writerOut.Flush();
            writerOut.Close();
            return(spacesRemaining);
        }
        }   // END OF MAIN()

        //===============================================================================

        //                               +++++++++

        //===============================================================================
        //                  our Greedy Word-Wrapping Algorithm
        //    it's non-optimal -- i.e., it's an approximate or heuristic solution
        //-------------------------------------------------------------------------------
        /// <summary>
        ///     this takes the words in our LinkedQueue, called 'words',
        ///     and word-wraps them to the given width (col-width)
        /// </summary>
        /// <param name="words">
        ///     our LinkedQueue with all the words from our inputFileName
        ///     file, tokenized by whitespace
        /// </param>
        /// <param name="columnLength">
        ///     how wide do we want our text? at what point do we wrap?
        /// </param>
        /// <param name="outputFileName">
        ///     the file that we're writing our word-wrapped results to
        /// </param>
        /// <returns></returns>
        ///------------------------------------------------------------
        private static int WrapSimply(IQueueInterface <string> words,
                                      int columnLength, string outputFileName)
        {
            StreamWriter output;

            try
            {
                // this is the one we'll be using in the big while-loop
                output = new StreamWriter(outputFileName);
            }
            catch (System.IO.FileNotFoundException ex)
            {
                Console.WriteLine("can't create or open " + outputFileName +
                                  " to write to..... using standard output instead!");
                using (output = new StreamWriter(Console.OpenStandardOutput()))
                {
                    Console.WriteLine("\nhere is your wrapped text:\n");
                }
                throw ex;
            }
            //---------------------------------------------------------

            // the vertical character location/space
            int col = 1;

            // running count of spaces left at the ends of the lines
            int spacesRemaining = 0;

            // as long as we've still got words in the LinkedQueue,
            // keep right on popping & wrapping.....
            while (!words.IsEmpty())
            {
                // assign the next word in the LinkedQueue to 'str'
                string str = words.Peek();
                // get the length of that word
                int strLength = str.Length;

                // do we need to wrap to next line?
                if (col == 1)
                {
                    output.Write(str);
                    col += strLength;
                    words.Pop();
                }
                // go to the next line.....
                else if ((col + strLength) >= columnLength)
                {
                    output.WriteLine(" "); // drop to next line
                    spacesRemaining += (columnLength - col) + 1;
                    col              = 1;  // reset this!
                }
                // the usual case of printing next word on same line:
                else
                {
                    output.Write(" ");  // put a space between each word
                    output.Write(str);
                    col += (strLength + 1);
                    words.Pop();
                }
            } // end while-loop!
            //---------------------------------------------------------
            output.WriteLine();
            output.Flush();
            output.Close(); // since we didn't use 'using' for this, we have to
                            // 'flush' and close Streamwriter ourselves
            return(spacesRemaining);
        }                   // end of wrapSimply() function