Faites entrer l'art ASCII dans la 3ème dimension

11

Dans ce défi, vous devez apporter de l'art ASCII (qui sont généralement 2D) à la 3D!

Comment?

comme ça,

X X DD 
 X  D D
X X DD 

à...

  X X DD 
 X X DD D
X X DDDD 
 X XDDD
X X DD

Alors comment on fait ça ?

Compte tenu de l'art ascii et N, répétez cette Nfois.

  • pour chaque personnage (nous l'appellerons ainsi A):
  • laissez - Bêtre le caractère qui est exactement 1 à droite et 1 à partirA
  • si Best un espace ou n'est pas défini:
  • réglé Bsur A.

Spécifications

  • La première entrée peut être une chaîne avec des caractères de nouvelle ligne ou une liste de chaînes représentant l'art ASCII 2D.
  • Vous êtes autorisé à utiliser %END%pour marquer la fin de l'entrée, mais cela n'est pas obligatoire.
  • La deuxième entrée sera N. Ce sera un entier positif.
  • toutes les lignes des cordes auront la même longueur.

Exemples

Contribution: ("###\n###",1)

Production:

 ###
####
###

Règles

Les règles de base du s'appliquent.

aussi, si vous avez des questions, n'oubliez pas de demander dans les commentaires!


la source
Vous voudrez peut-être préciser que «vide» fait référence à l'espace (U + 0020) ou à rien.
Leaky Nun
@LeakyNun Est-il corrigé maintenant?
Les espaces supplémentaires sont-ils autorisés?
Leaky Nun
Oui, ceux-ci sont autorisés.
1
Puis-je supposer que la longueur de chaque ligne sera la même? (Puis-je pré-remplir l'entrée avec des espaces sur la droite?)
Leaky Nun

Réponses:

18

Perl, 81 octets

75 octets code + 6 pour -i -n0.
Notez que les \ecaractères sont ASCII \x1bmais \esont utilisés pour faciliter les tests.

Veuillez noter que cette solution utilise des séquences d'échappement ANSI et nécessite un terminal compatible, ainsi que l'utilisation de l' -iargument de ligne de commande pour transmettre le nombre de «dimensions» que vous souhaitez.

$n=s/^//mg-1;s/ /\e[1C/g;print(s/^/\e[${^I}C/grm."\e[${n}A"),--$^I for($_)x$^I

Usage:

Dans un terminal compatible Linux, exécutez d' PS1=abord pour vous assurer que votre invite ne remplace pas l'image affichée.

perl -i10 -n0e '$n=s/^//mg-1;s/ /\e[1C/g;print(s/^/\e[${^I}C/grm."\e[${n}A"),--$^I for($_)x$^I' <<< ' 
ROFL:ROFL:ROFL:ROFL
         _^___
 L    __/   [] \    
LOL===__        \ 
 L      \________]
         I   I
        --------/
'

          ROFL:ROFL:ROFL:ROFL
         ROFL:ROFL:ROFL:ROFL
        ROFL:ROFL:ROFL:ROFL
       ROFL:ROFL:ROFL:ROFL\
      ROFL:ROFL:ROFL:ROFL\_]
     ROFL:ROFL:ROFL:ROFL\_]
    ROFL:ROFL:ROFL:ROFL\_]/
   ROFL:ROFL:ROFL:ROFL\_]/
  ROFL:ROFL:ROFL:ROFL\_]/
 ROFL:ROFL:ROFL:ROFL\_]/
   LOL==___^___]_\_\_]/
  LOL==__/ \_[]_\_\_]/
 LOL===__ \______\_]/
  L      \________]/
          I---I---/
         --------/

perl -i3 -n0e '$n=s/^//mg-1;s/ /\e[1C/g;print(s/^/\e[${^I}C/grm."\e[${n}A"),--$^I for($_)x$^I' <<< 'X X DD
 X  D D
X X DD
'
   X X DD
  X X DD D
 X X DDDD
  X XDDD
 X X DD
Dom Hastings
la source
8

CJam, 25 24 octets

{{' 1$f+La@+..{sS@er}}*}

Un bloc sans nom qui attend une liste de chaînes et le nombre de répétitions sur la pile et laisse une nouvelle liste de chaînes à la place.

Testez-le ici. (Comprend un wrapper de test qui lit la chaîne de STDIN pour plus de commodité.)

Explication

{       e# Repeat this block N times...
  '     e#   Push a space character.
  1$    e#   Copy the current grid.
  f+    e#   Prepend the space to each line of the grid.
  La    e#   Push [[]].
  @+    e#   Pull up the other copy of the grid and prepend the [].
        e#   We've now got two copies of the grid, one shifted right by
        e#   a cell and one shifted down by a cell. We now want to replace
        e#   spaces in the latter with the corresponding character in the
        e#   former.
  ..{   e#   For each pair of characters in corresponding positions...
    s   e#     Turn the character in the down-shifted grid into a string.
    S   e#     Push " ".
    @   e#     Pull up the character from the right-shifted grid.
    er  e#     Replace spaces with that character.
  }
}*
Martin Ender
la source
5
Dix roflcopters! goo.gl/PEK4iB
Pourquoi ne Sfonctionne pas pour l'espace initial? Est-il également autorisé d'utiliser des variables (qui auraient pu être écrasées) dans une fonction?
Luis Mendo
@LuisMendo Sne fonctionne pas, car il fserait alors mappé sur cette chaîne à la place. En ce qui concerne les fonctions, je crois, dans les langues "normales", il existe également de nombreuses soumissions de fonctions qui reposent sur des variables globales qui ne sont pas falsifiées entre les invocations.
Martin Ender
Merci. J'ai oublié qu'un caractère dans CJam n'est pas la même chose qu'une chaîne à un caractère
Luis Mendo
1
Vous pouvez enregistrer un octet en utilisant Convex car il possède un opérateur de translittération à un caractère au lieu d'un opérateur à deux caractères: convex.tryitonline.net/… (plug sans vergogne)
GamrCorps
4

APL, 49 octets

{⎕UCS 32⌈{s+(s=0)×1⊖¯1⌽s←0⍪⍵,0}⍣⍺⊣(32∘≠×⊣)⎕UCS↑⍵}

Entrée: vecteur de vecteurs de caractères. Exemple:

      2 {⎕UCS 32⌈{s+(s=0)×1⊖¯1⌽s←0⍪⍵,0}⍣⍺⊣(32∘≠×⊣)⎕UCS↑⍵} 'X X DD' ' X  D D' 'X X DD'
  X X DD 
 X X DD D
X X DDDD 
 X XDDD  
X X DD   

Comment ça fonctionne:

  • ↑⍵ transforme l'argument en une matrice de caractères
  • ⎕UCS de char à entier
  • (32∘≠×⊣) remplacer les espaces (32) par des zéros
  • ...⍣⍺⊣ appliquer ⍺ (l'argument de gauche) fois la fonction de gauche
  • s←0⍪⍵,0 frontière avec des zéros en haut et à droite l'argument
  • 1⊖¯1⌽ faire pivoter 1 vers le haut et 1 vers la droite
  • s+(s=0)× somme à l'original la version décalée mais uniquement au-dessus des zéros de l'original
  • 32⌈ retourne les zéros en 32s
  • ⎕UCS de l'entier au char
lstefano
la source
4

MATL , 24 octets

:"ct32>*TTYatFTEqYSy~*+c

Le format d'entrée est

2
{'X X DD', ' X  D D', 'X X DD'}

Donc, l'autre exemple est

1
{'###', '###'}

La sortie contient des espaces supplémentaires, ce qui est autorisé par le défi.

Essayez-le en ligne!


Si un tableau de caractères 2D est acceptable en entrée (j'ai demandé l'OP deux fois ...), le premier cpeut être supprimé, donc 23 octets :

:"t32>*TTYatFTEqYSy~*+c

Le format d'entrée dans ce cas est (toutes les chaînes ont des longueurs égales, ce qui peut nécessiter un remplissage à droite avec des espaces):

2
['X X DD '; ' X  D D'; 'X X DD ']

Essayez-le en ligne!


Explication

:        % Input number n implicitly. Generate [1 2 ... n]
"        % For loop: repeat n times
  c      %   Convert to char array. In the first iteration it inputs a cell array of
         %   strings implicitly and converts to a 2D char array, right-padding with
         %   spaces. In the next iterations it does nothing, as the top of the stack
         %   is already a 2D char array
  t32>*  %   Convert characters below 32 into 0
  TT     %   Push array [1 1]
  Ya     %   Pad the 2D char array with one zero in the two directions (up/down,
         %   left/right), on both sides
  t      %   Duplicate
  FTEq   %   Push array [-1 1]
  YS     %   Circularly shift the 2D char array one unit up and one unit right
  y      %   Push a copy of the non-shifted 2D array
  ~      %   Logical negate: nonzero entries become 0, zero entries become 1. This
         %   will be used as a mask for entries that need to be changed. Since the
         %   values at those entries are zero, we can simply add the new values. We do
         %   that by multiplying the mask by the shifted array and adding to the
         %   non-shifted array
  *      %   Multiply element-wise
  +      %   Add element-wise
  c      %   Convert the 2D array back to char
         % End for
         % Implicitly display
Luis Mendo
la source
3

Convexe , 23 octets

Le nombre d'octets suppose le codage CP-1252.

{{' 1$f+La@+..{sS@Ë}}*}

Un bloc sans nom qui attend une liste de chaînes et le nombre de répétitions sur la pile et laisse une nouvelle liste de chaînes à la place.

Essayez-le en ligne!

Ceci est un port direct de ma réponse CJam à Convex (qui est fortement basé sur CJam). La seule différence est que Convex utilise Ëau lieu de erpour la translittération, économisant un octet. Merci à GamrCorps de m'avoir prévenu.

Martin Ender
la source
2

Pyth, 54 33 octets

ju+++dhG.bsmh|-d;;.t,Y+dNdtGGeG.*

Suite de tests.

Leaky Nun
la source
pourquoi en avez-vous besoin de deux ;?
Ven
@ven ;n'est pas habituel ;dans les langages de programmation.
Leaky Nun
;est une variable.
Leaky Nun
ah surcharges pyth ;à lambdas ...
Ven
@ven Lorsque vous obtenez avec Pyth, vous pouvez utiliser I, .?, V, F, ;, (déclarations explicites) très moins, et ils seront remplacés par ?, m, u, F, M, L, R, #, ...
Leaky Nun
2

JavaScript (ES6), 128 octets

f=(a,n)=>n?f((a=[``,...a].map(s=>[...s||` `])).map((b,i)=>i--&&b.map((c,j)=>a[i][++j]>' '?0:a[i][j]=c))&&a.map(b=>b.join``),n-1):a

Accepte et renvoie un tableau de chaînes, ajoute une ligne supplémentaire pour la sortie, garantit que chaque ligne contient au moins un espace, les divise toutes en caractères, boucle en essayant de copier les caractères sur la ligne ci-dessus et la colonne de droite, puis s'appelle récursivement pour terminer la boucle.

Neil
la source
2

Python 2, 116 octets

S=' '
def f(a,d):e=[S*len(`a`)];exec"a=[''.join(t[t[1]>S]for t in zip(S+x,y+S))for x,y in zip(a+e,e+a)];"*d;return a

Je jouerai au golf plus bientôt.

Lynn
la source
Êtes-vous sûr que ce lambdan'est pas plus court?
wizzwizz4
J'ai besoin de l'affectation de elà-dedans. C'est aussi execune déclaration, donc elle ne peut pas être dans un lambda.
Lynn
D'accord. Juste pour être sûr.
wizzwizz4
2

Rubis, 95 octets

->a,n{n.downto(0){|i|f="<Esc>[1C"
$><<a.gsub(/^/,f*i).gsub(" ",f)+(i>0?"<Esc>[#{a.lines.size-1}A":"")}}

Chacun <Esc>est un caractère ESC littéral ( 0x1b).

Usage

Attribuez le lambda à une variable, par exemple func.

art = <<END
X X DD
 X  D D
X X DD
END

func[art, 2]
# Prints:
#   X X DD
#  X X DD D
# X X DDDD
#  X XDDD
# X X DD

Non golfé

->(art, num) {
  num.downto(0) do |i|
    forward = "\e[1C"
    $> << art.gsub(/^/, forward * i).gsub(" ", forward) +
            (i > 0 ? "\e[#{art.lines.size - 1}A" : "")
  end
}

La forwardséquence d'échappement \e[1C, déplace le curseur vers l'avant (à droite) d'un espace et le \e[<n>Adéplace vers le haut n. Fondamentalement, ce code fait imprimer les "couches" d'arrière en avant, en remplaçant les espaces par la forwardséquence pour éviter d'écraser les autres couches par un espace.

Jordan
la source
1
Vous avez accidentellement mis un f=avant ->dans la version golfée. Supprimez-le pendant -2 octets.
wizzwizz4