Lo scenario: sei un progettista di software che lavora per un'azienda gestita dal governo che progetta targhe per automobili e altri veicoli. Ti è stato chiesto di sviluppare software che genera targhe. Prima che tu potessi lavorare, i tuoi capi hanno stabilito queste regole di base.

Una targa non può contenere:

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

Regole e requisiti:

• La targa deve essere generata casualmente.
• Una volta generata una targa casuale, non è possibile generare nuovamente la stessa targa.
• È necessario produrre almeno 200 targhe uniche . Puoi generarne di più se vuoi .
• È possibile memorizzare le piastre generate in un file per "ricordarle".
• La targa contiene 2 sezioni, una contenente solo tre lettere e una contenente solo tre numeri, separati da un trattino, in questo modo: 233-ADFoppure ADF-233.
• Puoi usare solo numeri e lettere maiuscole.
• Le targhe possono essere scritte su stdout o su un file.
• Ogni "lato" di una targa conterrà tre numeri o lettere.
• Questo è un codice-golf , quindi la risposta più breve, più popolare, vince. Il vincitore verrà scelto dopo sette giorni.

Regole generali

• La risposta dovrebbe includere, a titolo esemplificativo, quanto segue.
• Nome della lingua.
• Conteggio dei caratteri.
• Dimensione del file.
• Come viene eseguito il codice.
• Il codice stesso.
• Esempio: caratteri Python 234 o Python 23mb .

Se devo chiarire ulteriori dettagli, ti preghiamo di menzionarlo nei commenti e lo aggiungerò al mio post. Comunque, buona fortuna e generami alcune targhe appropriate!

Aggiornamento 1: il vincitore verrà scelto leggermente prima.

Si scopre che dovrò partire presto per un viaggio, quindi sceglierò un vincitore intorno alle 00:00 UTC, il 25 luglio. Dopo aver scelto il vincitore, puoi comunque inviare gli impegni, basta sapere che è stato scelto un vincitore. Bai.

Aggiornamento 2: Vincitori!

Abbiamo vincitori! Sìì! Formaggio e vino a tutti coloro che hanno partecipato! Ecco chi ha vinto.

• 1 ° posto: Àngel - Bash (95 caratteri)
• 2 ° posto: Martin Büttner - Mathematica (182 byte)
• 2 ° posto: Emilio M Bumachar - Pyg (92?)
• 2 ° posto: Peter Taylor - Golfscript (98 caratteri)
• 3 ° posto: Mark Thomas - Ruby (127 personaggi)

Wow, tre pareggi al secondo posto. Wow. La competizione è finita, ma puoi inviarci le iscrizioni se lo desideri. Bai!

bash (95 caratteri)

Salvare lo script come min una cartella nel PERCORSO con il bit di esecuzione impostato.

Correre come bash m . I piatti sono memorizzati nel file 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

Ciò equivale a eseguire quanto segue:

# 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 

Avvertenza: la finale m dovrebbe effettivamente essere exec m(+5 caratteri) per evitare di lasciare processi in attesa di completamento (ma puoi avere migliaia senza molti problemi)

Il merito va a http://www.cyberciti.biz/faq/linux-random-password-generator/ per l'idea di usaretr -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))

Ora è in grado di selezionare uniformemente da tutte le piastre inutilizzate, rispettando le specifiche di OP, pur essendo più corto di 1 carattere in più.

È teoricamente possibile che l'elenco di 999 piatti conterrà abbastanza ripetizioni in modo che il set ritagliato sarà inferiore a 200. Ma le probabilità sono infinitamente piccole. In dieci prove, la lunghezza più bassa che ho ottenuto è stata 994.

EDIT: cambiato 999 in K (che è pyg per 1000), per salvare due caratteri su consiglio di bitpwner.

Mathematica, 182 byte

Questo è lungo

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

Ungolfed

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

Abbastanza diretto. Genera piatti casuali e filtra i duplicati e quelli proibiti fino a quando non vengono trovati 200.

GolfScript (98 caratteri)

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

Questo genera tutte le possibili targhe in ordine casuale usando una brutta conversione di base seguita da un filtro. Ce ne sono molti, quindi non aspettarti che si esegua rapidamente, ma la domanda non ha posto alcun limite ai tempi di esecuzione.

JavaScript (ES6) - 213

Probabilmente può essere migliorato. Testato su Firefox Console.

Modificare l'avviso in a console.log()se si desidera testare

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

Rubino - 136 133 129 caratteri

Hideous. Penso che ci sia spazio per miglioramenti, comunque. Basta inserire il codice irbo prye premere Invio per eseguire:

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

Rubino, 127 caratteri

Il mio tentativo di versione "leggibile" di Ruby:

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 caratteri

Non sono un programmatore professionista o altro, quindi direi che sono soddisfatto del risultato.

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 dimensione del file è di 4,0 K, eseguita con python file.py!

Python - 208

Ciao ecco la mia pugnalata alla generazione della targa. Questa soluzione è simile alla soluzione di @ bitpwner ma senza il modulo di stringa e invece di un elenco per la targa ho scelto di utilizzare un set e consente anche i numeri prima.

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)

Uscita campione:

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

Python, 252 byte

Ecco il mio contributo. Ne sono impressionato, ma so che altri hanno fatto meglio con 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

Quelle importazioni ...

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

Se è necessario iniziare in modo casuale con numeri o alfabeti, cosa che non credo sia davvero necessaria, quindi 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

È stato il massimo che potevo fare.

<?$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;}}}

Per eseguire il codice è sufficiente salvarlo come file .php e cercarlo su qualsiasi server Web. Tenterà di creare il file della blacklist p.txt se non esiste già. Tuttavia, potrebbe non essere necessario definirlo con un percorso completo del server se non si dispone dell'accesso root.

Il codice stesso è qui pre golfificazione:

<?
// 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;
        }
    }
}

Era il più corto possibile :-(

Uscita campione

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: riordinato un paio di istruzioni if ​​per usare la forma abbreviata.

Delfi, 161 byte

Ecco la mia opinione su questo. Emette targhe su stdout senza avanzamento di riga tra di loro. Se è necessario LF (non specificato nelle regole), questo aggiunge 4 byte extra.

Versione golfizzata:

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.

Ungolfed:

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.

Come eseguire:

app.exe > plates.txt

PHP, 267

Questo è il più breve possibile.

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

Le piastre sono memorizzate nel file "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 caratteri

Sono sicuro che questo potrebbe essere migliorato:

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="-")

Esegui nella console, stampa un elenco di targhe.

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

Avvertenza : 200 finestre di avviso (passare alerta console.logper testare)

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

Modifica : Oops. Versione originale stampati duplicati ...

Modifica 2 : ora più vicino alla partitura originale: passato da un set a un array associativo con alcuni controlli fugly duplicati che gli consentono di stampare mentre procede

Testato nella console di Firefox.

JavaScript (ES6) 184

Come di consueto, prova console FireFox e cambiamento alertdi console.logo essere preparati a premere escape200 volte.

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 caratteri

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

Uscita campione:

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

sono 100 caratteri in meno dei migliori PHP attuali :)

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

spero ti piaccia. Nel caso sia consentito:

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

è solo 141 caratteri ma non mescola caratteri e numeri. Eventuali suggerimenti benvenuti :)

F #, 264 caratteri

Non proprio un linguaggio progettato per il golf, ma sono sicuro che potrebbe essere migliorato. L'uso di Seq.exists con un lambda è piuttosto fastidioso, così come lo sono le molte parentesi e la mancanza di conversione implicita.

Usa la ricorsione, continua per sempre.

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

Può essere eseguito in FSI.

Python 203

Non sono sicuro se questo conta tecnicamente, ma mi è piaciuto, quindi lo sto pubblicando comunque. Mentre io generi le risposte in modo pseudo-casuale, come praticamente tutti gli altri, ho scelto strategicamente il seme casuale in modo che le risposte non valide non finissero nell'output. Quindi, la mia risposta non è effettivamente in grado di generare l'intero set di risposte valide, senza generare anche quelle non valide.

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 personaggi

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

Ungolfed:

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

Se qualcuno ha idee per giocare a golf ulteriormente, fammi sapere, sono interessato. Se vuoi ulteriori spiegazioni su parte del codice, lascia un commento e sarei felice di spiegarti di più.

Javascript - 283 327 caratteri

Modificare:

Dopo aver implementato i suggerimenti di Alconja , ecco la mia nuova versione:

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) Rimuovi variabile: se usa letterale: "\ n" [-4] [323]
2) Rimuovi "var o =" ", i, r, n, l," [-17] [306]
3) Rimuovi Variabile: te usa letterale: "ASS | KKK | SHT | 666" [-4] [302]
4) Imposta m = Math.random e usa "m" invece [-7] [296]
5) Usa (m ( ) + "") anziché m (). toString () [-6] [290]
6) Rimuovi non necessario ";" [-7] [283]

Vecchia versione: Javascript - 327 caratteri

Sono sicuro che c'è un po 'di spazio per migliorare ... Sono abbastanza inesperto nel golf del codice:

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 */

Ecco una versione formattata "Ungolfed" con nomi di variabili / funzioni "non minificati":

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();})()
/* */

Ecco la versione "debug", formattata:

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