Sie müssen ein Programm oder eine Funktion schreiben, die eine "treppenförmige" Zeichenfolge erstellt. Hier ist, wie Sie eine Zeichenfolge "treppen":

Für jedes Zeichen in der Zeichenfolge:

• Wenn das Zeichen ein Vokal in Groß- oder Kleinbuchstaben ohne 'y' ist, geben Sie es aus, und verschieben Sie den Rest der Zeichenfolge in einer Spalte nach oben.

• Wenn das Zeichen ein Leerzeichen oder ein Tabulator ist, geben Sie es aus und verschieben Sie den Rest der Zeichenfolge in einer Spalte nach unten .

• Wenn das Zeichen keines ist, wird es normal ausgegeben.

IO kann in jedem vernünftigen Format vorliegen. Die Eingabe enthält keine Zeilenumbrüche. Wenn Sie möchten, können Sie nachfolgende Leerzeichen entfernen.

Wenn Sie die Zeichenfolge zurückgeben möchten, anstatt sie zu drucken, fügen Sie bitte auch ein kurzes Programm hinzu, das Ihre Zeichenfolge druckt, damit sie visualisiert werden kann. Dies ist nicht obligatorisch und wird auch nicht für Ihre Byteanzahl verwendet. Dies ist nur eine Annehmlichkeit für Benutzer, die Golf oder Esolangs (wie ich) nicht verstehen, um die Ausgabe zu überprüfen oder mit dem Code zu basteln.

Beispiel IO:

Ausgabe für "bcdef ghijkl":

    f    jkl
bcde  ghi

Ausgabe für "Programmieren von Rätseln und Code-Golf":

                               lf
                            -Go
                  s  nd   de   
         ng   zzle  A   Co       
      mmi   Pu                 
   gra        
Pro

Ausgabe für "Abcdefghijklmnopqrstuvwxyz":

                     vwxyz
               pqrstu
         jklmno
     fghi          
 bcde             
A        

Wie üblich ist dies Codegolf, daher gewinnt die kürzeste Antwort in Bytes.

MATL , 38 37 Bytes

Oj33<G13Y2m-IL)hYstX<-"@Z"GX@)h]Xh!c!

Probieren Sie es online!

Erläuterung

Für jedes Zeichen berechnet der Code seine vertikale Position, gemessen von oben (0 ist die höchste). Anschließend wird die transponierte Ausgabezeichenfolge erstellt: Jedes Zeichen befindet sich in einer Zeile mit so vielen führenden Leerzeichen, wie die vertikale Position angibt. Dann werden alle Zeilen zu einem 2D-Zeichen-Array zusammengefügt, das schließlich transponiert und angezeigt wird.

O       % push a 0
j       % input a string
33<     % array of the same length as the input that contains true for spaces or tabs
G       % push input again
11Y2    % string 'aeiouAEIOU'
m       % array of the same length as the input that contains true for vowels
-       % subtract
IL)     % remove last element
h       % prepend the 0 that is at the bottom of the stack
Ys      % cumulative sum. This gives the vertical position of each char
tX<     % duplicate. Compute minimum
-       % subtract. This sets minimum vertical position to 0
"       % for each vertical position
  @     %   push vertical position of current character
  Z"    %   string with that many spaces
  G     %   push input again
  X@)   %   get the character corresponding to the current iteration index
  h     %   concatenate horizontally
]       % end for each
Xh      % concatenate all lines into a row cell array
!       % transpose into a column cell array
c       % convert into 2D array, padding with spaces if needed
!       % transpose. Implicitly display

Pyth, 63 Bytes

V_Q aY?}rN0"aeiou"=hZ?}N"     "=tZZ;Jh.mbYKh.MZYjC.b++*d+JNY*dK_YQ
                         ^^^^^
                         |||||
                         |tabs
                        space

Die Leerzeichen in der Mitte sind eigentlich ein einzelnes Tabulatorzeichen, aber StackExchange gibt es als vier Leerzeichen wieder.

Probieren Sie es online!

Python 2, 141 137 Bytes

def S(s,l=[0]):
 for c in s:l+=[l[-1]-(c in"aeiouAEIOU")+(c<"!")]
 for h in sorted(set(l)):print"".join([" ",c][i==h]for i,c in zip(l,s))

JavaScript (Firefox 30-57), 151 Byte

s=>[...s].map((c,i)=>r[c<'!'?n++:/[AEIOU]/i.test(c)?n--:n][i]=c,n=s.length,r=[for(_ of s+s)[]])&&[for(a of r)if(s=[for(c of a)c||' '].join``)s].join`\n`

Wobei \ndas wörtliche Zeilenumbruchzeichen darstellt.

C 180 Bytes

char s[99];i,j,p[99],m,M;main(c){for(gets(s);c=s[i];j+=strchr("aeiou",c|32)!=0,j-=c<33,m>j?m=j:M<j?M=j:0)p[i++]=j;for(;m<=M;putchar(10),M--)for(i=0;c=s[i];)putchar(M^p[i++]?32:c);}

Ungolfed:

char s[99];i,j,p[99],m,M;
main(c){for(gets(s);c=s[i];
j+=strchr("aeiou",c|32)!=0,j-=c<33,m>j?m=j:M<j?M=j:0)
  //move current height up or down, adjust minimum and maximum height
p[i++]=j;  //record height of character
for(;m<=M;putchar(10),M--)  //from maximum to minimum height
for(i=0;c=s[i];)putchar(M^p[i++]?32:c);}  //print only characters on this height

Perl, 110 Bytes (108 Bytes Skript + 2 Bytes Flags)

$h=0;map{$h{$h}.=' 'x($p-$p{$h}).$_;$p{$h}=++$p;$h+=/[aeiou]/i-/\s/}split//;print for@h{sort{$b<=>$a}keys%h}

Laufen Sie mit perl -nl script.pl , die Eingabe ist auf stdin, die Ausgabe ist auf stdout.

Deobfuscated

Ich habe die Variablen sinnvoller umbenannt, den Code gemacht use strictunduse warnings Kompatibilität verbessert und vieles explizit gemacht, was Magic Perl automatisch macht.

Dies wird nur ausgeführt als perl script.pl, weil es die Auswirkungen der -nlFlags innerhalb des Skripts repliziert .

use strict;
use warnings;
use English;

# The effect of -l in perl's flags
$INPUT_RECORD_SEPARATOR = "\n";
$OUTPUT_RECORD_SEPARATOR = "\n";

# These variables are magicked into existence
our $column = 0;
our %line_col = ();
our %lines = ();

# The implicit while-loop is the effect of -n in perl's flags
while (defined(my $line = <>)) {
    # The "chomp" is part of perl's -l flag too
    chomp $line;

    # Here starts the actual script. "$h=0" turns into...
    our $height = 0;
    for my $char (split '', $line) {
        if (!exists $line_col{$height}) {
            # Setting it to 0 is a bit of a white lie, but it might as well be 0.
            # Perl would otherwise have called the value "undef", which is
            # similar to 0 in numeric contexts.
            $line_col{$height} = 0;
        }

        $lines{$height} .= ' ' x ($column - $line_col{$height});
        $lines{$height} .= $char;

        $column++;
        $line_col{$height} = $column;

        $height++ if $char =~ /[aeiou]/i;
        $height-- if $char =~ /\s/;
    }

    # Sort line heights numerically descending (so the greatest is printed first)
    my @heights = sort { $b<=>$a } keys %lines;

    for my $line (@lines{ @heights }) {
        print $line;
    }
}

JavaScript (ES6), 133

s=>s.replace(/[^aeiou ]*(.?)/gi,(z,x,c)=>(q=o[r]||'',o[r]=q+=' '.repeat(c-q.length)+z,x<'!'?++r:r?--r:o=[,...o]),o=[],r=0)&&o.join`
`

Weniger golfen

s=>(
  s.replace(/[^aeiou ]*(.?)/gi,(z,x,c)=>(
    q = o[r] || '',
    o[r] = q += ' '.repeat(c - q.length) + z,
    x == ' ' ? ++r : r ? --r : o = [,...o]
  ), o = [], r = 0),
  o.join`\n`
)

Prüfung

f=s=>s.replace(/[^aeiou ]*(.?)/gi,(z,x,c)=>(q=o[r]||'',o[r]=q+=' '.repeat(c-q.length)+z,x<'!'?++r:r?--r:o=[,...o]),o=[],r=0)&&o.join`
`

function test() {
  i=I.value
  O.textContent=f(i)
}

test()

#I { width:90%}

<input id=I oninput='test()' value='Programming Puzzles And Code-Golf'>
<pre id=O>

Haskell (innerhalb des ANSI-Terminals), 75 Byte

("\27[2J"++).(h=<<)
h ' '="\27[B "
h c|elem c"aeiouAEIOU"=c:"\27[A"
h c=[c]

Anwendungsbeispiel: putStr $ ("\27[2J"++).(h=<<) $ "bcdef ghijkl"

Dies verwendet ANSI-Escape-Codes, um den Cursor nach oben und unten zu bewegen.

C 173 160 156 155 Bytes

Edit: Ausgeliehene Idee, mit strchr von @mIllIbyte 13 Bytes zu entfernen

Edit2: Min / Max-Vergleiche wurden optimiert, -4 Bytes

Edit3: c kann einen beliebigen Wert haben, der mit -> into main (c) beginnt, stattdessen -1 Byte

Edit4: Ungolf / Erklärung hinzugefügt

p,l,j,m;main(c){char b[99],*s=gets(b);for(;j<m+2;p?putchar(c?l?32:c:10):l<j?j=l:l>m?m=l:0,l-=c?(c&=223)&&c-9?!!strchr("AEIOU",c):-1:(p=s=b,l+j++))c=*s++;}

Ungolfed und erklärte:

/* declare and initialize these variables to int and 0 */
p,l,j,m;

/* declares main, but also int c */
main(c)
{

  /* we can handle strings of length 98 (+1 for string-terminating 0) */
  /* we declare and initialize s to point to the beginning of the input
     string for the first pass through the for loop */
  char b[99],*s=gets(b);

  /* the for-loop actually contains nested loops, where the inner loops
     behave differently depending on the outer loop parameter p as follows:
     p attains the values false (0) and true (non-null pointer), in this order.

     p == false:
      the inner loop has the parameter s and passes through all the characters
      in the string until the string is exhausted (*s == 0). l is the vertical
      position of the current character relative to the first character
      (l = 0), smaller number = higher up. The purpose here is simply to find
      the range of vertical positions [j, m] present in the string. The
      commands in execution order are:

      -- loop over s --

      // test does not do anything since j <= m by design
      1. j < m+2

      // puts current char in c and increments string counter
      2. c = *s++          

      // ensures that j (m) equals the min (max) of the vertical positions (l)
         encountered so far. At first step j = l = m = 0.
      3. l<j?j=l:l>m?m=l:0 

      // c != 0, this updates the vertical position for the next character
      // c = SPC or C = TAB -> lower (l increases by 1)
      // c = "aeiouAEIOU" -> higher (l decreases by 1)
      4a. l-=(c&=223)&&c-9?!!strchr("AEIOU",c):-1

      -- loop over s ends --

      // c == 0, this resets the string pointer s and puts p = true, and 
      //         thereby initiates the next phase of the algorithm
      //         see rest of the explanation at p == true)
      4b. p=s=b

    p == true:
     now there are two inner loops. The outer of these has the parameter j,
     which ranges from the smallest vertical position+1 (the value of j after
     the p == false pass) to the largest vertical position+1 (m+2 after the
     p == true pass). The innermost loop has the parameter s and passes through
     all characters in the string until the string is exhausted (*s == 0) just
     as in the p == false inner loop. Here l is now the vertical position
     relative to the current position j-1, so that l == 0 when a character is
     at the current level. Such characters are printed as is, whereas
     characters at other levels are replaced by space. The end-of-string
     marker 0 outputs a newline. The commands in execution order are:

      -- loop over j --

      // at first step increments j to point to be one more than the
      // current vertical position. At other steps moves the current position
      // (j-1) one vertical position downwards. Also, at all steps, this
      // biases the vertical position counter l to be zero at the current
      // vertical position (j-1)
      1. l=-j++

      // compare j to stopping criteria, exit if j > m+1
      2. j < m+2

       -- loop over s --

       // puts current char in c and increments string counter
       3. c = *s++          

       // outputs character as follows:
       // c == 0 (end of string), output newline
       // c != 0 (middle of string)
       //  l == 0 (character at current vertcial position), output c
       //  l != 0 (character not at current vertical position), output space
       4. putchar(c?l?32:c:10)

       // c != 0, this updates the vertical position for the next character
       // c = SPC or C = TAB -> lower (l increases by 1)
       // c = "aeiouAEIOU" -> higher (l decreases by 1)
       5a. l-=(c&=223)&&c-9?!!strchr("AEIOU",c):-1

       -- loop over s ends --

      // c == 0, this resets the string pointer s for next loop over s
      //         algorithm (see rest of the explanation at p == true)
      5b. p=s=b

     -- loop over j ends --
  */

  for(;
      j<m+2;
      p?putchar(c?l?32:c:10):
    l<j?j=l:l>m?m=l:0,
      l-=c?(c&=223)&&c-9?!!strchr("AEIOU",c):-1:
       (p=s=b,l+j++))
    c=*s++;
}