Chỉnh sửa: Sẽ có phần thưởng -20 cho mặt nạ ngẫu nhiên

Xin chào những người thổi còi và người mang kiến ​​thức bí mật.

Tôi là do một cuộc phỏng vấn qua thư và tôi - tất nhiên - không thể nói tên cụ thể đầy đủ. Nhưng khi tôi muốn tiết lộ nó theo một cách không rõ ràng - tôi cần sự giúp đỡ của bạn.

Tôi sẽ cung cấp những tên này dưới dạng

"evil_company_that_makes_me_shiver"

nhưng chắc chắn tôi không muốn đánh vần nó hoàn toàn. Nhiệm vụ của bạn là giúp tôi và cả thế giới là bạn cung cấp một chương trình hay, biến những điều trên thành

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

hoặc là

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

hoặc thậm chí

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

Tôi nghĩ rằng bạn nhận được nó. Nhưng có một lỗ hổng: Tôi muốn tiết lộ toàn bộ tên, vì vậy tôi cần chuyển số lần xuất hiện và từ đó cho tập lệnh và nó sẽ tiết lộ các chữ cái từng chút một. Một ví dụ có thể là

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

hoặc là

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

hoặc là

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

Tôi hy vọng bạn có thể giúp tôi và như chúng tôi biết rằng kích thước quan trọng là mã ngắn nhất sẽ thắng. Giúp làm cho thế giới này một nơi tốt đẹp hơn!

GolfScript, 26 người làm từ thiện

Vì không có cách tiết lộ cụ thể nào được chỉ định, tôi quyết định đi ngắn nhất:

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

Bạn có thể thử nghiệm với mã này trực tuyến .

Thí dụ:

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

Mã nhận xét:

: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 byte

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

Sử dụng mẫu:

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

Con trăn ( 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)

Trăn phô mai ( 55 35):

Bạn đã không cho tôi biết phân phối cần thiết;)

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

Trăn đồng phục ( 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)

Đầu ra:

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

cho

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

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

Trong hành động:

$ ./anon.sh stackoverflow.com 6
thứ ******
** ack ******.
***** ờ ******
****** * rfl ******
****** / TÌM
****** / TÌM
$ 

C #, 226

Điều này có thể được cắt giảm nếu bạn thay thế các công cụ ngẫu nhiên bằng một phân phối đơn giản hơn (mô đun suy nghĩ) nhưng tính ngẫu nhiên là điều khiến tôi quan tâm. =)

Dù sao, đặt mọi thứ vào chỉ một dòng tôi nhận được 226 ký tự. Trong mã có thể đọc được, nó trông như thế này:

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

Đầu ra mẫu:

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

Yêu cầu -pchuyển đổi, chiếm hai trong số các byte. Đọc từ STDIN.

Làm thế nào nó hoạt động

• Do công -ptắc, Perl đọc lời nói dối đầu vào đầu tiên và lưu trữ nội dung của nó vào $_.

• Lệnh $_ x=<>;nhân đôi dòng đầu vào đầu tiên số lần dòng đầu vào thứ hai ( <>) chỉ định.

• Lệnh s/(.|\n)./\1*/g;tiêu thụ hai ký tự và thay thế ký tự thứ hai (không thể là dòng mới) bằng dấu hoa thị. Nó làm điều này cho đến khi nó đã tiêu thụ toàn bộ nội dung của $_.

  Vì các dòng mới được tính là ký tự đầu tiên, điều này sẽ làm xáo trộn tất cả các ký tự chẵn trên dòng đầu tiên và tất cả các ký tự lẻ trên các dòng còn lại.

• Vì -pchuyển đổi, Perl in nội dung của $_.

Ví dụ đầu vào

codegolf
4

Ví dụ đầu ra

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

Java - 490

Vâng, không thực sự chơi golf hay bất cứ điều gì. Ồ, đây là:

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

Trong một định dạng đẹp, dễ đọc:

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

Sử dụng mẫu (Khi chạy từ lớp đã biên dịch)

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

Con trăn 3 - 187 (-20 = 167)

Mất một thời gian để viết, tôi có thể chơi golf nhiều hơn.

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)

Sử dụng mẫu:

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

Là một hàm - 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()));}}}

Không chơi gôn

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

Mẫu vật:

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

Perl 6 (77 byte)

Điều này có thể được tính là gian lận, nhưng nó giải quyết được vấn đề (nó không in toàn bộ chuỗi).

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

Và đầu ra mẫu.

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

Nhanh chóng, phá vỡ nếu bạn cung cấp một tên và yêu cầu nhiều mảnh hơn các ký tự, nhưng hoạt động đến thời điểm đó và xuống đến 1. Tôi có thể chơi golf nhiều hơn, vì vậy có thể sửa đổi hoặc đưa ra lời khuyên, vì đó là một mớ hỗn độn.

Chỉnh sửa: Đã đánh gôn thêm (từ 187) bằng cách xóa dấu ngoặc (@Synthetica) và thay thế Math.floor từ @tooth Brush. Để thay đổi vòng lặp như đề xuất dẫn đến lỗi trong đầu ra.

R, (120-20) = 100 byte (2 giải pháp khác nhau có cùng độ dài)

Bên cạnh sự đồng nhất, R chắc chắn có tính năng tạo số ngẫu nhiên tốt nhất! :) Đây là giải pháp đầu tiên có độ dài 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=""))
}

Nếu hàm được đặt tên là f , đầu ra trông như sau:

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

Và đây là giải pháp thứ 2, một lần nữa với mặt nạ ngẫu nhiên và một lần nữa dài 120 byte:

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 byte

Sau khi giải pháp trong RI cũng tìm thấy một trong Scala, đây là:

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 byte

Sau một nghiên cứu ngắn, tôi tìm thấy phương thức zipWithIndex . Tuyệt vời :)

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
}

Đây là giải pháp:

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ử dụng regex.

Mẫu vật

> 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 ký tự]

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

Giải trình

1. Đầu vào: x = Chuỗi cần được che, y = số dòng
2. Đếm số lượng ký tự c trong chuỗi và tạo các thùng y.
3. Đặt c mod y ký tự vào mỗi thùng.
4. Đối với mỗi nhóm, in "*" cho các số còn lại không nằm trong nhóm đó.

Thí dụ

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

Đầu ra

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

Cách sử dụng và đầu ra mẫu:

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

Vì mặt nạ là ngẫu nhiên, đầu ra cũng có thể trông như thế này:

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

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

Julia 56-20 = 36 (hoạt động thường xuyên)

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

Cố gắng tìm kiếm một giải pháp ngẫu nhiên ngắn hơn, tôi quyết định hy sinh chức năng được đảm bảo cho một giải pháp ngắn hơn. Đó thực sự không phải là một giải pháp tốt.

F # - 81 80 75

Điều này khá giống với những người khác đã được cung cấp:

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

Mẫu vật:

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

Là một ứng dụng độc lập, đầy đủ, nó có tới 160 155 156 ký tự:

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