Crea un programma che stampa tutti i numeri interi inclusivamente tra un intervallo (a, b)e sostituisce i multipli di 8 nella sequenza con caratteri ASCII stampabili casuali (distribuiti uniformemente, indipendenti da altri caratteri), non numerici, non bianchi.

Assumi 0 <a <b in tutti i casi.

Se il numero ha più di 1 cifra, assicurati che la quantità di caratteri nelle corrispondenze corrisponda!

Esempi:

(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

Non Esempi:

(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

Questo è il codice golf, quindi vince il codice più breve in byte!

Vincitore attuale:

Pyke (21 byte) di muddyfish

Più popolare:

Python 2 (119 byte) di Dennis

Pyke, 22 21 byte

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

Provalo qui!

Prende ingresso nella 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 byte

Provalo 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

Mille grazie a Flp.Tkc e EasterlyIrk per tutto il loro aiuto!

Python 2 , 119 byte

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)

Provalo online!

zsh, 100 98 byte

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

I due argomenti di input vengono passati come argomenti della riga di comando e i numeri vengono emessi su righe separate.

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 byte

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

Spiegazione

Per ingressi me n:

Range@##

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

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

Per tutti i numeri che sono divisibili per 8 (chiamalo a), applica questa regola di sostituzione:

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

Ottieni un elenco di tutti i caratteri ASCII stampabili, tranne le cifre.

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

Pseudo-casuali scegli i Floor[Log10[a] + 1]personaggi dalla lista, permettendo duplicati.

<>""

Unisciti ai personaggi.

R, 73 byte

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

Legge l'input da stdin e sostituisce i numeri divisibili per 8con un campione uniformemente scelto di caratteri ASCII nell'intervallo 32...47, 58...126. Per disegnare il campione casuale abbiamo bisogno di un vettore di caratteri, purtroppo intToUtf8()restituisce una stringa anziché un vettore, quindi dobbiamo anche vettorializzarlo nell'intervallo usando sapply.

Python 2, 126 byte

(non si supera semplicemente Dennis)

Visto che ho lavorato molto sulla risposta di Heather, ho pensato di pubblicare anche le mie soluzioni.

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

Questa è una funzione che accetta due argomenti e stampa direttamente su STDOUT .

127 byte

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

Questa è una funzione anonima senza nome - da usare, assegnare a una variabile (come f) e quindi chiamare con f(a, b). Ciò restituisce l'output come un elenco.

Pip , 28 byte

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

Prende i numeri come argomenti della riga di comando e stampa un elenco di risultati separato da una nuova riga. Provalo online!

Spiegazione:

                              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 byte

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>

Quei dannati built-in con nomi a 23 byte ....

MATL , 26 byte

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

Provalo online!

Spiegazione

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

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

Provalo online!

Spiegazione:

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 byte

Modifiche:

• Risolto il problema "8 8", escludere caratteri numerici da un set di caratteri casuali, +12 byte

golfed

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

Test

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

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

Spiegazione:

• { map { }, $^a .. $^b }: Un lambda che accetta due argomenti, genera l'elenco di numeri interi in quell'intervallo e lo restituisce con la seguente trasformazione applicata a ciascun elemento:
• $_ % 8 ?? $_ !!: Se l'elemento non è divisibile per 8, passalo invariato. Altrimenti...
• S:g/./{ }/: ... sostituisce ogni carattere della sua rappresentazione di stringa con il valore generato da questa espressione:
• grep(/\D/, "!" .. "~").pick: Genera l'intervallo di caratteri tra !e ~(in ordine Unicode), filtra le cifre e seleziona casualmente uno dei caratteri rimanenti.

PHP, 163 byte

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

Spiegazione:

• $n = range(48,57) Questi sono i codici ASCII per i numeri, che si trovano nel mezzo di caratteri speciali (32-47) e altri caratteri (58-126).
• $c = array_diff(range(32,126), $n)Utilizzando l' $narray, escludere i caratteri numerici e creare un array di caratteri ASCII accettabili.
• foreach(range($a,$b) as $v)Passa sopra l'intervallo di valori da $aa $b(incluso), come $ v all'interno del ciclo.
• if($v % 8 != 0) { echo $v; }Test per $ v che sia uniformemente divisibile per 8 usando l'operatore mod %.
• else { for($i = 0; $i < strlen($v); $i++) { ... }} Se non è divisibile uniformemente per 8, esegui un ciclo sufficiente per il numero di cifre nel numero e stampa i caratteri (nel passaggio successivo).
• echo chr($c[array_rand($c)])Stampa un singolo carattere dall'array accettabile di valori ASCII in $c.array_randrestituisce un indice nell'array, quindi dobbiamo ottenere il valore effettivo in quell'indice usando $c[random_key].

Probabilmente potrei $crimpicciolirlo creando diversamente, e il ciclo per stampare i caratteri ASCII sembra goffo, quindi continuerò a meditare su come accorciarlo.

postgresql9.6 251 caratteri

codice molto lungo ma anche postgresql lo fa.

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 formattato è qui:

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 byte

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

Esegui con -Ebandiera:

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

Questo è piuttosto semplice:
- <>..<>crea un elenco di numeri tra il numero di 2 ingressi. E poi mapscorre su di esso:
- $_%8||...: ...vengono eseguiti solo se $_è un multiplo di 8.
- s%.%xxx%ge: sostituisce ogni carattere con xxx.
- do{$_=chr rand 126}until/[!-\/:-~]/scegli un carattere casuale (dai codici da 0 a 126) fino a quando non ne otteniamo uno soddisfacente /[!-\/:-~]/, ad es. uno che è stampabile e non è una cifra.
- say: stampalo.

C (gcc) , 129 119 byte

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

Provalo online!

129 → 119 Usa il %94+33trucco di 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 byte

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

Provalo online qui . Grazie a jxh per giocare a golf 42 byte.

Versione non golfata:

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 byte (funzione 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;}

Provalo online.

Java 10, 227 225 byte (programma 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);}}

Provalo online.

Spiegazione:

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 byte

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

Provalo online!

Grazie enormi ad Adám e dzaima per il loro aiuto. Prima volta che usi Dyalog Extended!

Spiegazione:

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

Una versione funzionale migliorata con stato immutabile (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}

Provalo online!

Una soluzione di stile funzionale in Scala (350 byte) per il divertimento.

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}

Suggerimenti per miglioramenti sono i benvenuti.

Python 2, 180 byte

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

MODIFICARE:

Grazie @ Flp.Tkc per aver realizzato che non avevo letto correttamente l'attività.

Grazie a @Caleb per la segnalazione, potrei usarne alcuni per ridurre il conteggio dei byte.

Grazie @Dennis per aver sottolineato il fatto che i numeri non possono essere inclusi.

MODIFICA 2:

La versione attuale potrebbe probabilmente essere semplificata più di quanto non sia.

PowerShell , 82 89 byte

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

Provalo online!

QBIC , 79 byte

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

Saltare i numeri è un affare costoso, ecco una versione che potrebbe anche selezionare casualmente 0-9per 20 byte in meno:

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

Uscita campione per 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 

Spiegazione:

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

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

Prende l'input come highest\nloweste genera un elenco.

Provalo online o verifica tutti i casi di test .

Spiegazione:

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

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

Provalo

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

Forth (gforth) , 128 byte

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 ;

Provalo online!

Spiegazione

Ripeti dall'inizio alla fine, stampa il numero se non multiplo di 8, altrimenti ottieni il numero di cifre nel numero e stampa quel numero di caratteri casuali seguito da uno spazio

Spiegazione del codice

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

Di solito non desolgo le mie soluzioni, ma questa è abbastanza lunga / complicata da pensare che sia necessaria

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 byte

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

Provalo 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 byte

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

Provalo online!