interval 사이의 모든 정수를 인쇄 (a, b)하고 시퀀스에서 8의 배수를 임의의 (균일하게 분배되고 다른 문자와 무관하게) 숫자가 아닌 비 공백 인쇄 가능한 ASCII 문자로 대체 하는 프로그램을 작성하십시오 .

모든 경우에 0 <a <b로 가정하십시오.

숫자가 1 자리를 초과하면 대체 문자 수가 일치하는지 확인하십시오!

예 :

(1, 16) -> 1 2 3 4 5 6 7 $ 9 10 11 12 13 14 15 n@

(115, 123) -> 115, 116, 117, 118, 119, :F<, 121, 122, 123

(1, 3) -> 1 2 3

비 예제 :

(1, 16) -> 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

(115, 123) -> 115 116 117 118 119 $ 121 122 123

이것은 코드 골프이므로 바이트 단위의 가장 짧은 코드가 이깁니다!

현재 우승자 :

Muddyfish의 파이크 (21 바이트)

가장 인기 많은:

Dennis의 Python 2 (119 바이트)

파이크, 22 21 바이트

h1:Fi8%!I`lV~Kl7T>Hs0

여기 사용해보십시오!

형태의 입력을 받아 : higher,lower

h1:                   -  range(lower, higher+1, 1)
   F                  - for i in ^:
    i8%               -    i % 8 
       !              -   not ^
        I             -  if ^:
         `l           -    len(str(i))
           V          -   repeat V ^ times
            ~K        -        printable_ascii
              l7      -       ^.strip()
                T>    -      ^[10:]
                  H   -     random.choice(^)
                   s0 -    sum(^)

파이썬 2, 126 바이트

온라인으로 사용해보십시오!

import random,string
def f(a,b):
 while b/a:print[a,eval('random.choice(string.printable[10:-6])+'*len(`a`)+"''")][a%8<1];a+=1

그들의 모든 도움에 대해 Flp.Tkc와 EasterlyIrk에게 감사드립니다!

파이썬 2 , 119 바이트

import random,string
def f(a,b):print`[random.choice(string.printable[10:95])for _ in`a`]`[2+a%8*b::5]or a;a<b<f(a+1,b)

온라인으로 사용해보십시오!

zsh, 100 98 바이트

for i in {$1..$2};{((i%8))&&<<<$i||<<<`yes 'shuf -e {!..~}|grep "[^0-9]"|head -c1'|head -$#i|zsh`}

두 개의 입력 인수는 명령 행 인수로 전달되며 숫자는 별도의 행에 출력됩니다.

for i in {$1..$2};{   # loop through the range
((i%8))&&             # if the number is not divisible by 8 (i % 8 != 0),
<<<$i||               # output it
<<<`                  # otherwise, output the following:
yes '                 # using `yes' as a golfy loop
shuf -e {\!..\~}      # shuffle the range of printable ASCII (minus space)
|grep "[^0-9]"        # get rid of numbers
|head -c1'            # take the first character
|head -$#i            # obtain a string with that code repeated len(i) times... 
|zsh                  # ... and eval it
`}

수학, 96 바이트

Range@##/.a_?(8∣#&):>Join[33~(c=CharacterRange)~47,58~c~127]~RandomChoice~⌊Log10@a+1⌋<>""&

설명

입력 m및 n:

Range@##

일으키다 {m, m + 1, m + 2, ... , n}

/.a_?(8∣#&):>

8로 나눌 수있는 모든 숫자 ( a)에 다음 대체 규칙을 적용하십시오.

Join[33~(c=CharacterRange)~47,58~c~127]

숫자를 제외한 인쇄 가능한 모든 ASCII 문자 목록을 가져옵니다.

... ~RandomChoice~⌊Log10@a+1⌋

의사는 무작위로 Floor[Log10[a] + 1]목록에서 문자를 선택 하여 복제를 허용합니다.

<>""

캐릭터와 합류하십시오.

R, 73 바이트

i=scan();x=i[1]:i[2];x[!x%%8]=sample(sapply(c(32:46,58:126),intToUtf8));x

stdin에서 입력을 읽고 나눌 수있는 숫자를 8범위에서 균일하게 선택된 ASCII 문자 샘플 로 바꿉니다 32...47, 58...126. 무작위 샘플을 그리려면 문자 벡터가 필요합니다. 불행히도 벡터가 intToUtf8()아닌 하나의 문자열을 반환하므로를 사용하여 범위를 넘어 벡터화해야합니다 sapply.

파이썬 2, 126 바이트

(데니스를 단순히 아웃 고프하지 않습니다)

헤더의 답변에 대해 많은 작업을 수행하면서 내 솔루션도 게시 할 것이라고 생각했습니다.

import random,string
def f(a,b):
 while b/a:print[a,eval('random.choice(string.printable[10:-6])+'*len(`a`)+"''")][a%8<1];a+=1

이 함수는 두 개의 인수를 사용하여로 직접 인쇄하는 함수입니다 STDOUT.

127 바이트

import random,string
lambda a,b:[[x,eval('random.choice(string.printable[10:-6])+'*len(`x`)+`''`)][x%8<1]for x in range(a,b+1)]

이 함수는 이름이없는 익명 함수입니다. 사용하고 변수 (예 :)를 할당 f한 다음로 호출하십시오 f(a, b). 출력을 목록으로 반환합니다.

핍 , 28 바이트

Fia,b+1Pi%8?i{RC@>PA@`\D`}Mi

숫자를 명령 줄 인수로 사용하고 줄 바꿈으로 구분 된 결과 목록을 인쇄합니다. 온라인으로 사용해보십시오!

설명:

                              a,b are cmdline args; PA is string of all printable ASCII
Fia,b+1                       For i in range(a, b+1):
       P                       Print this:
        i%8?i                  If i%8 is truthy (nonzero), i; otherwise:
             {           }Mi   Map this function to the digits of i:
                @>PA           All but the first character of PA (removes space)
                    @`\D`      Find all regex matches of \D (nondigits)
              RC               Random choice from that list of characters
                               The map operation returns a list, which is concatenated
                               before printing

자바 스크립트 (ES6), 114 바이트

f=(x,y)=>(x+"").replace(/./g,d=>x%8?d:String.fromCharCode((q=Math.random()*84)+(q>15?43:33)))+(x<y?[,f(x+1,y)]:"")

O.textContent = f(1,200)

<pre id=O>

23 바이트 이름의 내장 기능 ...

MATL , 26 바이트

&:"@8\?@}6Y24Y2X-Xz@VnT&Zr

온라인으로 사용해보십시오!

설명

&:        % Input a and b (implicit). Push range [a a+1 ... b]
"         % For each k in that range
  @       %   Push k
  8\      %   Modulo 8
  ?       %   If non-zero
    @     %     Push k
  }       %   Else
    6Y2   %     Push string of all printable ASCII chars
    4Y2   %     Push string '0123456789'
    X-    %     Set difference
    Xz    %     Remove space. Gives string of possible random chars
    @Vn   %     Push number of digits of k
    T&Zr  %     Random sample with replacement of that many chars from the string
          % End if, end for each, display (implicit)

Pyth , 24 바이트

jm?%d8dsmO-r\~\ jkUT`d}F

온라인으로 사용해보십시오!

설명:

jm?%d8dsmO-r\~\ jkUT`d}FQ  # Auto-fill variables
                      }FQ  # Splat inclusive range on the input
 m?%d8d                    # Map over each number, if it isn't divisible by 8 return it
       smO          `d     # for each other number, select a character at random for
                             each of it's digits and then flatten into one string
           r\~\            # Printable ASCII excluding space
          -     jkUT       # Setwise difference with numeric values (remove numbers)
j                          # Join with newlines

배쉬 + apg ,64, 76 바이트

EDITS :

• "8 8"문제를 수정했습니다. +12 바이트의 임의 문자 세트에서 숫자를 제외합니다.

골프

seq $1 $2|sed "$[(7&(8-$1%8))+1]~8s/.*/a=&;apg -a1 -n1 -Mcsl -m\${#a} -x0/e"

테스트

>./crazy8 8 8
$

>./crazy8 115 123
115
116
117
118
119
As_
121
122
123

>./crazy8 1 16
1
2
3
4
5
6
7
"
9
10
11
12
13
14
15
x!

펄 6 , 60 바이트

{map {$_%8??$_!!S:g/./{grep(/\D/,"!".."~").pick}/},$^a..$^b}

설명:

• { map { }, $^a .. $^b }: 두 개의 인수를 사용하여 해당 범위의 정수 목록을 생성 한 다음 각 요소에 다음 변환이 적용된 람다를 반환합니다.
• $_ % 8 ?? $_ !!: 요소를 8로 나눌 수 없으면 변경되지 않은 채로 전달하십시오. 그렇지 않으면...
• S:g/./{ }/: ... 문자열 표현의 각 문자를이 표현식으로 생성 된 값으로 바꿉니다.
• grep(/\D/, "!" .. "~").pick: !및 ~유니 코드 순서 사이의 문자 범위를 생성하고 숫자를 필터링하여 나머지 문자 중 하나를 임의로 선택합니다.

PHP, 163 바이트

$n=range(48,57);$c=array_diff(range(32,126),$n);
foreach(range($a,$b) as $v){if($v%8!=0){echo $v;}
else{for($i=0;$i<strlen($v);$i++){echo chr($c[array_rand($c)]);}}}

설명:

• $n = range(48,57) 특수 문자 (32-47)와 다른 문자 (58-126)의 중간에있는 숫자의 ASCII 코드입니다.
• $c = array_diff(range(32,126), $n)$n배열을 사용하여 숫자를 제외하고 허용 가능한 ASCII 문자 배열을 작성하십시오.
• foreach(range($a,$b) as $v)의 값의 범위에 걸쳐 루프 $a로 $b(포함), 루프 내측 $ V 등.
• if($v % 8 != 0) { echo $v; }mod 연산자를 사용하여 $ v가 8로 균등하게 나눌 수 있는지 테스트합니다 %.
• else { for($i = 0; $i < strlen($v); $i++) { ... }} 8로 균등하게 나눌 수없는 경우 숫자의 자릿수에 대해 충분한 시간을 반복하고 문자를 인쇄하십시오 (다음 단계에서).
• echo chr($c[array_rand($c)])의 ASCII 값 배열에서 단일 문자를 인쇄하십시오 $c. array_rand배열의 인덱스를 반환하므로를 사용하여 해당 인덱스의 실제 값을 가져와야 $c[random_key]합니다.

나는 $c다르게 다르게 만들어서 이것을 더 작게 만들 수 있으며, ASCII 문자를 인쇄하는 루프는 어리석은 느낌이 들기 때문에 그것을 줄이는 방법을 계속 고민 할 것입니다.

postgresql9.6 251 자

매우 긴 코드이지만 postgresql 도이를 수행합니다.

do language plpgsql $$ begin for n in a..bloop raise info'%',case when 0=n%8then(select array_to_string(array(select*from(select chr(generate_series(33,126)))t where chr!~'\d'order by random()limit floor(log(n))+1),''))else n::text end;end loop;end;$$

형식이 지정된 SQL은 다음과 같습니다.

do language plpgsql $$
begin
for n in a..b loop
    raise info '%',
    case when 0 = n % 8 then (
        select array_to_string(array(select * from (
            select chr(generate_series(33, 126))
        ) t where chr !~ '\d' order by random() limit floor(log(n)) + 1), '')
    ) else n::text
    end;
end loop;
end;
$$

펄, 66 바이트

map{$_%8||s%.%do{$_=chr rand 126}until/[!-\/:-~]/;$_%ge;say}<>..<>

-E플래그로 실행 :

perl -E 'map{$_%8||s%.%do{$_=chr rand 126}until/[!-\/:-~]/;$_%ge;say}<>..<>' <<< "8
16"

이것은 매우 직설적입니다.
- <>..<>2 개의 입력 숫자 사이의 숫자 목록을 만듭니다. 그런 다음 map반복합니다
.- $_%8||...:는 8의 배수 인 ...경우에만 실행됩니다 .- : 모든 문자를로 바꿉니다 . -만족 하는 문자를 얻을 때까지 임의의 문자 (코드 0에서 126까지)를 선택하십시오 . 인쇄 가능하고 숫자가 아닌 것. - : 인쇄합니다.$_
s%.%xxx%gexxx
do{$_=chr rand 126}until/[!-\/:-~]//[!-\/:-~]/
say

C (gcc) , 129119 바이트

s(a,r){a&&s(!isdigit(r=rand()%94+33)?putchar(r),a/10:a,0);}f(a,b){b>a&&f(a,b-1);b%8?printf("%d",b):s(b,0);printf(" ");}

온라인으로 사용해보십시오!

129 → 119 OOBalance 의 %94+33트릭 사용

언 골프 드 :

s(a,r){
    a&&                                  // Loop recursively on a!=0
    s(!isdigit(r=rand()%94+33)           // Test random selection
      ?putchar(r),a/10                   // Print and reduce a
      :a                                 // Retry random selection
      ,0);                               // Second arg, recurse
}
f(a,b){
    b>a&&                                // Loop recursively on b>a
    f(a,b-1);                            // Reduce b, recurse
    b%8?printf("%d",b)                   // Print non 8's
       :s(b,0);                          // Call s() for 8's
    printf(" ");                         // Space separator
}

C, 157115 바이트

f(a,b){b-a&&f(a,b-1);if(b%8)printf("%d",b);else for(;b;b/=10){while(isdigit(a=rand()%94+33));putchar(a);}puts("");}

여기에서 온라인으로 사용해보십시오 . 42 바이트 골프를위한 jxh 덕분 입니다.

언 골프 버전 :

f(a, b) { // recursive function, parameters are implicitly int
    b-a && f(a, b-1); // recurse until a = b
    if(b % 8)            // if the number is a multiple of 8
        printf("%d", b); // simply print it
    else for(; b; b /= 10) { // while b > 0, lop off the last digit
        while(isdigit(a = rand() % 94 + 33)); // generate random characters in ASCII range [33, 127] until one is non-numeric
        putchar(a); // print the character
    }
    puts(""); // print a newline
}

Java 10, 149147 바이트 (람다 함수)

b->a->{var r="";for(;a<=b;r+=" ",a++)for(var c:(a+"").split("")){char t=0;for(;t<33|t>126|t>47&t<59;t*=Math.random())t=127;r+=a%8<1?t:c;}return r;}

온라인으로 사용해보십시오.

Java 10, 227 225 바이트 (전체 프로그램)

interface M{static void main(String[]A){var r="";for(var a=new Long(A[0]);a<=new Long(A[1]);r+=" ",a++)for(var c:(a+"").split("")){char t=0;for(;t<33|t>126|t>47&t<59;t*=Math.random())t=127;r+=a%8<1?t:c;}System.out.print(r);}}

온라인으로 사용해보십시오.

설명:

b->a->{          // Method with two integer parameters and String return-type
  var r="";      //  Result-String, starting empty
  for(;a<=b      //  Loop as long as `a` is smaller than or equal to `b`
      ;          //    After every iteration:
       r+=" ",   //     Append a space to the result-String
       a++)      //     And increase `a` by 1
    for(var c:(a+"").split("")){
                 //   Inner loop over the characters of the current number
      char t=0;  //    Random-char, starting at 0
      for(;t<33|t>126|t>47&t<59;
                 //    Loop until `t` is a non-digit printable ASCII char
          t*=Math.random())t=127;
                 //     Set `t` to a random character with a unicode in the range [0,127)
      r+=a%8<1?  //   If the current `a` is divisible by 8:
          t      //    Append the random character
         :       //   Else:
          c;}    //    Append the digit instead
  return r;}     //  Return the result

APL (Dyalog Extended) , 32 바이트

{(?84¨⍕⍵)⊇⎕D~⍨'!'…'~'}¨@{0=8|⍵}…

온라인으로 사용해보십시오!

도움 을 주신 Adám 과 dzaima 에게 큰 감사를드립니다 . Dyalog Extended를 처음 사용!

설명:

{(?84¨⍕⍵)⊇⎕D~⍨'!'…'~'}¨@{0=8|⍵}…  ⍝ Dyadic 2-train

                               …  ⍝ Tacit range: list of numbers from left arg 
                                  ⍝ to right arg inclusive
{(?84¨⍕⍵)⊇⎕D~⍨'!'…'~'}¨@{0=8|⍵}   ⍝ Monadic function applied to above          
                        {     }   ⍝ Function definition
                           8|⍵    ⍝ 8 modulo every item in our range
                         0=       ⍝ Transform list into a boolean vector, with
                                  ⍝ 1 where item was equal to zero, 0 otherwise
                      ¨@          ⍝ Applies left function to each item selected
                                  ⍝ by above
{                    }            ⍝ Function definition
              '!'…'~'             ⍝ Range of all printable ASCII chars
          ⎕D~⍨                    ⍝ Remove numeric characters from above
 (    ⍕⍵)                         ⍝ Convert function argument to string
                                  ⍝ (e.g., 123 -> "123")
   84¨                            ⍝ For each character, replace with number 84
                                  ⍝ (number of non-numeric printable ASCII chars)
  ?                               ⍝ Generate random number from 1-84 for each
                                  ⍝ 84 in list
         ⊇                        ⍝ Index the ASCII char list with above random
                                  ⍝ numbers

스칼라 , 198 바이트

불변 상태의 개선 된 기능 버전 (03-04-2018)

  def S(a: Int, b: Int)={
    val c=(33 to 47)++(58 to 126)
    val r = (a to b).toStream.map {case x if x%8==0=>c(Random.nextInt(c.length)).toChar.toString
      case x => String.valueOf(x)}
    r}

온라인으로 사용해보십시오!

재미를위한 스칼라 (350 바이트)의 기능적 스타일 솔루션.

def r(a:Int, b:Int)={
    var l=(33 to 47).toList:::(58 to 126).toList
    l=Random.shuffle(l)
    var x=ListBuffer[String]()
    var k=0
    (a to b).toList.foreach{e=>{
         if(k==l.length){k=0
         l=Random.shuffle(l)}
         if (e.toInt%8==0){x+=l(k).toChar.toString
           k+=1}
         else{x+=e.toString
             k+=1}}}
    x}

개선을위한 제안을 환영합니다.

파이썬 2, 180 바이트

from random import*
def f(a,b):
 for i in range(a,b+1):
  if i%8<1:
   k,i=str(i),''
   for _ in k:i+=choice([chr(j)for j in range(33,48)]+[chr(j)for j in range(57,126)])
  print i

편집하다:

작업을 제대로 읽지 못했다는 사실을 알고 @ Flp.Tkc에게 감사드립니다.

바이트 수를 줄이기 위해 몇 가지를 사용할 수 있다고 지적한 @Caleb에게 감사드립니다.

숫자를 포함 할 수 없다는 사실을 지적한 @Dennis에게 감사드립니다.

편집 2 :

현재 버전은 아마도 그보다 더 단순화 될 수 있습니다.

PowerShell , 82 89 바이트

$a,$b=$args;$a..$b|%{($_,(-join[char[]](33..47+58..127|random -c "$_".Length)))[!($_%8)]}

온라인으로 사용해보십시오!

QBIC , 79 바이트

::[a,b|~c%8=0|[_l!c$||_R33,116|~e>47 and e<58|e=e+z]Z=Z+chr$(e)]\Z=Z+!c$]Z=Z+@ 

숫자를 건너 뛰는 것은 비용이 많이 드는 일입니다. 여기 0-9에 20 바이트 이하 로 무작위로 선택할 수있는 버전이 있습니다 .

::[a,b|~c%8=0|[len(!c$)|Z=Z+chr$(_r33,126|)]\Z=Z+!c$]Z=Z+@ 

에 대한 샘플 출력 1, 89

1 2 3 4 5 6 7 U 9 10 11 12 13 14 15 M9 17 18 19 20 21 22 23 ^L 25 26 27 28 29 30 
31 <U 33 34 35 36 37 38 39 gH 41 42 43 44 45 46 47 aJ 49 50 51 52 53 54 55 1b 57 58 59 60 
61 62 63 ,C 65 66 67 68 69 70 71 ]; 73 74 75 76 77 78 79 [B 81 82 83 84 85 86 87 Ix 89 

설명:

::        Get inputs 'a' and 'b' from the command line
[a,b|     FOR(c=a; c<=b; c++)
~c%8=0|   IF c is cleanly divisible by 8 THEN
 _l!c$|   Take the length (_l) of the string representation (! ... $) of c 
[      |  FOR (d = 1; d<= length(c); d++)
_R33,116| Set e to a random value in the range 33 - 116 (all the printable ascii's - 10)
~e>47     IF e falls between 47
and e<58| and 58 (ASCII code for 0-9) THEN 
e=e+z     e = e + 10 (z == 10 in QBIC)
]         END IF
Z=Z+      Add to Z$
chr$(e)]  ASCII character e
\         ELSE if c is not cleanly divisible by 8
Z=Z+!c$   Add to Z the string representation of c
]         NEXT
Z=Z+@     Add a space to Z$ (@ is an implicitly delimited string literal with 1 significant space)

( Z$ is implicitly printed at end of program )

05AB1E , 17 바이트

ŸεD8ÖižQžhK¦.rsg£

입력을로 취하고 highest\nlowest목록을 출력합니다.

온라인으로 시도 하거나 모든 테스트 사례를 확인하십시오 .

설명:

Ÿ                  # Create a list in the range [low (implicit) input, high (implicit) input]
 ε                 # Map each value to:
  D                #  Duplicate the value
   8Öi             #  If it's divisible by 8:
      žQ           #   Push all printable ASCII characters (" " through "~")
        žhK        #   Remove all digits
           ¦       #   Remove the first character (the space)
            .r     #   Randomly shuffle the remaining characters
              s    #   Swap to take the map value again
               g   #   Get its length
                £  #   And leave that many characters from the string
                   # (and implicitly output the resulting list after we're done mapping)

Japt , 20 바이트

;òV ®%8?Z:EÅk9ò)öZìl

시도 해봐

;òV ®%8?Z:EÅk9ò)öZìl     :Implicit input of integers U & V
 òV                      :Range [U,V]
    ®                    :Map each Z
     %8                  :  Modulo 8
       ?Z:               :  If truthy, return Z, else
;         E              :  Printable ASCII
           Å             :  Slice off first character
            k            :  Remove
             9ò          :    Range [0,9]
               )         :  End remove
                 Zì      :  Digit array of Z
                   l     :  Length
               ö         :  Get that many random characters from the string

4 번째 (2 번째) , 128 바이트

include random.fs
: f 1+ swap do i 8 mod if i . else i 0 <# #s #> 0 do 83 random 33 + dup 47 > 10 * - emit loop ."  "then loop ;

온라인으로 사용해보십시오!

설명

시작부터 끝까지 반복, 8의 배수가 아닌 경우 숫자 인쇄

코드 설명

include random.fs          \ include/import the random module
: f                        \ start new word definition
  1+ swap                  \ add 1 to end number, because forth loops are [start, end), and swap order
  do                       \ start counted loop form start to end
    i 8 mod                \ get the remainder of dividing i (loop index) by 8
    if                     \ if true (not 0, therefore not multiple of 8)
      i .                  \ print the index
    else                   \ otherwise
      i 0                  \ convert index to double-length number
      <# #s #>             \ use formatted numeric output to convert number to a string
      0 do                 \ loop from 0 to (string-length - 1)
        84 random          \ get random number between 0 and 83
        33 +               \ add 33
        dup 47 >           \ check if result is larger than 47
        10 * -             \ if it is add 10 to result (results in number in range: 33-47,58-126)
        emit               \ output ascii char corresponding with number
      loop                 \ end inner loop
    ."  "then            \ output a space and then close the if/else
  loop                   \ end the outer loop
;                        \ end the word definition

언 골프

나는 보통 내 솔루션을 풀지 않지만, 이것이 필요하다고 생각할 정도로 길거나 복잡합니다.

include random.fs

\ get the length (in digits) of a number
: num-length 0 <# #s #> nip ;

\ check if a number is a multiple of another
: is-multiple mod 0= ;               

\ get a random printable non-digit ascii char           
: random-char 84 random 33 + dup 47 > 10 * - ;  

\ get a "random" string of printable ascii chars the same length as a number
: rand-str num-length 0 do random-char emit loop space ;

\ print numbers from a to b, replacing multiple of 8 with a random ascii string of the same length
: crazy-eights 1+ swap do i 8 is-multiple if i rand-str else i . then loop ;

PHP , 130 바이트

function($a,$b){for(;$a<=$b;$a++)echo$a%8?$a:(function($l){while($l--)echo chr(($x=rand(44,128))-($x>58?:11));})(strlen($a))," ";}

온라인으로 사용해보십시오!

언 골프 드 :

function c8( $a, $b ) { 
    for( ; $a<=$b; $a++ ) {                // loop between a -> b
        echo $a % 8 ? $a :                 // every 8, call anon func instead of value
            (function($l) {
                while( $l-- ) {            // repeat length of value
                    $x = rand( 44, 128 );  // range size is printable chars [33,47][58,127]
                    $x-= $x > 58 ?: 11;    // Subtract one from x. If x was less than or 
                                           // equal to 58, subtract a further ten from it
                                           // so that it now falls within the 33-47 range
                    echo chr( $x );        // echo ASCII value
                }
            })( strlen( $a ) )," ";
    }
}

코 틀린 , 136 바이트

{r:IntRange->var s=""
for(i in r){for(c in "$i"){var n=java.util.Random().nextInt(83)
if(n>14)n+=10
s+=if(i%8>0)c
else '!'+n}
s+=" "}
s}

온라인으로 사용해보십시오!