모음 운율 : 사과와 바나나

모든 모음이 임의의 모음으로 교체 될 때마다, 그러나 현재 스탠자에 걸쳐 일정 할 때마다 동일한 텍스트를 반복해서 반복하는 전통적인 어린이 노래가 있습니다.

도전

목표는 입력 텍스트에서 이러한 변환을 수행하는 가장 짧은 코드를 제안하는 것입니다.

규칙

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.

이것은 code-golf 이므로 바이트 수가 가장 적은 코드가 승리합니다 (영원한 PPCG 영광 외에는 아무것도 없습니다)!

망막 , 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$&

각 문자에 대해 Retina 코드 라인을 출력합니다.

~(

원래 입력을 사용하여 생성 된 코드 (아래 표시)를 평가합니다. 이로 .인해 코드가 (최종) 버퍼를 출력하지 않습니다. 는 /<vowel>/i&입력이 주어진 모음을 (대문자와 소문자를 구별하지 않고로)가 포함되어있는 경우에만 실행하는 라인의 나머지됩니다. 그 *결과 줄의 결과가 무시되어 다음 모음을 테스트 할 수 있습니다. 은 \이 무시되기 전에 한 줄에 인쇄되는 결과가 발생합니다. T`Vv`AAAAAa대문자 Vowel은 AAAAAs로, 모든 소문자 vowel 은 음역 합니다 a. \AASCII 07 (BEL)을 의미 탈출이 있지만 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

루비 , 78 바이트

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

온라인으로 사용해보십시오!

빠르고 순진한 접근. Y는 모음으로 간주되지 않습니다.

bash, 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으로 출력합니다.

05AB1E (레거시) , 19 바이트

(간접적으로) Kevin 덕분에 1 바이트를 절약했습니다 (결합하지 않고 루프 내부에서 직접 인쇄하면 레거시 버전에서만 작동합니다).

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

온라인으로 사용해보십시오!

20 바이트의 Elixir 재 작성 사용

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.

Japt 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

젤리 ,  23 20 18  17 바이트

-2 Outgolfer Erik에게 감사합니다

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

y모음으로 취급하려면 cs를 모두 s로 바꾸십시오 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

빨강 , 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
        ]
    ]
]

R , 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 모음으로 간주되지 않습니다

파이썬 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$ 모음으로.

@ Mr.Xcoder 덕분에 -7 바이트

JavaScript (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

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

@ joH1 덕분에 -8 바이트 .

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

파이썬 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자음으로 취급 합니다.

펄 6 , 64 바이트

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

온라인으로 사용해보십시오!

자바 (OpenJDK 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())))

온라인으로 사용해보십시오!