एक प्रोग्राम या एक फ़ंक्शन लिखें जो किसी दिए गए स्ट्रिंग को एक सीढ़ी फैशन में आउटपुट करेगा, एक शब्द के प्रत्येक भाग को लिखना जो पिछले भाग के नीचे एक स्वर से शुरू होता है।

उदाहरण के लिए:

Input: Programming Puzzles and Code Golf


Output: Pr          P           C    G
          ogr        uzzl   and  od   olf
             amm         es        e
                ing

इनपुट

एक स्ट्रिंग जिसमें अक्षर और स्थान के अलावा कुछ नहीं होता है।

स्ट्रिंग को STDINतर्कों या फ़ंक्शन तर्कों या किसी भी चीज़ के माध्यम से पारित किया जा सकता है ।

पत्र लोअरकेस या अपरकेस हो सकते हैं।

इनपुट हमेशा उन नियमों का पालन करने के लिए माना जाता है, आपको गलत इनपुट की जांच करने की आवश्यकता नहीं है।

उत्पादन

हर बार जब एक स्वर (यह है कि, a, e, i, o, uया y) एक शब्द में सामना करना पड़ा है, तो आप चाहिए उत्पादन अगली पंक्ति (का सामना करना पड़ा स्वर शामिल है) पर शब्द के बाकी, सही क्षैतिज स्थिति में। यह नियम पुनरावर्ती है, जिसका अर्थ है कि यदि शब्द में n स्वर हैं, तो इसे n + 1 लाइनों पर लिखा जाएगा।

स्वर को अगली पंक्ति की शुरुआत में लिखा जाना चाहिए, न कि पिछली पंक्ति के अंत में जब एक सामना करना पड़ता है।
प्रत्येक शब्द पहली पंक्ति पर शुरू होता है, और इस प्रकार अन्य शब्दों से स्वतंत्र रूप से प्रारूपित किया जाना चाहिए। एक स्थान से दो शब्द अलग हो जाते हैं।
यदि कोई शब्द एक स्वर से शुरू होता है, तो आपको इसे दूसरी पंक्ति में शुरू करना होगा।

परीक्षण के मामलों

इनपुट: Programming Puzzles and Code Golf

आउटपुट:

Pr          P           C    G
  ogr        uzzl   and  od   olf
     amm         es        e
        ing

इनपुट: The quick brown fox jumps over the lazy dog

आउटपुट:

Th  q     br    f   j          th  l    d
  e  u      own  ox  umps ov     e  az   og
      ick                   er        y

इनपुट: aeiouy

आउटपुट:

 
a
 e
  i
   o
    u
     y

इनपुट: YEAh UppErcAsE VOwEls

आउटपुट:

               V
Y    Upp        Ow
 E      Erc       Els
  Ah       As  
             E

इनपुट: If you only knew the power of the Dark Side

आउटपुट:

            kn   th  p        th  D    S
If y   onl    ew   e  ow   of   e  ark  id
    o     y             er                e
     u

स्कोरिंग

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

code-golf string

— Fatalize
स्रोत

तीसरा आउटपुट उदाहरण नियम के साथ असंगत लगता है "यदि कोई शब्द एक स्वर से शुरू होता है, तो आपको इसे दूसरी पंक्ति से शुरू करना होगा।"

— जॉन जूल

1

Y, एक स्वर है?

— ऑप्टिमाइज़र

1

@ जॉन वास्तव में यह था, मैंने इसे ठीक किया। धन्यवाद।

— 15

2

The vowel should be written at the beginning of the next line, and not at the end of the previous line when one is encountered.

कुछ विचार करने के बाद, मैं समझता हूं कि इसका मतलब यह है कि अगली पंक्ति में कदम स्वर के छपने से पहले होना चाहिए, उसके बाद नहीं, लेकिन यह इस तरह से शब्द को समझने लायक हो सकता है जो तुरंत समझ में आ जाए - यह मुझे थोड़ा समय लगा।

— ट्राइकोप्लाक्स

3

अनुगामी newlines / रिक्त स्थान की अनुमति है?

— लवजो

18

रेटिना , 50 44 34 (+10) 32 30 बाइट्स

वास्तविक नियंत्रण पात्रों का उपयोग करके 14 बाइट बचाने के लिए डेनिस के लिए धन्यवाद।

i`[aeiouy]
<VT>$0#
+`#(\S*)
$1<ESC>[A

इस उत्तर के आधार पर , मैं टर्मिनल कर्सर को लंबवत रूप से स्थानांतरित करने के लिए ANSI एस्केप कोड का उपयोग कर रहा हूं। <ESC>नियंत्रण चरित्र 0x1B साथ प्रतिस्थापित किया जाना चाहिए, और <VT>ऊर्ध्वाधर टैब के साथ 0x0B। सरल परीक्षण के लिए, आप भी जगह ले सकता है <ESC>के साथ \e, <VT>के साथ \vऔर के माध्यम से उत्पादन फ़ीड printf।

गिनती के उद्देश्यों के लिए, प्रत्येक पंक्ति एक अलग फ़ाइल में जाती है। हालाँकि, सुविधा के लिए कोड को केवल एक ही फाइल में पेस्ट करना सरल है और -sविकल्प के साथ रेटिना को आमंत्रित करें ।

पहला प्रतिस्थापन प्रत्येक स्वर को चारों ओर से घेरता है \v...#, जहाँ \vकर्सर को नीचे की ओर शिफ्ट किया जाता है और #दूसरे चरण के लिए एक मार्कर होता है। i`केस-संवेदी मिलान के लिए रेटिना के संकेतन है।

दूसरा चरण फिर बार-बार ( +`) #एक शब्द से निकालता है और शब्द e\[Aके अंत में डालता है जो कर्सर को ऊपर की तरफ बदलता है। एक बार स्ट्रिंग बदलना बंद हो जाता है, यानी जब #स्ट्रिंग में अधिक मार्कर नहीं होते हैं ।

— मार्टिन एंडर
स्रोत

आप की जरूरत नहीं है printf। बस \eESC बाइट (0x1b) के साथ बदलें ।

— डेनिस

@ डेनिस ओह, यह बहुत बेहतर है, धन्यवाद।

— मार्टिन एंडर जूल

1

यह तो कमाल है!!!

— kirbyfan64sos

यह उत्तर इस कारण है कि कोई भी रेटिना को गंभीरता से नहीं लेता;)

— क्रिस्टोफर विर्ट

@ChristopherWirt कृपया विस्तार से बताएं :) (हालाँकि मैं वास्तव में भयभीत हो जाऊंगा अगर किसी ने रेटिना को गंभीरता से लिया हो ।)

— मार्टिन एंडर

8

CJam, 39 36 बाइट्स

0000000: 6c 7b 5f 65 6c 22 61 65 69 6f 75 79 22  l{_el"aeiouy"
000000d: 26 7b 22 1b 5b 41 22 27 0b 6f 5c 7d 26  &{".[A"'.o\}&
000001a: 5f 53 26 7b 5d 7d 26 6f 7d 2f           _S&{]}&o}/

ऊपर एक प्रतिवर्ती xxd डंप है, क्योंकि स्रोत कोड में unprintable वर्ण VT (कोड बिंदु 0x0b) और ESC (कोड बिंदु 0x1b) है।

इस उत्तर की तरह , यह ऊर्ध्वाधर टैब और एएनएसआई से बचने के क्रम का उपयोग करता है ।

इसके लिए एक सहायक वीडियो टेक्स्ट टर्मिनल की आवश्यकता होती है, जिसमें अधिकांश गैर-विंडोज टर्मिनल एमुलेटर शामिल हैं।

परीक्षण चालन

वास्तविक कोड निष्पादित करने से पहले, हम संकेत को अक्षम कर देंगे और स्क्रीन को साफ़ कर देंगे।

$ PS1save="$PS1"
$ unset PS1
$ clear

यह सुनिश्चित करता है कि आउटपुट ठीक से दिखाया गया है।

echo -n Programming Puzzles and Code Golf | cjam <(xxd -ps -r <<< 6c7b5f656c226165696f757922267b221b5b4122270b6f5c7d265f53267b5d7d266f7d2f)
Pr          P           C    G
  ogr        uzzl   and  od   olf
     amm         es        e
        ing

प्रॉम्प्ट को पुनर्स्थापित करने के लिए, इसे निष्पादित करें:

PS1="$PS1save"

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

हम कर्सर को पहली पंक्ति में वापस ले जाने के लिए प्रत्येक स्थान के बाद बाइट अनुक्रम 1 बी 5 बी 41 ( "\e[A") के कर्सर को नीचे और पर्याप्त प्रतियों को स्थानांतरित करने के लिए प्रत्येक स्वर से पहले एक ऊर्ध्वाधर टैब डालते हैं ।

l           e# Read a line from STDIN.
{           e# For each character C:
  _el       e#   Push lowercase(C).
  "aeiouy"& e#   Intersect with "aeiouy".
  {         e#   If the intersection is non-empty:
    ".[A"   e#     Push "\e[A" (will be printed later).
    '.o     e#     Print "\v".
    \       e#     Swap "\e[A" with C.
  }&        e#
  _S&       e#   Intersect C with " ".
  {         e#   If the intersection is non-empty:
    ]       e#     Wrap the entire stack in an array.
  }&
  o         e#   Print C or the entire stack.
}/          e#

— डेनिस
स्रोत

unset PS1saveबाद में मत भूलना ।

— usandfriends

5

जावा, 428 बाइट्स

void s(String s){int l=s.length(),m=0;char[][]c=new char[l][];for(int i=0;i<c.length;java.util.Arrays.fill(c[i++],' '))c[i]=new char[l];String v="aeiouyAEIOUY";String[]a=s.split(" ");for(int r=0,p=0;r<a.length;r++){String u=a[r]+" ";int o=v.indexOf(u.charAt(0))>=0?1:0,x=p;for(;x<u.length()-1+p;o+=v.indexOf(u.charAt(x++-~-p))>=0?1:0)c[o][x]=u.charAt(x-p);p+=u.length();m=m<o?o:m;}for(int i=0;i<=m;i++)System.out.println(c[i]);}

मुझे पता है, यह भयानक है। वहाँ शायद कुछ आकर्षण है कि मुंडा किया जा सकता है, लेकिन मैं ऐसा करने के लिए बहुत आलसी हूँ।

— Loovjo
स्रोत

आप शायद अपने से कई घोषणा कर सकते हैं intचर (अर्थात् i, r, p, o, और x) जहां प्रारंभ lऔर mबाद से वे मान बाद में दिया जाएगा। आप भी कर सकते हैं String v="...",a[]=...;और ऊपर के लिए भी ऐसा ही कर सकते हैं String u। जिससे आपका स्कोर काफी कम हो जाए।

— टीएनटी

मुझे पसंद हैx++-~-p

— यपनप जूल

4

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

0000000: 24 5c 3d 22 1b 5b 41 22 78 20 73 2f 5b 61  $\=".[A"x s/[a
000000e: 65 69 6f 75 79 5d 2f 0b 24 26 2f 67 69     eiouy]/.$&/gi

ऊपर एक प्रतिवर्ती xxd डंप है, क्योंकि स्रोत कोड में unprintable वर्ण VT (कोड बिंदु 0x0b) और ESC (कोड बिंदु 0x1b) है।

कोड 27 बाइट्स लंबा है और स्विच 040p(4 बाइट्स) की आवश्यकता है।

कार्यक्रम में एक वीडियो पाठ टर्मिनल की आवश्यकता होती है जो ऊर्ध्वाधर टैब का समर्थन करता है और एएनएसआई से बचने के दृश्यों , जिसमें अधिकांश गैर-विंडोज टर्मिनल एमुलेटर शामिल हैं।

परीक्षण चालन

वास्तविक कोड निष्पादित करने से पहले, हम संकेत को अक्षम कर देंगे और स्क्रीन को साफ़ कर देंगे।

$ PS1save="$PS1"
$ unset PS1
$ clear

यह सुनिश्चित करता है कि आउटपुट ठीक से दिखाया गया है।

echo -n Programming Puzzles and Code Golf | perl -040pe "$(xxd -ps -r <<< 245c3d221b5b41227820732f5b6165696f75795d2f0b24262f6769)"
Pr          P           C    G
  ogr        uzzl   and  od   olf
     amm         es        e 
        ing

प्रॉम्प्ट को पुनर्स्थापित करने के लिए, इसे निष्पादित करें:

PS1="$PS1save"

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

perl -040pस्वचालित रूप से इनपुट को अंतरिक्ष-पृथक टोकन ( -040) के रूप में पढ़ता है , प्रत्येक टोकन को $_( -p) में बचाता है और प्रोग्राम को निष्पादित करता है।
s/[aeiouy]/.$&/gi$_स्वरों के लिए एक वैश्विक, असंवेदनशील खोज करता है और प्रत्येक स्वर को नियंत्रण वर्ण VT (कर्सर नीचे ले जाता है) द्वारा प्रतिस्थापित करता है, उसके बाद स्वर स्वयं।
sउसके द्वारा किए गए प्रतिस्थापनों की संख्या लौटाता है, इसलिए $\=".[A"x s...बाइट अनुक्रम 1 बी 5 बी 41 की कई प्रतियां बचाता है (कर्सर ऊपर ले जाता है)$\ प्रत्येक स्वर के लिए ।
कार्यक्रम के अंत में, पर्ल स्वचालित रूप से प्रिंट करता है "$_$\", -pस्विच के कारण।

— डेनिस
स्रोत

4

सी, 200 190 बाइट्स

i,j,k,l,M;f(char*s){M=strlen(s)+1;char t[M*M];for(;i<M*M;++i)t[i]=(i+1)%M?32:10;for(i=0;i<M-1;++i)k=(strspn(s+i,"aeiouyAEIOUY")?++j:s[i]==32?j=0:j)*M+i,l<k?l=k:0,t[k]=s[i];t[l+1]=0;puts(t);}

Ungolfed:

i,j,k,l,M;
f(char *s){
    M = strlen(s)+1;
    char t[M*M];
    for(; i<M*M; ++i) t[i] = (i+1)%M ? 32 : 10;
    for(i=0; i<M-1; ++i)
        k = (strspn(s+i,"aeiouyAEIOUY") ? ++j : s[i]==32 ? j=0 : j) * M + i,
        l<k ? l=k : 0,
        t[k] = s[i];
    t[l+1]=0;
    puts(t);
}

यह एक आयताकार बफर (वास्तव में चौकोर) आवंटित करता है, इसे रिक्त स्थान और नई लाइनों के साथ भरता है, फिर दिए गए स्ट्रिंग को ट्रैवर्स करता है। अंत में यह नई कहानियों को रोकने के लिए एक अशक्त चरित्र जोड़ता है।

तकनीकी रूप से यह एक समारोह नहीं है क्योंकि इसमें ग्लोबल्स होते हैं; वास्तव में इसे एक से अधिक बार नहीं कहा जा सकता ( jऔर lशुरुआत में 0 होना चाहिए)। पालन करने के लिए, समारोह की शुरुआत में i,j,k,l,M;स्थानांतरित किया जा सकता है int i,j=0,k,l=0,M;।

— jcai
स्रोत

char*t=malloc(M*M);-> char t[M*M];और for(i=0;i<M*M;++i)->for(;i<M*M;++i)

— Spikatrix

अच्छा कैच, संपादित।

— जकई

क्या यह C99 केवल के कारण नहीं है char t[M*M]?

— जच्ची

4

CJam, 47

हाँ, यह थोड़ा लंबा है, लेकिन यह ANSI कोड के साथ "धोखा" नहीं है :)

q_{_S&!\el"aeiouy"-!U+*:U}%_0|$])\zff{~@-S@?}N*

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

विचार प्रत्येक वर्ण के लिए एक पंक्ति संख्या की गणना करना है (0 पर शुरू, स्वरों में वृद्धि और अंतरिक्ष में 0 पर वापस कूदना), और फिर प्रत्येक पंक्ति के लिए, स्ट्रिंग को दोहराएं लेकिन उन वर्णों को प्रतिस्थापित करें जिनके पास एक स्थान के साथ एक अलग रेखा संख्या है ।

— aditsu
स्रोत

3

के, 81 72 70 66 बाइट्स

खैर, यह एक शुरुआत है:

`0:{+{(-z)!y,x#" "}[|/s].'x,'s:,/{+\{12>"aeiouyAEIOUY"?x}'x}'(0,&~{"  "?x}'x)_ x}

उपयोग के उदाहरण:

  `0:{+{(-z)!y,x#" "}[|/s].'x,'s:,/{+\{12>"aeiouyAEIOUY"?x}'x}'(0,&~{"  "?x}'x)_ x} "Programming Puzzles and Code Golf"
Pr          P           C    G   
  ogr        uzzl   and  od   olf
     amm         es        e     
        ing                      
  `0:{+{(-z)!y,x#" "}[|/s].'x,'s:,/{+\{12>"aeiouyAEIOUY"?x}'x}'(0,&~{"  "?x}'x)_ x} "YEAh UppErcAsE VOwEls"
               V     
Y    Upp        Ow   
 E      Erc       Els
  Ah       As        
             E

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

बेहतर। सतह के स्तर में कुछ सुधार किया:

`0:{+{(-z)!y,x#" "}[|/s].'x,'s:,/{+\{12>"aeiouyAEIOUY"?x}'x}'(0,&~{"  "?x}'x)_ x}
`0:{+{(-z)!y,x#" "}[|/s].'x,'s:,/(+\12>?["aeiouyAEIOUY"]')'_[0,&" "=x]x}

विशेष रूप से, मैंने ?स्वर खोज करते समय इसके लिए तर्कों को उल्टा कर दिया और इस तरह एक लंबोदर की आवश्यकता को समाप्त कर दिया, वही उलटा किया _जहां मैंने व्हाट्सएप पर शब्दों को विभाजित किया, और मुझे एहसास हुआ कि ~{" "?x}'xयह वास्तव में मूर्खतापूर्ण, कहने का तरीका है " "=x।

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

एक और सतह स्तर tweak- लैम्बडा में sइसे लागू करने से पहले नकारात्मक , अंदर parens की बचत:

`0:{+{(-z)!y,x#" "}[|/s].'x,'s:,/(+\12>?["aeiouyAEIOUY"]')'_[0,&" "=x]x}
`0:{+{z!y,x#" "}[|/s].'x,'-s:,/(+\12>?["aeiouyAEIOUY"]')'_[0,&" "=x]x}

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

ठीक है, चलो प्रत्येक वर्ण के लिए ऑफसेट की गणना करने के लिए एक अलग दृष्टिकोण लें। रिक्त स्थान पर अनुक्रम को विभाजित करने और +\स्वरों के पदों की एक रनिंग योग ( ) की गणना करने के बजाय , हम एक बार में पूरे इनपुट स्ट्रिंग पर काम कर सकते हैं, जब भी हम किसी स्थान का सामना करते हैं तो चल रहे योग को 0 से गुणा कर सकते हैं। मुझे इस अनुक्रम के निषेध की आवश्यकता है, इसलिए मैं स्कैन के रूप में जोड़ने के बजाय घटा सकता हूं और ऊर्ध्वाधर पैडिंग की मात्रा की गणना करते समय #?अधिकतम ( |/) के बजाय संख्या-विशिष्ट ( ) का उपयोग कर सकता हूं।

`0:{+{z!y,x#" "}[|/s].'x,'-s:,/(+\12>?["aeiouyAEIOUY"]')'_[0,&" "=x]x}
`0:{+{z!y,x#" "}[#?s].'x,'s:1_0{(~" "=y)*x-12>"aeiouyAEIOUY"?y}\x}

कि एक और 4 अक्षर बचाता है। ओह!

— JohnE
स्रोत

2

रूबी: 135 131 124 115 112 पात्र

a=[]
y=l=0
gets.split(r=/(?=[aeiouy ])/i).map{|w|w=~r&&y+=1
w<?A&&y=0
a[y]='%*s%s'%[-l,a[y],w]
l+=w.size}
puts a

नमूना रन:

bash-4.3$ ruby staircase.rb <<< 'Programming Puzzles and Code Golf'
Pr          P           C    G
  ogr        uzzl   and  od   olf
     amm         es        e
        ing

— आदमी काम पर है
स्रोत

अगर मैं गलत नहीं हूँ, तो आप अपने regex को छोटा कर सकते हैं /(?=[aeiouy ])/i।

— एलेक्स ए।

आह, आप सही हैं @AlexA। अलग शब्द के रूप में अंतरिक्ष केवल पहले के सिद्धांत के लिए महत्वपूर्ण था। धन्यवाद।

— मैनटवर्क

2

सी, 192 बाइट्स

f(char*s){int l=0,r=1,v,c;for(;r;l=1){v=l;r=0;char*p;for(p=s;*p;++p){c=*p;if(c==' ')v=l,putchar(c);else if((strchr("aoeuiyAOEUIY",c)?--v:v)<0)r=1,putchar(' ');else*p=' ',putchar(c);}puts(p);}}

यह स्ट्रिंग के माध्यम से पुनरावृति करता है, वर्णों को रिक्त करता है क्योंकि यह उन्हें प्रिंट करता है। यह तब तक दोहराता है जब तक कि कोई गैर-स्थान वर्ण प्रिंट करने के लिए शेष न हो। यह पोर्टेबल सी है, जो चरित्र एन्कोडिंग के बारे में कोई धारणा नहीं बनाता है।

पठनीय संस्करण

f(char *s) {
    int l=0,       /* true if we've done the first line (no vowels) */
        r=1,       /* true if characters remain in buffer */
        v,         /* how many vowels to print from current word */
        c;         /* current character value */
    for (l=0; r; l=1) {
        v = l;
        r = 0;
        char *p;
        for (p=s;*p;++p) {
            c=*p;
            if (c==' ') {       /* a space - reset vowel counter */
                v=l;
                putchar(c);
            } else if ((strchr("aoeuiyAOEUIY",c)?--v:v)<0) {
                /* vowel conter exceeded - print a space */
                putchar(' ');
                r=1;
            } else {
                /* print it, and obliterate it from next line of output */
                putchar(c);
                *p=' ';
            }
        }
        puts(p); /* p points at the NUL, so this just prints a newline */
    }
}

— टोबी स्पाईट
स्रोत

' '-> 32और f(char*s){int l=0,r=1,v,c;->l,r=1,v,c;f(char*s){

— Spikatrix

@ कूल - ' ' हो सकता है 32, लेकिन यह चरित्र एन्कोडिंग पर निर्भर करता है, और जैसा कि मैंने कहा, मैंने यह पोर्टेबल सी बनाया है। स्पष्ट छोड़ना intमहान है, हालांकि - निश्चित नहीं कि मैं क्यों भूल गया!

— टोबी स्पाइट

2

पायथन 3, 265 207 202 185 177 अक्षर

i=input()
w,e=i.split(" "),lambda:[[" "]*len(i)]
o,x=e(),0
for p in w:
    y=0
    for c in p:
        if c in"AEIOUYaeiouy":o+=e();y+=1
        o[y][x],x=c,x+1
    x+=1
for l in o:print("".join(l))

यह भयानक है और मुझे गर्व नहीं है। मुझे पता है कि इसे कम किया जा सकता है, लेकिन मुझे लगा कि मैं फिर भी पोस्ट करूंगा।

सी संस्करण से प्रेरित होकर, यह एक सूची बनाता है जो इनपुट स्ट्रिंग को ट्रैवर्स करते समय भरा जाता है।

— InputUsername
स्रोत

2

जीएनयू सैड, 151 + 1

(+1 क्योंकि इसे -rध्वज की आवश्यकता है )

s/^/ /;h;s/[aoeuiy]/_/ig;:a;s/_[^ _]/__/;ta;y/_/ /;g;:x;:b;s/ [^ aoeuiy]/  /i;tb;h;s/([^ ])[aoeuiy]/\1_/ig;:c;s/_[^ _]/__/;tc;y/_/ /;g;s/ [^ ]/  /ig;tx

मैंने सोचा था कि इस नौकरी के लिए sed उपकरण होगा, लेकिन यह आश्चर्यजनक रूप से कठिन पाया गया।

पठनीय संस्करण:

#!/bin/sed -rf

# make sure the string starts with a space
s/^/ /
h

# print leading consonants, if any
s/[aoeuiy]/_/ig
:a
s/_[^ _]/__/
ta
y/_/ /
p
g

:x
# strip the consonants just printed
:b
s/ [^ aoeuiy]/  /i
tb
h

s/([^ ])[aoeuiy]/\1_/ig
:c
s/_[^ _]/__/
tc
y/_/ /
p
g
# remove leading vowel of each word
s/ [^ ]/  /ig
tx

— टोबी स्पाईट
स्रोत

मुझे डर है, कि 128 अक्षर होने चाहिए। एक-लाइन संस्करण एक लापता है p, इसलिए यह कुछ भी नहीं आउटपुट करता है। एक छोटा मुद्दा यह है कि आउटपुट एक अतिरिक्त स्थान से शुरू होता है। एक बड़ा मुद्दा यह है कि स्वर से शुरू होने वाला पाठ का पहला टुकड़ा गायब हो जाता है।

— मैनटवर्क

मुझे यकीन है कि यह पहले काम कर रहा था। मैं देखूंगा और देखूंगा कि मैंने क्या तोड़ा है। हेड-अप, @manatwork के लिए धन्यवाद!

— टोबे स्पाइट

cपहले की लाइन के कारण, लूप में कूदना मैं गलत था tx। मैंने इसके समान लूप के साथ एक पुराने संस्करण को पुनः स्थापित किया है, और मुझे बाद में एक और प्रयास करना होगा।

— टोबे स्पाइट

2

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

संभवतः कुछ अन्य तरीकों की तरह प्रतिस्पर्धी नहीं है, लेकिन मुझे लगा कि यह रेगेक्स का उपयोग करने का एक अच्छा तरीका था।

import re;s=I=input()[::-1]+" ";i=0
while s.strip()or i<2:s=re.sub("(?!([^aeiouy ]*[aeiouy]){%s}[^aeiouy]* )."%i," ",I,0,2)[::-1];print s;i+=1

रेगेक्स (?!([^aeiouy ]*[aeiouy]){N}[^aeiouy]* ).किसी भी एकल वर्ण को एक शब्द के अंत से अक्षरों के एन-वें समूह के भीतर नहीं मिलाता है । चूंकि यह दुनिया के अंत से मायने रखता है मैं पहले और बाद में स्ट्रिंग को उल्टा करता हूं, और मुझे अंत में एक स्थान भी जोड़ना होगा, लेकिन इसके बाद re.subइन वर्णों के प्रत्येक उदाहरण को एक स्थान के साथ बदलने के लिए उपयोग करना एक सरल मामला बन जाता है। यह एन के हर मूल्य के लिए करता है जब तक कि स्ट्रिंग खाली न हो।

— KSab
स्रोत

उपयोग करने के लिए अच्छा और पठनीय होने के नाते re.I, आप उचित ध्वज मान, यानी प्रतिस्थापित करके 3 बाइट बचा सकते हैं 2।

— Sp3000

1

@ Sp3000 केवल कोड-गोल्फ में "अच्छा और पठनीय" के साथ नकारात्मक जुड़ाव रखते हैं

— केएसएबी

1

ऑक्टेव, 132 129 वर्ण

p=1;x=[];y=input(0);for j=1:numel(y);if regexpi(y(j),'[aeiouy]');p+=1;elseif y(j)==" ";p=1;end;x(p,j)=y(j);end;x(x==0)=32;char(x)

परीक्षा

इनपुट: "YEAh UppErcAsE VOwEls"

आउटपुट:

               वी     
वाई उप्प ओउ   
 ई एरक एल्स
  आह जैसा        
             ए

— सुडो rm -rf स्लेश
स्रोत

1

Gema : 53 48 वर्ण

/[aeiouyAEIOUY]/=@append{u;^[[A}^K$1
 = $u@set{u;}

ध्यान दें कि ^[(X1b) और ^K(x0b) एकल वर्ण हैं। (नीचे दिए गए सैंपल रन में मैं उनकी कॉपी-पेस्ट फ्रेंडली \eऔर \vसमकक्ष का उपयोग करता हूं , अगर आप इसे आज़माना चाहते हैं।)

नमूना रन:

bash-4.3$ gema '/[aeiouyAEIOUY]/=@append{u;\e[A}\v$1; = $u@set{u;}' <<< 'Programming Puzzles and Code Golf'
Pr          P           C    G    
  ogr        uzzl   and  od   olf 
     amm         es        e 
        ing

— आदमी काम पर है
स्रोत

1

जेली , 42 बाइट्स (गैर-प्रतिस्पर्धात्मक?)

Ḳµe€Øyœṗ⁸⁶ṁ$;¥\z⁶Zµ€µḷ/⁶ṁW⁸;ḣ®µ€L€Ṁ©$¡ZK€Y

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

क्यों जेली, क्यों? :-(

— आउटग्रॉफर को एरिक करें
स्रोत

सीजेएम की तुलना में लंबा अजीब लगता है

— घातक

@ जानिए यह इसलिए क्योंकि जेली सिर्फ स्ट्रिंग्स के साथ नहीं जाती ... आमतौर पर। इसके अलावा, आप वास्तव में विभिन्न प्रोग्रामिंग प्रतिमानों की तुलना नहीं कर सकते हैं (सीडीएम स्टैक-आधारित है, जेली टैसीट है)।

— आउटगॉल्फ जूल

लेखन की सीढ़ी

इनपुट

उत्पादन

परीक्षण के मामलों

स्कोरिंग

रेटिना , 50 44 34 (+10) 32 30 बाइट्स

CJam, 39 36 बाइट्स

परीक्षण चालन

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

जावा, 428 बाइट्स

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

परीक्षण चालन

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

सी, 200 190 बाइट्स

Ungolfed:

CJam, 47

के, 81 72 70 66 बाइट्स

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

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

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

रूबी: 135 131 124 115 112 पात्र

सी, 192 बाइट्स

पठनीय संस्करण

पायथन 3, 265 207 202 185 177 अक्षर

जीएनयू सैड, 151 + 1

पठनीय संस्करण:

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

ऑक्टेव, 132 129 वर्ण

परीक्षा

Gema : 53 48 वर्ण

जेली , 42 बाइट्स (गैर-प्रतिस्पर्धात्मक?)