Crie um programa que imprima todos os números inteiros inclusive entre um intervalo (a, b)e substitua múltiplos de 8 na sequência por caracteres ASCII imprimíveis aleatórios (distribuídos uniformemente, independentemente de outros caracteres), não numéricos, sem espaço em branco.

Assuma 0 <a <b em todos os casos.

Se o número tiver mais de um dígito, verifique se a quantidade de caracteres na substituição corresponde!

Exemplos:

(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

Não exemplos:

(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

Isso é código de golfe, então o código mais curto em bytes vence!

Vencedor atual:

Pyke (21 bytes) por muddyfish

Mais popular:

Python 2 (119 bytes) por Dennis

Pyke, 22 21 bytes

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

Experimente aqui!

Toma de entrada sob a forma: 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(^)

Python 2, 126 bytes

Experimente online!

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

Muito obrigado a Flp.Tkc e EasterlyIrk por toda a ajuda!

Python 2 , 119 bytes

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)

Experimente online!

zsh, 100 98 bytes

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

Os dois argumentos de entrada são passados ​​como argumentos de linha de comando e os números são emitidos em linhas separadas.

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

Mathematica, 96 bytes

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

Explicação

Para entradas me n:

Range@##

Gerar {m, m + 1, m + 2, ... , n}

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

Para todos os números divisíveis por 8 (chame isso a), aplique esta regra de substituição:

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

Obtenha uma lista de todos os caracteres ASCII imprimíveis, exceto dígitos.

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

Escolha pseudo-aleatoriamente Floor[Log10[a] + 1]caracteres da lista, permitindo duplicatas.

<>""

Junte-se aos personagens.

R, 73 bytes

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

Lê a entrada de stdin e substitui substitui os números divisíveis por 8uma amostra uniformemente escolhida de caracteres ascii no intervalo 32...47, 58...126. Para desenhar a amostra aleatória, precisamos de um vetor de caracteres, infelizmente, intToUtf8()retorna uma string em vez de um vetor, então também precisamos vetorizá-la no intervalo usando sapply.

Python 2, 126 bytes

(não se supera simplesmente Dennis)

Vendo como eu trabalhei muito na resposta de heather, pensei em publicar minhas próprias soluções também.

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

Esta é uma função que recebe dois argumentos e imprime diretamente em STDOUT.

127 bytes

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

Esta é uma função anônima sem nome - para usar, atribuir a uma variável (como f) e, em seguida, chamar com f(a, b). Isso retorna a saída como uma lista.

Pip , 28 bytes

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

Toma os números como argumentos da linha de comando e imprime uma lista de resultados separada por nova linha. Experimente online!

Explicação:

                              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

JavaScript (ES6), 114 bytes

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>

Esses malditos embutidos com nomes de 23 bytes ...

MATL , 26 bytes

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

Experimente online!

Explicação

&:        % 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)

Pitão , 24 bytes

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

Experimente online!

Explicação:

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

Bash + apg ,64, 76 bytes

EDITAS:

• Corrigido o problema "8 8", excluindo caracteres numéricos de um conjunto de caracteres aleatórios, +12 bytes

Golfe

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

Teste

>./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!

Perl 6 , 60 bytes

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

Explicação:

• { map { }, $^a .. $^b }: Um lambda que recebe dois argumentos, gera a lista de números inteiros nesse intervalo e a retorna com a seguinte transformação aplicada a cada elemento:
• $_ % 8 ?? $_ !!: Se o elemento não for divisível por 8, passe-o inalterado. De outra forma...
• S:g/./{ }/: ... substitua cada caractere de sua representação de sequência pelo valor gerado por esta expressão:
• grep(/\D/, "!" .. "~").pick: Gere o intervalo de caracteres entre !e ~(na ordem Unicode), filtre os dígitos e escolha aleatoriamente um dos caracteres restantes.

PHP, 163 bytes

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

Explicação:

• $n = range(48,57) Esses são os códigos ASCII para números, que estão no meio de caracteres especiais (32-47) e outros caracteres (58-126).
• $c = array_diff(range(32,126), $n)Usando a $nmatriz, exclua caracteres numéricos e crie uma matriz de caracteres ASCII aceitáveis.
• foreach(range($a,$b) as $v)Laço ao longo da gama de valores a partir $ade $b(inclusive), tal como $ v dentro do ciclo.
• if($v % 8 != 0) { echo $v; }Teste se $ v é divisível igualmente por 8 usando o operador mod %.
• else { for($i = 0; $i < strlen($v); $i++) { ... }} Se não for divisível igualmente por 8, faça um loop vezes suficientes para o número de dígitos no número e imprima os caracteres (na próxima etapa).
• echo chr($c[array_rand($c)])Imprima um único caractere da matriz aceitável de valores ASCII em $c. array_randretorna um índice na matriz, portanto, precisamos obter o valor real nesse índice usando $c[random_key].

Provavelmente, eu poderia diminuir esse tamanho criando $cdiferente, e o loop para imprimir os caracteres ASCII parece desajeitado, então continuarei pensando em como reduzi-lo.

postgresql9.6 251 caracteres

código muito longo, mas o postgresql também o faz.

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 formatado está aqui:

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

Perl, 66 bytes

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

Corra com a -Ebandeira:

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

Isso é bem direto:
- <>..<>cria uma lista dos números entre o número de 2 entradas. E então mapitera sobre ele:
- $_%8||...: o ...são executados apenas se $_for um múltiplo de 8.
- s%.%xxx%ge: substitua cada caractere por xxx.
- do{$_=chr rand 126}until/[!-\/:-~]/escolha um caractere aleatório (dos códigos 0 a 126) até obtermos um que satisfaça /[!-\/:-~]/, ie. um que é imprimível e não é um dígito.
- say: imprima.

C (gcc) , 129 119 bytes

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

Experimente online!

129 → 119 Use o %94+33truque de OOBalance

Ungolfed:

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, 157 115 bytes

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

Experimente online aqui . Agradecimentos a jxh por jogar 42 bytes.

Versão não destruída:

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, 149 147 bytes (função lambda)

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

Experimente online.

Java 10, 227 225 bytes (programa completo)

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

Experimente online.

Explicação:

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 bytes

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

Experimente online!

Muito obrigado a Adám e dzaima por sua ajuda. Primeira vez usando o Dyalog Extended!

Explicação:

{(?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

Scala , 198 bytes

Uma versão funcional aprimorada com estado imutável (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}

Experimente online!

Uma solução de estilo funcional em Scala (350 bytes) para a diversão.

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}

Sugestões para melhorias são bem-vindas.

Python 2, 180 bytes

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

EDITAR:

Obrigado @ Flp.Tkc por perceber que não tinha lido a tarefa corretamente.

Obrigado @Caleb por apontar que eu poderia usar alguns para reduzir a contagem de bytes.

Obrigado @Dennis por apontar o fato de que os números não podem ser incluídos.

EDIT 2:

A versão atual provavelmente poderia ser mais simplificada do que é.

PowerShell , 82 89 bytes

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

Experimente online!

QBIC , 79 bytes

::[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+@ 

Ignorar os números é um assunto caro, aqui está uma versão que também pode selecionar aleatoriamente 0-9por 20 bytes a menos:

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

Saída de amostra para 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 

Explicação:

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

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

Pega a entrada como highest\nloweste gera uma lista.

Experimente online ou verifique todos os casos de teste .

Explicação:

Ÿ                  # 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)

Japonês , 20 bytes

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

Tente

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

Quarto (gforth) , 128 bytes

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 ;

Experimente online!

Explicação

Faça um loop do início ao fim, imprima o número, se não for múltiplo de 8, caso contrário, obtenha o número de dígitos no número e imprima muitos caracteres aleatórios seguidos por um espaço

Código Explicação

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

UnGolfed

Normalmente, não desacredito minhas soluções, mas essa é longa / complicada o suficiente para ser necessária

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 bytes

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

Experimente online!

Ungolfed:

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

Kotlin , 136 bytes

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

Experimente online!