Semplice oggi. Scrivi il programma più breve che disegna un "alfabeto a dente di sega" dato un numero intero positivo per l'altezza. Devi scrivere il nome del tuo linguaggio di programmazione quando arrivi alla lettera con cui inizia.

Ad esempio, se la tua lingua è Python e l'input è 1l'output dovrebbe essere:

ABCDEFGHIJKLMNOPythonQRSTUVWXYZ

Se l'ingresso è 2l'output dovrebbe essere:

 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

Se l'ingresso è 4l'output dovrebbe essere:

   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

Gli appunti

• A inizia sempre in basso a sinistra.
• L'ingresso può avvenire tramite stdin o chiamata di funzione o simile. Uscita su stdout.
• L'input sopra 26non deve funzionare.
• Nessuno spazio finale.

se n mantiene l'altezza:

C + codici di 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 su gcc con alcuni avvisi. Le nuove righe non sono incluse nel conteggio dei personaggi.

122 caratteri se l'ingresso è già memorizzato n.

Grazie a user2992539 , tolos ed edc65 per miglioramenti.

TI-BASIC - 148 byte (testo non elaborato), 186 byte (grafico)

In risposta all'OP, la meravigliosa TI-83 (e più recenti) ha una dimensione di 16 x 8 (usando solo il testo grande standard) o con una dimensione di 94 x 62 pixel (che con un testo piccolo vale circa 10 righe ).

Ora, questo ha un piccolo problema (al quale vorrei un chiarimento). Le imposizioni dimensionali non possono essere "ignorate" dall'interprete; in altre parole, se dovessimo provare a impostare l'altezza del dente di sega a 20, darebbe un errore che impedisce la piena esecuzione del codice. io potuto scrivere codice che, in un ambiente infinito, produrre l'output corretto, tranne che non avrebbe eseguito sulla macchina.

Detto questo, ti presento le versioni (in esecuzione) dei programmi. Dipendono tutti dalla variabile Nimpostata sull'altezza desiderata in linee prima di eseguire:

• Approccio con testo non elaborato

  :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
  

  Per fare questo lavoro indipendentemente dal terminale, cambiamento For(C,1,16di For(C,1,33e rimuovere il controllo dei limiti superiore ( R<2 or). Ecco l'output con 5→N:

  

• Approccio grafico (questo potrebbe anche richiedere AxisOffchiarezza)

  :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
  

  Questo funziona bene, con due stranezze secondarie. L'altezza è ancora un problema, sebbene la larghezza non lo sia. Tuttavia, non ho spaziato le lettere, quindi in alcuni casi (quando la lettera inizia a salire o diminuire dal dente di sega), le lettere possono essere troncate dai loro successori. Per farlo funzionare indipendentemente dal terminale, rimuovere il segno di spunta superiore ( R<7 or). Quindi segue il grafico:

  

Pure Bash (no coreutils), 181 byte

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[@]%%+( )}"

Produzione:

Condotto cat -Esolo per dimostrare che non ci sono nuove righe finali.

$ ./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

Modifica correzione bug, alcuni riordini e un modo diverso di gestire l'altezza == 1
Inoltre, è stato cambiato in una funzione in quanto ciò è consentito da OP, quindi nessun prompt () per l'input

Nessuna modifica all'algoritmo generale che probabilmente NON è il migliore per questa sfida

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'))}

spiegato

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'))
}

Esempi

1

ABCDEFGHIJavascriptKLMNOPQRSTUVWXYZ

3 salendo

  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 in alto

   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 scendendo

      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

GIAVA (393)

Come sempre un'ottima lingua per il 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);}}}

Rubino, 112 byte

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')

Si aspetta che l'input venga archiviato h.

Fammi sapere se questo ha bisogno di chiarimenti.

J: 75 byte

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 meravigliosa congiunzione Amend . Come al solito l'IO è brutto e goffo, non entra nei dettagli lì. La soluzione di base richiede 3 gerundi (una sorta di verbo ified sostantivo (aka. Funzione)):

• a) generare l'alfabeto
• b) generare gli indici

• c) generare la matrice per fare ammenda

  x (a bc}) y

a) è una ricerca piuttosto banale nella tabella ASCII

c) è ancora più banale

b) è quello interessante. Il morale è che gli indici orizzontali dovrebbero iniziare da 0 andando a y-1 e tornare indietro, ripetendo questo 26 volte. Per esempio. per y == 4:

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

L'implementazione di questo dà per 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.

E oh sì, fatto pratico: il nome di J è ... "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="")
}

Risultato

> 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(""))

Ecco un link al jsfiddle, dove puoi provarlo.
modifica: creato un registro della console per un carattere a spaziatura singola e rimosso le virgole se 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

Questo programma prende input da STDINe stampa il risultato su STDOUT.

E bonus - una versione che è contro le regole in quanto stampa spazi finali, ma aggiunge alcune interazioni:

#!/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=$_)

... e alcuni test di seguito:

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 caratteri

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

Utilizzare come una funzione:

   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

Spiegazione: questa soluzione utilizza un approccio diverso rispetto all'altra soluzione J. Invece di generare un'onda a dente di sega 0 1 2 3 2 1 0 1 ... , ho osservato la spaziatura tra lettere consecutive. Ad esempio, per n = 4 se vai da A verso l'alto, passa alla seconda colonna e raggiungi B, quindi trovi quattro spazi tra A e B. Questo modello di spaziatura tra le lettere è molto regolare: per n = 4 il il modello è 4 4 4 2 2 2 4 4 4 ... .

Quindi l'idea è di costruire prima l'array appiattito (e trasposto), quindi riformularlo e capovolgerlo in modo che appaia giusto. La routine di output è semplice (almeno per essere J): dtb è "cancella gli spazi vuoti finali" e "1dice "opera su ogni riga". dtb ed echo sono entrambi forniti dalla libreria standard.

Grazie a Zsbán Ambrus per l'aiuto golfistico.

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;

Puoi provarlo qui.

Bash (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

Piccole modifiche e siamo arrivati ​​al 213.

Quello originale aveva un bug minore. Testato e confermato per funzionare su bash versione 4.2.37.

Grazie a @manatwork per aver segnalato il bug e alcuni suggerimenti.

Haskell - 432 byte (purtroppo ...)

Questo si è rivelato molto più difficile di quanto mi aspettassi di ottenere puramente, quindi il conteggio dei byte pesanti. Sono sicuro che io (o qualcuno) potremmo fare di meglio, ma ho passato troppo tempo a farlo così com'è. La versione golfizzata è la seguente:

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]]

Per eseguire, carica il codice ghcied esegui putStr $ s Intdove si Inttrova l'altezza desiderata. Puoi anche aggiungere

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

sotto la imports in un file di testo, compilarlo ghce passare l'altezza come argomento della riga di comando. Versione non golfata:

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 spiegazione: Enumerable.Range(0, N).Select(...)genera una stringa per ogni riga che viene eventualmente concatenata in una singola stringa con String.Join(Environment.NewLine, ...). Per ogni riga con cui passiamo in rassegna tutti i 26 caratteri Enumerable.Range(0, 26).Select(...), il test all'inizio dell'espressione lambda determina se generare un carattere o uno spazio mentre i segni di i==2spunta per "C" e convertirlo in "C #" o due spazi a seconda della linea . I String.Concat(...)convertiti la risultante IEnumerable<char>per ciascuna linea in una stringa prima di passarlo TrimEnd(...)al nastro in modo pulito via qualsiasi spazio vuoto iniziale.

PHP (216) (205)

Nuova versione:

$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));

Vecchia versione:

$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));

si aspetta che la variabile $ i sia l'altezza.

C, 214 169 byte, senza spazi finali

Grazie a @ edc65 e @tolos per i loro utili suggerimenti.

#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"))

MODIFICARE

Salvato 13 byte non creando un array e .join ("\ n"). Richiesto lanciando i cicli for. Quindi, con l'aiuto del figlio di codifica C, il codice è diventato troppo intelligente per salvare altri 12 byte.

Ecco la versione leggibile che mostra il cambio logico.

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)
}

Golfato (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)}

Golfato e offuscato (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 byte

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

Abbastanza semplice, e sembra che ho appena eliminato la soluzione J. :)

Innanzitutto, genera un alfabeto:

  `c$65+!26
"ABCDEFGHIJKLMNOPQRSTUVWXYZ"

E un'onda a dente di sega di una lunghezza appropriata:

  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

Riempi ogni lettera dell'alfabeto con spazi iniziali:

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

Comprimi l'alfabeto e l'onda quadra insieme e ruota ogni riga:

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

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

E la trasposizione di ciò è la nostra risposta:

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

Provalo qui in oK .

C: 142 139 caratteri

Terribilmente lungo, mi aspetto di essere in grado di accorciarlo un po ':

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]);}

Leggermente più leggibile:

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]);
}

Modifica: ho perso la regola "senza spazi finali", ma tornerò.

Scala, 246 byte

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(" +$",""))}

riformattato e commentato:

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
}

risultati:

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

Input da archiviare in 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)

Racchetta

Ecco una versione pulita e funzionale: suggerimenti per accorciarla.

(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")))))

Produzione

> (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