Edit: Il y aura un bonus de -20 pour le masquage aléatoire

Bonjour chers dénonciateurs et porteurs de connaissances secrètes.

Je suis due à un entretien par mail et je - bien sûr - ne peux pas dire des noms spécifiques en entier. Mais comme je veux le divulguer d'une manière plutôt pas si évidente, j'ai besoin de votre aide.

Je fournirai ces noms sous forme de

"evil_company_that_makes_me_shiver"

mais je ne veux sûrement pas l'expliquer complètement. Votre tâche pour m'aider et aider le monde entier est de fournir un programme agréable qui transforme ce qui précède en

"ev**************************"

ou

"**il************************"

ou même

"****_c**********************"

Je pense que vous avez compris. Mais il y a un défaut: je veux divulguer le nom au total, donc je dois transmettre le nombre d'occurrences et le mot lui-même au script et il divulguera les lettres petit à petit. Un exemple pourrait être

~$ ./whistle NSA 3
> "N**"
> "**A"
> "*S*"

ou

~$ ./whistle nuclear 3
> "nu*****"
> "***lea*"
> "**c***r"

ou

~$ ./whistle nuclear 2
> "nuc****"
> "***lear"

J'espère que vous pourrez m'aider et comme nous savons que la taille compte, le code le plus court l'emporte. Aidez à rendre ce monde meilleur!

GolfScript, 26 caractères

Puisqu'aucun moyen spécifique de divulgation n'a été spécifié, j'ai décidé d'aller le plus court:

:f,\`{{\)f%.!@42if}%\;n}+%

Vous pouvez tester ce code en ligne .

Exemple:

> "ABCDEFGHIJKLMNOPQRSTUVWXYZ" 7
******G******N******U*****
*****F******M******T******
****E******L******S******Z
***D******K******R******Y*
**C******J******Q******X**
*B******I******P******W***
A******H******O******V****

Code commenté:

:f           # Save the second input to variable f
,            # Makes the array [0 1 2 .... f-1]
\`{          # \´{}+% builds a code block where
             # first the input string is pushed (done
             # via the + operator and afterwards the whole
             # block is applied to above array, i.e.
             # For each line 0, 1, ...                                                
             #   Here, the stack contains the line number (counter)
             #   and the string
  {          #   {}% -> map to each character of the string
             #     Stack contains counter and current character
    \)f%     #     Increase the counter by one and calculate modulo f
    .        #     Duplicate counter (will be used for the if below)
    !        #     and test for zero 
             #     I.e. if counter==0
    @        #       Then Current character
    42       #       Else 42 (which is '*')
    if       #     
  }%         #   The mapping operation masked most of the characters
  \;         #   Discard the counter
  n          #   Add newline
}+%      

PHP - 80 octets

<?for(;($c=$argv[1][~-$i+=1])?:$k^++$j;)echo$c?$i%$k=&$argv[2]^$j?'*':$c:$i='
';

Exemple d'utilisation:

$ php whistle-blower.php ABCDEFGHIJKLMNOPQRSTUVWXYZ 7
******G******N******U*****
A******H******O******V****
*B******I******P******W***
**C******J******Q******X**
***D******K******R******Y*
****E******L******S******Z
*****F******M******T******

Python ( 157 149 139 138-20 = 118):

def f(a,b):
 from random import*;c=[["*"]*len(a) for i in range(b)]
 for d in range(len(a)):choice(c)[d]=a[d]
 for e in c:print "".join(e)

Python au fromage ( 55 35):

Vous ne m'avez pas dit la distribution requise;)

g=lambda a,b:["*"*len(a)]*(b-1)+[a]

Python uniforme ( 129 123 122 122):

def h(a,b):
 c=[["*"]*len(a)for i in range(b)]
 for d in range(len(a)):c=c[1:]+c[:1];c[0][d]=a[d]
 for e in c:print"".join(e)

Production:

a="Synthetica 'Evil' the Second"
b=7
f(a,b)
print
for i in g(a,b): print i
print
h(a,b)

donne

***t***i***'***** *********d
******************t** ******
******t*** ***********Se**n*
S**************l****e*******
*y******c***E************o**
**n*h****a**************c***
*****e*******vi*'**h********

****************************
****************************
****************************
****************************
****************************
****************************
Synthetica 'Evil' the Second

******t******v******e******d
S******i******i****** ******
*y******c******l******S*****
**n******a******'******e****
***t****** ****** ******c***
****h******'******t******o**
*****e******E******h******n*

Bash, 80 octets

m=${1//?/*}
for((i=1;d=i*${#1}/$2,i++<=$2;c=d)){
echo "${m:0:c}${1:c:d-c}${m:d}"
}

En action:

$ ./anon.sh stackoverflow.com 6
st ***************
** ack ************
***** ove *********
******** rfl ******
*********** ow. ***
************** com
$ 

C #, 226

Cela peut être réduit si vous remplacez les éléments aléatoires par une distribution plus simple (module de réflexion), mais le caractère aléatoire est ce qui m'a intéressé. =)

Quoi qu'il en soit, en mettant tout sur une seule ligne, je reçois 226 caractères. En code lisible, cela ressemble à ceci:

private void F(string n, int i)
{
    var l = n.Length;
    var r = new Random();
    var a = new string[i];

    for (var p = 0; p < l; p++)
    {
        var x = r.Next(0, i);
        for (var j = 0; j < i; j++)
        {
            a[j] += j == x ? n.Substring(p, 1) : "*";
        }
    }

    for (var j = 0; j < i; j++)
    {
        Console.WriteLine(a[j]);
    }
}

Exemple de sortie:

Anonymize.exe ABCDEFGHIJKLMNOPQRSTUVWXYZ 7
*****F**I**********T**W***
A*****************S****X**
**CDE**H*JKL**************
*************N************
**************O*****U****Z
*B****G*****M***QR********
***************P*****V**Y*

Perl, 24

$_ x=<>;s/(.|
)./\1*/g

Nécessite le -pcommutateur, qui représente deux des octets. Lit à partir de STDIN.

Comment ça fonctionne

• En raison du -pcommutateur, Perl lit le premier lie d'entrée et stocke son contenu dans $_.

• La commande $_ x=<>;duplique la première ligne d'entrée le nombre de fois <>spécifié par la deuxième ligne d'entrée ( ).

• La commande s/(.|\n)./\1*/g;consomme deux caractères et remplace le second (qui ne peut pas être une nouvelle ligne) par un astérisque. Il le fait jusqu'à ce qu'il ait consommé l'intégralité du contenu de $_.

  Étant donné que les retours à la ligne comptent comme le premier caractère, cela masquera tous les caractères pairs sur la première ligne et tous les caractères impairs sur les lignes restantes.

• En raison du -pcommutateur, Perl imprime le contenu de $_.

Exemple d'entrée

codegolf
4

Exemple de sortie

c*d*g*l*
*o*e*o*f
*o*e*o*f
*o*e*o*f

Java - 490

Ouais, pas vraiment joué au golf ou quoi que ce soit. Eh bien, le voici:

import java.util.ArrayList;public class Anonymise {public static void  main(String[] args){ArrayList[] c=new ArrayList[Integer.parseInt(args[1])];for(int i=0;i<c.length;i++)c[i]=new ArrayList();for(char a:args[0].toCharArray()){int f=new java.util.Random().nextInt(c.length);c[f].add(a);for(int i=0;i<c.length;i++)if(i!=f)c[i].add('*');}ArrayList<String> b = new ArrayList<String>();for(ArrayList a:c){String s = "";for(Object o : a)s += o;b.add(s);}for(String s : b)System.out.println(s);}}

Dans un format agréable et lisible:

import java.util.ArrayList;

public class Anonymise {

public static void main(String[] args){
    ArrayList[] c = new ArrayList[Integer.parseInt(args[1])];
    for(int i=0;i<c.length;i++)
        c[i]=new ArrayList();
    for(char a:args[0].toCharArray()){
        int f = new java.util.Random().nextInt(c.length);
        c[f].add(a);
        for(int i=0;i<c.length;i++)
            if(i!=f)c[i].add('*');
    }
    ArrayList<String> b = new ArrayList<String>();
    for(ArrayList a:c){
        String s = "";
        for(Object o : a)
            s += o;b.add(s);
    }
    for(String s : b)
        System.out.println(s);
}
}

Exemple d'utilisation (lors de l'exécution à partir de la classe compilée)

> java Anonymise OnlinePerson 3
*n****P***o*
O*li***e****
****ne**rs*n

Python 3-187 (-20 = 167)

Il m'a fallu un certain temps pour écrire, pourrait probablement être plus joué au golf.

import sys,random as a
b=sys.argv
x=[""for i in' '*int(b[2])]
for i in range(len(b[1])):n=a.randrange(len(x));x=[c+["*",b[1][len(c)]][j==n]for j,c in enumerate(x)]
for i in x:print(i)

Exemple d'utilisation:

$ python tx.py super_anonymous_user 3
s******n**y*ou****e*
**p***a**n*m**s_us*r
*u*er_**o***********

En fonction - 161 (-20 = 141)

from random import*
def f(c,n):
    x=[""for i in' '*n]
    for i in range(len(c)):n=randrange(len(x));x=[v+["*",c[len(v)]][j==n]for j,v in enumerate(x)]
    return x

C # 184

namespace System.Linq{class P{static void Main(string[] a){int n=int.Parse(a[1]);for(int i=0;i<n;i++)Console.WriteLine(new String(a[0].Select((c,x)=>(i+x)%n==0?c:'*').ToArray()));}}}

Non-golfé

namespace System.Linq
{
    class P
    {
        static void Main(string[] a)
        {
            int n = int.Parse(a[1]);
            for (int i = 0; i < n; i++)
                Console.WriteLine(new String(a[0].Select((c, x) => (i + x) % n == 0 ? c : '*').ToArray()));
        }
    }
}

Échantillon:

> Anonymize.exe "qwertyuio" 4
q***t***o
***r***i*
**e***u**
*w***y***

Perl 6 (77 octets)

Cela peut être considéré comme de la triche, mais cela résout le problème (il n'imprime pas entièrement la chaîne).

($_,$!)=@*ARGS;.say for .chop~"*","*"x.chars-1~.substr(*-1),"*"x.chars xx$!-2

Et l'exemple de sortie.

> ./script.p6 ultimately_awesome 6
ultimately_awesom*
*****************e
******************
******************
******************
******************

JavaScript - 170

function s(a,e){o="",b=a.length,x=b/e|0,y=b-x*e;for(c=1;c<=e;c++){r="*";o+=Array((c-1)*x+1).join(r)+a.substr(c*x-x,c==e?x+y:x)+Array(c<e?b-c*x+1:0).join(r)+"\n"}return o}

Rapide, se casse si vous fournissez un nom et demandez plus de pièces que de personnages, mais fonctionne jusqu'à ce point et jusqu'à 1. Je pourrais jouer au golf plus je suppose, donc peut réviser ou prendre des conseils, car c'est un peu le bordel.

Edit: Golfé plus loin (à partir de 187) avec suppression des supports (@Synthetica) et remplacement de Math.floor de @toothbrush. Un changement de boucle comme suggéré entraîne des erreurs dans la sortie.

R, (120-20) = 100 octets (2 solutions différentes de même longueur)

En plus de la concision, R dispose à coup sûr du meilleur générateur de nombres aléatoires! :) Voici la 1ère solution de longueur 120:

function(s,n){
  c=strsplit(s,"")[[1]]
  e=sample(n,nchar(s),T)
  sapply(1:n,function(i)paste(ifelse(e==i,c,"*"),collapse=""))
}

Si la fonction est nommée f , la sortie ressemble à:

> f("ABCDEFGHIJKLMNOPQRSTUVWXYZ", 7)
"******GH*****************Z" 
"ABCD*********N************" 
"***********L**O***********"
"*********J**M**P*RS*U**X**" 
"**********K***********W***" 
"*****F**I*******Q*********"
"****E**************T*V**Y*"

Et voici la 2ème solution, toujours avec un masquage aléatoire, et encore 120 octets de long:

function(s,n){
  x=matrix("*",n,(m=nchar(s)))
  x[cbind(sample(n,m,T),1:m)]=strsplit(s,"")[[1]]
  apply(x,1,paste,collapse="")
}

Scala (1) 177 octets

Après que la solution dans RI en ait également trouvé une à Scala, la voici:

def f(s:String, n:Int)={
  def c=s map (z=>z.toString)
  def r=(1 to s.length) map (v=>v%n+1)
  (for (i<-1 to n) yield s zip r map (t=>if(t._2==i) t._1 else "*") mkString "") map println
}

Scala (2) 129 octets

Après une courte recherche, j'ai trouvé la méthode zipWithIndex . Merveilleux :)

def f(s:String, n:Int)={
  (for (i<-0 until n) yield s.zipWithIndex.map (t=>if(t._2 % n==i) t._1 else "*") mkString "") map println
}

Voici la solution:

f("ABCDEFGHIJKLMNOPQRSTUVWXYZ", 4)
***D***H***L***P***T***X**
A***E***I***M***Q***U***Y*
*B***F***J***N***R***V***Z
**C***G***K***O***S***W***

Javascript - 166

function s(b,a){o="";k=Array(a).join("*");t=k+b+k;for(i=a;0<i;i--)o+=t.replace(RegExp(".{"+(a-1)+"}(.)","g"),k+"$1").substr(i-1,b.length)+"\n",t=t.substr(1);return o}

Utilisation de regex.

Échantillon

> s("four",5)                      
f***                            
*o**                             
**u*                             
***r                             
****                             

> s("evil_company_that_makes_me_shiver",3)
e**l**o**a**_**a**m**e**m**s**v**
*v**_**m**n**t**t**a**s**e**h**e*
**i**c**p**y**h**_**k**_**_**i**r

k [50-20 = 30 caractères]

{.{@[y#"*";z;:;x z]}[x;c]'=_d*y%#d:<<(-d)?!d:c:#x}

Explication

1. Entrée: x = chaîne à masquer, y = nombre de lignes
2. Comptez le nombre de caractères c dans la chaîne et créez des compartiments y.
3. Placez c caractères mod y dans chaque compartiment.
4. Pour chaque compartiment, imprimez "*" pour les nombres restants ne figurant pas dans ce compartiment.

Exemple

{.{@[y#"*";z;:;x z]}[x;c]'=_d*y%#d:<<(-d)?!d:c:#x}["abcdefghijklmnopqrstuvwxyz";4]

Production

"ab*d*f***j**********u*w***"
"**c*e*gh**k*****q*s*******"
"********i***mn*****t*v**y*"
"***********l**op*r*****x*z"

JavaScript - 139-20 = 119

function e(s,c){r=[];for(i=c;i--;)r[i]='';for(i=0;i<s.length*c;i++)x=i%c,n=(x<1?Math.random()*c|0:n),r[x]+=(n!=x?'*':s[(i/c)|0]);return r}

Utilisation et exemple de sortie:

console.log(e("evil_company_that_makes_me_shiver", 3));

["**i*_**mp*****h**_ma**********v**", 
 "*****co**a***t*a******s*me_*hi*e*", 
 "ev*l******ny_***t***ke*_***s****r"]

Comme le masquage est aléatoire, la sortie peut également ressembler à ceci:

console.log(e("evil_company_that_makes_me_shiver", 2));

["evil_company_that_makes_me_shiver", 
 "*********************************"]

Julia 56-20 = 36 (fonctionne souvent)

f(s,n)=[join([rand()<1.9/n?c:"*" for c in s]) for r=1:n]

julia> f("evilcompany!!!",4)
4-element Array{Union(UTF8String,ASCIIString),1}:
 "e**l**mp*ny*!*"
 "***lco********"
 "e*il**m*a*y!*!"
 "evil**m*an***!"

En essayant de choisir une solution aléatoire plus courte, j'ai décidé de sacrifier le fonctionnement garanti pour une solution plus courte. Ce n'est vraiment pas une très bonne solution.

F # - 81 80 75

Ceci est assez similaire à d'autres qui ont été proposés:

let a s n=[for i in 0..n-1->String.mapi(fun j c->[c;'*'].[min((j+i)%n)1])s]

Échantillon:

a "evil_company_that_makes_me_shiver" 7

e******m******h******e******h**** 
******o******t******k******s***** 
*****c******_******a******_****** 
****_******y******m******e******r 
***l******n******_******m******e* 
**i******a******t******_******v** 
*v******p******a******s******i*** 

En tant qu'application complète et autonome, il contient 160 155 156 caractères:

[<EntryPoint>]let m (a:string array)=
 let n=System.Int32.Parse a.[1]
 for i in 0..n-1 do printfn"%s"(String.mapi(fun j c->[c;'*'].[min((j+i)%n)1])a.[0])
 0