स्वरों पर एक कविता और लूप दोहराएं

Question

स्वर कविता: सेब और केले

एक पारंपरिक बच्चों का गीत है जो एक ही पाठ को बार-बार दोहराता है, केवल हर बार हर स्वर को एक यादृच्छिक स्वर से बदल दिया जाता है, लेकिन वर्तमान श्लोक में निरंतर।

चुनौती

इसका उद्देश्य सबसे छोटे कोड का प्रस्ताव करना है जो इनपुट टेक्स्ट पर इस तरह का परिवर्तन करता है।

नियम

1. आपको कविता को कई बार छापना चाहिए क्योंकि इसमें अलग-अलग स्वर हैं।
2. प्रत्येक प्रिंट को लाइन ब्रेक (प्लेटफ़ॉर्म-विशिष्ट कॉम्बो \nऔर \rस्वीकार किया जाता है) के साथ अलग किया जाना चाहिए ।
3. पुनरावृति के लिए i, प्रत्येक स्वर iको मूल पाठ में वें विशिष्ट स्वर से बदलें ।
4. इनपुट पाठ मुद्रण योग्य ASCII वर्णों का एक क्रम है (रेंज [32, 126]।
5. इनपुट में एम्बेडेड लाइन ब्रेक नहीं होंगे।
6. केवल स्वर वर्ण प्रभावित होने चाहिए, अन्य का आउटपुट बिल्कुल इनपुट के समान होना चाहिए।
7. केवल स्वर वर्णों की गणना होती है: नाक स्वर, हालांकि स्वर की तरह लग रहा है (जैसे कि फ्रांसीसी "टिनटिन" ), एक स्वर के रूप में संभाला नहीं जाना चाहिए।
8. उत्पादन के लिए मामला मायने रखता है, लेकिन स्थितीय है (एक बड़े अक्षर की जगह को बड़े पैमाने पर प्रतिस्थापन के साथ किया जाता है)
9. अपरकेस स्वर उनके लोअरकेस समकक्ष (यानी a<=> A) से अलग नहीं हैं
10. लगातार स्वरों को हमेशा अलग-अलग माना जाता है (जैसे। Boatपैदावार दोनों Bootऔर Baat)
11. चूँकि अक्षर yया तो एक स्वर या व्यंजन स्वर का प्रतिनिधित्व करता है (जैसा कि हम अंग्रेजी बोल रहे हैं), इसे एक स्वर या व्यंजन के रूप में हैंडल करने की अनुमति है, हालाँकि उत्तर में स्पष्ट रूप से बताया जाना चाहिए कि वे yस्वर के रूप में संभालते हैं या नहीं।

उदाहरण:

नमस्ते दुनिया

Hello world!

देता है:

Helle werld!
Hollo world!

मूल फ्रांसीसी पाठ से अनुवादित (अनुवादित), yएक स्वर के रूप में संभाला:

An elephant that was rambling all gently in the woods...

देता है:

An alaphant that was ramblang all gantla an tha waads...
En elephent thet wes rembleng ell gentle en the weeds...
In iliphint thit wis rimbling ill gintli in thi wiids...
Yn ylyphynt thyt wys rymblyng yll gyntly yn thy wyyds...
On olophont thot wos romblong oll gontlo on tho woods...

प्रमुख अपरकेस स्वर पर व्यवहार पर ध्यान दें: मामले को इसके सूचकांक (नियम 8 और 9) पर रखा जाता है।

स्वर रहित उदाहरण

इनपुट जिसमें कोई स्वर नहीं है, जैसे:

lgn@hst:~$ rm -rf ./* ~ /

कोई आउटपुट, या एकल पंक्ति विराम का उत्पादन करना चाहिए।

एकल-स्वर इनपुट

एकल स्वर वाला इनपुट आउटपुट है।

Dad sat at a car and saw a fat bat.

देता है:

Dad sat at a car and saw a fat bat.

यह कोड-गोल्फ है , इसलिए सबसे कम बायटेकाउंट कोड जीतता है (कुछ भी नहीं लेकिन अनन्त पीपीसीजी महिमा)!

Answer 1

रेटिना , 45 बाइट्स

~(K`A\EI\OU
L$`\\?(.)
./$1/i&$*\T`Vv`5*$&$L$&

इसे ऑनलाइन आज़माएं!yस्वर के रूप में नहीं गिना जाता है। स्पष्टीकरण:

K`A\EI\OU

पाठ को शाब्दिक स्ट्रिंग के साथ बदल देता है A\EI\OU।

L$`\\?(.)

बैकस्लैश के पहले प्रत्येक अक्षर को वैकल्पिक रूप से मिलाता है।

./$1/i&$*\T`Vv`5*$&$L$&

प्रत्येक पत्र के लिए रेटिना कोड की एक पंक्ति आउटपुट करता है।

~(

मूल इनपुट का उपयोग करके उत्पन्न कोड (नीचे दिखाया गया) का मूल्यांकन करता है। .कोड को आउटपुट नहीं करने का कारण बनता है (अंतिम) बफर। /<vowel>/i&शेष पंक्ति को केवल तभी चलाने का कारण बनता है जब इनपुट में दिए गए स्वर (केस-असंवेदनशील) होते हैं। *रेखा के परिणाम को अनदेखा करने का कारण बनता है, ताकि अगले स्वर का परीक्षण किया जा सके। \परिणाम को अनदेखा करने से पहले अपनी ही लाइन पर मुद्रित करने का कारण बनता है। T`Vv`AAAAAaअपरकेस transliterates Vको owels AAAAAऔर सभी लोअरकेस vको owels a। एक चरित्र वर्ग नहीं है, लेकिन सौभाग्य से यह भी एक पलायन नहीं है।)\Aएक ऐसा पलायन है जो एएससीआईआई 07 (बीईएल) को संदर्भित करता है, लेकिन E, Oऔर oअंतर्निहित चरित्र वर्ग हैं जिन्हें अपने शाब्दिक मूल्यों को देने से बचने की आवश्यकता है (e

./A/i&*\T`Vv`AAAAAa
./E/i&*\T`Vv`\E\E\E\E\E\e
./I/i&*\T`Vv`IIIIIi
./O/i&*\T`Vv`\O\O\O\O\O\o
./U/i&*\T`Vv`UUUUUu

Comments

Mmh, स्व-उत्पादक कोड। मैं रेटिना को अच्छी तरह से नहीं जानता लेकिन वह प्रभावशाली है!

— joH1

@ joH1 ठीक है, मेरे लिए प्रभावशाली बिट यह है कि इसने 60 बाइट्स बचाए हैं!

— नील

Answer 2

रूबी , 78 बाइट्स

->s{s.downcase.scan(/[aeiou]/).uniq.map{|v|s.tr"AEIOUaeiou",v.upcase*5+v}*?\n}

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

एक त्वरित और अनुभवहीन दृष्टिकोण। Y को स्वर नहीं माना जाता है।

Answer 3

बैश, 96 बाइट्स

दो समान लंबाई वाले समाधान:

v=aeiouAEIOU;for x in `grep -o [$v]<<<$1|sed 's/./\L&&&&&\U&/'|awk !a[\\$0]++`;{ tr $v $x<<<$1;}
v=aeiouAEIOU;for x in `tr -cd $v<<<$1|sed 's/./\L&&&&&\U&\n/g'|awk !a[\\$0]++`;{ tr $v $x<<<$1;}

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

कमांड लाइन तर्क के रूप में इनपुट लेता है और STDOUT को आउटपुट करता है।

Answer 4

05AB1E (विरासत) , 19 बाइट्स

(अप्रत्यक्ष रूप से) ने केविन की बदौलत एक बाइट को बचाया (सीधे जुड़ने के बजाय लूप के अंदर प्रिंट करना, केवल विरासत संस्करण में काम करना)।

lžMÃÙεžMDu«s5×Du«‡=

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

अमृत ​​पुनर्लेखन का उपयोग करते हुए, 20 बाइट्स

lžMÃÙεžMDu«s5×Du«‡}»

इसे ऑनलाइन आज़माएं! (बिनाy) | इसे ऑनलाइन आज़माएं! (साथy,žM द्वारा प्रतिस्थापित किया जा रहा है žO- वही विरासत संस्करण के लिए लागू होता है)

यह काम किस प्रकार करता है

lžMÃÙεžMDu«s5×Du«‡}»     Full program. Example: "Hello"
l                        Convert the input to lowercase. "Hello" –> "hello"
 žMÃ                     Keep only lowercase vowels. "hello" –> "eo"
    Ù                    Remove duplicates. "eo" –> "eo"
     ε            }      For each of the characters (example with "e"):
      žMDu«              Yield "aeiouAEIOU"
           s5×           Swap, and repeat the current char 5 times. "e" –> "eeeee"
              Du«        Duplicate, uppercase and merge. "eeeee" –> "eeeeeEEEE"
                 ‡       Transliteration. For each item in B, replace it in A with
                         the corresponding item in C.
                   »     Join on newlines.

Comments

अच्छा जवाब, मेरे द्वारा तैयार 21 बाइट उत्तर से कम । आप मैपिंग के बजाय लूपिंग और प्रिंटिंग द्वारा एक और बाइट को गोल्फ कर सकते हैं: 19 बाइट्स । आपके TIO के साथ yभी , btw के 6बजाय का उपयोग करना चाहिए 5।

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

@KevinCruijssen संपादित, धन्यवाद! y-Vowel संस्करण के बारे में , जब मैंने उत्तर दिया तो मैंने गलती से गलत TIO लिंक कॉपी कर लिया था: ... ...

— Mr. Xcoder

आह, अब मुझे फिर से पता है कि मेरे पास iमेरे कोड में क्यों था .. आपका उत्तर बिना स्वर के इनपुट के लिए विफल रहता है। अपेक्षित एक खाली आउटपुट है, लेकिन यह वास्तव में इनपुट को ही प्रिंट करता है .. :(

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

@ केविनक्रूजसेन 20-बाईटर काम करता है, इसलिए मैंने वापस रोल किया और दूसरा लिंक तय किया।

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

Answer 5

जाप v2.0a0 -R, 24 22 बाइट्स

yएक स्वर के रूप में व्यवहार करता है। इसे व्यंजन के रूप में मानने के \yलिए दोनों घटनाओं को बदलें \v।

v f\y â £r\y_Xc^H*ZøZu

कोशिश करो

---

व्याख्या

v                          :Lowercase
   \y                      :RegEx /[aeiouy]/gi (\v is /[aeiou]/gi)
  f                        :Get all matches as an array
      â                    :Deduplicate
        £                  :Map each X
         r\y               :  Replace all matches of the RegEx above in the input
             _             :  Pass matches through a function as Z
              Xc^          :    XOR the character code of X with
                 H*        :     32 multiplied by
                   Zø      :     Does Z contain
                     Zu    :      Uppercase Z
                           :Implicitly join with newlines and output

Answer 6

जेली ,  23 20 18  17 बाइट्स

-2 आउर द आउटग्राफर को धन्यवाद

ØcŒHZx5fƇðØc,yð€Y

yएक स्वर के रूप में व्यवहार करने के लिए दोनों को cएस के साथ बदलें y।

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

कैसे?

ØcŒHZx5fƇðØc,yð€Y - Link: list of characters, S
Øc                - vowels -> "AEIOUaeiou"
  ŒH              - split in half -> ["AEIOU", "aeiou"]
    Z             - transpose -> ["Aa", "Ee", "Ii", "Oo", "Uu"]
     x5           - times 5 -> ["AAAAAaaaaa", "EEEEEeeeee", "IIIIIiiiii", "OOOOOooooo", "UUUUUuuuuu"]
        Ƈ         - filter keep if:
       f          -   filter keep only -> those of X which have required vowels
                  -                       ...i.e. if S = "blah" then ["AAAAAaaaaa"]
         ð    ð€  - dyadic chain for €ach:
          Øc      -   vowels -> "AEIOUaeiou"
            ,     -   pair       e.g. ["AEIOUaeiou","AAAAAaaaaa"]
             y    -   translate  e.g. swap A for A, E for A, ...
                Y - join with newlines

Comments

18 बाइट्स (तुच्छ) ( ż/पर एक जोड़ी है Z, एक पंक्ति जहां बाईं एक एक इकाई में unpaired है में दो dyads तर्क के बीच परोक्ष)

— एरिक Outgolfer

धन्यवाद ( Z> _ <), सुनिश्चित नहीं है कि मेरे TIO सत्र के साथ क्या हो रहा था, लेकिन निरर्थक ðको हटाने से काम नहीं चल रहा था; पुनः आरंभ किया गया।

— जोनाथन एलन

टीबीएच, मैंने वास्तव में x€→ xभी तय किया है, लेकिन आप मुझे निंजा करेंगे। : P

— आउटगॉल्फ

Answer 7

लाल , 229 बाइट्स

yगैर-स्वर के लिए लेना

func[s][v: charset"aoeiu"w: charset"AOEIU"p: copy""parse s[any[[copy c[v | w](if not find p c[append p c lowercase c
parse s[any[[copy n to[v | w | end]](prin n)opt[v(prin c)|[w(prin uppercase copy c)]| skip]]]print""])]| skip]]]

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

थोड़ा अधिक पठनीय:

f: func [ s ] [
    v: charset "aoeiu"
    w: charset "AOEIU"
    p: copy ""
    parse s[ 
        any [
            [ copy c [ v | w ]
                ( if not find p c [ 
                    append p c
                    lowercase c
                    parse s [
                        any [
                            [ copy n to [ v | w | end ] ]
                                 ( prin n )
                            opt [ v ( prin c )
                                | [ w ( prin uppercase copy c ) ]
                                | skip
                                ]
                            ] 
                        ]
                    print ""
                ] )
            ]
            | skip
        ]
    ]
]

Answer 8

आर , 138 , 129 बाइट्स

function(x,U=utf8ToInt,a=U(V<-'aeiouAEIOU'))for(i in (which(a%in%U(x))-1)%%5)cat(chartr(V,intToUtf8(rep(a[i+c(1,6)],e=5)),x),'
')

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

• y एक स्वर नहीं माना जाता है

Answer 9

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

import re
f=lambda s:'\n'.join(r('[AEIOU]',v.upper(),r('[aeiou]',v,s))for v in'aeiou'if v in s.lower());r=re.sub

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

इलाज नहीं करता है $y$ स्वर के रूप में।

-7 बाइट्स @ Mr.Xcoder का धन्यवाद

Comments

खुशी है कि आप इसे काम कर रहे हैं और थोड़ा नीचे गोल्फ हो सकता है! अच्छा काम

— joH1

112 बाइट्स ।

— मिस्टर एक्सकोडर

Answer 10

जावास्क्रिप्ट (Node.js) , 99 बाइट्स

व्यवहार करता है $y$ व्यंजन के रूप में।

s=>(g=F=>Buffer(s).map(c=>2130466>>c&c>64?F(c):c)+`
`)(v=>g[v&=31]||(g[v]=S+=g(c=>c&96|v)),S='')&&S

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

टिप्पणी की गई

s => (                   // s = input string
  g = F =>               // g = helper function taking a callback function F
    Buffer(s)            // turn s into a Buffer
    .map(c =>            // for each ASCII code c in s:
      2130466            //   2130466 is a vowel bitmask: 1000001000001000100010
                         //                               u     o     i   e   a
      >> c               //   the ECMAScript specification enforces that the shiftCount is
                         //   the result of masking out all but the least significant 5 bits
      & c > 64           //   also make sure to ignore non-letter characters
      ?                  //   if a vowel is identified:
        F(c)             //     invoke F with c
      :                  //   else:
        c                //     just yield c
    ) + `\n`             // end of map(); coerce back to a string and append a newline
  )(v =>                 // invoke g with a callback that takes v:
    g[v &= 31] || (      //   unless this vowel has already been encountered:
      g[v] =             //     mark it as encountered
      S +=               //     and append to the output string S
      g(                 //     the result of another call to g:
        c => c & 96 | v  //       where vowels are replaced with v, using the original case
      )                  //     end of inner call to g
    ),                   //
    S = ''               //   start with S = ''
  ) && S                 // end of outer call to g; return S

Answer 11

जावा 10, 196 188 बाइट्स

s->{var d=new int[99];for(var c:s.toUpperCase().replaceAll("[^AEIOU]","").toCharArray())if(d[c]++<1)System.out.println(s.replaceAll("[AEIOU]",c+"").replaceAll("[aeiou]",(char)(c+32)+""));}

-8 बाइट्स @ joH1 की बदौलत ।

yबाइट्स को बचाने के लिए स्वर के बिना ।

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

स्पष्टीकरण:

s->{                       // Method with String parameter and no return-type
  var d=new int[99];       //  Integer-array indicating which vowels we've already output
  for(var c:s.toUpperCase()//  Convert the input to uppercase
            .replaceAll("[^AEIOU]","")
                           //  Remove all non-vowels
            .toCharArray())//  Convert it to a character array)
                           //  And loop over those vowel-characters
    if(d[c]++              //   Increase the vowel-count by 1
             <1)           //   And if it was 0 this iteration:
      System.out.println(  //    Print with trailing newline:
        s                  //     The input,
         .replaceAll("[AEIOU]",c+"")
                           //     with every uppercase vowel replace with the current vowel
         .replaceAll("[aeiou]",(char)(c+32)+""));}
                           //     and every lowercase vowel replaced as well

Comments

188 बाइट्सv लूप में वेरिएबल को

— इनलाइन करके

@ joH1 धन्यवाद, यकीन नहीं होता कि मैं कैसे चूक गया ..

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

Answer 12

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

s=input()
V='aeiouAEIOU'
for v in V:
 if v in s.lower():print''.join([c,[v.upper(),v][c>'Z']][c in V]for c in s)

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

yव्यंजन के रूप में व्यवहार करता है।

Answer 13

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

{m:g:i/<[aeiou]>/».lc.unique».&{$^v;say S:g:ii[<[aeiou]>]=$v}}

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

Answer 14

जावा (ओपनजेडके 8) , 184 बाइट्स

y एक स्वर है

s->s.chars().mapToObj(c->""+(char)(c>96?c:c+32)).filter("aeiouy"::contains).distinct().forEach(c->System.out.println(s.replaceAll("[aeiouy]",c).replaceAll("[AEIOUY]",c.toUpperCase())))

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