Sie möchten kein Geld für das teure Architekturprogramm bezahlen, also entscheiden Sie sich, Ihr eigenes zu rollen. Sie entscheiden sich für ASCII, um Ihre Gebäude zu entwerfen. Ihr Programm nimmt eine einzelne Zeichenfolge auf, die auf bestimmte Weise formatiert ist, und das Programm gibt das Gebäude aus.

Eingang

Die Eingabe besteht aus einer einzelnen Zeichenzeile. Es kann angenommen werden, dass es nur die Buchstaben a-j, die Zahlen 1-9und die Symbole -und enthält +.

Ausgabebeschreibung

Für jeden Buchstaben a-jgibt das Programm eine vertikale Linie wie folgt aus. Wir werden dies eine Spalte nennen.

         .
        ..
       ...
      ****
     *****
    ******
   -------
  --------
 +++++++++
++++++++++
abcdefghij

Die Eingabe abcdefgfedefghgfedcwürde beispielsweise Folgendes ausgeben:

             .
      *     ***
     ***   *****
    ***** *******
   ---------------
  -----------------
 ++++++++++++++++++
+++++++++++++++++++

Einem Buchstaben kann eine positive Ganzzahl vorangestellt werden n, die nLeerzeichen unter der Spalte hinzufügt . Wir werden dies als Offset bezeichnen. Wenn Sie beispielsweise Sein Leerzeichen notieren, gibt die Eingabe 3b2b3bFolgendes aus:

+ +
+++
S+S
SSS
SSS

Ein Brief kann auch mit einer vorangestellt wird negative ganze Zahl -m, das wird entfernt die unteren m Nicht-Leerzeichen Zeichen der Säule (sie nicht mit Leerzeichen ersetzen, entfernen sie ganz). Wir werden das eine Scheibe nennen. Die Eingabe -1j-2j-3j-4j-5j-6j-7j-8jwürde beispielsweise Folgendes ausgeben:

.
..
...
*...
**...
***...
-***...
--***...
+--***..

Ein Versatz und ein Schnitt können auf dieselbe Linie angewendet werden, aber der Versatz muss zuerst erfolgen. Mit anderen Worten, dem Buchstaben kann das Präfix vorangestellt werden n-m, wobei ndie Größe des Offsets und mdie Größe des Slice angegeben werden. Wenn Sie zum Beispiel Sein Leerzeichen notieren, würde die Eingabe '2-4j' Folgendes ausgeben:

.
.
.
*
*
*
S
S

Schließlich gibt der +zwischen zwei Spalten verwendete Operator an, dass sie in derselben Spalte statt in separaten Spalten übereinander gestapelt werden sollen. Beispielsweise gibt die Eingabe "2-4ja" Folgendes aus:

.
.
.
*
*
*
S
S+

Während die Input- 2-4j+aOutputs:

+
.
.
.
*
*
*
S
S

Hier ist eine Beispieleingabe:

abiehef+ehfhabc

Und die resultierende Ausgabe:

      *
      -
  .   -
  . . +. .
  * * +* *
  * * ****
  ********
  --------
  --------  -
 +++++++++ ++
+++++++++++++

Sieht aus wie ein alter zerstörter Schlossturm.

Hier ist ein weiteres Eingabebeispiel:

6b5b+a6b1-2d+3-4f1-2d+-2c+2-4f+1-2d+-2c2-2d+1-4g+1-2c+b+-2c+-4e2-7j+-4g+d+-2c+-4f2-7j+-5h+b+-2c+a+-3f2-7j+-7i+-4e+b+b+a+-4f2-7i+a+-7h+-4f+b+b+a+-4f2-7j+-7h+-4f+a+-7h+a+-7i+-4f2-7j+-7i+-6h+a+-7i+b+-4e3-7i+a+-7h+-4e+a+-7h+b+1-7h3-7j+1-4f+-7h+b+-4f+a3-7j+2-4f+a+-4f+b3-2d+-2d+3-4g+b3-2d+-2d+-2c

Und die resultierende Ausgabe:

      ****** +++
     ******+.*++
     ---++.+ ***
    -+-+++..++**
    -+--+++.+++*
    --++++.+..*
      +++++.+**
+++****.******  -
+++*****.**..  --
 +   ***....+..--
      ...+.....--
    --.........--
   ---......
   --

(Es sollte Mario sein, stellte sich aber nicht als sehr gut heraus ...)

Wenn die Spezifikation immer noch nicht klar ist, habe ich eine Implementierung ohne Golf in Python 2.7 geschrieben. Sie können es ausführen und experimentieren, um ein Gefühl dafür zu bekommen, wie die Spezifikation funktioniert. Sie können auch über meine Programmierkenntnisse lachen.

Dies ist Code-Golf, also gewinnt der kürzeste Einstieg. Stellen Sie Fragen in Kommentaren, wenn Sie unklar sind.

Ruby, 223 214 Bytes

g=$*[0].split(/(?<=[a-j])(?!\+)/).map{|r|r.scan(/(\d*)(-\d+)?([a-j])/).map{|a,b,c|' '*a.to_i+'++--***...'[-b.to_i..c.ord-97]}*''}
puts g.map{|s|s.ljust(g.map(&:size).max).chars.reverse}.transpose.map(&:join).join$/

Das hat Spaß gemacht. :)

Obwohl es ziemlich offensichtlich sein sollte, habe ich eine neue Methode gefunden, um diese Herausforderungen zu meistern, bei der Zeichenfolgen aus Spalten aufgebaut werden: Führen Sie sie einfach in Zeilen aus und transponieren Sie das Zeichenfeld, bevor Sie alles verbinden.

g=$*[0].split(/(?<=[a-j])(?!\+)/)               # Split into columns.
       .map{|r|                                 # For each column
            r.scan(/(\d*)(-\d+)?([a-j])/)       # Split into components.
             .map{|a,b,c|                       # For each component
                ' '*a.to_i+                     # Prepend spaces if any.
                '++--***...'[-b.to_i..c.ord-97] # Select the appropriate slice of the tower.
            }*''                                # Join all components together.
        }
puts g.map{|s|                                  # For each column
            s.ljust(g.map(&:size).max)          # Pad with spaces on the right such that. 
                                                # all columns are the same height.
            .chars.reverse                      # Turn into character array and reverse.
      }
      .transpose                                # Mirror in the main diagonal.
      .map(&:join)                              # Join lines.
      .join$/                                   # Join columns.

Cobra - 473

Ich glaube nicht, dass Cobra jemals einen dieser Titel gewinnen wird: /

use System.Text.RegularExpressions
class P
    def main
        r=Regex.matches(Console.readLine,r'(?<=^|[a-j])(([^a-j]*[a-j])+?)(?=[^+]|$)')
        z,l=0String[](r.count)
        for m in r.count,for n in'[r[m]]'.split('+'),l[m]+=' '.repeat(int.parse('0[Regex.match(n,r'(?<!-)\d+')]'))+'++--***...'[int.parse('0[Regex.match(n,r'(?<=-)\d+')]'):' abcdefghij'.indexOf(n[-1:])]
        for y in l,if y.length>z,z=y.length
        for x in-z+1:1
            for y in l,Console.write(if(-x<y.length,y[-x],' '))
            print

Alles schön und kommentiert:

EDIT: Ich habe gerade festgestellt, dass dies der Ruby-Lösung verdächtig ähnlich sieht. Große Köpfe denken ähnlich?

use System.Text.RegularExpressions
class P
    def main
        r=Regex.matches(Console.readLine,r'(?<=^|[a-j])(([^a-j]*[a-j])+?)(?=[^+]|$)')
        # Split into columns
        z,l=0,String[](r.count)
        # Assign the column-array
        for m in r.count
        # Loop through columns
            for n in'[r[m]]'.split('+')
            # Loop through individual letter instructions
            # - within columns
                l[m]+=
                # Add characters to the last column
                    ' '.repeat(int.parse('0[Regex.match(n,r'(?<!-)\d+')]'))+
                    # Any spaces, plus
                    '++--***...'[:' abcdefghij'.indexOf(n[-1:])]
                    # The default column string
                        [int.parse('0[Regex.match(n,r'(?<=-)\d+')]'):]
                        # Sliced to the right length
        for y in l,if y.length>z,z=y.length
        # Determine the maximum length of any column
        for x in-z+1:1
            for y in l
            # Loop through columns so that they rotate to the left
                Console.write(if(-x<y.length,y[-x],' '))
                # Write the character in the current position
            print
            # Insert newlines

Lua - 451

a=arg[1]j='++--***...'I=io.write M=string.match U=string.sub T=table.insert n=''y=0 t={}m=0 for i in a:gmatch('[%-%d]*[a-j]%+?')do b=M(i,'-(%d)')b=b or 0 s=M(U(i,1,1),'%d')s=s or 0 n=n..(' '):rep(s)..U(U(j,1,M(U(i,-2),'[a-j]'):byte()-96),1+b,-1)if U(i,-1,-1)~="+"then T(t,n)m=m<#n and #n or m n=""y=y+1 end end T(t,n)n=''for k,v in pairs(t)do n=#v<m and n..v..(' '):rep(m-#v)or n..v end for i=m,1,-1 do for k=0,m*y-1,m do I(U(n,i+k,i+k))end I'\n'end

Nichts Besonderes. Es hat Spaß gemacht, eine ganze Reihe von Funktionen einmal umzubenennen. Ich werde den ungolfed Code später bearbeiten.

Probieren Sie es hier aus. Beispielausgabe:

PowerShell , 214 212 209 206 200 Bytes

-3 Bytes danke @Veskah

switch -r($args-split'(-?.)'){\+{$c=1}\d{sv('ps'[0-gt$_])$_}[a-j]{if(!$c){$t+=,''}$t[-1]+=' '*$p+-join'++--***...'[-$s..($_[0]-97)];$c=$p=$s=0}}($t|% Le*|sort)[-1]..1|%{-join($t|% *ht $_|% ch*($_-1))}

Probieren Sie es online!

Weniger Golf Version:

# make table with lines instead columns
switch -r($args-split'(-?.)'){
    \+ {$c=1}
    \d {set-variable ('ps'[0-gt$_]) $_}
    [a-j] {
        if(!$c){$t+=,''}
        $t[-1]+=' '*$p+-join'++--***...'[-$s..($_[0]-97)]
        $c=$p=$s=0
    }
}
# transpose
($t|% Length|sort)[-1]..1|%{
    -join($t|% padRight $_|% chars($_-1))
}

Python 3, 268 Bytes

import re
q,t=[(p,' '*int(o or 0)+'++--***...'[-int(s or 0):ord(l)-96])for p,o,s,l in re.findall('(\+?)(\d?)(-\d)?(.)',input())],[]
while q:p,s=q.pop(0);t+=[t.pop()+s if p else s]
t=[*zip(*[[*c.ljust(max(map(len,t)))]for c in t])][::-1]
for l in t:print(*l,sep='')

Meistens ungolfed:

# import the regex module
import re

# array to store initial input
q = []
# array to store translated output
t = []

# split string from stdin into column groups, like: ('plus or blank', 'offset or blank', 'slice or blank', 'letter')
# ex: 6b1-2d+a would become:
# [('','6','','b'), ('', '1', '-2', 'd'), ('+', '', '', 'a')]
i = re.findall('(\+?)(\d?)(-\d)?(.)',input())

# iterate through the groups returned by the regex
for p,o,s,l in i:
    # create offset string
    # int() cannot parse '', but empty strings are falsey,
    # so (o or 0) is equivalent to 'parse the string as an int, or return 0 if it is empty'
    offset = ' ' * int(o or 0)

    # get the starting point of the slice
    # since the regex returns the minus, it must be negated after converting the string to an int
    # as before, (s or 0) ensures that the slice is converted to an int properly
    start = -int(s or 0)
    # since 'a' is ordinal 97, this ensures that the end position will be 1-9
    end = ord(l) - 96
    # slice the largest possible column string with the calculated start and end positions
    a = '++--***...'[start:end]
    # add the space offset
    a = offset + a
    # add the plus sting and the column string to the array
    q.append( (p, a) )

# while q is not empty
while q:
    # remove the first item from the list and separate it into a plus variable and a column string
    p, s = q.pop(0)

    # if p is not blank, it is a '+'
    # if p is truthy, remove the last item added and add s to it
    # otherwise just return s
    # append the resulting item to the ongoing list
    t += [t.pop()+s if p else s]

temp = []
for c in t:
    # call len() on all items in t, then return the maximum length
    m = max(map(len, t))
    # left justify c by adding spaces to the right, up to m total characters
    c = c.ljust(m)
    # unpack c into a list
    # this is equivalent to list(c), but shorter
    c = [*c]
    # add the list of characters to the array
    temp.append(c)

t = temp

# t is currently a list of rows, and needs to be rotated so that it displays correctly
# input: 'abcdefghij'
# before:
#
# +
# ++
# ++-
# ++--
# ++--*
# ++--**
# ++--***
# ++--***.
# ++--***..
# ++--***...
#
# after:
#
#  ++++++++++
#   +++++++++
#    --------
#     -------
#      ******
#       *****
#        ****
#         ...
#          ..
#           .
# 
t = [*zip(*t)]
# t is currently upside down, reverse the list
t = t[::-1]

# for each line (currently a list of characters)
for l in t:
    # unpack the list into print as arguments, do not add a space between arguments
    print(*l,sep='')