Форум программистов, компьютерный форум CyberForum.ru

Выравнивание текста пробелами по ширине. - C++

Восстановить пароль Регистрация
 
Рейтинг: Рейтинг темы: голосов - 14, средняя оценка - 4.64
oglazirin
0 / 0 / 0
Регистрация: 19.05.2014
Сообщений: 3
19.05.2014, 15:58     Выравнивание текста пробелами по ширине. #1
Очень нужно написать решение на C++. Кто-нибудь может помочь? Я пытался 2 дня - ничего не получается

Задача

Вашей программе дается абзац текста. Этот текст состоит из ряда слов, отделенных друг от друга пробелами и/или символами новой строки (символы табуляции не применяются). Слово может содержать знаки пунктуации. Текст завершается специальным словом "$$$", которое будет единственным на последней строке.

Например, в тексте

The quick brown-fox jump$
over, the --- lazy
dog.
$$$

словами являются "The", "quick", "brown-fox", "jump$", "over,", "the", "---", "lazy", "dog.".

Последнее слово "$$$" рассматривать не нужно.
  • количество символов в каждой строке не превышало 30 (за исключением символа новой строки).
  • между двумя словами на одной строке должен быть хотя бы один пробел.
  • крайний левый символ строки не должен быть пустым
  • крайний правый символ строки не должен быть пустым за исключением, может быть, последней строки
  • пробелы должны быть распределены по возможности равномерно между всеми словами строки. Если этого нельзя сделать точно, то большая порция пробелов должна располагаться ближе к правому краю строки.

Последняя строка содержит единственное слово "$$$".

Гарантируется что:
слово "$$$" не встречается внутри текста абзаца
суммарная длина двух любых, подряд идущих слов, разделенных одним пробелом, не превышает w
длина одного слова не превышает 50 символов
количество слов в абзаце не превышает 5000
ширина окна не превышает 100.
Описание вывода

Выходной файл должен состоять из слов текста абзаца.

Не должно быть никаких пробелов в начале и конце файла.
Лучшие ответы (1)
Similar
Эксперт
41792 / 34177 / 6122
Регистрация: 12.04.2006
Сообщений: 57,940
19.05.2014, 15:58     Выравнивание текста пробелами по ширине.
Посмотрите здесь:

Дана строка текста, в которой слова разделены пробелами... C++
C++ Линейный список. выравнивание текста.
C++ выравнивание по ширине
Занесение текста с пробелами в файл C++
C++ Выравнивание текста
После регистрации реклама в сообщениях будет скрыта и будут доступны все возможности форума.
Ilot
Модератор
Эксперт С++
1765 / 1140 / 221
Регистрация: 16.05.2013
Сообщений: 3,017
Записей в блоге: 5
Завершенные тесты: 1
19.05.2014, 16:05     Выравнивание текста пробелами по ширине. #2
Покажите как вы пытались.
oglazirin
0 / 0 / 0
Регистрация: 19.05.2014
Сообщений: 3
19.05.2014, 16:22  [ТС]     Выравнивание текста пробелами по ширине. #3
Вообщем я нагуглил следующий код. В нем есть ошибки, но я сейчас пытаюсь понять как отредактировать его так, чтобы больше пробелов было справа...

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
#include <stdio.h>
#include <ctype.h>
#include <string.h>
 
void justifytext(char *mytext, int width);
void justifyline(char *line, int linewidth);
 
void main() {
 
    char sstr[] = "  ModelSim provides an Integrated Debug "
        "Environment that facilitates efficient design debug "
        "for SoC and FPGA based designs. This GUI has continuously "
        "evolved to include new windows and support for new languages. "
        "This application note aims to give an introduction to the "
        "ModelSim 6.0 debug environment. This environment is "
        "trilingual supporting designs based on VHDL, Verilog "
        "(all standards including SystemVerilog, Verilog 2001 "
        "and Verilog 1995), and SystemC. Subsequent releases of"
        " ModelSim will enable even more debug capabilities "
        "supporting higher levels of abstractions for verification"
        " and modeling in SystemVerilog and SystemC. In ModelSim"
        " 6.0, the GUI has been enhanced and is based on Multiple"
        " Document Interface (MDI) layout standard. In addition, "
        "the debug windows have been re-organized in such a way as"
        " to display design data and simulation results in an intuitive manner.";
 
    int twid;
    int slen = 0;
 
    slen = strlen(sstr); // Length of the input string
 
    printf("\nLength of your text : %d\n", slen);
 
    printf("Enter text width :");
    scanf("%d", &twid);
    printf("\nText Width %d\n", twid);
 
    justifytext(sstr, twid);
 
    printf("\n\n");
}
 
void justifytext(char *mytext, int width){
 
    char temp[100];//a string array for calling my second function
    int i, j, currenti, counter = 0;
 
    for (i = 0; isspace(mytext[i]); i++);        //if there is any space at the 
    memmove(mytext, &mytext[i], strlen(mytext));//beginning of the text, DELETED.
 
    i = 0;
    while (counter < (int)strlen(mytext)){//I choose such a control-loop, because I try
        //some other ways and this is most trustable.
 
        for (i, j = 0; j < width; i++, j++){//finding each parts of text to justify
            temp[j] = mytext[i];
        }
 
        for (i; !(isspace(mytext[i])); i--, j--);//I cannot sperate any word, 
        //looking for spaces
        currenti = i;                               //I will use it to start the next line
 
        for (i; isspace(mytext[i]); i--, j--);//This makes part of array suitable 
        //for my second function.
        counter = i; //for controlling loop     //my second function works for only 
        //strings that do not have spaces
        //neither at the begining nor at the end.
 
        for (++j; j < 100; j++) // only temp[++j] = '\0' is enough without for loop
            temp[j] = '\0';        // but this makes me relax
 
        justifyline(temp, width);
 
        i = currenti + 1;    // this is where I start to sperate next time
 
    }
}
 
void justifyline(char *line, int linewidth)
{
    char *temp;   // it for usage of strtok function
    int i, j, spaces = 0, spacestoshare = 0, equalshare = 0, extras = 0;
 
    for (i = 0; line[i] != '\0'; i++){  //counting spaces. Also this means likely 
        //how many words there
 
        if (isspace(line[i])){
            spaces++;
        }
    }
 
    spacestoshare = linewidth - strlen(line);
 
    if (spaces == 0){
        equalshare = spacestoshare + spaces; //if spaces zero, there is only a word means
        extras = 0;                        // I put all my spaces after the word. No extras
    }
 
    else {
        equalshare = (spacestoshare + spaces) / spaces;//How many spaces I will put between 
        //each word in equal
        extras = spacestoshare % spaces;           //Extra spaces to put
    }
 
    for (temp = strtok(line, " "); temp != NULL; temp = strtok(NULL, " ")){ //takes 
        //each word sperately
 
        printf("%s", temp); //first write one word
 
        for (j = 0; j < equalshare; j++) { // add spaces after the word
            putchar(' ');
        }
 
        if (extras != 0){ // if there is extra 
            putchar(' ');  //also add them
            extras--;
        }
 
    }
    putchar('\n');
}
jurok_85
226 / 209 / 70
Регистрация: 21.02.2013
Сообщений: 494
19.05.2014, 19:50     Выравнивание текста пробелами по ширине. #4
Сообщение было отмечено автором темы, экспертом или модератором как ответ
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
#include <iostream>
#include <vector>
#include <string>
#include <sstream>
#include <cctype>
 
using namespace std;
 
 
 
int main()
{
    string str("The quick brown-fox jump$ over, the --- lazy dog. $$$");
    stringstream ss(str);
 
    string temp;
    vector<string> vec;
    while(ss>> temp)
    {
 
        vec.push_back(temp);
    }
    vec.pop_back();
 
 
    int counter;
string line;
    for(size_t i = 0; i != vec.size(); i++)
    {
        line.clear();
        counter = 0;
        while(counter < 30)
        {
            counter += (int)vec[i].length();
            if(counter >= 30||i >= vec.size())
            break;
            line += vec[i];
            counter++;
             if(counter >= 30)
            break;
            line.push_back(' ');
            i++;
        }
 
        i--;
        int e = line.length();
 
        int j = 0;
 
 
                while(e < 30){
                while(!isspace(line[j]))
                 j++;
                if(j < line.length()-1){
                 line.insert(line.begin() + j, ' ');
                 e++;
                 if(e >= 30)
                 break;
                }
                 j++;
                 if(j == line.length())
                 j = 0;
                  j++;
                }
 
 
 
 
        cout << line << endl;
 
    }
 
 
 
 
    return 0;
}
oglazirin
0 / 0 / 0
Регистрация: 19.05.2014
Сообщений: 3
20.05.2014, 13:32  [ТС]     Выравнивание текста пробелами по ширине. #5
jurok_85 большое спасибо за код!
Mr.X
Эксперт С++
 Аватар для Mr.X
2799 / 1575 / 246
Регистрация: 03.05.2010
Сообщений: 3,656
21.05.2014, 08:23     Выравнивание текста пробелами по ширине. #6
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
/////////////////////////////////////////////////////////////////////////////////////////
//Задача
//
//Вашей программе дается абзац текста. Этот текст состоит из ряда слов, отделенных друг от друга 
//пробелами и/или символами новой строки (символы табуляции не применяются). Слово может содержать 
//знаки пунктуации. Текст завершается специальным словом "$$$", которое будет единственным на последней строке.
//
//Например, в тексте
//
//The quick brown-fox jump$
//over, the --- lazy
//dog.
//$$$
//
//словами являются "The", "quick", "brown-fox", "jump$", "over,", "the", "---", "lazy", "dog.".
//
//Последнее слово "$$$" рассматривать не нужно.
//
//количество символов в каждой строке не превышало 30 (за исключением символа новой строки).
//между двумя словами на одной строке должен быть хотя бы один пробел.
//крайний левый символ строки не должен быть пустым
//крайний правый символ строки не должен быть пустым за исключением, может быть, последней строки
//пробелы должны быть распределены по возможности равномерно между всеми словами строки. Если этого 
//нельзя сделать точно, то большая порция пробелов должна располагаться ближе к правому краю строки.
//
//
//Последняя строка содержит единственное слово "$$$".
//
//Гарантируется что:
//слово "$$$" не встречается внутри текста абзаца
//суммарная длина двух любых, подряд идущих слов, разделенных одним пробелом, не превышает w
//длина одного слова не превышает 50 символов
//количество слов в абзаце не превышает 5000
//ширина окна не превышает 100.
//Описание вывода
//
//Выходной файл должен состоять из слов текста абзаца.
//
//Не должно быть никаких пробелов в начале и конце файла.
/////////////////////////////////////////////////////////////////////////////////////////.
#include <algorithm>
#include <conio.h>
#include <cstdlib>
#include <ctime>
#include <deque>
#include <iostream>
#include <sstream>
#include <string>
#include <vector>
/////////////////////////////////////////////////////////////////////////////////////////
typedef std::string                 T_str;
typedef T_str                       T_word;
typedef std::deque  < T_word    >   T_words;
/////////////////////////////////////////////////////////////////////////////////////////
int     const   WISHFUL_LINE_LEN_   =   30;
int     const   MAX_WORD_LEN        =   50;
char    const   LINE_DELIM_SYMB     =   '\n';
char    const   SPACE_SYMB          =   ' ';
T_word  const   FINAL_WORD          =   "$$$";
/////////////////////////////////////////////////////////////////////////////////////////
class  T_text_word
{
    //-----------------------------------------------------------------------------------
    T_word  word_;
    bool    is_last_in_line_;
    int     end_spaces_count_;
    //-----------------------------------------------------------------------------------
public:
    //-----------------------------------------------------------------------------------
    T_text_word( T_word const   &   word )
        :
        word_               ( word  ),
        is_last_in_line_    ( true  ),
        end_spaces_count_   ()
    {}
    //-----------------------------------------------------------------------------------
    T_str  str()                const
    {
        T_str   res_str     =   word_;
 
        return      res_str
                +=  is_last_in_line_
                        ?   T_str( 1, LINE_DELIM_SYMB )
                        :   T_str( end_spaces_count_, SPACE_SYMB );
    }
    //-----------------------------------------------------------------------------------
    int  size()                 const
    {
        return  word_.size() + end_spaces_count_;
    }
    //-----------------------------------------------------------------------------------
    void  append_space()
    {
        ++end_spaces_count_;
        is_last_in_line_    =   false;
    }
    //-----------------------------------------------------------------------------------
    bool  is_last_in_line()     const
    {
        return  is_last_in_line_;
    }
    //-----------------------------------------------------------------------------------
};
/////////////////////////////////////////////////////////////////////////////////////////
typedef std::vector< T_text_word >  T_text_words;
/////////////////////////////////////////////////////////////////////////////////////////
class  T_text_line
{
    //-----------------------------------------------------------------------------------
    int             size_;
    T_text_words    text_words_;
    //-----------------------------------------------------------------------------------
public:
    //-----------------------------------------------------------------------------------
    T_text_line()
        :
        size_()
    {}
    //-----------------------------------------------------------------------------------
    void  fill_from( T_words&  words )
    {
        for(;;)
        {
            //Пробел пока не вставляем.
            text_words_.push_back
                (
                    T_text_word
                        (
                            words.front()
                        )
                );
 
            words.pop_front();
            size_  +=  text_words_.back().size();
 
            if  (
                        words.empty()
                    ||      size_ + words.front().size() + 1//Единица учитывает еще не вставленный пробел.
                        >   WISHFUL_LINE_LEN_
                )
            {
                break;
            }
            //Вставляем пробел.
            text_words_.back().append_space();
            ++size_;
        }//for
    }
    //-----------------------------------------------------------------------------------
    void  align()
    {
        auto    post_rbegin_it  =   text_words_.rbegin  ();
        ++post_rbegin_it;
 
        while   (
                        text_words_.size()  >   1
                    &&  size_               <   WISHFUL_LINE_LEN_
                )
        {
            for (
                    auto
                    text_word_rev_it    =   post_rbegin_it;
                    text_word_rev_it    !=  text_words_.rend    ();
                    ++text_word_rev_it
                )
            {
                text_word_rev_it->append_space();
                ++size_;
 
                if( size_ >= WISHFUL_LINE_LEN_ )
                {
                    break;
                }//if
            }//for
        }//while
    }
    //-----------------------------------------------------------------------------------
    T_str   str()   const
    {
        T_str   res_str;
 
        for (
                auto
                text_word_it    =   text_words_.begin   ();
                text_word_it    !=  text_words_.end     ();
                ++text_word_it
            )
        {
            res_str     +=   text_word_it->str();
        }
 
        return  res_str;
    }
    //-----------------------------------------------------------------------------------
};
/////////////////////////////////////////////////////////////////////////////////////////
typedef std::vector< T_text_line >  T_text_lines;
/////////////////////////////////////////////////////////////////////////////////////////
class  T_aligned_text
{
    //-----------------------------------------------------------------------------------
    T_words         words_;
    T_text_lines    text_lines_;
    //-----------------------------------------------------------------------------------
public:
    //-----------------------------------------------------------------------------------
    T_aligned_text( T_str   const   &   str )
    {
        fill_words          ( str );
        fill_text_lines     ();
        align_text_lines    ();
    }
    //-----------------------------------------------------------------------------------
    T_str   str()   const
    {
        T_str   res_str;
 
        for (
                auto
                text_line_it    =   text_lines_.begin   ();
                text_line_it    !=  text_lines_.end     ();
                ++text_line_it
            )
        {
            res_str     +=   text_line_it->str();
        }
 
        return  res_str;
    }
    //-----------------------------------------------------------------------------------
private:
    //-----------------------------------------------------------------------------------
    void  fill_words( T_str const   &   str )
    {
        std::istringstream  ssin( str );
        T_word              word;
 
        for(;;)
        {
            ssin    >>  word;
 
            if( word == FINAL_WORD )
            {
                break;
            }
 
            words_.push_back( word );
        }
    }
    //-----------------------------------------------------------------------------------
    void  fill_text_lines()
    {
        while   (
                    !words_.empty()
                )
        {
            T_text_line     text_line;
            text_line       .fill_from  ( words_    );
            text_lines_     .push_back  ( text_line );
        }//while
    }
    //-----------------------------------------------------------------------------------
    void  align_text_lines()
    {
        std::for_each
            (
                text_lines_.begin   (),
                text_lines_.end     (),
                std::mem_fun_ref    ( &T_text_line::align )
            );
    }
    //-----------------------------------------------------------------------------------
};
/////////////////////////////////////////////////////////////////////////////////////////
int  get_rand_spaces_or_word_size()
{
    int     res     =   rand() % MAX_WORD_LEN + 1;
    res /= ( rand() % 15 + 1 );
    return  ++res;
}
/////////////////////////////////////////////////////////////////////////////////////////
bool  successfully_input_word_from
    (
        T_word          &   word,
        std::istream    &   str_stream_from
    )
{
    bool    bool_res    =   true;
    size_t  word_size   =   get_rand_spaces_or_word_size();
 
    std::ostringstream  sout;
 
    while   (
                sout.str().size()   <   word_size
            )
    {
        if  (
                !( str_stream_from >> word )
            )
        {
            bool_res = false;
            break;
        }
        
        sout    <<  word;
    }//while
 
    word    =   sout.str().substr( 0, word_size );
    return  bool_res;
}
/////////////////////////////////////////////////////////////////////////////////////////
void  generate_text_from_str_to_str
    (
        T_str   const   &   str_from,
        T_str           &   str_to
    )
{
    std::istringstream  ssin( str_from );
    std::ostringstream  sout_for_text;
 
    for(;;)
    {
        if( rand() % 2 == 0 )
        {
            sout_for_text   <<  LINE_DELIM_SYMB;
        }
 
        sout_for_text   <<  T_str   (
                                        get_rand_spaces_or_word_size(),
                                        SPACE_SYMB
                                    );
 
        T_word  word;
 
        if  (
                successfully_input_word_from
                    (
                        word,
                        ssin
                    )
            )
        {
            sout_for_text   <<  word;
        }
        else
        {
            sout_for_text   <<  FINAL_WORD;
            break;
        }//else
    }//for
 
    sout_for_text   <<  T_str   (
                                    get_rand_spaces_or_word_size(),
                                    SPACE_SYMB
                                );
 
    str_to  =   sout_for_text.str();
}
/////////////////////////////////////////////////////////////////////////////////////////
void  print_prompt_and_text_str
    (
        T_str   const   &   prompt,
        T_str   const   &   str
    )
{
    std::cout   <<  prompt
                <<  str;
}
/////////////////////////////////////////////////////////////////////////////////////////
int  main()
{
    std::locale::global(std::locale(""));
    srand(unsigned(time(0)));
 
    T_str   raw_text_str
        =   "Все счастливые семьи похожи друг на друга,  каждая  несчастливая  семья"
            "несчастлива по-своему."
                 "Все смешалось в доме Облонских. Жена узнала, что  муж  был  в  связи  с"
            "бывшею в их доме француженкою-гувернанткой, и объявила мужу,  что  не  может"
            "жить с ним в одном доме.  Положение  это  продолжалось  уже  третий  день  и"
            "мучительно чувствовалось и  самими  супругами,  и  всеми  членами  семьи,  и"
            "домочадцами. Все члены семьи и домочадцы чувствовали, что нет  смысла  в  их"
            "сожительстве и что на каждом постоялом дворе случайно сошедшиеся люди  более"
            "связаны между собой, чем они, члены семьи и  домочадцы  Облонских.  Жена  не"
            "выходила из своих комнат, мужа третий день не  было  дома.  Дети  бегали  по"
            "всему дому, как потерянные; англичанка поссорилась с  экономкой  и  написала"
            "записку приятельнице, прося приискать ей новое место; повар ушел  еще  вчера"
            "со двора, во время обеда; черная кухарка и кучер просили расчета."
                 "На третий день после ссоры князь Степан Аркадьич Облонский - Стива, как"
            "его звали в свете, - в обычный час, то есть в восемь часов  утра,  проснулся"
            "не в спальне жены, а в своем кабинете, на  сафьянном  диване..  Он  повернул"
            "свое полное, выхоленное тело на пружинах дивана, как бы желая опять  заснуть"
            "надолго, с другой стороны крепко обнял подушку и прижался к  ней  щекой;  но"
            "вдруг вскочил, сел на диван и открыл глаза.";
 
    for(;;)
    {
        T_str   starting_text_str;
 
        generate_text_from_str_to_str
            (
                raw_text_str,
                starting_text_str
            );
 
        print_prompt_and_text_str
            (
                "\n\n\n\n\n\n\n\n\nИсходный текст:\n\n\n",
                starting_text_str
            );
 
        T_aligned_text  aligned_text    ( starting_text_str );
        T_str   final_text_str  =   aligned_text.str();
 
        print_prompt_and_text_str
            (
                "\n\n\n\n\n\n\n\n\nВыровненный текст:\n\n\n",
                final_text_str
            );
 
        getch();
    }//for
}
Yandex
Объявления
21.05.2014, 08:23     Выравнивание текста пробелами по ширине.
Ответ Создать тему
Опции темы

Текущее время: 03:53. Часовой пояс GMT +3.
КиберФорум - форум программистов, компьютерный форум, программирование
Powered by vBulletin® Version 3.8.9
Copyright ©2000 - 2016, vBulletin Solutions, Inc.
Рейтинг@Mail.ru