Le scénario: Vous êtes un concepteur de logiciels travaillant pour une entreprise dirigée par le gouvernement qui conçoit des plaques d'immatriculation pour les voitures et autres véhicules. On vous a demandé de développer un logiciel qui génère des plaques d'immatriculation. Avant de vous mettre au travail, vos patrons ont établi ces règles de base.

Une plaque d'immatriculation ne peut pas contenir:

• ASS
• 666
• 69<any number here>
• <any number here>69
• KKK
• SHT

Règles et exigences:

• La plaque d'immatriculation doit être générée de manière aléatoire.
• Une fois qu'une plaque d'immatriculation aléatoire est générée, la même plaque d'immatriculation ne peut plus être générée.
• Vous devez produire au moins 200 plaques d'immatriculation uniques . Vous pouvez en générer plus si vous le souhaitez .
• Vous pouvez stocker les plaques générées dans un fichier pour les "mémoriser".
• La plaque d'immatriculation contient 2 sections, l'une ne contenant que trois lettres et l'autre ne contenant que trois chiffres, séparés par un tiret, comme ceci: 233-ADFou ADF-233.
• Vous ne pouvez utiliser que des chiffres et des majuscules.
• Les plaques d'immatriculation peuvent être écrites sur stdout ou dans un fichier.
• Chaque "côté" d'une plaque d'immatriculation contiendra soit trois chiffres ou lettres.
• Il s'agit d'un code-golf , donc la réponse la plus courte et la plus populaire l'emporte. Le gagnant sera choisi après sept jours.

Règles générales

• La réponse doit inclure, mais sans s'y limiter, les éléments suivants.
• Nom de la langue.
• Nombre de caractères.
• Taille du fichier.
• Comment le code est exécuté.
• Le code lui-même.
• Exemple: caractères Python 234 ou Python 23mb .

Si j'ai besoin de clarifier des détails supplémentaires, veuillez le mentionner dans les commentaires et je l'ajouterai à mon message. Quoi qu'il en soit, bonne chance et générez-moi des plaques d'immatriculation appropriées!

Mise à jour 1: le gagnant sera choisi un peu plus tôt.

Il s'avère que je dois partir en voyage bientôt, donc je choisirai un gagnant vers 00:00 UTC, le 25 juillet. Une fois le gagnant choisi, vous pouvez toujours soumettre des candidatures, sachez simplement qu'un gagnant a été choisi. Bai.

Mise à jour 2: gagnants!

Nous avons des gagnants! Yay! Du fromage et du vin à tous ceux qui ont participé! Voici qui a gagné.

• 1ère place: Àngel - Bash (95 caractères)
• 2e place: Martin Büttner - Mathematica (182 octets)
• 2ème place: Emilio M Bumachar - Pyg (92?)
• 2e place: Peter Taylor - Golfscript (98 caractères)
• 3e place: Mark Thomas - Ruby (127 caractères)

Wow, trois liens pour la deuxième place. Sensationnel. Le concours est terminé, mais n'hésitez pas à soumettre des candidatures si vous le souhaitez. Bai!

bash (95 caractères)

Enregistrez le script comme mdans un dossier de votre PATH avec le jeu de bits d'exécution.

Exécuter en tant que bash m. Les plaques sont stockées dans le fichier p

l(){ tr -dc $1</dev/urandom|head -c3;};egrep -ve"ASS|666|69|KKK|SHT" -fp>>p<<<`l 0-9`-`l A-Z`;m

Cela revient à exécuter ce qui suit:

# Print three random numbers and three random letters
echo $(tr -dc 0-9 < /dev/urandom | head -c3)-$(tr -dc A-Z < /dev/urandom | head -c3) |

# Print only plates not matching the blacklist or any line of p
# Append the plates ton p
egrep -v -e "ASS|666|69|KKK|SHT" -f p >> p

# Execute itself again
m 

Mise en garde: la finale mdevrait en fait être exec m(+5 caractères) afin d'éviter de laisser des processus en attente d'achèvement (mais vous pouvez en avoir des milliers sans trop de problèmes)

Nous remercions http://www.cyberciti.biz/faq/linux-random-password-generator/ pour l'idée d'utilisertr -dc

PYG - 92

Pe(Se(Re.sub(".*(666|69|ASS|KKK|SHT).*","",J(RSm(STuc*3,3)+[j]+RSm(STd*3,3)))for j in'-'*K))

Maintenant, vous pouvez sélectionner uniformément toutes les plaques inutilisées, en respectant les spécifications d'OP, tout en étant plus court d'un caractère de plus.

Il est théoriquement possible que la liste des 999 plaques contienne suffisamment de répétitions pour que l'ensemble coupé soit inférieur à 200. Mais les chances de cela sont infiniment petites. En dix essais, la longueur la plus basse que j'ai obtenue était de 994.

EDIT: changé 999 en K (qui est pyg pour 1000), pour enregistrer deux caractères sur les conseils de bitpwner.

Mathematica, 182 octets

Ugh, c'est long

l={};While[Length[l=Union@Pick[l,StringFreeQ[l,"ASS"|"666"|"69"|"KKK"|"SHT"]]]<200,AppendTo[l,RandomSample[FromCharacterCode/@{48+9~(r=RandomInteger)~3,65+25~r~3}]~Riffle~"-"<>""]];l

Non golfé

l = {};
While[
  Length[
    l = Union@
      Pick[l, StringFreeQ[l, "ASS" | "666" | "69" | "KKK" | "SHT"]]
  ] < 200,
  AppendTo[l, 
   RandomSample[
      FromCharacterCode /@ {48 + 9~(r = RandomInteger)~3, 
        65 + 25~r~3}]~Riffle~"-" <> ""]
  ];
l

Assez simple. Génère des plaques aléatoires et filtre les doublons et les interdits jusqu'à ce que 200 soient trouvés.

GolfScript (98 caractères)

260{3?}:^~,{.10^+`-3>'-'+\10^/26^+26base(;{65+}%+.-1%}%{'ASSKKKSHT66669'3/{1$\?)!},*},{,^^rand}$n*

Cela génère toutes les plaques d'immatriculation possibles dans un ordre aléatoire en utilisant une conversion de base laide suivie d'un filtrage. Il y en a beaucoup, alors ne vous attendez pas à ce qu'il s'exécute rapidement, mais la question n'a pas imposé de contraintes sur le temps d'exécution.

JavaScript (ES6) - 213

Cela peut probablement être amélioré. Testé sur Firefox Console.

Remplacez cette alerte par un console.log()si vous souhaitez tester

r=x=>~~(Math.random()*x)+'';l=x=>[...'ABCDEFGHIJKLMNOPQRSTUVWXYZ'][r(26)];a=[];while(a.length<200)p=r(10)+r(10)+r(10)+'-'+l()+l()+l(),!/ASS|666|69|KKK|SHT/.test(p)&&a.indexOf(p)<0&&a.push(p);a.forEach(x=>alert(x))

Ruby - 136 133 129 caractères

Hideux. Mais pensez qu'il y a place à amélioration. Déposez simplement le code irbou pryappuyez sur Entrée pour exécuter:

f=->*t{[0,1,2].map{t.sample}*''}
g=->l{(a=f[*?A..?Z]+?-+f[*?0..?9];l|=[a]if/69|666|ASS|SHT|KKK/!~a)until l.size>199;l}
puts g[[]]

Rubis, 127 caractères

Ma tentative d'une version Ruby "lisible":

a=[]
until a.size==200 do
  p="#{rand(899)+100}-#{('A'..'Z').to_a.sample(3).join}"
  a<<p unless p=~/69|666|ASS|SHT|KKK/
end
puts a

Python 2.7 - 258 caractères

Je ne suis pas un programmeur professionnel ou quoi que ce soit, donc je dirais que je suis satisfait du résultat.

import random as o
r=o.randint
t,j,k=[],0,""
b=["SHT","KKK","ASS","69","666"]
for i in range(200):
 l,j=b[0],b[4]
 while any(w in l for w in b):
  l,j="",""
  for i in range(3):
   l+=chr(r(65,90))
   j+=str(r(0,9))
 t.append(l+'-'+j)
print "\n".join(set(t))

La taille du fichier est de 4,0 K, exécutez avec python file.py!

Python - 208

Salut, mon coup de couteau à la génération de plaques d'immatriculation. Cette solution est similaire à la solution de @ bitpwner mais sans le module de chaîne et au lieu d'une liste pour la plaque d'immatriculation, j'ai choisi d'utiliser un ensemble et elle autorise également les chiffres en premier.

import random as r,re
f=r.randint
l=lambda x:chr(f(65, 90))if x else`f(0,9)`
d=set()
while len(d)<200:
 k=f(0,1);j=1-k;c=l(k)+l(k)+l(k)+'-'+l(j)+l(j)+l(j)
 if not(re.search("666|69|ASS|KKK|SHT",c)):d.add(c)

Exemple de sortie:

set(['DQJ-641', '086-QRY', '981-GAZ', 'UHN-718', '114-VMI', 'GLO-887',  ...

Python, 252 octets

Voici ma contribution. J'en suis impressionné, mais je sais que d'autres ont fait mieux avec python.

from random import randint as r
f=()
while len(f)<200:
 t=str(r(0,999))
 if not("666" in t or "69" in t):
  u=''.join(chr(r(65,90)) for _ in [1,2,3])
  if not("KKK" in u or "SHT" in u or "ASS" in u):f+=("%s-%s"%(t.zfill(3),u),)
 f=tuple(set(f))
print f

Python - 165

Ces importations ...

import random as r,re
j="666|69|ASS|KKK|SHT"
t=r.randint
while len(j)<2e3:
 exec"x="+"chr(t(0,25)+65)+"*3+"'-'"+"+`t(0,9)`"*3
 if not re.search(j,x):print x;j+='|'+x

S'il est nécessaire de commencer au hasard avec des chiffres ou des alphabets, ce qui ne me semble pas vraiment nécessaire, alors 190.

import random as r,re
j="666|69|ASS|KKK|SHT"
t=r.randint
while len(j)<2e3:
 exec"x="+"chr(t(0,25)+65)+"*3+"'-'"+"+`t(0,9)`"*3
 x=x[::r.choice((-1,1))]
 if not re.search(j,x):print x;j+='|'+x

PHP 341 324 320

C'était le mieux que je pouvais faire.

<?$a="p";$b=fopen($a,'a+');while($c<200){$d=rand(100,999);$e='';for($f=0;$f<3;++$f)$e.=chr(rand(65,90));$g=(rand(1,2)==1)?"$d-$e":"$e-$d";$h=array('ASS','666','69','kkk','SHT');$i=1;foreach($h as $j)!preg_match("/$j/",$g)?:++$i;if($i==1){$k=fread($b,filesize($a));if(!strpos($k,$g)){fwrite($b,$g);echo"$g<br />";++$c;}}}

Pour exécuter le code, enregistrez-le simplement en tant que fichier .php et accédez-y sur n'importe quel serveur Web. Il tentera de créer le fichier de liste noire p.txt s'il n'existe pas déjà. Cependant, vous devrez peut-être le définir avec un chemin d'accès complet au serveur si vous ne disposez pas d'un accès root.

Le code lui-même est ici avant la golfification:

<?
// create random plate
// check it does not break rules
// check is not on all time blacklist file
// Add to blacklist file
// Output to screen

// open file handle
$file = "p"; // filename and path if not root access
$fh = fopen($file, 'a+');

// do 200
while($x<200) {

    // get random number
    $rand_number = rand(100,999);

    // get random letters
    $letters = '';
    for($y=0; $y<3; ++$y) $letters .= chr(rand(65,90));


    // mix up combination
    $string = (rand(1,2)==1) ? "$rand_number-$letters" : "$letters-$rand_number";

    // assume is ok
    $ok = 1;

    // Set checks to be excluded on new plates.
    $checks = array('ASS','666','69','kkk','SHT');

    // do the exclusions
    foreach ($checks as $check) !preg_match("/$check/", $string) ? : ++$ok;


    // if all ok, check is not on the blacklist
    if($ok == 1) {

        // read blacklist
        $blacklist = fread($fh, filesize($file));

        // if not on blacklist, add it to file, echo it to output, increment counter
        if (!strpos($blacklist, $string)) {
            fwrite($fh, $string);
            echo "$string<br />";
            ++$x;
        }
    }
}

Était aussi courte que possible :-(

Exemple de sortie

XWU-888
PUD-534
355-QXG
WDE-402
113-QID
362-YBW
TBK-594
939-XDT
148-ARZ
838-ICY
723-ZDA
.... does exactly 200 new plates.

EDIT: ranger quelques instructions if à utiliser sous forme abrégée.

Delphi, 161 octets

Voici mon point de vue à ce sujet. Il sort les plaques d'immatriculation vers la sortie standard sans saut de ligne entre elles. Si LF est nécessaire (non spécifié dans les règles), cela ajoute 4 octets supplémentaires.

Version golfée:

var S,L:string;begin repeat Str(100+Random(69),S);S:=S+'-';while Length(S)<7do S:=S+Chr(65+Random(10));if Pos(S,L)=0then L:=L+S;until Length(L)>1393;Write(L)end.

Non golfé:

var
  S, L: string;
begin
  repeat
    Str(100 + Random(69), S); // generate and add first three numbers
    S := S + '-'; // add dash
    while Length(S) < 7 do // generate and add last three letters
      S := S + Chr(65 + Random(10));
    if Pos(S, L) = 0 then // check if its not in the L string and add it
      L := L + S;
  until Length(L) > 1393; // exit loop once L string has more than 1393 chars (199 * 7 = 1393)
  Write(L); // output L to stdout
end.

Comment exécuter:

app.exe > plates.txt

PHP, 267

C'est à peu près aussi court que possible.

<?php $g=file("p",2)?:[];$b=["ASS","666","KKK","SHT"];for($i=0;$i<200;){$m="A";$n=rand(702,18277);for($j=0;$j<$n;$j++){$m++;}$m.=-rand(100,999);if(!(strpos($m,"69")|in_array($m,$b)|in_array($m,$g))){$g[]=$m;echo"$m\n";$i++;}}file_put_contents("p",implode("\n",$g));?>

Les plaques sont stockées dans le fichier "p".

<?php
$g=file("p",2)?:[]; // Read existing plates
$b=["ASS","666","KKK","SHT"]; // Don't generate these
for($i=0;$i<200;){ // 200 plates
    $m="A"; // Base letter
    $n=rand(702,18277); // 3 random letters
    for($j=0;$j<$n;$j++){$m++;} // Increment until letters are reached (SLOW, but short)
    $m.=-rand(100,999); // Add a dash and three numbers
    if(!(strpos($m,"69")|in_array($m,$b)|in_array($m,$g))){ // Check that it's valid and unused
        $g[]=$m;echo"$m\n";$i++; // Echo it, add it to used array and increment counter
    }
}
file_put_contents("p",implode("\n",$g)); // Save the plates
?>

R, 229 caractères

Je suis sûr que cela pourrait être amélioré:

l=function(x)paste0(sample(x,3,r=T),collapse="")
a=function()c(l(LETTERS),l(0:9))
A=list()
for(i in 1:200)while(any(sapply(c("ASS","666","69","KKK","SHT"),grepl,A[[i]]<-a()))|A[i]%in%A[-i])A[[i]]=a()
lapply(A,paste,collapse="-")

Exécuter dans la console, imprime une liste de plaques d'immatriculation.

Cobra - 198

class P
    def main
        l,r=[],Random()
        while l.count<200
            a,b=r.next(1000),''
            for i in 3,b+='[r.next(65,91)to char]'
            if not ('69'in'[a]'or 666==a or b in'ASS KKK SHT'),l+=['[a]-'+b]
        print l

ECMAScript 6 - 155 168 158

Avertissement : 200 boîtes de dialogue d'alerte (passez alertà console.logpour tester)

for(i=0,s={},r=Math.random,l=x=>String.fromCharCode(65+r()*26);i<200;)/ASS|666|69|KKK|SHT/.test(p=(r()+'-'+l()+l()+l()).slice(-7))?0:s[p]=s[p]||(alert(p),i++)

Edit : Oups. Version originale imprimée en double ...

Edit 2 : Plus proche de la partition d'origine maintenant - passé d'un ensemble à un tableau associatif avec des vérifications en double qui lui permettent d'imprimer au fur et à mesure

Testé dans la console Firefox.

JavaScript (ES6) 184

Comme d' habitude, le test dans la console FireFox et le changement alertà console.logou être prêt à appuyer sur escape200 fois.

R=x=>Math.random()*++x|0
for(l='ABCDEFGHIKJLMNOPQRSTUVWXYZ',i=0,u={};i<200;)
!(/69|666|ASS|SHT|KKK/.test(k=l[R(25)]+l[R(25)]+l[R(25)]+'-'+R(9)+R(9)+R(9))&u[k])&&alert(k,u[k]=++i);

Python3, 257 caractères

import string as X,re,random as R
I=[0,1,2]
s={}
while len(s)<200:
 L=R.sample([[R.choice(X.digits) for i in I],[R.choice(X.ascii_uppercase) for i in I]],2);L=''.join(L[0]+['-']+L[1])
 if re.search('ASS|KKK|SHT|69|666',L) or L in s:continue
 print(L);s[L]=0

Exemple de sortie:

# python3 shortened.py
EUN-215
546-SIL
464-ZTR
XIX-794

PHP, 167

while(count($a)<200){$c="";for(;++$y&3;)$c.=chr(rand(65,90));$d=rand(100,999);$c=rand()&1?"$d-$c":"$c-$d";preg_match("/ASS|666|69|KKK|SHT/",$c)||$a[$c]=1;}print_r($a);

c'est 100 caractères de moins que le meilleur PHP actuel :)

while(count($a)<200)
{
    $c="";
    for(;++$y&3;) $c.=chr(rand(65,90));
    $d=rand(100,999);
    $c=rand()&1?"$d-$c":"$c-$d";
    preg_match("/ASS|666|69|KKK|SHT/",$c)||$a[$c]=1;
}
print_r($a);

J'espère que vous aimez. Dans le cas où il est autorisé:

while(count($a)<200){$c="";for(;++$y&3;)$c.=chr(rand(65,90));$c.=-rand(100,999);preg_match("/ASS|666|69|KKK|SHT/",$c)||$a[$c]=1;}print_r($a);

n'est que de 141 caractères mais ne mélange pas les caractères et les nombres. Toutes les suggestions sont les bienvenues :)

F #, 264 caractères

Pas vraiment un langage conçu pour le golf, mais je suis sûr que cela pourrait être amélioré. Utiliser Seq.exists avec un lambda est assez ennuyeux, tout comme les nombreuses parens et le manque de conversion implicite.

Utilise la récursivité, continue indéfiniment.

let g=System.Random()
let c()=char(g.Next(65,90))
let k(i:string)l=Seq.exists(fun e->i.Contains(e))l
let rec p d:unit=
 let l=sprintf"%i-%c%c%c"(g.Next(100,999))(c())(c())(c())
 if k l d||k l ["ASS";"666";"69";"KKK";"SHT"]then p d else
  printfn"%s"l
  p(l::d)
p[]

Peut être exécuté en FSI.

Python 203

Je ne sais pas si cela compte techniquement, mais je l'ai aimé, donc je le poste quand même. Bien que je génère les réponses de manière pseudo-aléatoire, comme à peu près tout le monde, j'ai stratégiquement choisi la graine aléatoire de sorte que les réponses invalides ne se retrouvent pas dans la sortie. Donc, ma réponse n'est pas réellement capable de générer l'ensemble des réponses valides, sans générer également les réponses invalides.

from random import*;seed(1);L='ABCDEFGHIJKLMNOPQRSTUVWXYZ';D='0123456789';C=choice
for i in 'x'*200:s=randint(0,1);a=''.join(C(L)for _ in'000');b=''.join(C(D)for _ in'000');i=[a,b];print i[s-1]+'-'+i[s]

Perl - 123 caractères

while(@p<200){$l=(AAA..ZZZ)[int rand 999]."-".(100+int rand 899);@p=grep!/ASS|666|69|KKK|SHT|$l/,@p;push@p,$l}$,=$/;print@p

Non golfé:

while(@p < 200){ # Repeat until we get 200 plates
    $l = (AAA..ZZZ)[int rand 999]."-".(100+int rand 899); # generate the license plate
    @p = grep !/ASS|666|69|KKK|SHT|$l/, @p; # remove disallowed license ones and duplicates
    push @p, $l # add a license plate
}
$,=$/; # so they print with newlines
print @p # print the plates

Si quelqu'un a des idées pour jouer au golf plus loin, faites-le moi savoir, je suis intéressé. Si vous voulez plus d'explications sur une partie du code, laissez un commentaire et je serais heureux de vous en expliquer plus.

Javascript - 283 327 caractères

Éditer:

Après avoir implémenté les suggestions d' Alconja , voici ma nouvelle version:

m=Math.random;function y(v){return "ASS|KKK|SHT|666".indexOf(v)<0&&v.indexOf("69")<0?0:!0}function c(){return String.fromCharCode(m()*26+65)}for(i=0;i<200;i++){do {do {n=(m()+"").slice(2,5)}while(y(n));do {l=c()+c()+c()}while(y(l));r=l+"-"+n}while(o.indexOf(r)>=0);o+=r+"\n"}alert(o)
/* 1 line - 283 Characters */

1) Supprimer la variable: s et utiliser le littéral: "\ n" [-4] [323]
2) Supprimer "var o =" ", i, r, n, l," [-17] [306]
3) Supprimer Variable: t et utilisez littéral: "ASS | KKK | SHT | 666" [-4] [302]
4) Définissez m = Math.random et utilisez plutôt "m" [-7] [296]
5) Utilisez (m ( ) + "") plutôt que m (). toString () [-6] [290]
6) Supprimer les inutiles ";" [-7] [283]

Ancienne version: Javascript - 327 caractères

Je suis sûr qu'il y a de la place pour l'amélioration ... Je suis assez inexpérimenté au Code-golf:

var o="",s="\n",i,r,n,l,t="ASS|KKK|SHT|666";function y(v){return t.indexOf(v)<0&&v.indexOf("69")<0?0:!0;}function c(){return String.fromCharCode(Math.random()*26+65);}for(i=0;i<200;i++){do {do {n=Math.random().toString().slice(2,5);}while(y(n));do {l=c()+c()+c();}while(y(l));r=l+"-"+n;}while(o.indexOf(r)>=0);o+=r+s;}alert(o);    
/* 1 line - 327 Characters */

Voici une version formatée, "non golfée" avec des noms de variable / fonction "non minifiés":

var outp="",lsep="\n",ndx,res,nbr,ltr,tbl="ASS|KKK|SHT|666";
function fnvfy(vinp){
  return tbl.indexOf(vinp)<0&&vinp.indexOf("69")<0?0:!0;
}
function fnchr(){
  return String.fromCharCode(Math.random()*26+65);
}
for(ndx=0;ndx<200;ndx++){
  do {
    do {
      nbr=Math.random().toString().slice(2,5);
    }
    while(fnvfy(nbr));
    do {
      ltr=fnchr()+fnchr()+fnchr();
    }
    while(fnvfy(ltr));
    res=ltr+"-"+nbr;
  }
  while(outp.indexOf(res)>=0);
  outp+=res+lsep;
}
alert(outp);

javascript:(function(){var outp="",lsep="\n",ndx,res,nbr,ltr,tbl="ASS|KKK|SHT|666";function fnvfy(vinp){return tbl.indexOf(vinp)<0&&vinp.indexOf("69")<0?0:!0;}function fnchr(){return String.fromCharCode(Math.random()*26+65);}for(ndx=0;ndx<200;ndx++){do {do {nbr=Math.random().toString().slice(2,5);}while(fnvfy(nbr));do {ltr=fnchr()+fnchr()+fnchr();}while(fnvfy(ltr));res=ltr+"-"+nbr;}while(outp.indexOf(res)>=0);outp+=res+lsep;}var x=window.open();x.document.write('<head>\n</head>\n<body>\n<form name=sa><textarea name=t rows=25 cols=80 wrap>'+outp+'</textarea><br />\n</body>\n');x.document.close();})()
/* */

Voici la version "debug", formatée:

javascript:
(function(){
  var outp="",lsep="\n",ndx,res,nbr,ltr,tbl="ASS|KKK|SHT|666";
  function fnvfy(vinp){
    return tbl.indexOf(vinp)<0&&vinp.indexOf("69")<0?0:!0;
  }
  function fnchr(){
    return String.fromCharCode(Math.random()*26+65);
  }
  for(ndx=0;ndx<200;ndx++){
    do {
      do {
        nbr=Math.random().toString().slice(2,5);
      }
      while(fnvfy(nbr));
      do {
        ltr=fnchr()+fnchr()+fnchr();
      }
      while(fnvfy(ltr));
      res=ltr+"-"+nbr;
    }
    while(outp.indexOf(res)>=0);
    outp+=res+lsep;
  }
  var x=window.open();
  x.document.write('<head>\n</head>\n<body>\n<form name=sa><textarea name=t rows=25 cols=80 wrap>'+outp+'</textarea><br />\n</body>\n');
  x.document.close();
}
)()