介绍：

在我小时候编写的文档中，我存储了许多不同的密码，我选择了一些我认为最适合挑战的密码（不太琐碎，也不太难），并将它们转变为挑战。它们中的大多数仍处于沙箱中，我不确定是否要全部发布还是仅发布其中几个。但是，这是第一个开始的事情。

计算机密码将给定的文本加密为给定的“随机”字符组length。如果这样的组包含一个数字，它将使用该数字索引到自己的加密字符组中。如果组中没有数字，则表示使用了第一个字符。

例如，假设我们要加密this is a computer cipher给定长度的文本5。这是一个潜在的输出（请注意：在下面的示例中，数字为1索引）：

t     h     i     s     i     s     a     c     o     m     p     u     t     e     r     c     i     p     h     e     r       (without spaces of course, but added as clarification)
qu5dt hprit k3iqb osyw2 jii2o m5uzs akiwb hwpc4 eoo3j muxer z4lpc 4lsuw 2tsmp eirkr r3rsi b5nvc vid2o dmh5p hrptj oeh2l 4ngrv   (without spaces of course, but added as clarification)

让我们以几个小组为例来说明如何解密该小组：

• qu5dt：该组包含一个数字5，因此该组的（第1个索引）第5个字符是用于解密文本的字符：t。
• hprit：该组不包含数字，因此该组的第一个字符隐含地用于解密的文本：h。
• osyw2：该组包含一个数字2，因此该组的（第1个索引）第二个字符是用于解密文本的字符：s。

挑战：

给定一个整数length和一个字符串word_to_encipher，输出一个如上所述的随机加密的字符串。

您只需加密给定的length和word_to_encipher，因此也无需创建解密程序/函数。但是，我可能会在将来对解密提出第二部分挑战。

挑战规则：

• 您可以假设length将会在范围内[3,9]。
• 您可以假定word_to_encipher遗嘱中仅包含字母。
• 您可以使用完整的小写字母或完整的大写字母（请说明您在答案中使用了哪一个）。
• 您的输出，每个组以及组中数字的位置（如果存在）应该一致地随机。因此，字母表中的所有随机字母都有相同的出现机会；每个组中加密字母的位置出现的机会相同；并且数字的位置具有相同的出现机会（除非是第一个字符且没有数字；而且显然不能与加密的字符位于同一位置）。
• 您也可以使用0索引数字而不是1索引数字。请说明您在答案中使用了哪两个。
• 数字1（或0当索引为0时）将永远不会出现在输出中。因此b1ndh，不是有效的密码“ b”组。然而，b4tbw是有效的，其中所述4<br/>加密的b在第4（1-索引）的位置，以及其他字符b，t，w是随机的（巧合还包含b）。的其它可能的有效组length5加密被字符“B”是：abcd2，ab2de，babbk，hue5b，等。

通用规则：

• 这是代码高尔夫球，因此最短答案以字节为单位。
  不要让代码高尔夫球语言阻止您发布使用非代码高尔夫球语言的答案。尝试针对“任何”编程语言提出尽可能简短的答案。
• 标准规则适用于具有默认I / O规则的答案，因此允许您使用STDIN / STDOUT，具有正确参数的函数/方法以及返回类型的完整程序。你的来电。
• 默认漏洞是禁止的。
• 如果可能的话，请添加一个带有测试代码的链接（即TIO）。
• 另外，强烈建议为您的答案添加说明。

测试用例：

Input:
 Length:           5
 Word to encipher: thisisacomputercipher
Possible output:
 qu5dthpritk3iqbosyw2jii2om5uzsakiwbhwpc4eoo3jmuxerz4lpc4lsuw2tsmpeirkrr3rsib5nvcvid2odmh5phrptjoeh2l4ngrv

Input:
 Length:           8
 Word to encipher: test
Possible output:
 ewetng4o6smptebyo6ontsrbtxten3qk

Input:
 Length:           3
 Word to encipher: three
Possible output:
 tomv3h2rvege3le

Pyth，22个字节

smsXWJOQXmOGQJdO-UQJJz

在线尝试。

使用小写字母和零索引。

说明

非常简单的算法。

                           Implicit: read word in z
                           Implicit: read number in Q
 m                   z     For each char d in z:
      OQ                     Choose a number 0..Q-1
     J                       and call it J.
         m  Q                Make an array of Q
          OG                 random letters.
        X     d              Place d in this string
             J               at position J.
    W                        If J is not 0,
   X                J        place J in this string
               O             at a random position from
                 UQ          0..Q-1
                -  J         except for J.
  s                          Concatenate the letters.
s                          Concatenate the results.

Perl 6，125个字节

->\n{*.&{S:g{.}=(65..90)>>.chr.roll(n).join.subst(/./,$/,:th($!=roll 1..n:)).subst(/./,$!,:th($!-1??(^n+1∖$!).roll!!n+1))}}

在线尝试！

以大写形式输入和输出。需要输入咖喱，例如f(n)(string)。使用1个索引。

说明：

->\n{*.&{ ...  }}   # Anonymous code block that takes a number n and returns a function
     S:g{.}=        # That turns each character of the given string into
                          .roll(n)      # Randomly pick n times with replacement
            (65..90)>>.chr              # From the uppercase alphabet
                                  .join # And join
            .subst(                         ) # Then replace
                   /./,  ,:th($!=roll 1..n:)  # A random index (saving the number in $!)
                       $/               # With the original character
            .subst(                )    # Replace again
                   /./,$!,:th( ... )    # The xth character with $!, where x is:
                           $!-1??          # If $! is not 1
                                 (^n+1∖$!).roll       # A random index that isn't $!
                                               !!n+1  # Else an index out of range

Python 2中，187个 177 176 156 154 148字节的

lambda l,s:''.join([chr(choice(R(65,91))),c,`n`][(j==n)-(j==i)*(n>0)]for c in s for n,i in[sample(R(l),2)]for j in R(l))
from random import*
R=range

在线尝试！

使用大写字母和0索引数字。

_{-3个字节，感谢Kevin Cruijssen}

JavaScript（Node.js），135字节

n=>f=([c,...s])=>c?(g=n=>n?g(--n)+(n-p?n-q|!p?(r(26)+10).toString(36):p:c):'')(n,r=n=>Math.random()*n|0,p=r(n),q=r(n-1),q+=q>=p)+f(s):s

在线尝试！

感谢Arnauld提供1B

[R ，134个 132 123字节

function(S,n,s=sample)for(k in utf8ToInt(S)){o=k+!1:n
P=s(n,1)
o[-P]=s(c(P[i<-P>1],s(17:42,n-1-i,T)))+48
cat(intToUtf8(o))}

在线尝试！

接受大写字母。

旧代码的解释（大致相同的方法）：

function(S,n){s=sample				# alias
K=el(strsplit(S,""))				# split to characters
o=1:n						# output array
for(k in K){					# for each character in the string
P=s(n,1)					# pick a Position for that character
o[-P]=						# assign to everywhere besides P:
      s(					# a permutation of:
	c(P[i<-P>1],				# P if it's greater than 1
		s(letters,n-1-i,T)))		# and a random sample, with replacement, of lowercase letters
o[P]=k						# set k to position P
cat(o,sep="")}}					# and print

Java（JDK），193字节

s->n->s.flatMap(c->{int a[]=new int[n],i=n,x=0;for(;i-->0;)a[i]+=Math.random()*26+97;a[i+=Math.random()*n+1]=c;x+=Math.random()*~-n;if(i>0)a[x<i?x:x+1]=48+i;return java.util.Arrays.stream(a);})

在线尝试！

• 索引从0开始。
• 该条目使用IntStream（通过String::chars）获得，以及一个数字作为输入，并返回另一个IntStream。
• 由于被黑客入侵，从double到的强制转换int是不必要的+=。

Japt，29个字节

;£=VöJ;CöV hUÎX hUÅÎUÎ?UÎs:Cö

在线尝试！

零索引。

说明：

;                                :Set C = [a...z]
 £                               :For each character of the input:
  =VöJ;                          : Get two different random indexes from [0,length)
       CöV                       : Get 5 random letters
           hUÎX                  : Replace one at random with the character from the input
                hUÅÎ             : Replace a different random character with:
                    UÎ?          :  If the input character was not placed at 0:
                       UÎs       :   The index of the input character
                          :      :  Otherwise:
                           Cö    :   A random letter
                                 :Implicitly join back to a string

C，115字节

g(_,n)char*_;{int i=rand(),j=i%~-n,k=0;for(i%=n;k<n;k++)putchar(k-i?!i|i<k^k-j?rand()%26+97:48+i:*_);*++_&&g(_,n);}

在线尝试！

0索引，小写。

略微偏离和扩展：

g(char*_,int n) {
    int i = rand(), j = i%(n-1), k = 0;
    for(i = i%n; k<n; k++)
        putchar(k!=i ? i!=0 || k==j + (k>i)
                          ? rand()%26 + 'A'
                          : i + '0')
                    : *_);
    if (*++_!=0) g(_,n);
}

该代码应该非常简单。两个随机量i，j在一个所生成的rand()呼叫是好的为独立自GCD（ n，~-n）= 1，RAND_MAX是大的。

干净 256字节

import StdEnv
s::!Int->Int
s _=code {
ccall time "I:I"
ccall srand "I:I"
}
r::!Int->Int
r _=code {
ccall rand "I:I"
}
$n|s 0<1#k=map\e.r e rem n
=flatten o map\c.hd[map(\i|i==x=c=toChar if(i==y&&x>0)(x+48)(r i rem 26+97))[0..n-1]\\x<-k[0..]&y<-k[0..]|x<>y]

在线尝试！

选择：

• 一个随机的 x（字符在段中的位置）
• y不等于的随机数x（段中数字的位置）的数
• 每个位置不等于x和不等于的随机小写字母y除非x为零

JavaScript，134个字节

l=>w=>w.replace(/./g,c=>eval("for(s=c;!s[l-1]||s[t?t-1||9:0]!=c;t=s.replace(/\\D/g,''))s=(p=Math.random()*36**l,p-p%1).toString(36)"))

在线尝试！

该答案从所有可能的编码字符串中统一选择了编码字符串。因此，更有可能使编码字母成为第一个字母。

C＃（Visual C＃交互式编译器），171个字节

s=>n=>{var r=new Random();return s.SelectMany(c=>{int i=r.Next(n),j=r.Next(n-1);j+=j<i?0:1;return new int[n].Select((_,k)=>(char)(i==k?c:j==k&i>0?i+49:r.Next(26)+97));});}

在线尝试！

说明...

// s is the input string
// n is the input length
s=>n=>{
  // we need to create an instance
  // of Random and use throughout
  var r=new Random();
  // iterate over s, each iteration
  // returns an array... flatten it
  return s.SelectMany(c=>{
    // i is the position of the letter
    // j is the position of the number
    int i=r.Next(n), j=r.Next(n-1);
    // ensure i and j are different
    j+=j<i?0:1;
    // create an iterable of size n
    return new int[n]
      // iterate over it with index k
      .Select((_,k)=>(char)(
        // return the letter
        i==k?c:
        // return the number
        j==k&i>0?i+49:
        // return a random letter
        r.Next(26)+97)
      );
  });
}

木炭，35 30字节

ＮθＦＳ«≔‽θη≔∧η‽Φθ⁻κηζＦθ≡κζＩηηι‽β

在线尝试！链接是详细版本的代码。0索引。说明：

Ｎθ

输入长度。

ＦＳ«

输入单词并在字符上循环。

≔‽θη

为解密后的字母选择一个随机位置。

≔∧η‽Φθ⁻κηζ

除非字母位于位置0，否则请为数字选择其他随机位置，在这种情况下，也将数字也置于位置0。

Ｆθ≡κ

为每个输出字符循环一次，然后打开位置。

ζＩη

如果这是数字的位置，则输出已解密字母的位置。

ηι

但是，如果这是解密后的字母的位置，则输出该字母。这优先于数字的位置，因为如果多个开关盒具有相同的值，则木炭会取最后一个条目。

‽β

否则输出一个随机字母。

05AB1E，26 个字节

ε²Ý¨Ω©A.r²£Šǝ®Āi®²Ý¨®KΩǝ]J

0索引。

在线尝试或验证所有测试用例。

说明：

ε            # Map over the characters of the first (implicit) input-string:
 ²Ý¨         #  Create a list in the range [0, second input)
    Ω        #  Get a random item from this list
     ©       #  Store it in the register (without popping)
 A           #  Push the lowercase alphabet
  .r         #  Shuffle it
    ²£       #  Leave only the first second input amount of characters
      Š      #  Triple swap, so the stack order becomes:
             #  random index; random string; map-character
       ǝ     #  Insert the map-character at this random index into the random string
 ®Āi         #  If the random index was NOT 0:
    ®        #   Push the random index
    ²Ý¨      #   Push the list in the range [0, second input) again
       ®K    #   Remove the random index from this list
         Ω   #   Get a random item from this list
          ǝ  #   Insert the first random index at the second random index into the string
]            # Close both the if-else and map
 J           # Join all strings together (and output implicitly)