辛苦了几个月的工作，我觉得我只想向老板的脸大喊大叫。但是，我不是直接面对遇到问题的人的人。我也不想丢掉工作。

所以这是一个主意：我希望能够侮辱他，而不会发现他。我意识到了一种完美的方法：我需要某种软件来编码本来是完美的消息中的侮辱。看到他是众所周知的看不见树木的森林，我想我知道如何：

写给我一个程序，该程序将一个未知长度的字符串作为输入，但不包含换行符。这将是我要发送的原始消息。

如果可能，返回格式化的字符串，以使消息“ DIE IN A GREASE FIRE”构成整个左列。在新的段落中，单词之间应留有空格。现在，由于我非常生气，每个字母都大写同样重要。

您不能以任何其他方式修改字符串，即，您不能将所有字符串都变成大写字符。

如果不能以这种方式格式化所讨论的字符串，则应返回原始字符串。从标准输入读取输入。

适用一般规则：无需HTTP请求，无需THGTTG咨询Marvin等。

输入示例：

亲爱的老板，最近怎么样？引起我注意的是，上个星期五，我为这次不幸事件受到了所有责备。不只是大多数。每一刻。我以为团队的其他成员至少应该承担部分责任，对我来说是错误的吗？毕竟，我们所有人都从一开始就参与其中。不是说我认为我应该不受责。一点也不。我要说的是：我尽力而为。我努力 我不断进步。而且我一直在承担责任。总的来说，我对自己的行为负全部责任。但是在今年春天之后，看来我得到了应得的收益。还记得Flakenhauser合同吗？一切都像人们希望的那样顺利进行。大概乍一看。直到最后一刻，一切都崩溃了。所有团队都同意，这更像是一场怪胎事故，而不是草率的计划或管理不善的资源。不过，我一个人-对此负责。即使我当时什么也没说，但当时我对责备的容忍度却严重降低了。从那时起，我觉得有必要始终加倍努力，以免受到审查。而且，我们又来了。尽管我取得了所有成就。就在这些天我们似乎总是会结束的地方。每个项目。它变得难以忍受。只是为了逃避审查。而且，我们又来了。尽管有我所有的成就。就在这些天我们似乎总是会结束的地方。每个项目。它变得难以忍受。只是为了逃避审查。而且，我们又来了。尽管有我所有的成就。就在这些天我们似乎总是会结束的地方。每个项目。它变得难以忍受。

输出示例：

亲爱的老板，最近怎么样？
引起我注意的是，上个星期五，我为这次不幸事件受到了所有责备。不只是大多数。
每一刻。

我以为团队的其他成员至少应该承担部分责任，对我来说是错误的吗？毕竟，我们所有人都从一开始就参与其中。
不是说我认为我应该不受责。一点也不。

我要说的是：我尽力而为。我努力 我不断进步。而且我一直在承担责任。

总的来说，我对自己的行为负全部责任。但是在今年春天之后，看来我得到了应得的收益。
记住Flakenhauser合同。
一切都像人们希望的那样顺利进行。大概乍一看。直到最后一刻，一切都崩溃了。
所有团队都同意，这更像是一场怪胎事故，而不是草率的计划或管理不善的资源。
不过，我一个人-对此负责。
即使我当时什么也没说，但我对受到指责的容忍度却严重降低了。

从那时起，我觉得有必要始终加倍努力，以免受到审查。而且，我们又来了。
尽管我取得了所有成就。
就在这些天我们似乎总是会结束的地方。
每个项目。它变得难以忍受。

这是代码高尔夫。最短的代码胜出。

CJam，56 53字节

q_"DIEIINAAGGREASEFFIRE"{S@:A+S@+#:BA<AB>}%(!B)*\N*@?

在线尝试！

这个怎么运作

q_                     Read all input from STDIN and push a copy.
"DIEIINAAGGREASEFFIRE" Push the characters we're searching for in form of a
                       string. We'll try to prepend a linefeed to all of them.
                       Some characters are duplicated to prepend two linefeeds.
{                      For every character C in that string:
  S@                   Push ' ' and rotate the string on the stack on top of it.
  :A                   Save the string (initially the input) in A.
  +                    Prepend the space to A.
  S@+                  Construct the string " C".
  #                    Compute the index of " C" in the modified A.
  :B                   Save the index in the variable B.
  A<                   Push the substring of A up to the index.
  AB>                  Push the substring of A after the index.
}%
(                      Shift the first element of the resulting array.
!                      Compute the logical NOT. This pushes 1 if and only if the
                       array's first element is an empty string, which is true
                       if and only if the input string started with a D.
B)                     Push the last value of B and increment. If the last match
                       was successful and, therefore, all matches were successful,
                       B != -1, so B + 1 != 0.
*                      Compute the product of the two topmost items on the stack.
\                      Swap the resulting Booleanr with the array of substrings.
N*                     Join the array, separating by linefeeds.
@                      Rotate the input string on top of the stack.
?                      Select the joined array if the Boolean is 1 and the input
                       string otherwise.

Perl-60个字节

#!perl -p
$_=(join$/,$_=~('DIE\IN\A\GREASE\FIRE'=~s/./($&.*)/gr))||$_

把shebang算作一个。

此解决方案使用最里面的字符串来构建以下正则表达式：

(D.*)(I.*)(E.*)(\.*)(I.*)(N.*)(\.*)(A.*)(\.*)(G.*)(R.*)(E.*)(A.*)(S.*)(E.*)(\.*)(F.*)(I.*)(R.*)(E.*)

这类似于m.buettner解决方案中使用的正则表达式。然后将生成的正则表达式与输入进行匹配。在列表上下文中，这将返回一个包含每个匹配组的数组，这些匹配组通过换行符连接在一起（“不匹配”组的原因(\.*)是要插入额外的换行符）。如果不匹配，则输出原始字符串。

Perl-73个字节

#!perl -pl
$s=$_}for(map$s!~s/.*?(?=$_)//?$\='':$&,'DIEI.NA.G.REASEF.IRE$'=~/./g){

把shebang算作两个。

这将在适当的定界符处分割字符串，并将片段收集为数组。如果它们中的任何一个都不匹配，则未设置输出记录分隔符（已使用该-l选项将其设置为换行符），因此该字符串的输出未修改。

GolfScript，53个字节

看起来像丹尼斯和我并行提出了非常相似的内容……但这是我的尝试。

单击每个代码块之前的链接以在线尝试。不幸的是，在线解释器不允许您运行大于1024个字符的代码，因此我不得不对测试输入内容进行“压缩”。但是它仍然有效。

压版

..(\;68=(>"IEIINAAGGREASEFFIRE"{1$.@?:^<n@^>}/](]^0<=

未经压缩的评论版本

.       # (Save input)
.(\;    # Get first character
68=(>   # If 'D', work with input; else, work with one-character string
"IEIINAAGGREASEFFIRE"
{       # For each character
 1$.@   # (Duplicate message twice)
 ?:^    # Find first index of character
 <n     # Extract part before index and add a newline
 @^>    # Extract part including and after index as new "message"
}/      # (Close loop)
](]^0<= # If last line was successfully matched, select result; else, select input

丹尼斯提出的观点：所有GolfScript程序都会打印一条自动的最终换行符。我不确定这是否会使我的解决方案无效。我相信，通过"":n在末尾添加一些内容来抑制最后的换行符将花费4个字符。

红宝石-140

a="DIEINAGREASEFIRE";n=[4,6,7,13];i=0;o='';s=ARGV[0]
s.chars.each{|c|
if c==a[i]
i+=1;o+="\n";o+="\n"if n-[i]!=n
end
o<<c
}
puts((i<16)?s:o)

在此没有正则表达式。它同时在ARGV [0]输入中遍历字符，并包含一个字符串，其中包含我们需要折断以产生左列消息的字符。原本打算在需要换行的字母后面加上空格，但是发现硬编码插入换行符的索引要短一些。

一切都说完之后，它会检查i索引是否增加了足够的次数以遍历需要打破的每个字母。如果没有，我们只打印出原始字符串。如果有，我们给他们格式化的。

n-[i]!=n在检查当前索引是否需要额外的换行符（与相比n.include? i）时，这是一种保存字符的巧妙技巧。还使用{}s而不是do/end多行块来保存一些字符，并且在最后一个put上使用三元条件来保存字符，以确定要输出哪个字符。

不是最短的，但是我认为没有正则表达式会很整洁。

Perl，184个字节

对于Perl而言，这并不是一个惊人的成绩，但这是一个简单的正则表达式解决方案

$_=<>;s/^(D.*) (I.*) (E.*) (I.*) (N.*) (A.*) (G.*) (R.*) (E.*) (A.*) (S.*) (E.*) (F.*) (I.*) (R.*) E/$1\n$2\n$3\n\n$4\n$5\n\n$6\n\n$7\n$8\n$9\n$10\n$11\n$12\n\n$13\n$14\n$15\nE/;print;

JavaScript的116

m-buettner想法的Javascript实现

console.log((RegExp('^('+[...'DIE IN A GREASE FIRE$'].join('.*)(')+')').exec(z=prompt())||[,z]).slice(1).join('\n'))

测试片段

z="Dear Boss, how are things? It has come to my attention that I received all the blame for the mishap last Friday. Not just the majority of it. Every last bit of it. Is it wrong for me to think that the rest of the team were at least in part responsible? After all, all six of us were involved from the get-go. Not that I think I should stand without blame. Not at all. All I'm saying is this: I do my best. I try hard. I improve constantly. And I am constantly taking responsibility. Generally speaking, I am very okay with taking full responsibility for my actions. But after this spring, it seems I get more than I deserve. Remember the Flakenhauser contract? Everything went down just about as smooth as one could have hoped. Or so it seemed at first. It was just at the very last minute that things fell apart. All of the team agreed that it was more akin to a freak accident than sloppy planning or mismanaged resources. Still, I - alone - took blame for it. Even though I said nothing then, my tolerance level for taking the blame took a serious dent then. From that point on, I have felt it necessary to always try twice as hard, just to escape scrutiny. And still, here we are again. In spite of all my accomplishments. Right where we always seem to end up these days. Every single project. It's becoming unbearable.";

T1.textContent = (RegExp('^('+[...'DIE IN A GREASE FIRE$'].join('.*)(')+')').exec(z)|| [,z]).slice(1).join('\n')

z='From that FIFA point on'
T2.textContent = (RegExp('^('+[...'DIE IN A GREASE FIRE$'].join('.*)(')+')').exec(z)|| [,z]).slice(1).join('\n')

pre { border: 1px solid black }

T1<pre id=T1></pre>
T2 (the FIFA test)<pre id=T2></pre>

Python3（166 138）

打高尔夫球：

s='';o=input()
for n in o.split():s+=[n,'\n'+n.title()][n[0]==("DIEINAGREASEFIRE"*len(o))[s.count('\n')]]+' '
print([o,s][s.count('\n')==16])

空洞的：

format_s = ''
unformat_s = input()
for n in unformat_s.split():
    format_s += [n, '\n' + n.title()][n[0] == ("DIEINAGREASEFIRE"*len(unformat_s))[format_s.count('\n')]] + ' '
print([unformat_s, format_s][format_s.count('\n') == 16])

尽管使用lambda使我有些满意，但是使用的大量变量和有些混乱的发展却产生了相反的效果。正则表达式也可能是一个好主意。Hay ho，至少它有效:)。

编辑：用count内置替换lambda变量，并缩短了split语句。

Python3（165）

def c(m,h,l=[]):
 if h:s=m.rindex(h[0]);l=[m[s:]]+l;return c(m[:s],h[1:],l)
 return[m]+l
i=input()
try:print('\n'.join(c(i,"ERIF ESAERG A NI EID")))
except:print(i)

不打高尔夫球

def headings_remaining(headings): return len(headings) > 0
def head(s): return s[0]
def tail(s): return s[1:]
def prepend(l,e): l.insert(0, e)
def reverse(s): return s[::-1]

def chunk(message,headings,output_list=[]):
    if headings_remaining(headings):
        split_index = message.rindex(head(headings))
        message_init = message[:split_index]
        message_last = message[split_index:]

        prepend(output_list, message_last)
        return chunk(message_init, tail(headings), output_list)
    else:
        prepend(output_list, message)
        return output_list

input_message=input()
try:
    headings=reverse("DIE IN A GREASE FIRE")
    print('\n'.join(chunk(input_message,headings)))
except ValueError: # Couldn't keep splitting chunks because didn't find heading
    print(input_message)

说明

chunk 以递归方式拆分包含最后一个标题的消息末尾，并将其添加到列表中。

注意：如果出于某种原因，如果您的信中的两个建议标题之间没有空格，这将不起作用，但是在给老板的信中似乎不太可能。

红宝石115

n,a,c,i=[4,6,7,13],gets,'',0;a.chars{|x|x=='DIEINAGREASEFIRE'[i]?(i+=1;c+="\n"if n-[i]!=n;c+="\n#{x}"):c+=x};puts c

红宝石95

a,c,i=gets,"",0;a.chars{|x|x=="DIEINAGREASEFIRE"[i]?(i+=1;c+="\n#{x}"):(c+=x)};puts c

的J - 110个 103字节

为什么J没有好的函数来处理字符串，而只有数组函数？如果我发现一些聪明的地方，我会进行修改。

编辑：缩短并固定输出（之前有多余的空格）并检查。我也改进了解释。

f=:[:>,&.>/@('IEIINAAGGREASEFFIRE'&t=:(}.@[t{.@[(}:@],(((0{I.@E.)({.;LF;}.)])>@{:))])`]@.(0=#@[))@< ::]

说明：

我将函数用法表示为[<left argument>] <function name> <right argument>，例如f <text>。我也不会解释每个细节，因为该功能很长。

@ 将右功能应用于左功能，例如 f@g x == f(g(x))

t=:(}.@[t{.@[(}:@],(((0{I.@E.)({.;LF;}.)])>@{:))])']@.(0=#@[) 是一个递归函数 <delimiters> t <boxed string>，它使用每个定界符按顺序分割字符串。如果找不到某些定界符，则失败。

(((0{I.@E.)({.;LF;}.)])>@{:) 从定界符的左侧分割字符串，并在它们之间添加换行符。

>@{: 从列表中获取最后一个字符串（尚未拆分的字符串）

0{I.@E. 获取要分割的索引，如果分隔符不存在，则失败。

{.;LF;}. 连接拆分的左侧，换行符和拆分的右侧

}:@], 连接先前分割的结果和最后一个函数的结果（最后一个含义：查找）

']@.(0=#@[)检查是否还有定界符，如果有则调用上述函数（5行）。否则返回。

'IEIINAAGGREASEFFIRE'&将的左参数t设置为该字符串

[:>,&.>/@ 结合分裂的结果

::] 如果失败（我将搜索分割索引作为薄弱点），则返回原始字符串。

示例（时间太长？）：

   f 'Dear Boss, how are things? It has come to my attention that I received all the blame for the mishap last Friday. Not just the majority of it. Every last bit of it. Is it wrong for me to think that the rest of the team were at least in part responsible? After all, all six of us were involved from the get-go. Not that I think I should stand without blame. Not at all. All I''m saying is this: I do my best. I try hard. I improve constantly. And I am constantly taking responsibility. Generally speaking, I am very okay with taking full responsibility for my actions. But after this spring, it seems I get more than I deserve. Remember the Flakenhauser contract? Everything went down just about as smooth as one could have hoped. Or so it seemed at first. It was just at the very last minute that things fell apart. All of the team agreed that it was more akin to a freak accident than sloppy planning or mismanaged resources. Still, I - alone - took blame for it. Even though I said nothing then, my tolerance lev...
Dear Boss, how are things? 
It has come to my attention that I received all the blame for the mishap last Friday. Not just the majority of it. 
Every last bit of it. 

Is it wrong for me to think that the rest of the team were at least in part responsible? After all, all six of us were involved from the get-go. 
Not that I think I should stand without blame. Not at all. 

All I'm saying is this: I do my best. I try hard. I improve constantly. And I am constantly taking responsibility. 

Generally speaking, I am very okay with taking full responsibility for my actions. But after this spring, it seems I get more than I deserve. 
Remember the Flakenhauser contract? 
Everything went down just about as smooth as one could have hoped. Or so it seemed at first. It was just at the very last minute that things fell apart. 
All of the team agreed that it was more akin to a freak accident than sloppy planning or mismanaged resources. 
Still, I - alone - took blame for it. 
Even though I said nothing then, my tolerance level for taking the blame took a serious dent then. 

From that point on, 
I have felt it necessary to always try twice as hard, just to escape scrutiny. And still, here we are again. In spite of all my accomplishments. 
Right where we always seem to end up these days. 
Every single project. It's becoming unbearable.
   f 'Die in a grease fire. It''s fun. Every time.'
Die in a grease fire. It's fun. Every time.
   f 'hai'
hai

的JavaScript（ES6），93个 115字节

alert(prompt(x=[...'DIEI1NA1G1REASEF1IRE',i=0]).replace(/\b./g,a=>i<20&&a.match(x[i])?(+x[++i]?i++&&`

`:`
`)+a:a))

我过去经常使用replace匹配项来/\b./g逐步查找字符串，以便仅找到在空格后或字符串开头的字符。然后，我检查了每个字符，看它是否与我要查找的数组中的当前索引匹配，如果匹配，则在它之前添加一个换行符，然后递增i。

编辑：错过了在单词之间创建换行符的需要。我现在已经完成了，将其提高到115。

PHP，328字节

给定一个名为“ G”的文件，其中包含“ enmessage”的原始文本

<?php
$a=implode(file("G"));$b=str_split('DIEINAGREASEFIRE');foreach(array_unique($b) as $c){foreach(str_split($a) as $h=>$d){if($c==$d)$l[$c][]=$h;}}$e=-1;$n=$a;foreach($b as $f=>$c){foreach($l as $j=>$m){if($c==$j){foreach($m as $k=>$h){if($h>$e){$n=substr($n,0,$h)."\n".$c.substr($a,$h+1);$e=$h+2;break 2;}}}}}echo nl2br($n);

说明（〜ungolfed &&注释代码）：

<?php
$string=implode(file("G"));          // raw text to deal with
$msg=str_split('DIEINAGREASEFIRE');  // hidden message (make it an array)

 // 2D array : [letters of the message][corresponding positions in txt]
foreach(array_unique($msg) as $letter) {
    foreach (str_split($string) as $pos=>$let) {
        if ($letter==$let) $l[$letter][]=$pos; //1 array per seeked letter with its positions in the string
    }
}

$currentPos=-1;
$newString=$string;
foreach ($msg as $key=>$letter) { // deal with each letter of the desired message to pass
    foreach($l as $cap=>$arrPos) {// search in letters list with their positions
        if($letter==$cap) {       // array of the current parsed letter of the message
            foreach($arrPos as $kk=>$pos) { // see every position
                if ($pos>$currentPos) {     // ok, use the letter at that position
                    $newString=substr($newString,0,$pos)."\n".$letter.substr($string,$pos+1); // add line break
                    $currentPos=$pos+2; // take new characters into account (\n)
                    break 2;            // parse next letter of the message
                }
            }
        }
    }
}                    /* (note that I could have added some other (random) line breaks management, so that
                      * the message is not TOO obvious... !*/
echo nl2br($newString);

PHP，136字节

for($f=" ".join(file(F));$c=DIEINAGREASEFIRE[$i++];){while(($p=strpos($f,$c,$p))&&$f[$p-1]>" ");$p?$f[$p-1]="\n":$i=20;}echo$i<20?$f:"";

如果可以全部侮辱；打印带有前导空格或换行符的修改后的字符串；如果没有，则为空。用运行-r。

分解

for($f=" ".join(file(F));       // read input from file "F"
    $c=DIEINAGREASEFIRE[$i++];) // loop through insult characters:
{
    while(($p=strpos($f,$c,$p))     // find next position of $c
        &&$f[$p-1]>" ");            // ... preceded by a space
    $p?$f[$p-1]="\n"                // if found, replace the space with a newline
    :$i=20;                         // else break the loop
}
echo$i<20?$f                // if modified text has the full insult, print it
    :"";                    // else print nothing

Python-190字节

l,r="IExINxAxGREASExFIRE","\n";k=p=raw_input();y=i=0
for c in l:
    if c!="x":
        h=len(p);x=p[y:h].find(c)
        if x==-1:i+=1
        p=p[0:x+y-1]+r+p[x+y:h];y=x+y;r="\n"
    else:r=r+r
if i!=0:p=k

不打高尔夫球

这是我的第一个高尔夫尝试：)无论如何，我都希望学习一些出色的编码技术，我只专注于使用find然后进行一些字符串拼接来找到合适的字符并格式化输出。

变量-

lr = l被分配了字符，我们将以此为指导来创建新的格式化段落。为r分配了新的换行符，以分隔新输出。

k，p =输入段落。K用于恢复为原始，因为在脚本执行期间未将其重新分配。我对照x进行检查，以了解何时出于间隔目的添加双换行。

y，i = y是种类的“光标”，跟踪找到字符的最后位置，因此我们可以正确地在段落中找到用于拼接的目的，我是健全性检查，如果我们未击中所有字符，通过k变量将段落（p变量）还原为原始输入。

h =输入长度，我们在拼接中使用。

x =由C表示的当前字符的位置，也用于拼接。

c = l中的字符进行迭代和搜索。

下面的代码经过改写，并从原始代码中分解出来，以使其易于理解：

letters,return="IExINxAxGREASExFIRE","\n"
input1=input2=raw_input()
lastpos=sanity=0

for char in letters:
    if char != "x":
        inputlength=len(input1)
        charposition=input1[lastpos:inputlength].find(char)
        if charposition==-1:
            sanity+=1
        input1=input1[0:position+lastpos-1]+return+input1[position+lastpos:inputlength]
        lastpos=position+lastpos
        return="\n"
    else:return=return+return
if sanity!=0:
    input1=input2

非常感谢您的反馈！我想学习。