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}

Pyth, 22 bytes

smsXWJOQXmOGQJdO-UQJJz

Try it online.

Uses lowercase and zero-indexing.

Explanation

Very straightforward algorithm.

                           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.

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

Java (JDK), 193 bytes

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

Try it online!

• The index are 0-based.


• This entry uses an IntStream (gotten through String::chars) as input, as well as a number and returns another IntStream.


• Casts from double to int are unnecessary because of the += hack.

Japt, 29 bytes

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

Try it online!

Zero-indexed.

Explanation:

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

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

Try it online!

0-indexed, lowercase.

Slightly ungolfed and expanded:

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

}

The code should be pretty straightforward.
The two randoms i,j generated in one rand() call are good as independent since gcd(n,~-n)=1 and RAND_MAX is large.

Clean, 256 bytes

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=mape.r e rem n

=flatten o mapc.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]

Try it online!

Chooses:

• a random x (position of the character in the segment)


• a random y that isn't equal to x (position of the digit in the segment)


• a random lowercase letter for each position not equal to x and not equal to y unless x is zero

JavaScript, 134 bytes

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

Try it online!

This answer chose the encoded string from all possible encoded string uniformly. So it is more possible to make the encoded letter as the first one.

C# (Visual C# Interactive Compiler), 171 bytes

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

Try it online!

Explanation...

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

      );

  });

}

Charcoal, 35 30 bytes

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

Try it online! Link is to verbose version of code. 0-indexed. Explanation:

Ｎθ

Input the length.

ＦＳ«

Input the word and loop over the characters.

≔‽θη

Choose a random position for the deciphered letter.

≔∧η‽Φθ⁻κηζ

Choose a different random position for the digit, unless the letter is at position 0, in which case put the digit at position 0 as well.

Ｆθ≡κ

Loop once for each output character and switch on the position.

ζＩη

If this is the position of the digit then output the position of the deciphered letter.

ηι

But if this is the position of the deciphered letter then output the letter. This takes precedence over the position of the digit because Charcoal takes the last entry if multiple switch cases have the same value.

‽β

Otherwise output a random letter.