बिल्ली में टोपी रखो

Question

^{आगामी शीतकालीन बैश कार्यक्रम से प्रेरित है}

objetive

इनपुट के प्रत्येक शब्द में एक टोपी ^, ´या `एक स्वर में जोड़ें ।

नियम

• hatऔर vowelयादृच्छिक पर चुना जाना चाहिए। प्रत्येक टोपी को एक ही प्रायिकता (33%) के साथ दिखना पड़ता है और स्वर में शब्द में मान्य स्वर के भीतर एक ही संभावना होनी चाहिए (यदि शब्द में 2 वैध स्वर हैं तो प्रत्येक को 50% चुना जाना चाहिए) - या निकटतम कि आपकी भाषा है
• केवल AEIOUaeiouस्वर माना जाता है (क्षमा करें y)
• इनपुट में टोपी के साथ स्वर नियम के साथ हस्तक्षेप नहीं करते हैं (आप इसे व्यंजन के रूप में मान सकते हैं)
• यदि इनपुट में कोई स्वर नहीं है तो इसे संशोधित नहीं किया जाएगा
• पूंजीकरण को संरक्षित किया जाना चाहिए।

उदाहरण

winter> wintér
bash> bâsh
rhythm> rhythm
rng ftw> rng ftw
cat in the hat> cât ìn thê hát
dès> dès
tschüss> tschüss
principî> prìncipî
PROGRAMMING PUZZLES & code golf>PROGRÂMMING PÚZZLES & codé gòlf

जीतना

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

Comments

"यादृच्छिक पर (या आपकी भाषा के सबसे नज़दीकी)" तो अगर मेरी भाषा में कोई यादृच्छिक कमांड नहीं है, तो मैं बस कुछ नियतात्मक कर सकता हूँ ???

— घातक

@LuisMendo बेहतर है?

— रॉड

@ get the current timeयादृच्छिक भी नहीं यादृच्छिक?

— रॉड

@ मेरे मन में कोई भाषा नहीं है। मैं सिर्फ इतना कह रहा हूं कि आपको यह थोपना है कि यह यादृच्छिक है (और किस तरह का यादृच्छिक है) अन्यथा इसका कोई मतलब नहीं है।

— घातक

चश्मा कहते हैं कि हमें ^ ick या बैकटिक जोड़ना है, लेकिन उदाहरण tschuss एक umlaut दिखाता है। Umlauts की आवश्यकता है या नहीं?

— लेवल रिवर सेंट

Answer 1

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

~*.words.map: {(my$p=m:ex:i/<[aeiou]>/».to.pick)~~Mu:D??~S/.**{$p}<(/{("\x300".."\x302").pick}/!!$_}

कोशिश करो

विस्तारित:

~      # stringify (join with spaces)
*\     # Whatever lambda (input parameter)
.words # split into words

.map:  # for each word

{ # bare block lambda with implicit parameter ｢$_｣
  (

    my $p =

    m
    :exhaustive               # all possible matches
    :ignorecase
    /<[aeiou]>/\              # match a vowel

    ».to.pick                 # pick one of the positions

  ) ~~ Mu:D                   # is it defined ( shorter than ｢.defined｣ )

  ??                          # if ｢$p｣ is defined

    ~                         # stringify

    S/
      . ** {$p}               # match ｢$p｣ positions

      <(                      # ignore them
    /{
      ("\x300".."\x302").pick # pick one of the "hats" to add
    }/


  !!                          # if ｢$p｣ is not defined    
    $_                        # return the word unchanged
}

Answer 2

सी #, 273 267 बाइट्स

using System.Linq;A=s=>{var r=new System.Random();var a=s.Split(' ');return string.Join(" ",a.Select(w=>w.Select((c,i)=>"AEIOUaeiou".Any(d=>c==d)?i:-1).Where(x=>x>=0).ToList()).Select((l,i)=>l.Any()?a[i].Insert(l[r.Next(l.Count)]+1,""+(char)r.Next(768,771)):a[i]));};

repl.it डेमो

मुझे वास्तव में ऐसा लगता है कि मैं धोखा दे रहा हूं, क्योंकि मैं अभी भी पात्रों के संयोजन से पहले से ही उच्चारण किए गए स्वरों में टोपी जोड़ता हूं । यदि यह स्वीकार्य नहीं है, तो मुझे बताएं ताकि मैं बॉयलरप्लेट कोड जोड़ सकूं, इस उत्तर को गैर-प्रतिस्पर्धी घोषित कर सकता हूं ।

यह बात प्रत्येक इनपुट शब्द (यदि कोई हो) के यादृच्छिक स्वर के बाद, U + 0300 या U + 0301 या U + 0302 के बीच एक यादृच्छिक चरित्र जोड़ता है ।

अनगुल्ड (लैम्ब्डा बॉडी केवल)

var r=new System.Random();
// Split sentence to array of words
var a=s.Split(' ');
// Join the (hat-ed) words back to sentence
return string.Join(
    " ",
    // Select an IEnum of list of integers indicating the positions of vowels
    a.Select(w=>
        w.Select((c,i)=>
            // If it's vowel, return position (>=0), else return -1
            "AEIOUaeiou".Any(d=>c==d)?i:-1
        // Filter vowels only
        ).Where(x=>x>=0)
        .ToList()
    // Convert each list of integers to hat-ed words
    ).Select((l,i)=>
        l.Any()
            // Insert "something" into the word...
            ?a[i].Insert(
                // ...at the position after a random vowel in that word...
                l[r.Next(l.Count)]+1,
                // "something" is a random integer in [0x0300, 0x0303), then casted to UTF16 i.e. [U+0300, U+0302]
                ""+(char)r.Next(768,771))
            // List is empty => just return original word
            :a[i]));

Answer 3

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

Join@@((p=Position[w=#,Alternatives@@(v=Characters@"aeiouAEIOU")];If[p!={},i=#&@@RandomChoice@p;w[[i]]=FromCharacterCode[ToCharacterCode["àèìòùÀÈÌÒÙ"][[#&@@Position[v,w[[i]]]]]+RandomInteger@2]];w)&/@Split[#,{##}~FreeQ~" "&])&

वर्णों की सूची को इनपुट के रूप में लेने और वर्णों की सूची लौटाने का कार्य करें। आसान-से-पढ़ा गया संस्करण, साथ ही साथ थोड़ा-सा ungolfed:

 1  v = Characters["aeiouAEIOU"];
 2  a = ToCharacterCode["àèìòùÀÈÌÒÙ"];
 3  Join @@ (
 4    (p = Position[w = #, Alternatives @@ v]; 
 5      If[p != {},
 6        i = First[RandomChoice[p]]; 
 7        w[[i]] =
 8          FromCharacterCode[
 9            a[[ First[ Position[ v, w[[i]] ] ] ]] + RandomInteger[2]
10          ]
11        ]; w
12    ) &
13  ) /@ Split[#1, FreeQ[{##1}, " "] &] &

लाइन 13 सभी स्थानों पर शब्दों (वर्णों के उदात्त) में इनपुट को विभाजित करता है; प्रत्येक शब्द 4-12 लाइनों द्वारा परिभाषित फ़ंक्शन द्वारा संचालित होता है, और परिणाम पंक्ति 3 द्वारा एक सूची में फिर से एक साथ शामिल हो जाते हैं।

पंक्ति 4 pसूचकांकों की सूची को दर्शाती है कि शब्द के कौन से अक्षर wस्वर हैं। यदि कोई स्वर (पंक्ति 5) हैं, तो हम इस तरह के सूचकांक i(लाइन 6) का एक यादृच्छिक विकल्प बनाते हैं और फिर शब्द के उस एकल वर्ण को एक नए वर्ण (लाइन 7-10) पर रीसेट करते हैं। अंत में हम (संभवतः संशोधित) शब्द का उत्पादन करते हैं w।

नए वर्ण का चयन करने के लिए, हम पाते हैं कि स्वर को स्ट्रिंग में प्रतिस्थापित किया जा सकता है vऔर उसमें से संबंधित वर्ण कोड का चयन किया जाता है a। लेकिन बेतरतीब ढंग से तीन टोपियों का चयन करने के लिए, हम उस कोड को लेते हैं और किसी वर्ण में वापस परिवर्तित करने से पहले 0 और 2 (पंक्ति 9) के बीच एक यादृच्छिक पूर्णांक जोड़ते हैं। (सौभाग्य से बीमित स्वर सभी UTF-8 वर्ण कोड के लगातार तीनों में आते हैं।)

Answer 4

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

from random import *
c=choice
print(' '.join([w,w[:i]+c('̀́̂')+w[i:]][i>0]for w in input().split()for i in[c([j+1 for j,x in enumerate(w)if x in 'aeiouAEIOU']or[0])]))

Ungolfed:

from random import choice
print(' '.join([
                   w,  # Don't modify the word if no vowels were found

                   w[:i] + choice('̀́̂') + w[i:]
               ][i > 0]
               for w in input().split()
                   for i in [choice([j + 1 for j, x in enumerate(w) if x in 'aeiouAEIOU']
                                    or [0])  # choice requires a non-empty sequence
                             ]))

Comments

आप के बीच जगह की जरूरत नहीं है importऔर *।

— श्री एक्सकोडर

j+1 forहो सकता है j+1for।

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