Un simple aujourd'hui. Ecrivez le programme le plus court qui dessine un "alphabet en dents de scie" avec un entier positif pour la hauteur. Vous devez écrire le nom de votre langage de programmation lorsque vous arrivez à la lettre par laquelle il commence.

Par exemple, si votre langage est Python et que l’entrée est 1la sortie, elle devrait être:

ABCDEFGHIJKLMNOPythonQRSTUVWXYZ

Si l'entrée est 2la sortie devrait être:

 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 l'entrée est 4la sortie devrait être:

   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

Remarques

• A commence toujours en bas à gauche.
• L'entrée peut être via stdin ou appel de fonction ou similaire. Sortie sur stdout.
• L'entrée ci 26- dessus n'a pas besoin de fonctionner.
• Pas d'espaces de fuite.

si n tient la hauteur:

Codes d'échappement C +: 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);
}

Compile sur gcc avec quelques avertissements. Les nouvelles lignes ne sont pas incluses dans le nombre de caractères.

122 caractères si l'entrée est déjà stockée dans n.

Merci à user2992539 , tolos et edc65 pour des améliorations.

TI-BASIC - 148 octets (texte brut), 186 octets (graphique)

En réponse au PO, la merveilleuse TI-83 (et plus récente) est livrée avec une taille de 16 x 8 (en utilisant seulement le texte large standard) ou avec une taille de 94 x 62 pixels (qui avec un petit texte vaut environ 10 lignes ).

Maintenant, cela a un petit problème (pour lequel je voudrais des éclaircissements). Les impositions de taille ne peuvent pas être "ignorées" par l'interprète; en d'autres termes, si nous essayions de régler la hauteur de la dent de scie à 20, cela produirait une erreur empêchant l'exécution complète du code. Je pourrais écrire du code qui, dans un environnement infini, produirait la sortie correcte, à moins qu'il ne s'exécute pas sur la machine.

Ceci étant dit, je vous présente les versions (en cours d'exécution) des programmes. Ils dépendent tous de la variable Nétant définie à la hauteur souhaitée dans les lignes avant d'exécuter:

• Approche texte brut

  :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
  

  Pour faire ce travail quel que soit le terminal, le changement For(C,1,16de For(C,1,33et retirer le contrôle majorant ( R<2 or). Voici la sortie avec 5→N:

  

• Approche graphique (cela peut aussi nécessiter AxisOffde la clarté)

  :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
  

  Celui-ci fonctionne bien, avec deux bizarreries mineures. La hauteur est toujours un problème, bien que la largeur ne soit pas. Cependant, je n'ai pas espacé les lettres, de sorte que dans certains cas (lorsque la lettre commence à remonter ou à diminuer en dents de scie), les lettres peuvent être découpées par leurs successeurs. Pour que cela fonctionne quel que soit le terminal, supprimez la coche de la limite supérieure ( R<7 or). Suit ensuite le graphique:

  

Pure Bash (no coreutils), 181 octets

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

Sortie:

Piped to cat -Ejuste pour prouver qu'il n'y a pas de saut de ligne.

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

Éditer le correctif, une nouvelle commande et une façon différente de gérer height == 1
De plus, changé pour une fonction comme cela est autorisé par l'OP, donc pas d'invite () pour l'entrée

Aucun changement à l'algorithme général qui n'est probablement pas le meilleur pour ce défi

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

A expliqué

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

Exemples

1

ABCDEFGHIJavascriptKLMNOPQRSTUVWXYZ

3 monter

  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 sur le dessus

   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 descendant

      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)

Comme toujours une excellente langue pour le 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 octets

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

S'attend à ce que l'entrée soit stockée dans h.

Faites-moi savoir si cela nécessite une clarification.

J: 75 octets

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

Utilisation de la merveilleuse modification Amend . Comme d'habitude, les entrées-sorties sont laides et maladroites, sans entrer dans les détails. La solution de base prend 3 gérondages (une sorte de verbe nominal).

• a) générer l'alphabet
• b) générer les indices

• c) générer la matrice pour compenser

  x (a bc}) y

a) est une recherche assez triviale dans la table ascii

c) est encore plus trivial

b) est l'intéressant. Le moral est que les indices horizontaux sont censés commencer à partir de 0 et passer à y-1, puis redescendre, ce qui est répété 26 fois. Par exemple. pour y == 4:

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

La mise en œuvre de ceci donne pour 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.

Et oui, fait pratique: le nom de J est ... "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="")
}

Résultat

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

Voici un lien vers le jsfiddle, où vous pouvez le tester.
edit: Création d'un journal de console pour une police à espacement fixe et suppression des virgules si une entrée == 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

Ce programme prend l’entrée de STDINet affiche le résultat dans STDOUT.

Et bonus - une version qui va à l’encontre des règles car elle affiche des espaces de fin, mais ajoute une interaction:

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

... et quelques tests ci-dessous:

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 caractères

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

Utiliser comme fonction:

   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

Explication: cette solution utilise une approche différente de l’autre solution J. Au lieu de générer une onde en dents de scie 0 1 2 3 2 1 0 1 ... , j'ai examiné l'espacement entre les lettres consécutives. Par exemple, pour n = 4, si vous passez du A au maximum, passez à la deuxième colonne et atteignez B, vous trouverez quatre espaces entre A et B. Ce modèle d’espacement entre les lettres est très régulier: pour n = 4, le motif est 4 4 4 2 2 2 4 4 4 ... .

L’idée est donc d’abord de construire le tableau aplati (et transposé), puis de le remodeler et de le retourner afin qu’il ait l’air juste. La routine de sortie est simple (pour être J, au moins): dtb est "supprime les blancs" et "1"opère sur chaque ligne". dtb et echo sont tous deux fournis par la bibliothèque standard.

Merci à Zsbán Ambrus pour son aide au 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;

Vous pouvez l'essayer ici.

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

Réglages mineurs et nous sommes à 213.

L'original avait un bug mineur. Testé et confirmé pour fonctionner sur la version 4.2.37 de Bash.

Merci à @manatwork pour avoir signalé le bogue et quelques astuces.

Haskell - 432 octets (malheureusement ...)

Cela s'est avéré être beaucoup plus difficile que ce à quoi je m'attendais, donc le nombre d'octets important. Je suis sûr que je (ou quelqu'un) pourrait faire mieux, mais j'ai passé trop de temps là-dessus. La version golfée est la suivante:

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

Pour exécuter, charger le code dans ghciet exécuter putStr $ s Intoù Intest la hauteur désirée. Vous pouvez aussi ajouter

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

sous le imports dans un fichier texte, compilez-le avec ghcet passez la hauteur en argument de ligne de commande. Version non-golfée:

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

Brève explication: Enumerable.Range(0, N).Select(...)une chaîne est générée pour chaque ligne qui est finalement concaténée en une seule chaîne avec String.Join(Environment.NewLine, ...). Pour chaque ligne, nous parcourons les 26 caractères avec Enumerable.Range(0, 26).Select(...), le test au début de l'expression lambda détermine s'il faut générer un caractère ou un espace pendant que le i==2contrôle de "C" et le convertit en "C #" ou en deux espaces en fonction de la ligne. . Le String.Concat(...)convertit le résultat IEnumerable<char>pour chaque ligne en une chaîne avant de la passer afin TrimEnd(...)d'éliminer proprement tous les espaces finaux.

PHP (216) (205)

Nouvelle version:

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

Ancienne version:

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

s'attend à ce que la variable $ i soit à la hauteur.

C, 214 169 octets, pas d'espaces de fin

Merci à @ edc65 et @tolos pour leurs suggestions utiles.

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

MODIFIER

Sauvegardé 13 octets en ne construisant pas de tableau et .join ("\ n"). Obligatoire de retourner les boucles for. Puis, avec l’aide de fils de codage C, le code est devenu trop intelligent pour économiser 12 octets supplémentaires.

Voici la version lisible montrant le changement de logique.

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

Golfé (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)}

Golfé et obscurci (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 octets

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

Assez simple, et il semble que je viens de sortir de la solution J. :)

Tout d'abord, générez un alphabet:

  `c$65+!26
"ABCDEFGHIJKLMNOPQRSTUVWXYZ"

Et une onde en dents de scie de longueur appropriée:

  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

Tapotez chaque lettre de l'alphabet en commençant par les espaces:

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

Compressez l’alphabet et l’onde carrée, et faites pivoter chaque ligne:

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

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

Et la transposition de cela est notre réponse:

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

Essayez-le ici à OK .

C: 142 139 caractères

Extrêmement long, je pense pouvoir le raccourcir un peu:

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

Un peu plus lisible:

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

Edit: J'ai raté la règle "pas d'espaces", mais je serai de retour.

Scala, 246 octets

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

reformaté et commenté:

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
}

Résultats:

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

Entrée à stocker dans 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)

Raquette

Voici une version fonctionnelle épurée: des suggestions pour le raccourcir sont les bienvenues.

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

Sortie

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