इस बिल्ली में कीड़े हैं? वास्तव में?

Question

चुनौती:

कुछ संशोधनों के साथ इनपुट (दृश्यमान ASCII सीमा के भीतर) और आउटपुट पढ़ें:

1. इनपुट के 10 अक्षरों के प्रत्येक सेट में बेतरतीब ढंग से (50/50):
   • एक वर्ण बदलें * (एक यादृच्छिक ** एक दृश्यमान ASCII सीमा के साथ) (पूर्व lumberjackबन जाता है lumbeZjack)
   • या एक वर्ण को हटा दें (उदा। lumberjackबन जाता है lmberjack)

^{* यदि सेट 10 वर्णों से कम का है, तो आपको इसे संशोधित करने की आवश्यकता नहीं है, लेकिन आप कर सकते हैं।
** चरित्र एक इनपुट के समान हो सकता है, जब तक कि यह अभी भी यादृच्छिक है।}

उदाहरण:

इनपुट: Go home cat! You're drunk!
आउटपुट: Go hom cat! YouLre drunk!
(सिर्फ एक उदाहरण, क्योंकि आउटपुट यादृच्छिक हो सकता है, परीक्षण के मामले के रूप में उपयोग न करें)

नियम:

• कोड-गोल्फ , कम से कम वर्ण जीतता है!

Comments

@ n4melyh4xor आप सैंडबॉक्स पर भविष्य की चुनौतियों को भी पोस्ट कर सकते हैं । वहां आपको अपनी चुनौती के बारे में कुछ प्रतिक्रिया मिलेगी।

— रॉड

क्या होगा अगर प्रतिस्थापन चार को बदलने के लिए चार के रूप में ही है?

— ब्रैड गिल्बर्ट b2gills

@ ब्रैडगिल्बर्ब २गिल्स, मैं वह पिकी नहीं हूं, यह ठीक है।

— n4melyh4xor

बारीकी से संबंधित

— AdmBorkBork

क्या चरित्र के सूचकांक को यादृच्छिक होना चाहिए?

— यति

Answer 1

पायथ, 27 25 बाइट्स

VczTpXNOT?<JOr\ \ÞKC127JK

टेस्ट सूट यहां उपलब्ध है।

2 बाइट्स से शेविंग करने के लिए माल्टीसेन को धन्यवाद ।

व्याख्या

VczTpXNOT?<JOr\ \ÞKC127JK    z autoinitalizes to input, T autoinitializes to 10 
 czT                         chop input into strings of length 10, returned as list of strings
V                            for each string N in this list:
            Or\ \Þ            randomly pick a char between ' ' (32) and 'Þ' (222)
           J                  and assign it to variable J
                  KC127       assign the DEL char to variable K
         ?<J      K           if J < K:
     XNOT              J       replace a random character in N with J
         ?<J      K           else:
     XNOT               K      replace a random character in N with K
    p                         print this string with no trailing newline

जैसा कि अक्सर होता है, मुझे लगता है कि यह थोड़ा अनुभवहीन तरीका है और इसमें सुधार किया जा सकता है। आमतौर पर मुझे स्पष्टीकरण लिखते समय कुछ स्पष्ट लगता है लेकिन इस समय मेरे ऊपर कुछ भी नहीं निकला।

Comments

डिलीट चार का अच्छा उपयोग! एक टिप यह है कि सीमा स्ट्रिंग पर भी काम करती है

— माल्टीसेन

@Maltysen धन्यवाद! मैंने आपकी टिप्पणी के बारे में सोचा है, लेकिन मुझे पूरी तरह से यकीन नहीं है कि मैं इसका उपयोग अंतरिक्ष को बचाने के लिए कहां कर सकता हूं। OC\¾के रूप में बाइट्स की एक ही संख्या है O190, और कश्मीर को डिलीट करने के लिए असाइन करना किसी भी स्थान को नहीं बचाता है।

— माइक बुफर्देसी

@ मैलेट्सन तो यह मुझे थोड़ा सा लगा लेकिन मुझे एहसास हुआ कि आपका क्या मतलब है और मैंने 2 बाइट्स काट दी हैं। एक बार फिर धन्यवाद!

— माइक बुफर्देसी

Answer 2

* <>> , 44 46 52 50 बाइट्स

rl5(?voooo/!|Ou+1Ox:@=?~o~oooo!
ol5(?v" ":/
o;!?l<

यहाँ यह कोशिश करो!

यह यादृच्छिक पात्रों के लिए अंतरिक्ष के निकट / ऊपर किसी भी एसेसी चरित्र का उपयोग करता है। यह हमेशा 6 वें चरित्र को संपादित करता है, जब तक कि यह एक स्ट्रिंग का अंत नहीं है और उस स्ट्रिंग की लंबाई 10. से अधिक नहीं है। 6 वें को संपादित करने के बजाय 7 वें वर्ण को हटाने का 50% मौका है।

इनपुट

फ्लोटिंग-पॉइंट अंकगणित (IEEE 754) के लिए IEEE मानक 1985 में इलेक्ट्रिकल और इलेक्ट्रॉनिक्स इंजीनियर्स संस्थान (IEEE) द्वारा स्थापित फ्लोटिंग-पॉइंट कम्प्यूटेशन के लिए एक तकनीकी मानक है। मानक ने विभिन्न फ़्लोटिंग पॉइंट कार्यान्वयनों में पाई जाने वाली कई समस्याओं को संबोधित किया जिससे उन्हें मज़बूती से और आंशिक रूप से उपयोग करना मुश्किल हो गया। कई हार्डवेयर फ़्लोटिंग पॉइंट इकाइयाँ अब IEEE 754 मानक का उपयोग करती हैं।

उत्पादन

आईईई स्टैण्डर्ड फ्लोट $ एनजी-पॉइंट एथमेटिक (ईईई 754) ia टेक्नीकल स्टैंडर! फ्लो के लिए! ing-point! Computati # n establised in thebyby of the Insitute of the-lectrical # और Electrnics Engi! eers (IEE%)। सेंट! Ndard जोड़ने! निबंधित आदमी! समस्याओं # में पाया! वह गोताखोरों! फ्लोटिंग ऑइंट इम्प्रेशन! उल्लेख है कि पागल # उन्हें डिफरेंट! ue reliabl # और पोर्ट बेली के लिए कई। बहुत सारे!

संपादित करें: यह उत्तर संभवतः दृश्यमान एएससीआई रेंज में हमेशा नहीं होता है, संपादन ... फिक्स्ड।

Edit2: नहीं देखा था कि एक चरित्र को हटाने के लिए 50/50 का मौका चाहिए, फिर से संपादन ... मुझे विश्वास है कि सब कुछ अब क्रम में है :)।

Comments

एक और बात, किसी ने एक यादृच्छिक चरित्र का सुझाव दिया ताकि यह अब यादृच्छिक हो।

— n4melyh4xor

@ n4melyh4xor, वो मैं था! यह यादृच्छिक है :)।

— redstarcoder

Answer 3

पर्ल 6 ,  78  67 बाइट्स

{[~] map {~S/.**{(^.chars).pick}<(./{(' '..'~').pick x Bool.pick}/},.comb(10)}

{[~] .comb(10)».&{~S/.**{10.rand}<(./{(' '..'~').pick x 2.rand}/}}

कोशिश करो

स्पष्टीकरण:

{
  [~]                  # reduce with string concatenation operator

  .comb(10)\           # take input and break it into chunks of up-to 10 chars

  ».\                 # on each of them call the following

  &{
    ~                  # Stringify the following

    S/                 # substituted
      .                # any char
        **             # repeated
           { 10.rand } # a random number of times

      <(               # ignore all of that

      .                # the char to be removed/replaced
    /{

      ( ' ' .. '~' ).pick  # choose a character
      x                    # string repeated
      2.rand               # zero or one times

    }/

  }
}

Answer 4

पायथ - 21 बाइट्स

smO,XdOTOr;\~.DdOTcQT

इसे यहाँ ऑनलाइन आज़माएँ ।

Answer 5

पायथन 3 , 75 बाइट्स

75-बाइट प्रत्येक समूह के पहले चरित्र में परिवर्तन को लागू करता है, और केवल 2 यादृच्छिक वर्णों से चुनता है, जैसे कि जेली उत्तर (जिसे ओपी अनुमति देता है):

from random import*
f=lambda s:s and choice(['','a','b'])+s[1:10]+f(s[10:])

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

यह एक पुनरावर्ती कार्य है, जो, प्रत्येक पुनरावृत्ति, या तो कुछ भी नहीं करता है 'a', या 'b', और फिर पहले 10 वर्णों को काट दिया जाता है। अंतिम पुनरावृत्ति शॉर्ट सर्किट s and(एक खाली स्ट्रिंग मिथ्या है), अनंत पुनरावृत्ति से बचता है।

सभी अलग-अलग कॉल के परिणाम को फिर से मिलाया जाता है, और उस संदर्भ पर वापस लौटता है जिसे फ़ंक्शन कहा जाता है।

120 बाइट्स

बेशक, यह धोखा सा लगता है, इसलिए यहाँ एक है जो पूरी तरह से यादृच्छिक है:

from random import*;r=randint
def f(S):a=S[:10];R=r(0,len(a)-1);print(end=a[:R]+chr(r(32,126))*r(0,1)+a[R+1:]);f(S[10:])

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

Comments

ओपी ने कहां उल्लेख किया है कि प्रतिस्थापित चरित्र का सूचकांक 0 हो सकता है?

— यति

@TuukkaX को अव्यवस्था से बचने के लिए टिप्पणियों को हटा दिया गया है, लेकिन यह है कि जेली उत्तर क्या करता है, और ओपी ने कहा कि यह ठीक था।

— फ्लिपकैक

Answer 6

जेली , 15 14  13 बाइट्स 13 वर्ण

2X
s⁵µ¢1¦ṫ¢µ€

TryItOnline!

प्रत्येक १० वर्णों में से पहला स्थान बदल देता है या निकाल देता है जिसमें अंतिम १- ९ भी शामिल है अगर ऐसा कोई हिस्सा है। चयनित, वर्णों के छोटे, से, का चयन 1:; 2।

कैसे?

2X         - Link 1, flip a coin: no arguments
 X         - random choice from
2          - 2 (treated as the integers [1,2])

s⁵µ¢1¦ṫ¢µ€ - Main link: string of printable ASCII
s⁵         - split (s) into chunks of size ten (⁵)
  µ     µ  - monadic chain separation 
         € - for each chunk
   ¢       -     last link as a nilad
    1¦     -     apply to index 1 (replace 1st of the 10 char chunk with the chosen integer)
       ¢   -     last link as a nilad
      ṫ    - tail - if it was 1 this has no effect (50%)
                  - if it was 2 this discards the replaced character (50%)
           - implicit print

---

21 बाइट्स में केवल 1और 2(अभी भी प्रत्येक चंक के 1 वर्ण को बदलने या हटाने) के बजाय सभी मुद्रण योग्य ASCII से चुनने के लिए :

s⁵µ32r126¤ỌX¤1¦ṫ2X¤µ€

---

एक के लिए पूरी तरह से यादृच्छिक संस्करण (50/50 निकालें / बदलें, वर्दी यादृच्छिक प्रिंट योग्य ASCII, और प्रत्येक टुकड़ा के भीतर एक समान रूप से यादृच्छिक चरित्र स्थान) मैं 30 बाइट्स (शायद गैर इष्टतम) है:

95R+31ỌX;

s⁵µṙ⁵X¤©Ṗ2X¤Ŀṙ®C¤µ€

यह रैंडम राशि के द्वारा छोड़े गए प्रत्येक चंक को घुमाता है, अंतिम वर्ण को बंद करता है और फिर पहले दो लिंक में से एक यादृच्छिक कॉल करता है, जिसमें से एक खाली होता है और दूसरा जो यादृच्छिक प्रिंट करने योग्य ASCII वर्ण के साथ मिलता है; यह चंक को फिर से घुमाता है।

Comments

यह वास्तव में पोस्ट की भावना के खिलाफ जाता है

— माल्टसेन

@ माल्टीसेन - ओपी ने कहा कि ये सभी चीजें ठीक हैं।

— जोनाथन एलन

कहाँ पे? मैं टिप्पणियों या ओपी में कुछ भी नहीं देखता हूं।

— माल्टसेन

@ मैलेटेन से उन्हें मंजूरी दे दी गई है।

— जोनाथन एलन

एक टिप्पणी स्पष्ट रूप से यह कह रही थी कि हम 2 पात्रों में से चुन सकते हैं और वे इसे प्रश्न निकाय में नहीं रखना चाहते हैं।

— जोनाथन एलन

Answer 7

पायथन 3, 188 186 184 114 वर्ण

from random import*
s=input()
for c in[s[i:i+10]for i in range(0,len(s),10)]:print(end=choice(["","x","y"])+c[1:])

बहुत लंबा लगता है। शायद एक मेमने के साथ बहुत कम किया जा सकता है।

जाहिर तौर पर ओपी ने दो पात्रों की सूची से यादृच्छिक चरित्र को चुनने की अनुमति दी है और चरित्र के सूचकांक को प्रतिस्थापित किया जा सकता है। संशोधनों के बाद, मेरा उत्तर @FlipTacks के समान दिखाई देगा पायथन प्रस्तुत करने , इसलिए यह वह रूप है जिसके साथ मैं रह रहा हूं।

@FlipTack ने बचाए 5 बाइट्स!

Answer 8

क्लोजर, 135 139 बाइट्स

संपादित करें: के partition-allबजाय उपयोग करना भूल गए partition।

(fn[i](apply str(flatten(map #(let[r rand-int [b e](split-at(r 9)%)][b(if(<(rand)0.5)""(char(+(r 25)97)))(rest e)])(partition-all 10 i)))))

Ungolfed:

(def f (fn[i]
         (->> i
              (partition-all 10)
              (map #(let [[begin end] (split-at (rand-int 9) %)]
                      [begin (if (< 0.5 (rand)) "" (char (+(rand-int 25)97))) (rest end)]))
              flatten
              (apply str))))

मैन उन फ़ंक्शन नाम लंबे हैं ... वैसे भी, यह 10 वर्णों के विभाजनों में इनपुट को विभाजित करता है, उन्हें यादृच्छिक बिंदु पर दो हिस्सों में विभाजित करता है, यादृच्छिक रूप से उनके बीच एक खाली स्ट्रिंग या यादृच्छिक चरित्र इंजेक्ट करता है और 2 छमाही के पहले चरित्र को छोड़ देता है।

Answer 9

गणितज्ञ 133 बाइट्स (129 अक्षर)

StringReplacePart[#,Table[If[(r=RandomInteger)[]<1,"",FromCharacterCode@r@128],c=⌊StringLength@#/10⌋],Array[{g=10#-9+r@9,g}&,c]]&

8 कार्यों के नाम लिखने के लिए 76 वर्ण: /

का उपयोग ⌊..⌋करने के बजाय Floor[]5 अक्षर, 1 बाइट की बचत होती है।

Answer 10

पायथन 3, 129 बाइट्स

def f(s):f=id(s)%9+1;print(''.join(j[0:f-1]+chr(33+id(s)%94)*(id(s)//10%2)+j[f:]for j in [s[i:i+10]for i in range(0,len(s),10)]))

कुछ बाइट्स को बचाने के लिए, पायथन के यादृच्छिक मॉड्यूल को आयात करने के बजाय, मैंने बस स्ट्रिंग की आईडी पर कुछ मॉडुलो ऑपरेशन किए, जो हर बार अलग होना चाहिए। उदाहरण के लिए कार्यक्रम यह तय करेगा कि एक चार्ट को हटाया जाए या नहीं या एक के आधार पर प्रतिस्थापित किया जाए या नहीं id(string)//10(मैं पूर्णांक को 10 से विभाजित करता हूं क्योंकि अंतिम अंक हमेशा भी होगा)।