Sono stati alcuni mesi difficili al lavoro e mi sento come se volessi solo urlare fino alla faccia del mio capo. Tuttavia, non sono uno che affronta direttamente le persone con cui ho problemi. Inoltre, non voglio perdere il lavoro.

Quindi ecco un'idea: voglio essere in grado di insultarlo, senza che lui lo scopra mai. E ho realizzato il modo perfetto: ho bisogno di una sorta di software che codifichi un insulto all'interno di un messaggio altrimenti perfettamente perfetto. E visto che sa di non vedere foreste per alberi, penso di sapere come:

Scrivimi un programma che accetta come input una stringa di lunghezza sconosciuta, ma che non contiene interruzioni di riga. Questo sarà il messaggio non elaborato che voglio inviare.

Se possibile, restituire la stringa formattata in modo tale che il messaggio "DIE IN A GREASE FIRE" componga l'intera colonna di sinistra. Con nuovi paragrafi in cui gli spazi tra le parole dovrebbero andare. Ora, dato che sono molto arrabbiato, è altrettanto importante che ogni lettera sia in maiuscolo.

Non puoi modificare la stringa in nessun altro modo, ovvero non puoi trasformare tutta la stringa in caratteri maiuscoli.

Se la stringa in questione non può essere formattata in questo modo, è necessario restituire la stringa originale. Lettura dell'input dall'input standard.

Si applicano le normali regole: nessuna richiesta HTTP, nessuna consulenza Marvin da THGTTG, ecc.

Esempio di input:

Caro capo, come vanno le cose? Mi è venuto in mente che ho ricevuto tutta la colpa per l'incidente venerdì scorso. Non solo la maggior parte. L'ultimo pezzo. È sbagliato per me pensare che il resto della squadra fosse almeno in parte responsabile? Dopotutto, tutti e sei siamo stati coinvolti sin dall'inizio. Non che penso che dovrei stare senza colpa. Affatto. Tutto quello che sto dicendo è questo: faccio del mio meglio. Ci provo duramente. Miglioramento costantemente. E mi assumo costantemente la responsabilità. In generale, sto molto bene assumendomi la piena responsabilità delle mie azioni. Ma dopo questa primavera, sembra che io ottenga più di quello che merito. Ricorda il contratto Flakenhauser? Tutto è andato quasi liscio come si sarebbe potuto sperare. O almeno così sembrava all'inizio. Fu proprio all'ultimo minuto che le cose andarono in pezzi. Tutto il team ha concordato sul fatto che era più simile a un incidente bizzarro che a una pianificazione sciatta o a risorse mal gestite. Eppure, da solo, ho preso la colpa per questo. Anche se allora non ho detto nulla, il mio livello di tolleranza per prendermi la colpa ha subito una grave ammaccatura. Da quel momento in poi, ho sentito la necessità di provare sempre il doppio, solo per sfuggire al controllo. E ancora, eccoci di nuovo qui. Nonostante tutti i miei successi. Proprio dove sembriamo sempre finire in questi giorni. Ogni singolo progetto. Sta diventando insopportabile. solo per sfuggire al controllo. E ancora, eccoci di nuovo qui. Nonostante tutti i miei successi. Proprio dove sembriamo sempre finire in questi giorni. Ogni singolo progetto. Sta diventando insopportabile. solo per sfuggire al controllo. E ancora, eccoci di nuovo qui. Nonostante tutti i miei successi. Proprio dove sembriamo sempre finire in questi giorni. Ogni singolo progetto. Sta diventando insopportabile.

Esempio di output:

Caro capo, come vanno le cose?
Mi è venuto in mente che ho ricevuto tutta la colpa per l'incidente venerdì scorso. Non solo la maggior parte.
L'ultimo pezzo.

È sbagliato per me pensare che il resto della squadra fosse almeno in parte responsabile? Dopotutto, tutti e sei siamo stati coinvolti sin dall'inizio.
Non che penso che dovrei stare senza colpa. Affatto.

Tutto quello che sto dicendo è questo: faccio del mio meglio. Ci provo duramente. Miglioramento costantemente. E mi assumo costantemente la responsabilità.

In generale, sto molto bene assumendomi la piena responsabilità delle mie azioni. Ma dopo questa primavera, sembra che io ottenga più di quello che merito.
Ricorda il contratto Flakenhauser.
Tutto è andato quasi liscio come si sarebbe potuto sperare. O almeno così sembrava all'inizio. Fu proprio all'ultimo minuto che le cose andarono in pezzi.
Tutto il team ha concordato sul fatto che era più simile a un incidente bizzarro che a una pianificazione sciatta o a risorse mal gestite.
Eppure, da solo, ho preso la colpa per questo.
Anche se allora non ho detto nulla, il mio livello di tolleranza per prendermi la colpa ha subito una grave ammaccatura.

Da quel momento in poi, ho sentito la necessità di provare sempre il doppio, solo per sfuggire al controllo. E ancora, eccoci di nuovo qui.
Nonostante tutti i miei successi.
Proprio dove sembriamo sempre finire in questi giorni.
Ogni singolo progetto. Sta diventando insopportabile.

Questo è il codice golf. Il codice più corto vince.

CJam, 56 53 byte

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

Provalo online!

Come funziona

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 byte

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

Contando lo shebang come uno.

Questa soluzione utilizza la stringa più interna per creare la seguente regex:

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

che è simile al regex usato nella soluzione di m.buettner . Il regex generato viene quindi confrontato con l'input. In un contesto di elenco, ciò restituirà un array contenente ciascuno dei gruppi di corrispondenza, che sono uniti da una nuova riga (il motivo per cui i gruppi "non corrispondono a nulla" (\.*)è l'inserimento di una nuova riga aggiuntiva). Se non vi è alcuna corrispondenza, viene invece generata la stringa originale.

Perl - 73 byte

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

Contando lo shebang come due.

Questo divide la stringa nei delimitatori appropriati e raccoglie i pezzi in un array. Se qualcuno di questi non riesce a corrispondere, il separatore del record di output (che è stato impostato su una nuova riga con l' -lopzione) non è impostato e quindi la stringa viene emessa non modificata.

GolfScript, 53 byte

Sembra che Dennis e io abbiamo inventato cose abbastanza simili in parallelo ... Ma ecco il mio tentativo.

Fai clic sui collegamenti prima di ogni blocco di codice per provarlo online. Sfortunatamente, l'interprete online non ti consentirà di eseguire un codice di dimensioni superiori a 1024 caratteri, quindi ho dovuto eseguire un po 'di "compressione" dell'input di test. Ma funziona ancora.

Versione squished

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

Versione non richiesta e commentata

.       # (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

Un punto sollevato da Dennis: tutti i programmi GolfScript stampano una nuova riga automatica finale. Se questo dovrebbe invalidare la mia soluzione così com'è, non sono sicuro. Credo che costerebbe 4 caratteri per sopprimere la nuova riga finale aggiungendo un punto "":nvicino alla fine.

Rubino - 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)

Nessuna regex in questo . Cammina simultaneamente i caratteri nell'input ARGV [0] e una stringa contenente caratteri che dobbiamo rompere per rendere il nostro messaggio nella colonna di sinistra. Inizialmente aveva intenzione di incollare spazi dopo le lettere che avevano bisogno di avere una nuova riga, ma ho scoperto che era un po 'più breve codificare gli indici in corrispondenza dei quali inserire l'interruzione di riga.

Una volta che tutto è stato detto e fatto, controlla che l' iindice sia aumentato abbastanza volte da passare attraverso ogni lettera che aveva bisogno di essere spezzata. In caso contrario, stampiamo solo la stringa originale. Se lo è, diamo loro quello formattato.

n-[i]!=nera un bel trucco per salvare i personaggi quando si controllava se l'indice corrente fosse o meno uno che necessitava di un'interruzione di riga aggiuntiva (rispetto a n.include? i). Inoltre ha salvato alcuni caratteri usando {}s invece di do/endessere un blocco multilinea, e ha usato una condizione ternaria sui put finali per salvare i caratteri quando si determina quale output.

Non il più breve, ma ho pensato che sarebbe stato bello fare a meno delle espressioni regolari.

Perl, 184 byte

Non è un punteggio spettacolare per Perl, ma ecco una semplice soluzione regex

$_=<>;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

Implementazione Javascript dell'idea di m-buettner

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

Test snippet

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)

golfed:

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])

Ungolfed-ish:

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])

Sebbene l'uso della lambda mi piaccia in qualche modo, quel numero di massa di variabili utilizzate e lo sviluppo un po 'disordinato hanno l'effetto opposto. Anche Regex potrebbe essere stata una buona idea. Hay ho, almeno funziona :).

Modifica: sostituisce la variabile lambda con countbuiltin e abbreviata istruzione divisa.

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)

Ungolfed

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)

Spiegazione

chunk divide in modo ricorsivo la fine del messaggio contenente l'ultima intestazione e lo antepone a un elenco.

Avvertenza: questo non funzionerà se non ci sono spazi tra due titoli proposti nella tua lettera per qualche motivo, ma ciò sembra improbabile in una lettera al tuo capo.

Ruby 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

Ruby 95

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

J - 110 103 byte

Perché J non ha buone funzioni per gestire le stringhe, ma solo funzioni di array? Lo rivedrò se scoprissi qualcosa di intelligente.

Modifica: output ridotto e fisso (prima aveva spazi extra) e controllo. Ho anche migliorato la spiegazione.

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

Spiegazione:

Indicheremo l'utilizzo della funzione come [<left argument>] <function name> <right argument>, ad es f <text>. Inoltre non spiegherò ogni dettaglio perché la funzione è piuttosto lunga.

@ applica la funzione destra alla funzione sinistra, ad es. f@g x == f(g(x))

t=:(}.@[t{.@[(}:@],(((0{I.@E.)({.;LF;}.)])>@{:))])']@.(0=#@[)è una funzione ricorsiva <delimiters> t <boxed string>che divide la stringa con ogni delimitatore, in ordine. Non riesce se non viene trovato delimitatore.

(((0{I.@E.)({.;LF;}.)])>@{:) divide la stringa dal lato sinistro del delimitatore, aggiungendo un avanzamento di riga tra di loro.

>@{: ottiene l'ultima stringa da un elenco (quella che non è stata ancora divisa)

0{I.@E. ottiene la divisione dell'indice, fallendo se il delimitatore non esiste.

{.;LF;}. concatena il lato sinistro della divisione, l'alimentazione della linea e il lato destro della divisione

}:@], concatena i risultati delle suddivisioni precedenti e il risultato dell'ultima funzione (ultimo significato: cerca)

']@.(0=#@[)controlla se sono rimasti delimitatori e chiama la funzione sopra descritta (5 righe) se esiste. Altrimenti ritorna.

'IEIINAAGGREASEFFIRE'&imposta l'argomento sinistro di tquella stringa

[:>,&.>/@ unisce i risultati della divisione

::] se qualcosa non riesce (ho reso la ricerca dell'indice diviso il punto debole), restituisce la stringa originale.

Esempi (troppo lunghi?):

   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 byte

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

`:`
`)+a:a))

Ho usato replaceper scorrere la stringa, con una corrispondenza per in /\b./gmodo da trovare solo caratteri che seguissero uno spazio o iniziassero la stringa. Quindi ho controllato ogni personaggio per vedere se corrispondeva all'indice corrente nell'array che stavo cercando e ho aggiunto una nuova riga prima di esso, se lo ha fatto, e incrementato i.

EDIT: perse la necessità di creare nuove righe tra le parole. L'ho fatto ora, il che lo porta a 115.

PHP, 328 byte

Dato un file chiamato "G" contenente il testo non elaborato da "inviare"

<?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);

Spiegazione (~ ungolfed && commented code):

<?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 byte

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:"";

se l'intero insulto può essere messo; stampa la stringa modificata con uno spazio iniziale o un'interruzione di riga; uscita vuota in caso contrario. Corri con -r.

abbattersi

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 byte

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

Ungolfed

Questo è il mio primo tentativo di golf :) Cercando di imparare alcune grandi tecniche di codifica, a prescindere, mi sono concentrato sull'uso di find e poi su alcune giunzioni di stringhe per trovare i caratteri appropriati e formattare l'output.

Variabili -

lr = l è assegnato a caratteri che useremo come guida per creare il nostro nuovo paragrafo formattato. A r viene assegnato il nuovo carattere di linea per noi nello spazio tra il nuovo output.

k, p = Il paragrafo di input. K viene utilizzato per ripristinare l'originale in quanto non viene riassegnato durante l'esecuzione dello script. Controllo x per sapere quando aggiungere una doppia nuova riga a scopo di spaziatura.

y, i = y è un "cursore" di sorta, tiene traccia dell'ultima posizione in cui un personaggio è stato trovato, quindi troviamo il paragrafo correttamente per scopi di giunzione, sono un controllo di sanità mentale, se non colpiamo tutti i nostri personaggi ripristina il paragrafo (variabile p) al suo input originale tramite la variabile k.

h = Lunghezza input, che usiamo nella giunzione.

x = La posizione del carattere corrente rappresentato da C, usata anche per la giunzione.

c = Caratteri in l per scorrere e cercare.

Il seguente codice viene riformulato e suddiviso dal codice originale per essere leggibile come ciò che sta accadendo:

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

Gradirei il tuo feedback! Sto cercando di imparare.