Una simple hoy. Escriba el programa más corto que dibuje un "alfabeto de diente de sierra" dado un entero positivo para la altura. Debe escribir el nombre de su lenguaje de programación cuando llegue a la letra con la que comienza.

Por ejemplo, si su idioma es Python y la entrada es 1la salida debe ser:

ABCDEFGHIJKLMNOPythonQRSTUVWXYZ

Si la entrada es 2la salida debe ser:

 B D F H J L N Python R T V X Z
A C E G I K M O      Q S U W Y

Si la entrada es 4la salida debe ser:

   D     J     Python     V
  C E   I K   O      Q   U W
 B   F H   L N        R T   X Z
A     G     M          S     Y

Notas

• A siempre comienza en la parte inferior izquierda.
• La entrada puede ser a través de stdin o llamada de función o similar. Salida a stdout.
• La entrada anterior 26no necesita funcionar.
• Sin espacios finales.

si n tiene la altura:

C + códigos de escape: 81

x;main(y){for(y=n--;x<26;x++)printf("\033[%d;%dH%c",n?x/n&1?y++:y--:y,x+1,x+65);}

C: 110

x;char a[702]={[0 ...701]=32};main(y){for(y=--n;x<26;a[x*27-1]=10)a[27*(n?x/n&1?y++:y--:y)+x]=x+++65;puts(a);}

C, 134

n,m,c,p;
main(r){
for(scanf("%d",&n),m=--n?n*2:1;n+r--;puts(""))
for(c=-1,p=1;c++<25;)
p+=(c-n-r)%m*((c-n+r)%m)?1:1-printf("%*c",p,c+65);
}

Compila en gcc con algunas advertencias. Las nuevas líneas no se incluyen en el recuento de caracteres.

122 caracteres si la entrada ya está almacenada n.

Gracias a user2992539 , tolos y edc65 por las mejoras.

TI-BASIC: 148 bytes (texto sin formato), 186 bytes (gráfico)

En respuesta al OP, la maravillosa TI-83 (y más reciente) viene con un tamaño de 16 x 8 (solo usando el texto grande estándar) o con un tamaño de 94 x 62 píxeles (que con texto pequeño vale aproximadamente 10 líneas )

Ahora, esto tiene un pequeño problema (al que me gustaría una aclaración). El intérprete no puede "ignorar" las imposiciones de tamaño; en otras palabras, si intentamos establecer la altura del diente de sierra en 20, daría un error que impide la ejecución completa del código. Yo podría escribir código que, en un entorno infinito, producir el resultado correcto, excepto que no se ejecutan en la máquina.

Dicho esto, te presento las versiones (en ejecución) de los programas. Todos dependen de la variable que Nse establece en la altura deseada en líneas antes de ejecutar:

• Enfoque de texto sin procesar

  :ClrHome
  :"ABCDEFGHIJKLMNOPQRSTI-BASICUVWXYZ"→Str1
  :8→R
  :For(C,1,16
  :If N=1
  :Then
  :0→F
  :Else
  :If R<2 or 10-R>N
  :1→F
  :If R>7
  :-1→F
  :End
  :If C≠20
  :Then
  :Output(R,C,sub(Str1,C,1
  :Else
  :Output(R,C,sub(Str1,C,8
  :C+7→C
  :End
  :R+F→R
  :End
  

  Con el fin de hacer que esto funcione independientemente de la terminal, el cambio For(C,1,16de For(C,1,33y quite la comprobación de límite superior ( R<2 or). Aquí está la salida con 5→N:

  

• Enfoque gráfico (esto también puede necesitar AxisOffclaridad)

  :ClrDraw
  :N*6→N
  :"ABCDEFGHIJKLMNOPQRSTI-BASICUVWXYZ"→Str1
  :57→R
  :For(C,1,56
  :If N=6
  :Then
  :0→F
  :Else
  :If R<7 or 64-R>N
  :6→F
  :If R>51
  :-6→F
  :End
  :If C≠20
  :Then
  :If C>50
  :Then
  :Text(R,C,sub(Str1,C-23,1
  :Else
  :Text(R,C,sub(Str1,C,1
  :End
  :Else
  :Text(R,C,sub(Str1,C,8
  :C+30→C
  :End
  :R+F→R
  :End
  

  Este funciona bien, con dos peculiaridades menores. La altura sigue siendo un problema, aunque el ancho no lo es. Sin embargo, no separé las letras, así que en algunos casos (cuando la letra comienza a subir o bajar del diente de sierra), las letras pueden ser cortadas por sus sucesores. Para que funcione independientemente del terminal, elimine la marca de límite superior ( R<7 or). Luego sigue el gráfico:

  

Pure Bash (sin coreutils), 181 bytes

m=$1
for l in A Bash {C..Z};{
((m))||s=++
((m>$1-2))&&s=--
for((m=$1==1?1:m,m$s,i=0;i<$1;i++));{
((i-m))&&a[i]+=${l//?/ }||a[i]+=$l
}
}
shopt -s extglob
printf %s\\n "${a[@]%%+( )}"

Salida:

Dirigido a cat -Esolo para demostrar que no hay nuevas líneas finales.

$ ./sawtooth.sh 1 | cat -E
ABashCDEFGHIJKLMNOPQRSTUVWXYZ$
$ ./sawtooth.sh 5 | cat -E
       E       M       U$
      D F     L N     T V$
     C   G   K   O   S   W$
 Bash     H J     P R     X Z$
A          I       Q       Y$
$ 

JavaScript (ES6) 231 244

Editar corrección de errores, algunos reordenamientos y una forma diferente de administrar la altura == 1
Además, se cambió a una función ya que OP lo permite, por lo que no se solicita () para la entrada

No hay cambios en el algoritmo general que probablemente NO sea el mejor para este desafío.

F=h=>{for(p=s=[i=z=b=t=''];++p<h;)i=1,z=b=' ',s[p]=t;for(p=--h,k=64;++k<91;)s[p]+=t+String.fromCharCode(k),k-74||(s=s.map((x,q)=>x+(p-q?'         ':'avascript'))),p-=i,p<0|p>h?(i=-i,p-=i+i,t=z,b=t+t):t+=b;console.log(s.join('\n'))}

Explicado

F=h=>{
  // row in s for output must be initialized to ''. In the same step I make other initializations
  for(p=s=[i=z=b=t='']; ++p < h;) // initialize for height 1, all increment and spacing can be null
    i=1,z=b=' ',s[p]=t; // the for body is entered only if height > 1, initializing spacing and increment to the right values
  for(p=--h,k=64;++k<91;)
    s[p]+=t+String.fromCharCode(k),
    k-74||(s=s.map((x,q)=>x+(p-q?'         ':'avascript'))), // if 'J' modify each line of output adding the name or spacing
    p-=i,p<0|p>h?(i=-i,p-=i+i,t=z,b=t+t):t+=b; // index bouncing
  console.log(s.join('\n'))
}

Ejemplos

1

ABCDEFGHIJavascriptKLMNOPQRSTUVWXYZ

3 subiendo

  C   G            K   O   S   W
 B D F H Javascript L N P R T V X Z
A   E   I            M   Q   U   Y

4 en la parte superior

   D     Javascript     P     V
  C E   I          K   O Q   U W
 B   F H            L N   R T   X Z
A     G              M     S     Y

7 bajando

      G                    S
     F H                  R T
    E   I                Q   U
   D     Javascript     P     V
  C                K   O       W
 B                  L N         X Z
A                    M           Y

JAVA (393)

Como siempre, un gran idioma para el golf:

public class P{public static void main(String[]a){int h=Integer.valueOf(a[0]);String x="ABCDEFGHIJKLMNOPQRSTUVWXYZ";String[]l=new String[h];Arrays.fill(l,"");int i=h-1;int d=-1;for(char c:x.toCharArray()){for(int n=0;n<l.length;n++){String k=(n==i)?(c=='J')?"Java":c+"":(c=='J')?"    ":" ";l[n]+=k;}if(i==0&&d==-1)d=1;if(i==h-1&&d==1)d=-1;if(h>1)i+=d;}for(String s:l){System.out.println(s);}}}

Ruby, 112 bytes

o="#{' '*29}
"*h
26.times{|i|o[(h-i%(h<2?1:2*h-2)-1).abs*30+i+(i>17?3:0)]=(i+65).chr}
puts o.gsub('R   ','Ruby')

Espera que la entrada se almacene en h.

Avíseme si esto necesita aclaración.

J: 75 bytes

NB. without IO |:26([:u:65+i.@[)`(($(,|.@}.@}:)@i.)<"1@,.i.@[)`(' '$~,~)}5
2(1!:2)~|.26([:u:65+i.@[)`(($(,|.@}.@}:)@i.)<"1@,.i.@[)`(' '$~,~)}".1!:1[1

Usando la maravillosa enmienda Conjunta . Como de costumbre, el IO es feo y torpe, sin entrar en detalles allí. La solución central toma 3 gerundios (una especie de verbo con sustantivo (también conocido como función)):

• a) generar el alfabeto
• b) generar los índices

• c) generar la matriz para enmendar

  x (a bc}) y

a) es una búsqueda bastante trivial en la tabla ASCII

c) es aún más trivial

b) es el interesante. La moral es que se supone que los índices horizontales comienzan desde 0 hasta y-1 y retroceden, repitiendo esto 26 veces. P.ej. para y == 4:

0 1 2 3 2 1 0 1 2 3 2 1 ...

La implementación de esto da para b):

($(,|.@}.@}:)@i.) <"1@,. i.@[)       NB. is equivalent too
(tine0 tine1 tine2)                  NB. a fork with tines defined as
tine0 =: 
  hook0 =: hook0_0 hook0_1           NB. a dyadic hook: x (g h) y -: x g h y
     hook0_0 =: $                    NB. reshape
     hook0_1 =: (hook1_0 hook1_1)@i. NB. do hook1 after making 0-y
       hook1_0=: ,                   NB. append to self
       hook1_1=: |.@}.@}:            NB. rotated version of y after beheading and curtailing
tine2 =: i.@[                  NB. generate 0-x
tine1 =: <"1@,.                NB. glue together coordinates.

Y sí, hecho práctico: el nombre de J es ... "J".

R (204)

f=function(x) {
  m=matrix(" ",x,26)
  i=x
  d=ifelse(x==1,0,-1)
  for (j in 1:26) {
    m[i,j]=LETTERS[j]
    if (!((i+d) %in% 1:x)) d=-d
    i=i+d
  }
  for (i in 1:x) cat(m[i,],"\n",sep="")
}

Resultado

> f(1)
ABCDEFGHIJKLMNOPQRSTUVWXYZ
> f(2)
 B D F H J L N P R T V X Z
A C E G I K M O Q S U W Y 
> f(3)
  C   G   K   O   S   W   
 B D F H J L N P R T V X Z
A   E   I   M   Q   U   Y 
> f(7)
      G           S       
     F H         R T      
    E   I       Q   U     
   D     J     P     V    
  C       K   O       W   
 B         L N         X Z
A           M           Y 

Javascript - 248 224 235

z=~~prompt(),y="ABCDEFGHIJKLMNOPQRSTUVWXYZ".split("");y[9]="Javascript";for(w=[],v=0;v<z;v++)w[v]="\n";v--;for(i=0;i<26;i++){for(j=0;j<z;j++)w[j]+=j-v?i-9?" ":"          ":y[i];~~(i/(z-1))%2?v++:v--;}if(z==1)w=y;console.log(w.join(""))

Aquí hay un enlace al jsfiddle, donde puede probarlo.
editar: hizo un registro de consola para una fuente monoespaciada y eliminó las comas si input == 1.

Perl 119

$s.=/26/?++$r&&$/:$m-1&&$r-abs$_%(2*$m-2)+1-$m?$"x(1+3*/15/):/15/?Perl:(A..Z)[$_]for(0..26)x($m=<>);print$s=~s/\s+$//rg

Este programa toma datos STDINe imprime el resultado en STDOUT.

Y bonificación: una versión que va en contra de las reglas, ya que imprime espacios finales, pero agrega cierta interacción:

#!/usr/bin/perl -p
$r=0;$_=join'',map{/26/?++$r&&$/:$m-1&&$r-abs$_%(2*$m-2)+1-$m?$"x(1+3*/15/):/15/?Perl:(A..Z)[$_]}(0..26)x($m=$_)

... y algunas pruebas a continuación:

1
ABCDEFGHIJKLMNOPerlQRSTUVWXYZ
2
 B D F H J L N Perl R T V X Z
A C E G I K M O    Q S U W Y
4
   D     J     Perl     V
  C E   I K   O    Q   U W
 B   F H   L N      R T   X Z
A     G     M        S     Y
6
     F         Perl         Z
    E G       O    Q       Y
   D   H     N      R     X
  C     I   M        S   W
 B       J L          T V
A         K            U

J, 67 57 61 caracteres

echo@dtb"1@|.@|:@(26&,$(u:65+i.26)#~1 j.26$(0#~1=]),<:#-&0 2)

Usar como una función:

   echo@dtb"1@|.@|:@(26&,$(u:65+i.26)#~1 j.26$(0#~1=]),<:#-&0 2)
   D     J     P     V
  C E   I K   O Q   U W
 B   F H   L N   R T   X Z
A     G     M     S     Y

Explicación: esta solución utiliza un enfoque diferente que la otra solución J. En lugar de generar una onda de diente de sierra 0 1 2 3 2 1 0 1 ... , miré el espacio entre letras consecutivas. Por ejemplo, para n = 4 si vas desde A hacia arriba, pasa a la segunda columna y alcanzas B, entonces encuentras cuatro espacios entre A y B. Este patrón de espaciado entre letras es muy regular: para n = 4 el patrón es 4 4 4 2 2 2 4 4 4 ... .

Entonces, la idea es construir primero la matriz aplanada (y transpuesta), y luego volver a darle forma y voltearla para que se vea bien. La rutina de salida es sencilla (por ser J, al menos): dtb es "eliminar espacios en blanco finales" y "1dice "operar en cada línea". dtb y echo son proporcionados por la biblioteca estándar.

Gracias a Zsbán Ambrus por su ayuda en el golf.

MetaPost (207)

numeric h,d,y;h=5;d=-1;y=1;u=5mm;pair p;string s;for x=1upto26:p:=(x,y)*u;s:=char(x+64);if x=13:s:="MetaPost";elseif x>13:p:=(x+2,y)*u;fi;label.rt(s,p);if(y=h)or(y=1):d:=d*-1;fi;if h=1:d:=0;fi;y:=y+d;endfor;

Puedes probarlo aquí.

Golpe (213) (223)

read i
p=0
d=1
printf '\n%.0s' `seq $i`
for l in {A..Z}
do (($p==$i-1))&&((p=$p*-1))
(($i==1))&&p=0
(($p!=0))&&echo -en "\033[s\033[${p#-}A"
[[ "$l" == "B" ]]&&l="Bash"
echo -en $l"\033[s\033[${p#-}B"
((p++))
done

Pequeños ajustes y hemos llegado a 213.

El original tenía un error menor. Probado y confirmado para trabajar en bash versión 4.2.37.

Gracias a @manatwork por señalar el error y algunos consejos.

Haskell: 432 bytes (desafortunadamente ...)

Esto resultó ser mucho más difícil de lo que esperaba lograr puramente, de ahí la gran cantidad de bytes. Estoy seguro de que yo (o alguien) podría hacerlo mejor, pero he pasado demasiado tiempo en esto. La versión de golf es la siguiente:

import Data.Matrix
import Data.Vector(toList)
r=repeat
s h=y h$l(take 26(case h of 1->r 1;_->concat$r$[h,h-1..1]++[2..h-1]))['A'..'Z']$matrix h 32(const ' ')<|>matrix h 1(const '\n')
l _[]m=m
l(x:i)(r:e)m=l i e$u m(let z=26-length i in if z<9 then z else z+6)x r
l _ _ m=m
u m c r h=case h of 'H'->t c r"Haskell"m;_->setElem h(r,c)m
t _ _[]m=m
t c r(x:i)m=t(c+1)r i$setElem x(r,c)m
y h m=concat[toList$getRow x m|x<-[1..h]]

Para ejecutar, cargue el código ghciy ejecute putStr $ s Intdonde Intestá su altura deseada. También podrías agregar

import System.Environment
main :: IO ()
main = fmap (s . read . head) getArgs >>= putStr

debajo de la imports en un archivo de texto, compílelo ghcy pase la altura como argumento de línea de comando. Versión sin golf:

import System.Environment
import Data.Matrix
import Data.Vector (toList)

main :: IO ()
main = fmap (sawtooth . read . head) getArgs >>= putStr

type M = Matrix Char

sawtooth :: Int -> String
sawtooth height = let mat     = matrix height 32 (const ' ') <|> matrix height 1 (const '\n')
                      numbers = take 26 (case height of 1 -> repeat 1
                                                        _ -> concat $ repeat $ [height,height-1..1]++[2..height-1])
                      chars   = ['A'..'Z']
                  in toString height $ makeMatrix numbers chars mat

makeMatrix :: [Int] -> String -> M -> M
makeMatrix []     []     mat = mat
makeMatrix (x:xs) (s:ss) mat = makeMatrix xs ss $ updateMatrix
                                                    mat (let z = 26 - length xs in if z < 9 then z else z + 6) x s
makeMatrix _      _      mat = mat

updateMatrix :: M -> Int -> Int -> Char -> M
updateMatrix mat col row char = case char of 'H' -> insertHaskell col row "Haskell" mat
                                             _   -> setElem char (row, col) mat

insertHaskell :: Int -> Int -> String -> M -> M
insertHaskell _   _   []     mat = mat
insertHaskell col row (x:xs) mat = insertHaskell (col+1) row xs $ setElem x (row, col) mat

toString ::Int -> M -> String
toString height mat = concat [ toList $ getRow x mat | x <- [1..height] ]

C # / LINQ:

using System;
using System.Linq;

namespace SawtoothAlphabet
{
    class Program
    {
        static void Main(string[] args)
        {
            int N = Int32.Parse(args[0]);   // eg 4
            Console.WriteLine(
                String.Join(Environment.NewLine, Enumerable.Range(0, N).Select(line =>
                    String.Concat(Enumerable.Range(0, 26).Select(i =>
                        line == Math.Abs(i % (2 * (N - 1)) - (N - 1))
                            ? (i == 2) ? "C#" : Char.ConvertFromUtf32(i + 'A')
                            : (i == 2) ? "  " : " ")
            ).TrimEnd())));
        }
    }
}

Breve explicación: Enumerable.Range(0, N).Select(...)hace que se genere una cadena para cada línea que finalmente se concatena en una sola cadena con String.Join(Environment.NewLine, ...). Para cada línea con la que pasamos los 26 caracteres Enumerable.Range(0, 26).Select(...), la prueba al comienzo de la expresión lambda determina si se genera un carácter o un espacio mientras se i==2comprueba "C" y se convierte en "C #" o en dos espacios según la línea . Los String.Concat(...)convierte la resultante IEnumerable<char>para cada línea en una cadena antes de pasarlo al TrimEnd(...)a la tira limpiamente cualquier espacio en blanco al final.

PHP (216) (205)

Nueva versión:

$b=array_fill(65,26,' ');$b[80]='   ';$b=array_fill(0,$i,$b);for($j=--$i,$x=64;++$x<91;$i||$j=0){$b[$j][$x]=chr($x);$x==80&&$b[$j][$x]='PHP';$j+=($d=$j<($d?$i:1))*2-1;}echo join("\n",array_map('join',$b));

Versión antigua:

$b=array_fill(0,$i,array_fill(0,28,' '));for($j=--$i,$x=-1;++$x<28;$i||$j=0){$q=&$b[$j];$q[$x]=chr($x-($x&16)/8+65);$x==15&&($q[++$x]='H')*$q[++$x]='P';$j+=($d=$j<($d?$i:1))*2-1;}echo join("\n",array_map('join',$b));

espera que la variable $ i sea la altura.

C, 214 169 bytes, sin espacios finales

Gracias a @ edc65 y @tolos por sus útiles sugerencias.

#define C ((c-i+n-65)%z&&(c+i+n-67)%z)
n,i,m,c,z;main(){scanf("%d",&n);z=n<2?1:2*n-2;for(;i++<n;){for(m=c=64;c++<90;)m=C?m:c;for(c=64;c++<m;)putchar(C?32:c);puts("");}}

Javascript ( 204 185 150)

h=m=4;d=h>1?-1:0;o=[];for(a=0;a<35;a++){for(r=h;r;r--)o[r]=(o[r]||"")+(r==m?"ABCDEFGHIJavascriptKLMNOPQRSTUVWXYZ"[a]:" ");if(a<9||a>17){m+=d;if(m<2||m==h)d=-d}}console.log(o.join("\n"))

EDITAR

Ahorró 13 bytes al no construir una matriz y .join ("\ n"). Se requiere voltear los bucles for. Luego, con la ayuda de C coding son, hizo que el código fuera demasiado inteligente para guardar otros 12 bytes.

Aquí está la versión legible que muestra el cambio de lógica.

for (row = height; row; row--) {
    rowOfNextActiveLetter = 1;
    direction = height > 1 ? -1 : 0;
    output = "";
    for (a = 0; a < 35; a++) {
        output += (row == rowOfNextActiveLetter ? "ABCDEFGHIJavascriptKLMNOPQRSTUVWXYZ"[a] : "");
        if (a < 9 || a > 17) {
            rowOfNextActiveLetter -= direction;
            if (rowOfNextActiveLetter < 2 || rowOfNextActiveLetter == height)direction = -direction
        }
    }
    console.log(output)
}

Golfizado (161):

for(r=h;r;r--){m=1;d=h>1?-1:0;o="";for(a=0;a<35;a++){o+=(r==m?"ABCDEFGHIJavascriptKLMNOPQRSTUVWXYZ"[a]:" ");if(a<9||a>17){m-=d;if(m<2||m==h)d=-d}}console.log(o)}

Golfizado y ofuscado (149):

for(r=h;r;r--,console.log(o))for(m=1,d=h>1?1:0,o="",a=0;a<35;)if(o+=r==m?"ABCDEFGHIJavascriptKLMNOPQRSTUVWXYZ"[a]:" ",a<9|a++>17)d=(m+=d)<2|m==h?-d:d

K, 60 bytes

`0:'{+{x!y}.'+(26#{(!x),|1_!x-1}x;(((x-1)#" "),)'`c$65+!26)}

Bastante sencillo, y parece que acabo de superar la solución J. :)

Primero, genera un alfabeto:

  `c$65+!26
"ABCDEFGHIJKLMNOPQRSTUVWXYZ"

Y una onda de diente de sierra de una longitud adecuada:

  26#{(!x),|1_!x-1}5
0 1 2 3 4 3 2 1 0 1 2 3 4 3 2 1 0 1 2 3 4 3 2 1 0 1

Rellene cada letra del alfabeto con espacios iniciales:

  (((5-1)#" "),)'"ABC"
("    A"
 "    B"
 "    C")

Comprime el alfabeto y la onda cuadrada, y gira cada fila:

  +(0 1 2;("  A";"  B";"  C"))
((0
  "  A")
 (1
  "  B")
 (2
  "  C"))

  {x!y}.'+(0 1 2;("  A";"  B";"  C"))
("  A"
 " B "
 "C  ")

Y la transposición de eso es nuestra respuesta:

  +{x!y}.'+(0 1 2;("  A";"  B";"  C"))
("  C"
 " B "
 "A  ")

Pruébalo aquí en OK .

C: 142 139 caracteres

Terriblemente largo, espero poder acortarlo un poco:

char a[26][27],i,j,p,d;main(n){for(scanf("%d",&n);i<26;d^=!p^p+2>n,p+=d-(d^n>1),i++)for(j=n;j--;a[j][i]=p^j?32:i+65);while(n)puts(a[--n]);}

Ligeramente más legible:

char a[26][27], i, j, p, d;
main(n) {
    for (
        scanf("%d", &n);
        i < 26;
        d ^= !p ^ p + 2 > n,
        p += d - (d ^ n > 1),
        i++
    )
        for (
            j = n;
            j--;
            a[j][i] = p ^ j
                ? 32
                : i + 65
        );

    while (n)
        puts(a[--n]);
}

Editar: Me perdí la regla "sin espacios finales", pero volveré.

Scala, 246 bytes

def f(h:Int)={val a=Seq.fill(h)(Array.fill(32)(' '));var(r,x,d)=(h-1,0,if(h==1)0 else-1);def p(c:Char){a(r)(x)=c;x+=1};for(c<-'A'to'Z'){p(c);if(c==83)"cala"foreach p;r+=d;if(r==0|r==h-1)d*= -1};for(z<-a)println(new String(z)replaceAll(" +$",""))}

reformateado y comentado:

def f(h: Int) = {
  val a = Seq.fill(h)(Array.fill(32)(' '));
  // r - row; x - x coordinate, column; d - direction
  var (r, x, d) = (h - 1, 0, if(h==1) 0 else -1); 
  def p(c: Char) { // p for "put the character"
    a(r)(x) = c;
    x += 1
  };
  for(c <- 'A' to 'Z') { 
    p(c);
    if(c == 83)      // 83 == 'S'
      "cala" foreach p;
    r += d;
    if(r == 0 | r == h - 1)     // | is shorter than || 
      d *= -1
  };
  for(z <- a)
    println(new String(z) replaceAll (" +$", ""))  // trimming trailing whitespace
}

Resultados:

scala> f(4)
   D     J     P         V
  C E   I K   O Q       U W
 B   F H   L N   R     T   X Z
A     G     M     Scala     Y

scala> f(5)
    E       M           U
   D F     L N         T V
  C   G   K   O   Scala   W
 B     H J     P R         X Z
A       I       Q           Y

scala> f(1)
ABCDEFGHIJKLMNOPQRScalaTUVWXYZ

Python - 137

Entrada para ser almacenada en ieg i=8

l=[""]*h;k=j=0;y=h-1;exec'l[y]+=" "*(j-len(l[y]))+chr(k+65)+"ython"*(k==15);j=len(l[y]);y-=1^k/(h-(h>2))%2*-2;k+=1;'*26;print"\n".join(l)

Raqueta

Aquí hay una versión funcional limpia: sugerencias para acortarlo bienvenido.

(define (sawtooth n)
  (define (ST i d m lns)
    (if (null? m) 
        lns
        (let* ([v (first m)]
               [spc (make-string (string-length v) #\space)]
               [I (+ i d)])
          (ST I
              (if (or (zero? I) (= (sub1 n) I)) (* d -1) d)
              (rest m)
              (for/list ([ln lns] [j n])
                       (~a ln (if (= i j) v spc)))))))
  (displayln
   (string-join 
    (ST (sub1 n)
        (if (= n 1) 0 -1) 
        (string-split "A B C D E F G H I J K L M N O P Q Racket S T U V W X Y Z")
        (make-list n "\n")))))

Salida

> (sawtooth 1)
ABCDEFGHIJKLMNOPQRacketSTUVWXYZ

> (sawtooth 2)
 B D F H J L N P Racket T V X Z 
A C E G I K M O Q      S U W Y 

> (sawtooth 8)
       H                  V     
      G I                U W    
     F   J              T   X   
    E     K            S     Y  
   D       L     Racket       Z 
  C         M   Q               
 B           N P                
A             O