34

एक ऐसा प्रोग्राम बनाएं जो एक अंतराल के बीच सभी पूरी संख्याओं को सम्मिलित करता है (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

यह कोड गोल्फ है, इसलिए बाइट्स जीत में सबसे छोटा कोड है!

वर्तमान विजेता:

मैडीफ़िश द्वारा पक्के (21 बाइट्स)

सबसे लोकप्रिय:

डेनिस द्वारा अजगर 2 (119 बाइट्स)

— GracefulLemming
स्रोत

11

एक चुनौती देने के लिए बधाई जो मेरी गोल्फ भाषा में लागू करने के लिए सभी सुपर लंबी चीजों को जोड़ती है

— ब्लू

1

@muddyfish मैं यह मतलब है एक चुनौती;)

— GracefulLemming

मुझे यकीन नहीं है कि मुझे कुछ याद आ रहा है, लेकिन क्या यादृच्छिक चरित्र अद्वितीय होने चाहिए या नहीं? उदाहरण के लिए यदि इनपुट था 16, 16 तो उत्पादन हो सकता है आ ? यदि यह मामला नहीं है, तो क्या होगा यदि संख्या में 85 से अधिक अंक हैं (यह मानते हुए कि मैंने सही तरीके से गिना है)?

— FryAmTheEggman

@FryAmTheEggman प्रत्येक चरित्र ज्यादातर अद्वितीय होना चाहिए, लेकिन अगर "a" और "a" को यादृच्छिक रूप से लगातार चुना जाता है जो ठीक है, लेकिन यह सभी मामलों में नहीं होना चाहिए क्योंकि संभावना इतनी कम है

— GracefulLemming

@FryAmTheEggman और मामला 16, 16 अन्य उदाहरणों में या तो 0 या 2 यादृच्छिक वर्ण देता है, लेकिन उस मामले के बारे में चिंता न करें क्योंकि एक इच्छा के रूप में हमेशा कड़ाई से कम होगा

— GracefulLemming

4

पाइके, 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(^)

— नीला
स्रोत

सूचियाँ सभी अच्छी हैं!

— ग्रेसफुल

यह दिलचस्प है, पहला मामला ive देखा गया जहां 8n, 8n एक त्रुटि का कारण बनता है

— GracefulLemming

मेरा बुरा मैं उत्पादन को गलत

— GracefulLemming

11

पायथन 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 और ईस्टरलीक के लिए बहुत धन्यवाद!

— हीथ
स्रोत

2

आप b/aइसके बजाय उपयोग कर सकते हैं a<=bऔर आपको ;अंत में इसकी आवश्यकता नहीं है । import random,stringकुछ बाइट्स भी बचाता है। tio.run/nexus/…

— डेनिस

@ डेनिस, शुक्रिया, जिसने 7 बाइट्स छीन लीं!

— हीदर

10

अजगर 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)

इसे ऑनलाइन आज़माएं!

— डेनिस
स्रोत

4

Flp.Tkc के शब्दों में: "एक करता है बस नहीं डेनिस outgolf"

— GracefulLemming

6

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

— Doorknob
स्रोत

क्या मैं पूछ सकता हूं कि आप उन संख्याओं का आउटपुट क्यों दे रहे हैं जो 8 से विभाज्य हैं ?

— ग्रेसफुल

1

@ कालेब वूप्स, यह एक टाइपो था। यह " 8 से विभाज्य नहीं " पढ़ने के लिए था ।

— दरवाज़े

5

गणितज्ञ, 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]डुप्लिकेट की अनुमति देते हुए, छद्म यादृच्छिक रूप से सूची से वर्ण चुनें ।

<>""

पात्रों से जुड़ें।

— जंगवान मिन
स्रोत

96 बाइट का उपयोग करने के लिए एक और दृष्टिकोणFromCharacterCode (r=Range)@##/.a_?(8∣#&):>FromCharacterCode[Join[33~r~47,58~r~127]~RandomChoice~⌊Log10@a+1⌋]<>""&

— गाया गया

5

आर, 73 बाइट्स

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

स्टैडिन से इनपुट को पढ़ता है और 8एक समान रूप से चुने गए नमूने के साथ विभाज्य की संख्या को श्रेणी में बदल देता है 32...47, 58...126। यादृच्छिक नमूने को खींचने के लिए हमें वर्णों की एक वेक्टर की आवश्यकता होती है, दुर्भाग्य intToUtf8()से एक वेक्टर के बजाय एक स्ट्रिंग लौटाता है , इसलिए हमें इसे उपयोग करने वाली सीमा पर वेक्टर करना होगा sapply।

— Billywob
स्रोत

5

पायथन 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)। यह आउटपुट को एक सूची के रूप में लौटाता है।

— FlipTack
स्रोत

यह गलत है। यादृच्छिक रूप से चयनित वर्णों में अंक नहीं हो सकते हैं।

— डेनिस

@ डेनिस ठीक है, वापस मेरे splicing विचार करने के लिए: P सिर के लिए धन्यवाद

— FlipTack

अजगर 2 लोकप्रिय दावेदार लगता है, मुझे यह पसंद है!

— ग्रेसफुल

4

पिप , 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

— DLosc
स्रोत

4

जावास्क्रिप्ट (ईएस 6), 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-बाइट के नाम के साथ निर्मित वे डार ...।

— ETHproductions
स्रोत

1

प्रतिस्थापन

— चार्ट

@LarsW किसी भी तरह से याद किया, धन्यवाद

— ETHproductions

3

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)

— लुइस मेंडो
स्रोत

वाऊ मज़ेदार! अच्छा जवाब। +1

— हीदर

@ हीदर थैंक्स! मुझे लग रहा है कि इसे और कम किया जा सकता है ...

— लुइस मेंडो

3

अजगर , 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

— FryAmTheEggman
स्रोत

3

बैश + एप्ग ,64, 76 बाइट्स

संपादन:

"8 8" समस्या को ठीक किया, यादृच्छिक वर्णों के एक सेट से संख्यात्मक वर्णों को बाहर रखा, +12 बाइट्स

golfed

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!

— टसेपेल्लिन
स्रोत

क्या आप दे सकते हैं? यह देखने के लिए उत्सुक हैं कि crazy8 8 8उपज क्या होगी

— GracefulLemming

@ कालेब, वास्तव में यह सिर्फ 8 ए के लिए एक आउटपुट है , ऐसा लगता है कि मैंने इसे थोड़ा-थोड़ा खत्म कर दिया है, जो अब ठीक है। यह यादृच्छिक स्ट्रिंग कैरेक्टर सेट से अंकों को फ़िल्टर नहीं करता है (मैंने भी याद किया है)।

— zeppelin

2

पर्ल 6 , 60 बाइट्स

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

स्पष्टीकरण:

{ map { }, $^a .. $^b }: एक लंबोदर जो दो तर्क लेता है, उस सीमा में पूर्णांकों की सूची तैयार करता है, और प्रत्येक तत्व पर लागू निम्नलिखित परिवर्तन के साथ इसे लौटाता है:
$_ % 8 ?? $_ !!: यदि तत्व 8 से विभाज्य नहीं है, तो इसे अपरिवर्तित पर पास करें। अन्यथा...
S:g/./{ }/: ... इस अभिव्यक्ति द्वारा उत्पन्न मूल्य के साथ इसके स्ट्रिंग प्रतिनिधित्व के प्रत्येक चरित्र को बदलें:
grep(/\D/, "!" .. "~").pick: के बीच वर्णों की श्रेणी उत्पन्न !और ~बाहर अंक (यूनिकोड आदेश), फिल्टर, और बेतरतीब ढंग से शेष पात्रों में से एक उठाओ।

— SMLS
स्रोत

1

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) ये संख्याओं के लिए ASCII कोड हैं, जो विशेष वर्णों (32-47) और अन्य वर्णों (58-126) के मध्य में हैं।
$c = array_diff(range(32,126), $n)$nसरणी का उपयोग करना , संख्यात्मक वर्णों को छोड़कर स्वीकार्य ASCII वर्णों की एक सरणी का निर्माण करना।
foreach(range($a,$b) as $v)से मूल्यों की सीमा पर लूप $aके लिए $b(सम्मिलित), लूप के अंदर $ वी के रूप में।
if($v % 8 != 0) { echo $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 वर्णों को मुद्रित करने के लिए लूप को क्लिंकी लगता है इसलिए मैं इसे छोटा करना जारी रखूंगा।

— जेक बाथमैन
स्रोत

1

धन्यवाद जेक! आप से सुनकर खुशी हुई! अगर आपके पास समय हो तो मेरी नई चुनौती रैंडम पिक्सेल पोकिंग पर भी नज़र डालें!

— ग्रेसफुल

1

postgresql9.6 251 chars

बहुत लंबा कोड है, लेकिन 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;$$

स्वरूपित वर्ग यहाँ है:

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

— andryk
स्रोत

1

पर्ल, 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. का एक बहु है :
- s%.%xxx%geहर वर्ण को प्रतिस्थापित करें xxx।
- do{$_=chr rand 126}until/[!-\/:-~]/एक यादृच्छिक चरित्र चुनें (कोड 0 से 126 तक) जब तक हमें एक ऐसा नहीं मिलता है जो संतुष्ट करता है /[!-\/:-~]/, अर्थात। एक जो मुद्रण योग्य है और एक अंक नहीं है।
- say: इसे प्रिंट करें।

— बापू
स्रोत

1

सी (जीसीसी) , 129 119 बाइट्स

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 से चाल का उपयोग करें

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
}

— jxh
स्रोत

यदि आप एक नई लाइन विभाजक ( putsबदले printf) में बदलते हैं तो आप 3 बाइट्स बचा सकते हैं ।

— ओबैलेंस

अपने समाधान के साथ खेलना ज्यादा मजेदार है :-)

— jxh

1

सी, 157 115 बाइट्स

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 के लिए धन्यवाद ।

Ungolfed संस्करण:

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
}

— OOBalance
स्रोत

इस बातचीत को चैट में जारी रखा जा सकता है ।

— DJMcMayhem

1

जावा 10, 149 147 बाइट्स (लंबा फंक्शन)

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

इसे ऑनलाइन आज़माएं।

जावा 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

— केविन क्रूज़सेन
स्रोत

रेंज [0,127] कल्पना के अनुरूप नहीं है: "गैर-संख्यात्मक, गैर-

— व्हाट्सएप

@OOBalance शायद मेरी टिप्पणी को बहुत अच्छी तरह से समझाया नहीं गया है, लेकिन यह वह जगह है जहां t<33|(t>47&t<59)|t>126;इसके ऊपर है। यह मूल रूप से रेंज में एक यादृच्छिक संख्या उत्पन्न [0,127)करता है, फिर जांचता है कि क्या यह वैध है (इसलिए सीमा में [33..47,59..126], सभी मुद्रण योग्य गैर-अंक ASCII वर्ण)। यदि यह है: अच्छा, इसे जोड़ें। यदि नहीं: [0,127)फिर से सीमा में एक यादृच्छिक संख्या उत्पन्न करें और इसे फिर से मान्य करें जब तक कि हमें एक वैध चरित्र नहीं मिला।

— केविन क्रूज़सेन

नहीं, मुझे लगता है कि आपकी टिप्पणी ठीक है। मेरा बुरा :)

— OOBalance

1

APL (Dyalog Extended) , 32 बाइट्स

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

इसे ऑनलाइन आज़माएं!

उनकी मदद के लिए Adám और dzaima को बहुत धन्यवाद । Dyalog विस्तारित का उपयोग करते हुए पहली बार!

स्पष्टीकरण:

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

— voidhawk
स्रोत

1

स्काला , 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}

सुधार के सुझावों का स्वागत किया जाता है।

— firephil
स्रोत

1

यहाँ कोड गोल्फ से पर हम केवल उन उत्तरों की अनुमति देते हैं जिन्हें कम से कम गोल्फ होने का प्रयास किया गया है। इसका मतलब है कि 1 वर्ण चर नाम और रिक्त स्थान को हटाने वाला एंड्रॉइड आपके उत्तर के लिए बाइट गिनती जोड़ रहा है

— ब्लू

@ muddyfish ठीक है, मैंने अपना कोड गढ़ा है, एंड्रॉइड बाइट की गिनती कैसे जोड़ रहा है?

— फायरफिल

यह मुझे अभी ठीक लगता है

— ब्लू

0

पायथन 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 साकार करने के लिए मैंने कार्य को ठीक से नहीं पढ़ा था।

धन्यवाद @ कैलेब को इंगित करने के लिए मैं बाइट की संख्या को कम करने के लिए कुछ का उपयोग कर सकता हूं।

इस तथ्य के बारे में बताने के लिए धन्यवाद @Dennis कि संख्याएँ शामिल नहीं की जा सकतीं।

संपादित करें 2:

वर्तमान संस्करण शायद इससे अधिक सरल हो सकता है।

— sonrad10
स्रोत

0

पॉवरशेल , 82 89 बाइट्स

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

इसे ऑनलाइन आज़माएं!

— briantist
स्रोत

1

58..127 में प्रिंटेबल ASCII प्रतीक 33 (!) से लेकर 47 (/) तक शामिल नहीं हैं।

— ज़ेपेलिन

@zeppelin सच है, मुझे नहीं लगता था कि यह एक आवश्यकता थी, लेकिन इसे फिर से पढ़ना, मुझे लगता है कि यह एक समान वितरण होना चाहिए। अपडेट किया गया!

— रिश्वतखोर

0

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-920 बाइट्स के लिए बेतरतीब ढंग से चयन कर सकता है :

::[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 )

— steenbergh
स्रोत

0

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)

— केविन क्रूज़सेन
स्रोत

0

जाप , 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

— झबरा
स्रोत

0

फोर्थ (gforth) , 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

UnGolfed

मैं आमतौर पर अपने समाधानों को अनफॉल नहीं करता, लेकिन यह एक लंबा / जटिल है जो मुझे लगता है कि इसकी आवश्यकता है

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 ;

— reffu
स्रोत

0

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

इसे ऑनलाइन आज़माएं!

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

— 640KB
स्रोत

हां, मेरी गलती है। के बारे में $x-= $x > 58 ?: 11; // subtract 11, if x is less than 58- क्या आप विस्तृत कर सकते हैं?

— जोनाथन फ्रेच

@JonathanFrech दूसरे शब्दों में हम एक संख्या चाहते हैं जो 33-47 या 58-127 के बीच हो। इसलिए हम एक ऐसी संख्या को चुनते हैं जो कि निचली श्रेणी के आकार का 58 माइनस हो। यदि संख्या 58 से कम है, तो इसे अंतर को घटाकर केवल निचली सीमा तक अनुवाद किया जाता है। क्योंकि निश्चित रूप से हम संख्याओं को प्रदर्शित नहीं कर सकते हैं (ASCII char

— 48-57

टर्नरी इसे करने का एक शॉर्टकट है। मूल रूप से $ x> 58 1 का मूल्यांकन करता है, और इसलिए हम $ x से उस या 11 को घटाते हैं। इस मामले में जहां यह अधिक है, यह एएससीआईआई द्वारा रैंड () बयान में एक से अधिक होने के कारण ऑफसेट है। आप देख सकते हैं कि यह समान रूप से रैंडम (PHP के रैंड के रूप में एक समान) वितरण में सक्षम है: tio.run/…

— 640KB

मुझे लगता है कि मैं जानता हूं कि एल्विस ऑपरेटर क्या करता है, मुझे लगता है कि आपकी टिप्पणी भ्रामक है।

— जोनाथन फ्रेच

मुझे लगता है कि यह काम करेगा Subtract one from x. If x was less than or equal to 58, subtract a further ten from it., नहीं?

— जोनाथन फ्रेच

0

कोटलिन , 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}

इसे ऑनलाइन आज़माएं!

— JohnWells
स्रोत

क्रेजी 8s कोड गोल्फ

पाइके, 22 21 बाइट्स

पायथन 2, 126 बाइट्स

अजगर 2 , 119 बाइट्स

zsh, 100 98 बाइट्स

गणितज्ञ, 96 बाइट्स

आर, 73 बाइट्स

पायथन 2, 126 बाइट्स

127 बाइट्स

पिप , 28 बाइट्स

जावास्क्रिप्ट (ईएस 6), 114 बाइट्स

MATL , 26 बाइट्स

व्याख्या

अजगर , 24 बाइट्स

स्पष्टीकरण:

बैश + एप्ग ,64, 76 बाइट्स

पर्ल 6 , 60 बाइट्स

PHP, 163 बाइट्स

स्पष्टीकरण:

postgresql9.6 251 chars

पर्ल, 66 बाइट्स

सी (जीसीसी) , 129 119 बाइट्स

Ungolfed:

सी, 157 115 बाइट्स

जावा 10, 149 147 बाइट्स (लंबा फंक्शन)

जावा 10, 227 225 बाइट्स (पूरा कार्यक्रम)

APL (Dyalog Extended) , 32 बाइट्स

स्काला , 198 बाइट्स

अपरिवर्तनीय स्थिति के साथ एक बेहतर कार्यात्मक संस्करण (03-04-2018)

पायथन 2, 180 बाइट्स

पॉवरशेल , 82 89 बाइट्स

QBIC , 79 बाइट्स

05AB1E , 17 बाइट्स

जाप , 20 बाइट्स

फोर्थ (gforth) , 128 बाइट्स

व्याख्या

कोड स्पष्टीकरण

UnGolfed

PHP , 130 बाइट्स

कोटलिन , 136 बाइट्स