Cañón del alfabeto

34

Se dispara una bala de cañón de modo que en el primer parpadeo de su vuelo asciende por las Ncopas de los árboles, durante el segundo parpadeo por las N-1copas de los árboles, etc., hasta que alcanza el punto más alto de su trayectoria. Luego comienza a caer en 1, 2, etc., copas de los árboles por parpadeo hasta que toca el suelo. Al mismo tiempo, la bala de cañón se mueve horizontalmente con una velocidad constante de 1 copa de árbol / parpadeo.

Su tarea es dibujar la trayectoria con letras consecutivas del alfabeto inglés. Si te quedas sin letras, comienza de nuevo desde 'A'. Escribe una función o un programa. La entrada es un entero N( 1≤N≤15). La salida puede ser una matriz de caracteres en cualquier forma razonable, por ejemplo, una cadena separada por una nueva línea o una lista de cadenas. Las letras pueden ser todas minúsculas o mayúsculas. Se permiten espacios iniciales y finales adicionales. Las lagunas estándar están prohibidas. Un código más corto es mejor.

in:
5
out:
    OP
   N  Q
   M  R
  L    S
  K    T
  J    U
 I      V
 H      W
 G      X
 F      Y
E        Z
D        A
C        B
B        C
A        D

in:
1
out:
AB
ngn
fuente
77
Estrechamente relacionado .
Dom Hastings
2
¿Por qué O y P están en el mismo nivel en el ejemplo? Si leo la especificación correctamente, parece que debería subir una copa de árbol para P y descender en una para Q.
Skyler
2
@Skyler En cada marca, el alfabeto va 1 a la derecha y N verticalmente. N también disminuye cada tic. Entre Oy P, la marca va 1 a la derecha, pero 0 hacia arriba o hacia abajo.
Olivier Grégoire
44
Parece que los cañones del alfabeto ahora son canon.
Carl Witthoft
2
@ngn Hah, estaba jugando con la solución Perl de @ TonHospel y se me ocurrió 1 byte menos, ¡ pero solo admite hasta 14 !
Dom Hastings

Respuestas:

8

05AB1E , 33 32 29 28 bytes

>*As∍2ä`R)ζRIL£vyε`N·úJ])˜.c

Pruébalo en línea!

Explicación

>*                             # push input*(input+1)
  As∍                          # take that many characters from the alphabet (with wrap)
     2ä                        # split in 2 parts
       `R)                     # reverse the second part
          ζ                    # zip (gives a list of pairs)
           R                   # reverse
            IL£                # split into parts of sizes equal to [1,2...]
               vy              # for each (part y, index N)
                 ε             # for each pair in that part
                  `N·úJ        # insert N*2 spaces between the characters
                       ]       # end loops
                        )˜     # wrap in a flattened list
                          .c   # format as lines padded to equal length
Emigna
fuente
Siento que Nú»algo así podría usarse para imprimir sobre la marcha en lugar de])~.c
Urna mágica del pulpo
Todo lo que podía llegar a es esta aplicación aquí , pero eso es peor por 2 bytes.
Magia pulpo Urna
8

Stax , 29 24 bytes

╦'♫ΓqπL⌂δ@╚n>DI∙Q┴òkεwö╔

Ejecútelo y depúrelo en línea

La correspondiente representación ASCII del mismo programa es el siguiente.

VA*xRr:m|/xH({rix/|1*_%:T)mMm

VA*                             repeat alphabet input times
   xRr:m                        [x ... 1, 1 ... x] where x=input
        |/xH(                   get consecutive substrings of specified sizes
             {           m      map substrings using block
              ix<|1*            reverse string if index<x
                    _%:T)       left-pad to appropriate triangular number
                          Mm    transpose and output
recursivo
fuente
7

R, 169 , 163, 161, 153, 150, 110, 109 bytes

Este enfoque completa una matriz y luego imprime la matriz.

Golfed

function(n)write(`[<-`(matrix(" ",M<-2*n,k<-sum(1:n)),cbind(rep(1:M,c(n:1,1:n)),c(k:1,1:k)),LETTERS),1,M,,"")

Gracias @Giuseppe por 153.

Gracias @JDL por 150.

Vea el comentario de @ Giuseppe para 112, y algunas ediciones para 110 ahora 109. Rasgue el código original.

function(n){a=matrix(" ",M<-2*n,k<-sum(1:n))
Map(function(x,y,z)a[x,y]<<-z,rep(1:M,c(n:1,1:n)),c(k:1,1:k),head(LETTERS,2*k))
cat(rbind(a,"
"),sep="")}

Si traza una salida válida, entonces 73 bytes

function(n,k=sum(1:n))plot(rep(1:(2*n),c(n:1,1:n)),c(1:k,k:1),pc=LETTERS)

ingrese la descripción de la imagen aquí

Vlo
fuente
153 bytes : su solución imprimió un espacio adicional en el ápice que arreglé, y luego también bajé algunas cosas. ¡Buena respuesta!
Giuseppe
puedes usar en Maplugar de mapply?
JDL
@JDL Tienes razón. Siempre pienso que Map es un contenedor para en lapplylugar de mapply. Gracias por 150
Vlo
Esto me seguía molestando, porque pensé que debería haber una forma de indexar la matriz por row,columnpares directamente en [lugar de tener que pasar por mapply(o Map), así que encontré una manera de hacerlo. ¡También recordé que writeexiste y puede reemplazar catpor 112 bytes !
Giuseppe
@Giuseppe Mi comentario sobre "" no funcionó, pero con [<-, podemos lograr exprimir todo dentro de una línea, eliminando la necesidad de algunas definiciones variables. 110 bytes: tio.run/##K/qfpmCj@z@tNC@5JDM/…
Vlo
6

Python 2 , 140 135 133 bytes

lambda n:[' '*(n-j)+chr(~-i%26+65)+'  '*j+chr((n*-~n-i)%26+65)for i,j in zip(range(n*-~n/2,0,-1),sum([-~i*[i]for i in range(n)],[]))]

Pruébalo en línea!

TFeld
fuente
5

MATL , 29 bytes

,G:tPY"tf1Y2y@?tn+P])Z?]Pv1X!

Pruébalo en línea!

Cómo funciona

,        % Do twice
  G:     %   Push [1 2 ... n], where n is the input
  tP     %   Duplicate, flip: pushes [n n-1 ... 1]
  Y"     %   Run-length decoding: gives vector with n ones, n-1 twos ... (*)
  tf     %   Duplicate, find: gives [1 2 3 ... n*(n-1)/2] (**)
  1Y2    %   Push string 'ABC...Z'
  y      %   Duplicate from below: pushes [1 2 3 ... n*(n-1)/2]  again
  @?     %   If we are in the second iteration
    tn   %     Duplicate, length: pushes n*(n-1)/2
    +    %     Add: gives [n*(n-1)/2+1 n*(n-1)/2+2 ... n*(n-1)*2] 
    P    %     Flip: gives [n*(n-1)/2 n*(n-1)/2-1 ... n*(n-1)/2+1]
  ]      %   End if
  )      %   Index (1-based, modular) into the string. Gives a substring
         %   with the letters of one half of the parabola (***)
  Z?     %   Sparse: creates a char matrix with the substring (***) written
         %   at specified row (*) and column (**) positions. The remaining
         %   positions contain char(0), which will be displayed as space
]        % End do twice. We now have the two halves of the parabola, but
         % oriented horizontally instead of vertically
P        % Flip the second half of the parabola vertically, so that the
         % vertex matches in the two halves
v        % Concatenate the two halves vertically
1X!      % Rotate 90 degrees, so that the parabola is oriented vertically.
         % Implicitly display
Luis Mendo
fuente
4

Java (OpenJDK 8) , 121 bytes

n->{for(int l=n*++n/2,r=l,i=1,j=0;l>0;j=j-->0?j:i++)System.out.printf("%"+(n-i)+"c%"+(2*i-1)+"c%n",--l%26+65,r++%26+65);}

Pruébalo en línea!

Explicación

n->{                             // int-accepting consumer
 for(                            //  loop
   int l=n*++n/2,                //    declare l (left) is the first character to print.
                                 //              Oh, and n is increased to reduce byte count later.
       r=l,                      //            r (right) is the second character to print.
       i=1,                      //            i is the "outer-loop" index
       j=0;                      //            j is the "inner-loop" index
   l>0;                          //    while there are characters to print        
   j=j-->0?j:i++)                //    simulate two loops in one,
                                 //      where j starts from 0 and always decreases until it reaches 0
                                 //      at which point j is reset to i and i is increased
  System.out.printf(             //   Print...
   "%"+(n-i)+"c%"+(2*i-1)+"c%n", //    2 characters
                                 //    - the first with n-i-1 whitespaces (remember, n was increased)
                                 //    - the second characters with 2*i-2 whitespaces
   --l%26+65,                    //    the first character to print is the left one, we decrease it.
   r++%26+65                     //    the second character to print is the right one, we increase it.
  );                             //   
                                 //  end loop
}                                // end consumer
Olivier Grégoire
fuente
3

C, 184 bytes

i,j,k,l,m,h,o;f(n){char L[o=n*n][n*3];for(i=o;i--;)for(L[i][j=n*2]=h=k=0;j--;)L[i][j]=32;for(m=n;!h|~i;m-=1-h*2)for(h+(l=m)?++j:++h;l--;)L[h?i--:++i][j]=65+k++%26;for(;o--;)puts(L+o);}

Pruébalo en línea!

Desenrollado:

i, j, k, l, m, h, o;
f(n)
{
    char L[o=n*n][n*3];

    for (i=o; i--;)
        for (L[i][j=n*2]=h=k=0; j--;)
            L[i][j] = 32;

    for (m=n; !h|~i; m-=1-h*2)
        for (h+(l=m)?++j:++h; l--;)
            L[h?i--:++i][j] = 65 + k++%26;

    for (; o--;)
        puts(L+o);
}
Steadybox
fuente
interesante, no puedo compilar este (no hay principal) pero TIO puedo
NGN
1
@ngn Es solo una función , necesita agregar el mainpara compilarlo. En TIO, el mainestá en la sección de pie de página.
Steadybox
3

Clojure, 417 319 bytes

(defn cannon[n](let[a(map #(char(+ 65 %))(iterate #(if(> % 24)0(inc %))0))m1(reverse(reduce #(concat %(repeat %2(- n %2)))[](range 0(inc n))))p1(map-indexed #(str(apply str(repeat %2 " "))(nth a %))m1)m2(reverse(reduce #(concat %(repeat %2(-(* 2 %2)2)))[](reverse(range 0(inc n)))))p2(reverse(map-indexed #(str(apply str (repeat %2 " "))(nth a(+(count p1)%)))m2))](doseq[x(reverse(map #(str % %2)p1 p2))](println x))))

En algún momento me enredé en reversellamadas y renuncié a la idea de hacerlo lo más breve posible. Solo quería tener una solución de trabajo. Aqui tienes...

Una especie de no golfista

(defn cannon [n]
  (let [a (map #(char (+ 65 %)) (iterate #(if (> % 24) 0 (inc %)) 0))
        m1 (reverse (reduce #(concat % (repeat %2 (- n %2))) [] (range 0 (inc n))))
        p1 (map-indexed #(str (apply str (repeat %2 " ")) (nth a %)) m1)
        m2 (reverse (reduce #(concat % (repeat %2 (- (* 2 %2) 2))) [] (reverse (range 0 (inc n)))))
        p2 (reverse (map-indexed #(str (apply str (repeat %2 " ")) (nth a (+ (count p1) %))) m2))]
    (doseq [x (reverse (map #(str % %2) p1 p2))] (println x))))

Actualizar

Motivado por el comentario de Olivier, logré cortar varias reversellamadas y aplicar algunos trucos generales de golf para cortar personajes. También creé alias para reverse, map-indexed, concat, repeaty strporque he usado varias veces cada uno.

(defn c[n](let[a(map #(char(+ 65 %))(iterate #(if(> % 24)0(inc %))0))k #(reduce %[](range 0(inc n)))r #(apply str(repeat % " "))rv reverse m map-indexed c concat t repeat s str p(m #(s(r %2)(nth a %))(rv(k #(c %(t %2(- n %2))))))](rv(map #(s % %2)p(rv(m #(s(r %2)(nth a(+(count p)%)))(k #(c %(t %2(-(* 2 %2)2))))))))))

Sin golf

(defn c [n]
  (let [a (map
           #(char (+ 65 %))
           (iterate
            #(if (> % 24) 0 (inc %))
            0))
        k #(reduce
            %
            []
            (range 0 (inc n)))
        r #(apply str (repeat % " "))
        rv reverse
        m map-indexed
        c concat
        t repeat
        s str
        p (m
           #(s
             (r %2)
             (nth a %))
           (rv (k #(c % (t %2 (- n %2))))))]
    (rv
     (map
      #(s % %2)
      p
      (rv
       (m
        #(s
          (r %2)
          (nth a (+ (count p) %)))
        (k #(c % (t %2 (- (* 2 %2) 2))))))))))

Crea la función cque acepta el valor n y devuelve una lista de líneas.

Joshua
fuente
Esta no es una respuesta ya que aparentemente no hay ningún intento de jugar golf (incluso lo dices).
Olivier Grégoire
Ok, esto es mucho mejor! ;-)
Olivier Grégoire
3

Carbón , 33 31 bytes

≔⁰ηF…±N⊕θ«¿ι→↓F↔ι«P§αη≦⊕η¿›ι⁰↓↑

Pruébalo en línea! El enlace es a la versión detallada del código. Editar: Guardado 2 bytes gracias a @ ASCII-only. Explicación:

≔⁰η

Inicialice la letra actual como índice en el alfabeto en mayúscula a 0.

F…±N⊕θ«

Haga un bucle desde la negación de la entrada hasta la entrada inclusive.

¿ι→↓

Normalmente cada columna está a la derecha de la anterior. Sin embargo, no hay columna para cero. En cambio, se necesita una corrección para garantizar que los lados izquierdo y derecho se alineen.

F↔ι«

Bucle para cada letra en la columna.

P§αη

Imprime la carta actual.

≦⊕η

Incrementa el índice de letras.

¿›ι⁰↓↑

Mover hacia arriba o hacia abajo dependiendo de qué lado de la trayectoria estemos.

Neil
fuente
Parece que podría haber una forma más corta de hacer esto, pero no estoy seguro de cómo: /
ASCII solo
44
31 bytes
solo ASCII
3

Perl 5 , -n 112 92 90 88 bytes

Por una vez, el terriblemente largo printfparece ganar.

#!/usr/bin/perl -n
$p=$q=$_*($%=$_+1)/2;map{printf"%$%c%$.c
",--$p%26+65,$q++%26+65for--$%..$';$.+=2}//..$_

Pruébalo en línea!

Ton Hospel
fuente
Buena mejora! Estaba tratando de llegar (A..Z)x9al trabajo, ¡pero era demasiado corto para el límite! Tenía eso solo por 91. :)
Dom Hastings
1
@DomHastings Tuyo fue un buen intento de sinergia entre los dos cálculos de letras casi repetidos. Ese también me molesta.
Ton Hospel
2

Python3 + numpy, 124 115

from pylab import*
def i(N):
 x=zeros((N,2*N),'U');x[r_[N-1:-1:-1,0:N],r_[:2*N]]=map(chr,r_[0:2*N]%26+65)
 return x

Esto crea una matriz de tamaño apropiado, encuentra los índices para la trayectoria y les asigna el carácter apropiado. La parte más compleja es generar los caracteres AZ, que se basan en un elenco de números muy hack para un tipo de cadena. El objeto devuelto es una matriz unicode.

Editar : se guardaron 9 bytes reemplazando el código numpy que generó los caracteres AZ ( (r_[0:2*N]%26+65).view('U1')[::2]) map, como se sugiere aquí .

usuario2699
fuente
2

Python 3 , 139 136 bytes

f=lambda n,o=0:n and'\n'.join([f(n-1,o+n).replace('\n','\n ')]+[chr(65+(n+o+~i)%26)+'  '*~-n+chr(65+(n*n+o+i)%26)for i in range(n)])or''

Pruébalo en línea!

Genera cada capa de forma recursiva, dado el tamaño y el desplazamiento.

-3 bytes gracias a Jo King

Matthew Jensen
fuente
@JoKing Gracias, ¡siempre me olvido del ~operador!
Matthew Jensen el
También puede cambiar n and ... or''a n*' 'and ...por otro byte
Jo Rey
2

J , 78 75 bytes

(26{.65|.a.)($~#)`(;/@])`(' '$~1+{:@])}i.@+:(,.~(|.,])@i.@-:@#)@#~1+i.@-,i.

Pruébalo en línea!

-3 gracias a ngn

Jonás
fuente
1
(,|.)@i.@-->i.@-,i.
ngn
Gracias @ngn. Este es uno de esos en los que parecía que debería haber una solución en 40-50 bytes, pero si la hubiera, no podría verla ...
Jonás,
1

Python 2 , 182 bytes

I=input()
S=list('ZYXWVUTSRQPONMLKJIHGFEDCBA'*I)
R=range
print zip(*[(' '*(sum(R(abs(i))))+eval('S.pop()+'*abs(i)+"''")[::[-1,1][i>0]]).ljust(sum(range(I+1)))for i in R(-I,I+1)if i])

Pruébalo en línea!

Devuelve la lista de listas de caracteres. Verificación primitiva aquí

Zarigüeya muerta
fuente
1

Yabasic , 125 bytes

Una solución que utiliza el modo gráfico para imprimir los caracteres en la columna y fila correcta de la pantalla.

Input""n
Clear Screen
For i=-n To n
For j=1To Abs(i)
k=i>0
?@(i+n-k,(i^2-i)/2+j-2*j^(!k)+k)Chr$(c+65)
c=Mod(c+1,26)
Next
Next

Debido a que esta solución utiliza el modo gráfico, no se puede ejecutar en TIO.

Salida

A continuación se muestra la salida para entrada 7

Salida del programa (n = 7)

Taylor Scott
fuente
1

Ruby , 106103 bytes

->n,f=2*s=-~n*n/2-1{l=*?A..?Z;(1..n).map{|i|i.times{puts' '*(n-i)+l[(f-s)%26]+' '*~-i*2+l[(s+=1)%26]}}}

Pruébalo en línea!

Asone Tuhid
fuente
1

QBasic 1.1 , 124 bytes

norte6 6

INPUT n
CLS
FOR i=-n TO n
FOR j=1TO ABS(i)
k=i>0
LOCATE(i^2-i)/2+j-2*j^-(k=0)-k+1,i+n+k+1
?CHR$(c+65)
c=(c+1)MOD 26
NEXT j,i
Taylor Scott
fuente
1

Python 3 , 190 bytes

j,r,c,s=int(input()),range,[],[];a=(j+1)*j;b=a//2
for i in r(j):k=i+1;c.extend([j-k]*k)
for i in r(a):s+=chr(ord('A')+(i%26))
for i in r(b):print(' '*c[i]+s[b-i-1]+' '*(2*(j-c[i]-1))+s[b+i])

Pruébalo en línea!

Hice lo mejor que pude. Avíseme si hay alguna optimización posible.

Koishore Roy
fuente
1

k4, 76 71 bytes

{+|:'p$(-k,|k:+\l)$(x#b),|:'x_b:(i:-1_0,+\l,|l)_a:(2*p:+/l:|1+!x)#.Q.a}

algunas reorganizaciones + asignaciones para guardar 5 bytes


{+|:'(+/l)$(-k,|k:+\l)$(x#i_a),|:'((-x)#i:-1_0,+\l,|l)_a:(2*+/l:|1+!x)#.Q.a}

esfuerzo de media hora con algo de esfuerzo para reducir algunos bytes, pero probablemente hay mucho más que se puede hacer aquí. volveremos a eso. desafío divertido!

garabatear
fuente