Изменить: Там будет бонус -20 для случайной маскировки

Привет собратьям-разоблачителям и носителям тайных знаний.

Я из-за собеседования по почте и, конечно, не могу назвать конкретные имена в полный рост. Но поскольку я хочу раскрыть это довольно не так очевидно, мне нужна ваша помощь.

Я приведу эти имена в виде

"Evil_company_that_makes_me_shiver"

но, конечно, я не хочу изложить это полностью. Ваша задача помочь мне и всему миру в том, что вы предлагаете замечательную программу, которая превращает вышесказанное в

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

или

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

или даже

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

Я думаю, вы поняли. Но есть один недостаток: я хочу раскрыть имя целиком, поэтому мне нужно передать количество вхождений и само слово в сценарий, и он будет раскрывать буквы по крупицам. Примером может быть

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

или

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

или

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

Я надеюсь, что вы можете помочь мне, и, как мы знаем, размер имеет значение, выигрывает самый короткий код. Помогите сделать этот мир лучше!

GolfScript, 26 символов

Поскольку не было указано конкретного способа раскрытия, я решил пойти на самое короткое:

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

Вы можете поэкспериментировать с этим кодом онлайн .

Пример:

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

Код комментария:

: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 байт

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

Пример использования:

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

Сырный питон ( 55 35):

Вы не сказали мне необходимый дистрибутив;)

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

Равномерный питон ( 129 123 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)

Выход:

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

дает

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

Баш, 80 байт

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

В бою:

$ ./anon.sh stackoverflow.com 6
ул ***************
** извед ************
***** ********* Ове
******** ****** RFL
*********** вл. ***
************** ком
$ 

C #, 226

Это можно урезать, если вы замените случайный материал более простым распределением (модуль мышления), но случайность - это то, что меня заинтересовало. знак равно

В любом случае, поместив все в одну строку, я получаю 226 символов. В читаемом коде это выглядит так:

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

Пример вывода:

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

Требуется -pпереключатель, который составляет два байта. Читает из STDIN.

Как это устроено

• Благодаря -pпереключателю Perl читает первую ложь ввода и сохраняет ее содержимое в $_.

• Команда $_ x=<>;дублирует первую строку ввода, сколько раз <>указывается вторая строка ввода ( ).

• Команда использует s/(.|\n)./\1*/g;два символа и заменяет второй (который не может быть символом новой строки) звездочкой. Он делает это до тех пор, пока не израсходует все содержимое $_.

  Так как символы новой строки считаются первым символом, это запутывает все четные символы в первой строке и все нечетные символы в оставшихся строках.

• Из-за -pпереключателя Perl печатает содержимое $_.

Пример ввода

codegolf
4

Пример вывода

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

Ява - 490

Да, не совсем в гольф или что-то в этом роде. Ну что ж, вот оно:

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

В хорошем, разборчивом формате:

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

Пример использования (при запуске из скомпилированного класса)

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

Питон 3 - 187 (-20 = 167)

Мне потребовалось некоторое время, чтобы написать, возможно, еще бы сыграть в гольф.

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)

Пример использования:

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

Как функция - 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-golfed

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

Образец:

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

Perl 6 (77 байт)

Это может считаться мошенничеством, но это решает проблему (не выводит строку полностью).

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

И образец вывода.

> ./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}

Быстрый, ломается, если вы предоставляете имя и запрашиваете больше фигур, чем персонажей, но работает до этого момента и вплоть до 1. Я полагаю, можно больше играть в гольф, поэтому могу пересмотреть или принять совет, так как это немного беспорядок.

Изменить: Гольф дальше (из 187) с удалением скобок (@Synthetica) и заменой Math.floor из @toothbrush. Для изменения цикла, как предложено, ошибки в выводе.

R, (120-20) = 100 байт (2 разных решения одинаковой длины)

Помимо краткости, R наверняка обладает лучшим генератором случайных чисел! :) Вот 1-е решение длиной 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=""))
}

Если функция названа как f , вывод выглядит так:

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

И вот второе решение, опять со случайной маскировкой, и снова длиной 120 байт:

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 байт

После того, как решение в RI также нашло решение в Scala, вот оно:

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 байт

После короткого исследования я нашел метод zipWithIndex . Замечательный :)

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
}

Вот решение:

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}

Использование регулярных выражений.

Образец

> 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

к [50-20 = 30 символов]

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

объяснение

1. Ввод: x = строка, которая должна быть замаскирована, y = количество строк
2. Подсчитайте количество символов c в строке и создайте y сегментов.
3. Поместите модные символы в каждое ведро.
4. Для каждого сегмента выведите «*» для оставшихся номеров, которых нет в этом сегменте.

пример

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

Выход

"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}

Использование и образец вывода:

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

Поскольку маскирование является случайным, вывод также может выглядеть следующим образом:

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

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

Юлия 56-20 = 36 (работает часто)

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***!"

Пытаясь найти более короткое случайное решение, я решил пожертвовать гарантированным функционированием ради более короткого решения. Это действительно не очень хорошее решение.

F # - 81 80 75

Это довольно похоже на другие, которые были предложены:

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

Образец:

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

В качестве полноценного автономного приложения оно может содержать 160 155 156 символов:

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