Introduction:

I have loads of different ciphers stored in a document I once compiled as a kid, I picked a few of the ones I thought were best suitable for challenges (not too trivial, and not too hard) and transformed them into challenges. Most of them are still in the sandbox, and I'm not sure yet whether I'll post all of them, or only a few. But here is the first of them to start things of.

A Computer Cipher will encipher the given text into 'random' character groups of a given length. If such a group contains a digit, it will use that digit to index into its own group for the enciphered character. If no digit is present in the group, it means the first character is used.

For example, let's say we want to encipher the text this is a computer cipher with a given length of 5. This is a potential output (note: numbers are 1-indexed in the example below):

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)

Let's take a few groups as examples to explain how to decipher the group:

• 
  qu5dt: This group contains a digit 5, so the (1-indexed) 5th character of this group is the character used for the deciphered text: t.


• 
  hprit: This group contains no digits, so the first character of this group is used implicitly for the deciphered text: h.


• 
  osyw2: This groups contains a digit 2, so the (1-indexed) 2nd character of this group is the character used for the deciphered text: s.

Challenge:

Given an integer length and string word_to_encipher, output a random enciphered string as described above.

You only have to encipher given the length and word_to_encipher, so no need to create a deciphering program/function as well. I might make a part 2 challenge for the deciphering in the future however.

Challenge rules:

• You can assume the length will be in the range [3,9].


• You can assume the word_to_encipher will only contain letters.


• You can use either full lowercase or full uppercase (please state which one you've used in your answer).


• Your outputs, every group, and the positions of the digits in a group (if present) should be uniformly random. So all random letters of the alphabet have the same chance of occurring; the position of the enciphered letter in each group has the same chance of occurring; and the position of the digit has the same chance of occurring (except when it's the first character and no digit is present; and it obviously cannot be on the same position as the enciphered character).


• You are also allowed to use 0-indexed digits instead of 1-indexed. Please state which of the two you've used in your answer.


• The digit 1 (or 0 when 0-indexed) will never be present in the output. So b1ndh is not a valid group to encipher the character 'b'. However, b4tbw is valid, where the 4 enciphers the b at the 4th (1-indexed) position, and the other characters b,t,w are random (which coincidentally also contains a b). Other possible valid groups of length 5 to encipher the character 'b' are: abcd2, ab2de, babbk, hue5b, etc.

General rules:

• This is code-golf, so shortest answer in bytes wins.
  
  Don't let code-golf languages discourage you from posting answers with non-codegolfing languages. Try to come up with an as short as possible answer for 'any' programming language.


• 
  Standard rules apply for your answer with default I/O rules, so you are allowed to use STDIN/STDOUT, functions/method with the proper parameters and return-type, full programs. Your call.


• 
  Default Loopholes are forbidden.


• If possible, please add a link with a test for your code (i.e. TIO).


• Also, adding an explanation for your answer is highly recommended.

Test cases:

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

Perl 6, 125 bytes

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

Try it online!

Takes input and output in uppercase. Takes input curried, like f(n)(string). Uses 1 indexing.

Explanation:

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

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

Try it online!

Uses uppercase letters, and 0-indexed numbers.

_{-3 bytes, thanks to Kevin Cruijssen}

JavaScript (Node.js), 135 bytes

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

Try it online!

Thank Arnauld for 1B

R, 134 132 123 bytes

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

Try it online!

Takes uppercase letters.

Explanation of old code (mostly the same approach):

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