16

संपादित करें: यादृच्छिक मास्किंग के लिए -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"

मुझे उम्मीद है कि आप मेरी मदद कर सकते हैं और जैसा कि हम जानते हैं कि आकार सबसे कम कोड जीतता है। इस दुनिया को एक बेहतर जगह बनाने में मदद करें!

code-golf

— german_guy
स्रोत

1

आप इस बारे में कोई विवरण नहीं देते हैं कि मास्किंग कैसे होनी चाहिए, इसलिए आपको जो भी सबसे छोटा कोड होना चाहिए, वह आपके उदाहरणों से कोई फर्क नहीं पड़ता।

— बिल वुडनर

मुझे लगा कि यह स्पष्ट है कि सबसे छोटा कोड जीतता है? हम्म, शायद मुझे इसके अनुसार अपने अंग्रेजी व्याकरण में सुधार करने की आवश्यकता है :( / संपादित करें: मैं वास्तव में इस बात पर ध्यान नहीं देता कि मास्किंग कैसे किया जाता है, उपरोक्त सिर्फ एक उदाहरण है, लेकिन अगर आप एक उच्चारण पढ़ते हैं तो यह "अपठनीय" होना चाहिए अकेले "

— जर्मन_गुई

हां, सबसे छोटा कोड स्पष्ट था। लेकिन आप ज्यादातर अपने नमूनों की तरह "नियमित" मास्किंग प्राप्त करेंगे। शायद, चूंकि आप किसी भी तरह से बुरा नहीं मानते हैं, अपने नमूना आउटपुट को नियमित रूप से बदलें। विशेष रूप से आपके द्वारा इसका दूसरा उदाहरण चल रहा है, साथ ही आपके प्रश्न में उदाहरण है

— Bill Woodger

1

या आप यादृच्छिक मास्किंग के लिए एक बोनस दे सकते हैं।

— atı

12

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
}+%

— हावर्ड
स्रोत

अच्छा! क्या आप बता सकते हैं कि कोड का प्रत्येक भाग क्या करता है?

— जॉन ओडम

9

क्यों नहीं देख सकता। GolfScript बहुत स्व-दस्तावेजीकरण है।

— Evpok

@ जॉनऑनडोम फिर भी मैंने कुछ टिप्पणियों को कोड में जोड़ा।

— हावर्ड

यदि आप बेतरतीब ढंग से तय करते हैं कि आप सभी * को एक-एक करके दाईं ओर शिफ्ट करने जा रहे हैं, तो क्या यह रैंडम मास्किंग बोनस की गणना करता है?

— क्रंचर

7

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

— Primo
स्रोत

7

पायथन ( 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*

— ɐɔıʇǝɥʇuʎs
स्रोत

आपके चीयर्स पाइथन को छोटा किया जा सकता है g=lambda a,b:[a]+["*"*len(a)]*(b-1)। : पी

— cjfaure

@ मैं देख रहा हूँ, धन्यवाद :)

— ʇǝɥʇıʎu Aprs

3

मुझे लगता है लेकिन निश्चित रूप से मैं इसे पूरी तरह से स्पष्ट रूप से रद्द नहीं करना चाहता हूं जो एक समाधान को सुनिश्चित करता है जो यह सुनिश्चित नहीं करता है कि आउटपुट की प्रत्येक पंक्ति में कम से कम एक वर्ण नकाबपोश है।

— हॉवर्ड

@ मुझे पता है कि यह नियमों को बढ़ा रहा है, लेकिन disclose the letters bit by bitइसका मतलब यह भी हो सकता है first, disclose the first bit (that just happens to be the entire thing), repeat until the b is met। यह पहले उत्तर के लिए भी हो सकता है, इसलिए बस दावा करें कि आपने इसका उपयोग किया था, और यह इस परिणाम का उत्पादन करने के लिए खुश है। (मुझे सिर्फ एहसास हुआ कि आप इसे भी लिख सकते हैं ["*"*len(a)]*(b-1)+[a], ताकि आप बिट्स का खुलासा करने से शुरू करें जो कि वास्तविक जानकारी के 0 बाइट्स को शामिल करने के लिए होता है, और अंतिम पंक्ति पर, आप एक और बिट का खुलासा करते हैं।) मुझे हालांकि, एहसास है, कि यह अधिकतम तक खींच रहा है।

— atı 13uʎs

3

बैश, 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
सेंट ***************
** पावती ************
***** ove *********
******** RFL ******
***********ओउ।***
************** कॉम
$

— डिजिटल आघात
स्रोत

2

सी #, 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*

— deroby
स्रोत

क्या यह हमेशा इनपुट से कम से कम चरित्र की गारंटी देता है?

— बिल वुडगेर

हम्म .. नहीं, शायद नहीं; अच्छी पकड़। छोटे तार और आपके लिए कम मूल्यों के iसाथ शायद समाप्त हो सकता है ***/test।

— डर्बी

2

पर्ल, २४

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

-pस्विच की आवश्यकता है , जो दो बाइट्स के लिए खाता है। STDIN से पढ़ता है।

यह काम किस प्रकार करता है

की वजह से -pस्विच, पर्ल पहला इनपुट झूठ पढ़ता है और में उसकी सामग्री को संग्रहीत करता है $_।
कमांड $_ x=<>;पहली इनपुट लाइन को दूसरी इनपुट लाइन ( <>) निर्दिष्ट करता है।
आदेश s/(.|\n)./\1*/g;दो वर्णों का उपभोग करता है और दूसरे (जो एक नई पंक्ति नहीं हो सकता है) को तारांकन चिह्न से बदल देता है। यह तब तक करता है जब तक कि यह पूरी सामग्री का उपभोग नहीं करता है $_।

चूँकि नई सूचियाँ पहले वर्ण के रूप में गिनी जाती हैं, यह पहली पंक्ति के सभी वर्णों और शेष रेखाओं पर सभी विषम वर्णों को बाधित करेगा।
की वजह से -pस्विच, पर्ल की सामग्री को प्रिंट $_।

उदाहरण इनपुट

codegolf
4

उदाहरण आउटपुट

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

— डेनिस
स्रोत

डुप्लिकेट स्ट्रिंग्स, बहुत साफ नहीं ...

— CSᵠ

क्या आपको लगता है कि आप इनपुट के साथ इसे दो लाइनों पर रखने के लिए गड़बड़ कर सकते हैं?

— बिल वुडगेर

@ बेलवर्गर: प्रश्न इनपुट के किसी भी रूप को निर्दिष्ट नहीं करता है।

— डेनिस

काफी उचित। couldआपको :-)

— बिल वुडगेर

Since newlines count as the first character, this will obfuscate all even characters on the first line and all odd characters on the remaining lines.

ऐसा लगता है जैसे के लिए विफल हो जाएगाcodegolf\n1

— Cruncher

1

जावा - 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

— इसहाक
स्रोत

क्या आप वह चला रहे हैं या टाइप कर रहे हैं? P को P कैसे मिलता है?

— बिल वुडनर

कोई दिक्कत नहीं है। बस इस्तेमाल की गई टिप्पणियों को अभी दूर करें

— बिल वुडर

बस import java.util.*इसके अलावा, ArrayList<String> = new ArrayList<>();काम करेंगे। आप बहुत सारे रिक्त स्थान भी निकाल सकते हैं। और ज्यादातर समय, आप Listइसके बजाय उपयोग कर सकते हैं ArrayList।

— यपनिप

1

पायथन 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

— cjfaure
स्रोत

क्या यह हमेशा इनपुट से कम से कम चरित्र की गारंटी देता है?

— बिल वुडनर

@ बेलवर्गर नं।

— cjfaure

2

क्षमा करें, व्यक्तिगत रूप से मैं इसे तब काम नहीं करने के रूप में मानता हूं। फिर।

— बिल वुडगेर

चीजों को छोटा करने के कुछ सरल तरीके: sys.argvअसाइनमेंट में अनपैक करें, और xजैसा कि आपके द्वारा अनपैकिंग में उपयोग किए जाने वाले वैरिएबल को नाम दिया गया है , के रूप x=['']*int(b[2])में b[2]प्रतिस्थापित करें।

— user2357112

2

मुझे लगता है लेकिन निश्चित रूप से मैं इसे पूरी तरह से स्पष्ट रूप से रद्द नहीं करना चाहता हूं जो एक समाधान को सुनिश्चित करता है जो यह सुनिश्चित नहीं करता है कि आउटपुट की प्रत्येक पंक्ति में कम से कम एक वर्ण नकाबपोश है।

— हावर्ड

1

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

गैर 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***

— रिक
स्रोत

1

पर्ल 6 (77 बाइट्स)

यह धोखा के रूप में गिना जा सकता है, लेकिन यह समस्या को हल करता है (यह स्ट्रिंग को पूरी तरह से प्रिंट नहीं करता है)।

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

और नमूना उत्पादन।

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

— कोनराड बोरोस्की
स्रोत

1

जावास्क्रिप्ट - 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 से नीचे। मुझे अधिक ग्रहण किया जा सकता है, इसलिए यह थोड़ा गड़बड़ है या सलाह ले सकता है, क्योंकि यह थोड़ा गड़बड़ है।

संपादित करें: कोष्ठक (@Synthetica) को हटाने और @toothbrush से Math.floor प्रतिस्थापन के साथ (187 से) आगे गोल्फ। आउटपुट में त्रुटियों के लिए सुझाए गए परिणाम के रूप में लूप परिवर्तन के लिए।

— मैट
स्रोत

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

बंद-compiler.appspot.com/home 8 वर्णों को बंद करने में सक्षम था;)

— ʇǝɥʇı Apru's

क्या आप कह रहे हैं कि यदि पाठ पाँच वर्णों का है और इसे छह प्रतिस्थापनों के लिए कहा जाता है?

— बिल वुडगेर

@BillWoodger उन्होंने कहा कि क्लोजर कंपाइलर का उपयोग करके उन्होंने कोड की कुल लंबाई से 8 वर्णों का मुंडन किया।

— एडुआर्ड फ्लोरिंसक्यू

@EduardFlorinescu, क्षमा करें, मैं अस्पष्ट था, मेरा मतलब यह था breaks if you supply a name and ask for more pieces than characters

— बिल वुडनर

1

के x=b/e|0बजाय का उपयोग करें x=Math.floor(b/e)। इसके अलावा, for(c=1;c<=e;c++)छोटा किया जा सकता है for(c=1;c++<=e;)।

— टूथब्रश

1

आर, (120-20) = 100 बाइट्स (एक ही लंबाई के 2 अलग-अलग समाधान)

संगति के साथ, आर यकीन है कि सबसे अच्छा यादृच्छिक संख्या जनरेटर सुविधाएँ! :) यहाँ लंबाई 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="")
}

— lambruscoAcido
स्रोत

0

स्काला (1) 177 बाइट्स

आरआई में समाधान के बाद भी स्काला में एक मिला, यहां यह है:

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
}

स्काला (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***

— lambruscoAcido
स्रोत

0

जावास्क्रिप्ट - 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

— जोरो
स्रोत

0

k [५०-२० = ३० वर्ण]

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

व्याख्या

इनपुट: x = स्ट्रिंग जिसे मास्क किया जाना है, y = लाइनों की संख्या
स्ट्रिंग में c अक्षर की संख्या गिनें और y बकेट बनाएँ।
प्रत्येक बाल्टी में c mod y अक्षर रखें।
प्रत्येक बकेट के लिए, बकेट में शेष संख्याओं के लिए "*" प्रिंट करें।

उदाहरण

{.{@[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"

— NYI
स्रोत

0

जावास्क्रिप्ट - 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", 
 "*********************************"]

— codeporn
स्रोत

0

जूलिया 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***!"

एक छोटे से यादृच्छिक समाधान के लिए जाने की कोशिश कर रहा हूँ मैंने एक छोटे समाधान के लिए गारंटीकृत कामकाज का त्याग करने का निर्णय लिया। यह वास्तव में एक बहुत अच्छा समाधान नहीं है।

— gggg
स्रोत

0

एफ # - 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

— pswg
स्रोत

नाम अनाम - की तरह

GolfScript, 26 चार्टर्स

PHP - 80 बाइट्स

पायथन ( 157 149 139 138-20 = 118):

चीज़ पाइथन ( 55 35):

वर्दी अजगर ( 129 123 122):

आउटपुट:

बैश, 80 बाइट्स

सी #, 226

पर्ल, २४

यह काम किस प्रकार करता है

उदाहरण इनपुट

उदाहरण आउटपुट

जावा - 490

पायथन 3 - 187 (-20 = 167)

एक समारोह के रूप में - 161 (-20 = 141)

सी # 184

पर्ल 6 (77 बाइट्स)

जावास्क्रिप्ट - 170

आर, (120-20) = 100 बाइट्स (एक ही लंबाई के 2 अलग-अलग समाधान)

स्काला (1) 177 बाइट्स

स्काला (2) 129 बाइट्स

जावास्क्रिप्ट - 166

k [५०-२० = ३० वर्ण]

व्याख्या

उदाहरण

उत्पादन

जावास्क्रिप्ट - 139-20 = 119

जूलिया 56-20 = 36 (अक्सर काम करता है)

एफ # - 81 80 75