Schreiben Sie ein Programm oder eine Funktion, die eine bestimmte Zeichenfolge treppenförmig ausgibt, indem Sie jeden Teil eines Wortes schreiben, der mit einem Vokal eine Zeile unter dem vorherigen Teil beginnt.

Beispielsweise:

Input: Programming Puzzles and Code Golf


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

Eingang

Eine Zeichenfolge, die nur Buchstaben und Leerzeichen enthält.

Die Zeichenfolge kann über STDINoder Funktionsargumente oder etwas Äquivalentes übergeben werden.

Buchstaben können in Klein- oder Großbuchstaben geschrieben werden.

Es wird immer davon ausgegangen, dass Eingaben diesen Regeln entsprechen. Sie müssen nicht nach falschen Eingaben suchen.

Ausgabe

Jedes Mal , wenn ein Vokal (das heißt, a, e, i, o, uoder y) in einem Wort auftritt, müssen Sie Ausgang des Rest des Wortes in der nächsten Zeile (die auftretenden Vokal enthalten), in der richtigen horizontalen Position. Diese Regel ist rekursiv, dh wenn das Wort n Vokale enthält, wird es in n + 1 Zeilen geschrieben.

• Der Vokal sollte am Anfang der nächsten Zeile und nicht am Ende der vorherigen Zeile geschrieben werden, wenn einer auftritt.

• Jedes Wort beginnt in der ersten Zeile und sollte daher unabhängig von anderen Wörtern formatiert werden. Zwei Wörter werden durch ein Leerzeichen getrennt.

• Wenn ein Wort mit einem Vokal beginnt, müssen Sie es in der zweiten Zeile beginnen.

Testfälle

• Eingang: Programming Puzzles and Code Golf

Ausgabe:

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

• Eingang: The quick brown fox jumps over the lazy dog

Ausgabe:

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

• Eingang: aeiouy

Ausgabe:

 
a
 e
  i
   o
    u
     y

• Eingang: YEAh UppErcAsE VOwEls

Ausgabe:

               V
Y    Upp        Ow
 E      Erc       Els
  Ah       As  
             E

• Eingang: If you only knew the power of the Dark Side

Ausgabe:

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

Wertung

Das ist Code-Golf , also gewinnt der kürzeste Code.

Retina , 50 44 34 (+10) 32 30 Bytes

Vielen Dank an Dennis für das Speichern von 14 Bytes mithilfe der tatsächlichen Steuerzeichen.

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

Basierend auf dieser Antwort verwende ich ANSI-Escape-Codes, um den Terminal-Cursor vertikal zu bewegen. Das <ESC>sollte durch das Steuerzeichen 0x1B und <VT>die vertikale Registerkarte ersetzt werden 0x0B. Für einfachere Tests können Sie auch ersetzen <ESC>mit \e, <VT>mit \vund die Ausgabe durch füttern printf.

Zu Zählzwecken wird jede Zeile in einer eigenen Datei abgelegt. Der Einfachheit halber ist es jedoch einfacher, den Code in eine einzelne Datei einzufügen und Retina mit der -sOption aufzurufen .

Die erste Ersetzung umgibt jeden Vokal \v...#, wobei der \vCursor nach unten verschoben wird und der #eine Markierung für den zweiten Schritt ist. Das i`ist Retina Notation für Groß- und Kleinschreibung Matching.

Der zweite Schritt entfernt dann wiederholt ( +`) a #aus einem Wort und setzt a e\[Aan das Ende des Wortes, wodurch der Cursor nach oben verschoben wird. Dies stoppt, sobald sich die Zeichenfolge nicht mehr ändert, dh wenn #die Zeichenfolge keine Markierungen mehr enthält .

CJam, 39 36 Bytes

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}/

Das obige ist ein reversibler xxd-Speicherauszug, da der Quellcode die nicht druckbaren Zeichen VT (Codepunkt 0x0b) und ESC (Codepunkt 0x1b) enthält.

Wie diese Antwort werden vertikale Tabulatoren und ANSI-Escape-Sequenzen verwendet .

Dies erfordert ein unterstützendes Videotext-Terminal, das die meisten Nicht-Windows-Terminalemulatoren enthält.

Testlauf

Bevor wir den eigentlichen Code ausführen, deaktivieren wir die Eingabeaufforderung und löschen den Bildschirm.

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

Dadurch wird sichergestellt, dass die Ausgabe korrekt angezeigt wird.

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

Führen Sie Folgendes aus, um die Eingabeaufforderung wiederherzustellen:

PS1="$PS1save"

Wie es funktioniert

Vor jedem Vokal wird ein vertikaler Tabulator eingefügt, um den Cursor nach unten zu bewegen, und nach jedem Leerzeichen werden ausreichend Kopien der Bytefolge 1b 5b 41 ( "\e[A") eingefügt, um den Cursor zurück in die erste Zeile zu bewegen.

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#

Java, 428 Bytes

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]);}

Ich weiß, es ist schrecklich. Es gibt wahrscheinlich einige Zeichen, die rasiert werden können, aber ich bin zu faul, das zu tun.

Perl, 31 Bytes

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

Das obige ist ein reversibler xxd-Speicherauszug, da der Quellcode die nicht druckbaren Zeichen VT (Codepunkt 0x0b) und ESC (Codepunkt 0x1b) enthält.

Der Code ist 27 Byte lang und erfordert die Schalter 040p(4 Byte).

Das Programm erfordert ein Videotextterminal, das vertikale Tabulatoren und ANSI-Escape-Sequenzen unterstützt , einschließlich der meisten Nicht-Windows-Terminalemulatoren.

Testlauf

Bevor wir den eigentlichen Code ausführen, deaktivieren wir die Eingabeaufforderung und löschen den Bildschirm.

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

Dadurch wird sichergestellt, dass die Ausgabe korrekt angezeigt wird.

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

Führen Sie Folgendes aus, um die Eingabeaufforderung wiederherzustellen:

PS1="$PS1save"

Wie es funktioniert

• perl -040pLiest die Eingabe automatisch als durch Leerzeichen getrennte Token ( -040), speichert jedes Token in $_( -p) und führt das Programm aus.

• s/[aeiouy]/.$&/giFührt eine globale Suche $_nach Vokalen durch , bei der die Groß- und Kleinschreibung nicht beachtet wird, und ersetzt jeden Vokal durch das Steuerzeichen VT (bewegt den Cursor nach unten), gefolgt vom Vokal selbst.

• sgibt die Anzahl der durchgeführten Ersetzungen zurück, $\=".[A"x s...speichert also mehrere Kopien der Byte-Sequenz 1b, 5b, 41 (bewegt den Cursor nach oben) in $\einer für jeden Vokal.

• Am Ende des Programms druckt Perl "$_$\"aufgrund des -pWechsels automatisch .

C 200 - 190 Bytes

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);
}

Es ordnet einen rechteckigen Puffer (tatsächlich quadratisch) zu, füllt ihn mit Leerzeichen und Zeilenumbrüchen und durchläuft dann die angegebene Zeichenfolge. Am Ende wird ein Nullzeichen hinzugefügt, um das Nachziehen von Zeilenumbrüchen zu verhindern.

Technisch gesehen ist es keine Funktion, da es Globale enthält. Tatsächlich kann es nicht mehr als einmal aufgerufen werden ( jund lmuss am Anfang 0 sein). Zu beachten, i,j,k,l,M;könnte zu int i,j=0,k,l=0,M;Beginn der Funktion verschoben werden.

CJam, 47

Ja, es ist ein bisschen lang, aber es "schummelt" nicht mit ANSI-Codes :)

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

Probieren Sie es online aus

Die Idee ist, für jedes Zeichen eine Zeilennummer zu berechnen (beginnend bei 0, inkrementell bei Vokalen und zurück zu 0 bei Leerzeichen) und dann für jede Zeile die Zeichenfolge zu wiederholen, aber die Zeichen mit einer anderen Zeilennummer durch ein Leerzeichen zu ersetzen .

K, 81 72 70 66 Bytes

Nun, es ist ein Anfang:

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

Anwendungsbeispiele:

  `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       

Bearbeiten 1:

Besser. Einige Verbesserungen an der Oberfläche vorgenommen:

`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}

Insbesondere habe ich die Argumente für die Vokalsuche umgekehrt ?und damit die Notwendigkeit für ein Lambda beseitigt, die gleiche Umkehrung vorgenommen, bei der _ich Wörter in Leerzeichen aufteilte, und mir wurde klar, dass dies ~{" "?x}'xeine wirklich alberne, überkomplizierte Art zu sagen ist " "=x.

Bearbeiten 2:

Eine weitere Optimierung auf Oberflächenebene, sbevor Sie sie auf das Lambda anwenden, spart Parens im Inneren:

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

Edit 3:

OK, gehen wir bei der Berechnung des Offsets für jedes Zeichen anders vor. Anstatt die Sequenz in Leerzeichen aufzuteilen und eine laufende Summe ( +\) der Positionen der Vokale zu berechnen , können wir die gesamte Eingabezeichenfolge in einem Durchgang bearbeiten und die laufende Summe mit 0 multiplizieren, wenn wir auf ein Leerzeichen stoßen. Ich brauche die Negation dieser Sequenz, damit ich subtrahieren kann, anstatt beim Scannen zu addieren, und beim Berechnen des Betrags der vertikalen Polsterung number-of-distinct ( #?) anstelle von max ( |/) verwenden kann.

`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}

Das spart weitere 4 Zeichen. Puh!

Ruby: 135 131 124 115 112 Zeichen

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

Probelauf:

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

C 192 Bytes

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);}}

Dies durchläuft die Zeichenfolge und löscht die Zeichen, während sie gedruckt werden. Es wird wiederholt, bis keine Leerzeichen mehr zum Drucken vorhanden sind. Es handelt sich um portables C, bei dem keine Annahmen zur Zeichenkodierung gemacht werden.

Lesbare Version

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 */
    }
}

Python 3, 265 207 202 185 177 Zeichen

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))

Das ist schrecklich und ich bin nicht stolz. Ich weiß, dass dies kürzer gemacht werden kann, aber ich dachte, ich würde trotzdem posten.

Inspiriert von der C-Version wird eine Liste erstellt, die dann beim Durchlaufen der Eingabezeichenfolge gefüllt wird.

GNU Sed, 151 + 1

(+1 wie es die -rFlagge braucht )

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

Ich dachte, dass sed das Werkzeug für diesen Job sein würde, fand es aber überraschend schwierig.

Lesbare Version:

#!/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

Python 2, 145 142 Bytes

Wahrscheinlich ist es nicht so wettbewerbsfähig wie einige andere Methoden, aber ich dachte, dies wäre eine coole Art, Regex zu verwenden.

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

Der reguläre Ausdruck (?!([^aeiouy ]*[aeiouy]){N}[^aeiouy]* ).stimmt mit einem einzelnen Zeichen überein, das sich nicht in der N-ten Buchstabengruppe am Ende eines Wortes befindet. Da es vom Ende der Welt an zählt, vertausche ich die Zeichenfolge vorher und nachher und muss am Ende auch ein Leerzeichen einfügen, aber danach wird es zu einer einfachen Angelegenheit re.sub, jede Instanz dieser Zeichen durch ein Leerzeichen zu ersetzen. Dies geschieht für jeden Wert von N, bis die Zeichenfolge leer ist.

Oktave, 132 129 Zeichen

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)

Prüfung

Eingang: "YEAh UppErcAsE VOwEls"

Ausgabe:

               V     
Y Upp Ow   
 E Erc Els
  Ah wie        
             E       

Gema : 53 48 Zeichen

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

Beachten Sie, dass ^[(x1b) und ^K(x0b) einzelne Zeichen sind. (Im folgenden Probelauf verwende ich deren Copy-Paste-freundlich\e und \vEntsprechungen, falls Sie es ausprobieren möchten.)

Probelauf:

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 

Jelly , 42 Bytes (nicht konkurrierend?)

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

Probieren Sie es online!

Warum Gelee, warum? :-(