Schreiben Sie ein Programm in einer beliebigen Sprache, die Eingaben aus stdin liest und eine leicht geänderte Ausgabe an stdout ausgibt. Das Programm sollte einige Zeichen aus der Eingabe und Ausgabe mit einem möglichst großen Präfix ausleihen, *language-name* is awesome!gefolgt von einer neuen Zeile und dem Rest der Eingabe.

• Die Eingabe enthält keine Großbuchstaben.
• Wenn das erste Zeichen des Sprachnamens nicht in der Zeichenfolge enthalten ist, sollte nur das Zeilenumbruchzeichen ausgeliehen werden.
• Wenn die Eingabe kein Zeilenumbruchzeichen enthält, wird die Eingabe unverändert ausgegeben.
• Es spielt keine Rolle, welche der verfügbaren Charaktere Sie ausleihen.

Ich benutze \nals Zeilenvorschubzeichen ( 0x0a), um beim Schreiben Platz zu sparen. Das echte Programm sollte sich nur um das echte Newline-Zeichen kümmern, nicht um die \nZeichenfolge.

Beispiel: Python.
Eingang: abcdefghijklmnopqrstuvwxyz\n0123456789
Ausgang: python\nabcdefgijklmqrsuvwxz0123456789
Da die Eingabe keine Leerzeichen nicht hat, können wir nicht weiter , obwohl wir genügend Zeichen für das nächste Wort haben: is.

Beispiel: C.
Eingabe: i don't see anything!
Ausgabe: i don't see anything!
C wurde in der Zeichenfolge nicht gefunden, daher war keine Änderung möglich. Es ist auch kein Newline-Zeichen vorhanden.

Beispiel: C ++.
input: i don't\nsee anything!
output: \ni don'tsee anything!
C wurde nicht in der Zeichenfolge gefunden, daher war keine Änderung möglich.

Beispiel: Obj-C.
input: objectively, clojure is amazing.\nq.e.d.
output: obj\nectively, clojure is amazing.q.e.d.
Die Eingabe enthält genügend Zeichen zum Schreiben, objaber das -fehlt.

Die Byteanzahl Ihres Quellcodes abzüglich der Byteanzahl des Namens Ihrer Sprachen, utf-8-codiert (falls möglich), ist Ihre Punktzahl. niedrigste Gewinne!

Pyth, 37 Bytes

.-Jjb.zpef!.-TJ+,kb+Rb._"pyth is awesome!

Der Quellcode ist 41 Bytes lang. Probieren Sie es online aus.

Wie es funktioniert

  Jjb.z                                      Save all user input in J.
                      ._"pyth is awesome!    Compute all prefixes that string:
                                               ["p", "py", ... ]
                   +Rb                       Append a linefeed to each prefix.
               +,kb                          Concatenate ["", "\n"] with the result.
         f                                   Filter the resulting array; for each T:
           .-TJ                                Perform bagwise difference between T
                                               and J (respects multiplicities).
         !                                     Take the logical NOT.
                                             Keep T if ! returned True, i.e., if J
                                             contains all of T's characters.
        e                                    Retrieve the last, longest match.
       p                                     Print it.
.-J                                          Remove its characters from J.
                                             (implicit) Print the result.

Python, 186 - 6 = 180

import sys
a=sys.stdin.read()
s="python is awesome!"
r=''
if'\n'not in a:print a;exit()
a=a.replace('\n','',1)
for c in s:
 if c in a:a,r=a.replace(c,'',1),r+c
 else:break
print r+'\n'+a

Probieren Sie es online aus

Python, 146 Bytes

import sys
r=sys.stdin.read();y='\npython is awesome!';a=''
for i in y:
    if i in r:a+=i
    else:break
print a[1:]+'\n'+''.join(b for b in r if not b in a)

Ceylon, 235 - 6 = 229

void a(){variable value i="";variable value r="\nceylon is awesome!";while(exists l=process.readLine()){i=i+"\n"+l;}i=i.rest;for(j->c in r.indexed){if(c in i){i=i.replaceLast(c.string,"");}else{r=r[0:j];break;}}print(r.rest+r[0:1]+i);}

Hier ist eine formatierte und kommentierte Version:

void a() {
    // our target string, with the \n shuffled to the start.
    variable value r = "\nceylon is awesome!";

    // read the whole input line by line
    // (there doesn't seem a way to do this shorter :-/)
    variable value i = "";
    while (exists l = process.readLine()) {
        i = i + "\n" + l;
    }
    // remove first \n:
    i = i.rest;
    for (j->c in r.indexed) {
        if (c in i) {
            // remove some occurence of c
            i = i.replaceLast(c.string, "");
        } else {
            // stop the loop, and take the part of `r` processed so far.
            r = r[0:j];
            break;
        }
    }
    // reshuffle first \n in r to its end.
    // This will result in the empty string if r is empty, i.e. no \n was found.
    print(r.rest + r[0:1] + i);
}

Es verwendet, replaceLastanstatt replaceFirstweil es kürzer ist.

Einige Beispiele für Ein- und Ausgaben im gleichen Format wie in der Frage:

• abcdefghijklmnopqrstuvwxyz\n0123456789 → ceylon\nabdfghijkmpqrstuvwxz0123456789
• i don't see anything! → i don't see anything!
• i don't\nsee anything! → \ni don't see anything!
• objectively, closure is amazing.\nq.e.d. → ceylon is a\nobjectivel, sureiamzng.\q..d.

JavaScript (ES6) 90 (100-10)

Als Funktion, die die angeforderte Ausgabe zurückgibt. Die Implementierung mit E / A ist schwierig, da STDIN prompt()normalerweise keine Zeilenumbrüche innerhalb der Eingabezeichenfolge akzeptiert.

Als eine Funktion mit realer Ausgabe (unter Verwendung von alert) ist die Byteanzahl 107

f=s=>alert(([...`
javascript is awesome`].every(c=>(z=s.replace(c,''))!=s&&(s=z,q?o+=c:q=c),q=o=''),o+q+z))

Testen Sie die Ausführung des folgenden Snippets in einem EcmaScript 6-kompatiblen Browser (Implementierung des Spread-Operators und der Pfeilfunktion - ich verwende FireFox).

f=s=>([...`
javascript is awesome`].every(c=>(z=s.replace(c,''))!=s&&(s=z,q?o+=c:q=c),q=o=''),o+q+z)

function test()
{
  O.innerHTML=f(I.value)
}

test()

#I {width: 80%}

<textarea id=I>
objectively, clojure is amazing.
q.e.d.</textarea><button onclick="test()">-></button>
<pre id=O></pre>

Perl, 72 - 4 = 68 Bytes

Beinhaltet 2 Schalter.

perl -0pe 'for$c("\nperl is awesome!"=~/./gs){s/$c//?$p.=$c:last}s/^/$p\n/;s/\n//'

Erläuterung : "\nperl is awesome"Entfernen Sie für jedes Zeichen in der Zeichenfolge das entsprechende Zeichen aus der Eingabezeichenfolge ( $_), bis ein Zeichen gefunden wird, das in nicht vorhanden ist $_. Es werden die übereinstimmenden Zeichen gespeichert, $pdenen das Präfix vorangestellt wird, $_das dann gedruckt wird.

Der -0Schalter liest die gesamte Eingabe ein und nicht zeilenweise, und der -pSchalter macht das Lesen der Eingabe und das Drucken der Ausgabe implizit.

JavaScript (ES7), 101 107 - 10 = 97

Es war früher kürzer und hat sogar an allen vier Testfällen gearbeitet, aber anscheinend habe ich eine Regel verpasst, also ...

x=>(i=r=q='',[for(c of`
javascript is awesome`)(y=x.replace(c,''),i||y==x?i=1:(c<' '?q=c:r+=c,x=y))],r+q+x)

Funktioniert in Firefox 42 einwandfrei. Dies begann ursprünglich mit 119 Bytes, aber ein Trick aus der Antwort von @ edc65 trug dazu bei, es erheblich zu verkürzen. Ich denke, es gibt noch Raum für Verbesserungen. Wie immer sind Vorschläge willkommen!