Écrivez un programme dans n'importe quelle langue qui lit les entrées de stdin et sort une sortie légèrement modifiée vers stdout. Le programme devrait emprunter certains caractères de l'entrée et de la sortie avec un préfixe aussi grand que possible, *language-name* is awesome!suivi d'un retour à la ligne et de ce qui reste de l'entrée.

• L'entrée ne contient aucun caractère majuscule.
• Si le premier caractère du nom de la langue n'est pas présent dans la chaîne, seul le caractère de nouvelle ligne doit être emprunté.
• S'il n'y a pas de caractère de nouvelle ligne dans l'entrée, sortez l'entrée non modifiée.
• Peu importe lequel des personnages disponibles vous empruntez.

J'utilise \ncomme caractère de nouvelle ligne ( 0x0a) pour économiser de l'espace lors de l'écriture. Le vrai programme ne doit se soucier que du vrai caractère de nouvelle ligne, pas de la \nchaîne.

Exemple: python.
entrée: abcdefghijklmnopqrstuvwxyz\n0123456789
sortie: python\nabcdefgijklmqrsuvwxz0123456789
Depuis l'entrée ne comporte pas d' espace, nous ne pouvons pas continuer , même si nous avons assez de caractères pour le mot suivant: is.

Exemple: C.
entrée: i don't see anything!
sortie: i don't see anything!
C n'a pas été trouvé dans la chaîne, donc aucune modification n'a été possible. De plus, aucun caractère de nouvelle ligne n'est présent.

Exemple: C ++.
entrée: i don't\nsee anything!
sortie: \ni don'tsee anything!
C n'a pas été trouvé dans la chaîne, donc aucune modification n'a été possible.

Exemple: Obj-C.
entrée: objectively, clojure is amazing.\nq.e.d.
sortie:obj\nectively, clojure is amazing.q.e.d.
L'entrée contient suffisamment de caractères pour écrire objmais il -manque.

Le nombre d'octets de votre code source moins le nombre d'octets du nom de votre langue, utf-8 encodé (si possible), est votre score; victoires les plus faibles!

Pyth, 37 octets

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

Le code source fait 41 octets de long.Essayez-le en ligne.

Comment ça fonctionne

  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

Essayez-le en ligne

Python, 146 octets

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)

Ceylan, 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);}

Voici une version formatée et commentée:

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

Il utilise à la replaceLastplace de replaceFirstcar il est plus court.

Quelques exemples d'entrées et de sorties dans le même format que dans la question:

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

En tant que fonction renvoyant la sortie demandée. Il est difficile à implémenter avec les E / S, comme le substitut habituel de STDIN prompt(), qui n'accepte pas de nouvelle ligne à l'intérieur de la chaîne d'entrée.

En fonction de la sortie réelle (en utilisant alert), le nombre d'octets est 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))

Testez l'exécution de l'extrait ci-dessous dans un navigateur compatible EcmaScript 6 (implémentation de l'opérateur de propagation et de la fonction flèche - j'utilise 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 octets

Comprend 2 commutateurs.

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

Explication : Pour chaque caractère de la chaîne "\nperl is awesome", supprimez le caractère correspondant de la chaîne d'entrée ( $_) jusqu'à ce que nous trouvions un caractère non présent dans $_. Les caractères correspondants sont stockés dans $plesquels est préfixé et $_ensuite imprimés.

Le -0commutateur lit l'entrée complète plutôt que ligne par ligne et le -pcommutateur rend la lecture d'entrée et imprime la sortie implicite.

JavaScript (ES7), 101 107-10 = 97

Il était plus court auparavant et a même fonctionné sur les quatre cas de test, mais apparemment, j'ai raté une règle, alors ...

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)

Fonctionne correctement dans Firefox 42. Cela commençait à l'origine à 119 octets, mais une astuce de la réponse de @ edc65 a beaucoup raccourci. Je pense qu'il y a encore place à amélioration. Comme toujours, les suggestions sont les bienvenues!