段落中的 \hbox 未满(不良率 10000):删除 `\\` 并仍然具有正确的预期效果

段落中的 \hbox 未满(不良率 10000):删除 `\\` 并仍然具有正确的预期效果

我收到以下错误消息:

Underfull \vbox (badness 10000) has occurred while \output is active [78]
Underfull \hbox (badness 10000) in paragraph at lines 3836--3837

Underfull \vbox (badness 10000) has occurred while \output is active [79]
Underfull \hbox (badness 10000) in paragraph at lines 3853--3854 [80]
Underfull \hbox (badness 10000) in paragraph at lines 3901--3902

Underfull \hbox (badness 10000) in paragraph at lines 3915--3920

Underfull \hbox (badness 10000) in paragraph at lines 3921--3922

Underfull \vbox (badness 10000) has occurred while \output is active [81]

Underfull \hbox (badness 10000) in paragraph at lines 3950--3951

Underfull \hbox (badness 10000) in paragraph at lines 3956--3957

Underfull \hbox (badness 10000) in paragraph at lines 3961--3963

Underfull \hbox (badness 10000) in paragraph at lines 3963--3964

Underfull \hbox (badness 10000) in paragraph at lines 3974--3975 [82]
Underfull \hbox (badness 10000) in paragraph at lines 4028--4029

Underfull \hbox (badness 10000) in paragraph at lines 4054--4057

Underfull \hbox (badness 10000) in paragraph at lines 4073--4078

Underfull \hbox (badness 10000) in paragraph at lines 4082--4086

Underfull \hbox (badness 10000) in paragraph at lines 4087--4088

Underfull \vbox (badness 10000) has occurred while \output is active [83]
Underfull \hbox (badness 10000) in paragraph at lines 4093--4097

Underfull \hbox (badness 10000) in paragraph at lines 4112--4113

Underfull \hbox (badness 10000) in paragraph at lines 4114--4115


Underfull \vbox (badness 10000) has occurred while \output is active [84]
Underfull \hbox (badness 10000) in paragraph at lines 4148--4151


Underfull \hbox (badness 10000) in paragraph at lines 4156--4157


Underfull \vbox (badness 3872) has occurred while \output is active [85]
Underfull \hbox (badness 10000) in paragraph at lines 4173--4178

Underfull \hbox (badness 10000) in paragraph at lines 4179--4183 [86] [87] [88] Chapitre 5.

Underfull \hbox (badness 10000) in paragraph at lines 4261--4262

Underfull \hbox (badness 10000) in paragraph at lines 4269--4270

Underfull \hbox (badness 10000) in paragraph at lines 4270--4271

Underfull \hbox (badness 10000) in paragraph at lines 4272--4273

Underfull \hbox (badness 1077) in paragraph at lines 4286--486
 []|$\OML/ztmcm/m/it/10 Q$ $\OMS/ztmcm/m/n/10 ^^B$|

Underfull \hbox (badness 2050) in paragraph at lines 4286--4286
 []|$\OT1/ztmcm/m/n/10 ^^F$|

Underfull \hbox (badness 1924) in paragraph at lines 4286--4286
 []|$\OML/ztmcm/m/it/10 Q$|
[89]
Underfull \hbox (badness 10000) in paragraph at lines 4292--4294

Underfull \hbox (badness 10000) in paragraph at lines 4337--4339 [90] [91] [92]
Underfull \hbox (badness 10000) in paragraph at lines 4494--4495

我尝试使用

\usepackage{parskip}

但它不能修复错误消息。

我已经在这里检查了许多关于此错误消息的问题Underfull \vbox (badness 10000) has occurred while,但没有一个能帮助我解决错误。

下面是重现错误消息的代码示例:

\documentclass[11pt]{book}
\usepackage[paperwidth=20cm, paperheight=29cm]{geometry}
\usepackage[T1]{fontenc}
\usepackage[french]{babel}
\usepackage{qtree}
\usepackage{xcolor}
\usepackage{hyperref}
\usepackage{caption}
\usepackage{parskip}

\begin{document}

            \begin{enumerate}
                \item [] \textbf{Phase 1: analyse lexicale}
                    Les jetons de l'expression précédente sont identifiés ainsi qu'il suit par l'analyseur lexical:

            L'analyseur lexical établit ensuite l'arbre de dérivation de cette dernière expression obtenue. Cet arbre est représenté ainsi:

                \begin{figure}  
                    \Tree [.= 
                                    [.$id_1$ ]
                                    [.+
                                        [.$id_2$ ]
                                        [.$^*$ 
                                            [.$id_3$ ]
                                            [.50 ] 
                                            ] ] ] 
                \end{figure}

            L'arbre de dérivation généré est transmis à l'analyseur syntaxique.
\\
            \item [] \textbf{Phase 2: analyse syntaxique}
\\

            L'analyseur syntaxique reçoit en entrée l'arbre de dérivation élaboré précédemment et vérifie si l'expression analysée est dans le bon ordre et est correcte selon les règles de grammaire du langage.

            Si l'arbre de dérivation a été fait correctement alors la syntaxe de la phase 2 est sans erreur.

            Si la syntaxe de l'arbre est correcte alors le processus de compilation se poursuit à la phase suivante. Sinon un message d'erreur de syntaxe est généré.

                \Tree [.= 
                                [.$id_1$ ]
                                [.+
                                    [.$id_2$ ]
                                    [.$^*$ 
                                        [.$id_3$ ]
                                        [.50 ] 
                                        ] ] ] 

            \item [] \textbf{Phase 3: analyse sémantique}
\\

            \item [] \textbf{Phase 4: génération du code intermédiaire}
\\

            \item [] \textbf{Phase 5: optimisation de code}
\\

                Il y a des redondances dans le code issu de la phase précédente. Il faut l'optimiser. De 4 instructions on passe à 2 instructions ainsi qu'il suit:
                
                L'instruction de conversion du nombre 50 en réel a disparu, mais à cette étape le processus de conversion est déjà effectué.

            \item [] \textbf{Phase 4: génération du code machine}
                \begin{verbatim}
                    MOV R2, id_3
                    MUL R2, #50
                    MOV R1, id_2
                    ADD R1, R2
                    MOV id_1, R1
                \end{verbatim}
            \end{enumerate}

~\\         \begin{enumerate}
                \item Les langages réguliers de type 3, sont strictement contenus dans les langages algébriques, de type 2;
                \item Les langages algébriques propres, de type 2, sont strictement contenus dans les langages contextuels, de type 1;
                \item les langages contextuels, de type 1, sont strictement contenus dans les langages récursifs;
                \item les langages récursifs sont strictement contenus dans les langages récursivement énumérables, de type 0.
            \end{enumerate}

            Exemples de mots:
~\\

            Les langages algébriques propres, de type 2, sont strictement contenus dans les langages contextuels, de type 1;
            les langages contextuels, de type 1, sont strictement contenus dans les langages récursifs;

~\\
            En outre, dans le cas de l'interprétation, le code généré est multi-plateforme, il suffit que les utilisateurs disposent de l'interpréteur sur leur ordinateur. Par exemple, en considérant le cas du langage JavaScript, tous les utilisateurs d'un ordinateur disposent d'un navigateur web sur leur poste de travail. Dans le navigateur web, est incorporé un interpréteur JavaScript. Donc si un code source écrit.

            ~\\
            Ensuite, un autre avantage à utiliser un interpréteur, c'est que le programme écrit est très facile à tester. 


~\\         \begin{enumerate}
                \item Les langages réguliers de type 3, sont strictement contenus dans les langages algébriques, de type 2;
                \item Les langages algébriques propres, de type 2, sont strictement contenus dans les langages contextuels, de type 1;
                \item les langages contextuels, de type 1, sont strictement contenus dans les langages récursifs;
                \item les langages récursifs sont strictement contenus dans les langages récursivement énumérables, de type 0.
            \end{enumerate}

            ~\\

            lang.age = langage

        La concaténation et le produit sont associatifs, distributifs à droite et à gauche pour l'union et sont nonncommutatifs. L’élément neutre du produit est $\epsilon$ et l'élément absorbant $\emptyset$.

            En outre, dans le cas de l'interprétation, le code généré est multi-plateforme, il suffit que les utilisateurs disposent de l'interpréteur sur leur ordinateur. Par exemple, en considérant le cas du langage JavaScript, tous les utilisateurs d'un ordinateur disposent d'un navigateur web sur leur poste de travail. Dans le navigateur web, est incorporé un interpréteur JavaScript. Donc si un code source écrit.

            ~\\
                    Imaginons que nous lisons un programme et faisons ce qu'il dit de faire étape par étape

~\\             Avec $\delta$ définie ainsi qu'il suit:
~\\
                $\delta = \{\\
                \delta (s, 0) = t, \\
                \delta (s, 1) = t, \\
                \delta (s, 2) = t, \\
                \delta (t, 0) = s, \\
                \delta (t, 1) = s, \\
                \delta (t, 2) = s$ \\ \}

~\\         Dessinez l'automate correspondant.\\
~\\         Quel est le langage de mots reconnus par cet automate?
~\\
                \emph{Réponse:} \\

                Cet automate reconnaît l'ensemble des mots de longueur impair, formés de 0, 1, 2.\\

                Dessinez l'automate qui reconnaît ce langage de mots: \\
~\\
                \emph{Réponse:} \\
\end{document}

谢谢。

在发布问题之前,我已经阅读了 3 个建议答案链接。问题是,如果我简单地删除所\\引用答案中的建议,文本就无法垂直缩进以便根据需要阅读。

正如附件显示的是我想要得到的显示。在此处输入图片描述

答案1

你使用 LaTeX 就像使用文字处理器一样。但它不是。

\documentclass[11pt]{book}
\usepackage[paperwidth=20cm, paperheight=29cm]{geometry}
\usepackage[T1]{fontenc}
\usepackage[french]{babel}
\usepackage{amsmath}
\usepackage{qtree}
\usepackage{xcolor}
\usepackage{caption}
\usepackage{parskip}
\usepackage{hyperref}

\newcommand{\phase}[1]{\par\medskip\textbf{#1}\par\nopagebreak}


\begin{document}

\phase{Phase 1: analyse lexicale}

Les jetons de l'expression précédente sont identifiés ainsi qu'il suit par l'analyseur lexical:

L'analyseur lexical établit ensuite l'arbre de dérivation de cette dernière expression 
obtenue. Cet arbre est représenté ainsi:
\[
  \Tree [.= 
         [.$id_1$ ]
          [.+
           [.$id_2$ ]
           [.$^*$ 
            [.$id_3$ ]
            [.50 ] 
           ]
          ]
         ] 
\]
L'arbre de dérivation généré est transmis à l'analyseur syntaxique.

\phase{Phase 2: analyse syntaxique}

L'analyseur syntaxique reçoit en entrée l'arbre de dérivation élaboré 
précédemment et vérifie si l'expression analysée est dans le bon ordre 
et est correcte selon les règles de grammaire du langage.

Si l'arbre de dérivation a été fait correctement alors la syntaxe de la phase 2 est sans erreur.

Si la syntaxe de l'arbre est correcte alors le processus de compilation se poursuit 
à la phase suivante. Sinon un message d'erreur de syntaxe est généré.
\[
                \Tree [.= 
                                [.$id_1$ ]
                                [.+
                                    [.$id_2$ ]
                                    [.$^*$ 
                                        [.$id_3$ ]
                                        [.50 ] 
                                        ] ] ] 
\]
\phase{Phase 3: analyse sémantique}

\phase{Phase 4: génération du code intermédiaire}

\phase{Phase 5: optimisation de code}

Il y a des redondances dans le code issu de la phase précédente. Il faut l'optimiser. 
De 4 instructions on passe à 2 instructions ainsi qu'il suit:
                
L'instruction de conversion du nombre 50 en réel a disparu, mais à cette étape le 
processus de conversion est déjà effectué.

\phase{Phase 4: génération du code machine}
\begin{verbatim}
    MOV R2, id_3
    MUL R2, #50
    MOV R1, id_2
    ADD R1, R2
    MOV id_1, R1
\end{verbatim}

\begin{enumerate}
\item Les langages réguliers de type 3, sont strictement contenus dans 
les langages algébriques, de type 2;

\item Les langages algébriques propres, de type 2, sont strictement 
contenus dans les langages contextuels, de type 1;

\item les langages contextuels, de type 1, sont strictement contenus 
dans les langages récursifs;

\item les langages récursifs sont strictement contenus dans les langages 
récursivement énumérables, de type 0.
\end{enumerate}

Exemples de mots:\par\nopagebreak

Les langages algébriques propres, de type 2, sont strictement contenus 
dans les langages contextuels, de type 1; les langages contextuels, 
de type 1, sont strictement contenus dans les langages récursifs;

En outre, dans le cas de l'interprétation, le code généré est multi-plateforme, 
il suffit que les utilisateurs disposent de l'interpréteur sur leur ordinateur. 
Par exemple, en considérant le cas du langage JavaScript, tous les utilisateurs 
d'un ordinateur disposent d'un navigateur web sur leur poste de travail. Dans 
le navigateur web, est incorporé un interpréteur JavaScript. Donc si un code source écrit.

Ensuite, un autre avantage à utiliser un interpréteur, c'est que le programme 
écrit est très facile à tester. 


\begin{enumerate}
\item Les langages réguliers de type 3, sont strictement contenus dans 
les langages algébriques, de type 2;

\item Les langages algébriques propres, de type 2, sont strictement 
contenus dans les langages contextuels, de type 1;

\item les langages contextuels, de type 1, sont strictement contenus 
dans les langages récursifs;

\item les langages récursifs sont strictement contenus dans les langages 
récursivement énumérables, de type 0.
\end{enumerate}

lang.age = langage

La concaténation et le produit sont associatifs, distributifs à droite 
et à gauche pour l'union et sont nonncommutatifs. L’élément neutre du 
produit est $\epsilon$ et l'élément absorbant $\emptyset$.

En outre, dans le cas de l'interprétation, le code généré est multi-plateforme, 
il suffit que les utilisateurs disposent de l'interpréteur sur leur ordinateur. 
Par exemple, en considérant le cas du langage JavaScript, tous les utilisateurs 
d'un ordinateur disposent d'un navigateur web sur leur poste de travail. Dans 
le navigateur web, est incorporé un interpréteur JavaScript. Donc si un code 
source écrit.

Imaginons que nous lisons un programme et faisons ce qu'il dit de faire étape par étape

Avec $\delta$ définie ainsi qu'il suit:
\[
  \begin{aligned}
    \delta = \{&\\
               & \delta (s, 0) = t, \\
               & \delta (s, 1) = t, \\
               & \delta (s, 2) = t, \\
               & \delta (t, 0) = s, \\
               & \delta (t, 1) = s, \\
               & \delta (t, 2) = s \\
             \}
  \end{aligned}
\]
Dessinez l'automate correspondant.

Quel est le langage de mots reconnus par cet automate?

\emph{Réponse:}

Cet automate reconnaît l'ensemble des mots de longueur impair, formés de 0, 1, 2.

Dessinez l'automate qui reconnaît ce langage de mots:

\emph{Réponse:}

\end{document}

在此处输入图片描述

相关内容