Inspiration : en 1939, un homme nommé Ernest Vincent Wright écrivit un roman intitulé Gadsby sans utiliser la lettre «e».

Votre tâche consiste à écrire un ensemble de programmes (jusqu’à 5) dans n’importe quelle langue (avec une syntaxe textuelle *) afin d’afficher les 26 lettres de l’alphabet dans l’ordre. Cependant, pour chaque voyelle, au moins un des programmes ne doit inclure aucune occurrence de la voyelle.

Donc il doit y avoir

• un programme qui n'utilise pas « un » ou « A » partout dans la syntaxe du programme.
• un programme qui n'utilise pas ' e ' ou ' E ' n'importe où dans la syntaxe du programme.
• un programme qui n'utilise ni « i » ni « je » dans la syntaxe du programme.
• un programme qui n'utilise ni " o " ni " O " dans la syntaxe du programme.
• un programme qui n'utilise pas " u " ou " U " n'importe où dans la syntaxe du programme.

Tous doivent sortir abcdefghijklmnopqrstuvwxyz.

Le gagnant sera la solution lorsque la longueur de tous les programmes est la plus courte.

_{* puisque la contrainte ne serait pas un défi en Piet ou Whitespace}

Classement actuel (06 mars 2014):

• Un PL : 11
• B ash : 31
• B éfunge : 26
• B urlesque : 12
• B rainfuck : 38
• C : 84
• C # : 278/149
• C jam : 6
• C lojure : 81
• D c : 18
• E rlang escript : 75
• F # : 96
• Acteur F : 264
• F ission : 21
• F orth : 46
• G olfscript : 8
• H askell (interprète) : 12
• H TML : 50
• J : 17
• J ava : 137
• J avascript : 92

• K : 9

• K otlin : 112

• L ua : 57
• M arbelous : 96
• M ATLAB : 11
• P erl 5 (ligne de commande) : 23
• P erl 5.10+ : 23
• P erl : 101
• P HP : 31
• P ostscript : 45
• P owershell : 62
• P coquille ython : 48
• P ython : 83
• R : 36
• R ebmu : 15
• R uby : 20
• R uby 1,8 : 18
• S cala : 55
• S âge CLI : 42
• T cl : 49
• T- SQL : 120
• V BA : 70

Golfscript - 8 caractères

123,97>+

Brainfuck, 38 caractères

++++++[->++++<]>[->+>++++<<]>++[->+.<]

Bien sûr, il n'y a pas de voyelles (ou d'autres lettres) dans la syntaxe du brainfuck .

PHP, 31 octets

Non a, e, i, o, u:

<?=~žœ›š™˜—–•”“’‘ŽŒ‹Š‰ˆ‡†…;

La chaîne binaire située après le tilde a la représentation hexadécimale suivante:

\x9e\x9d\x9c\x9b\x9a\x99\x98\x97\x96\x95\x94\x93\x92\x91\x90\x8f\x8e\x8d\x8c\x8b\x8a\x89\x88\x87\x86\x85

Puisqu'il y a un tableau d'affichage des langues, je pourrais aussi bien vous soumettre celui-ci:

Ruby (v1.8) 18 octets

$><<[*97.chr..'z']

Rubis ( 24 22)

Edit: les parenthèses peuvent être omises, moins de 2 caractères:

$><<'%c'*26%[*97..122]

24 caractères en rubis:

$><<('%c'*26)%[*97..122]

Comment ça fonctionne

$>est un alias pour $stdoutou STDOUT. Vous pouvez y écrire en utilisant l' <<opérateur. Le terme '%c'*26répète la chaîne '%c'26 fois. L' %opérateur est défini sur String comme un alias sprintf, ce qui str % valrevient à écrire sprintf(str,val). Le caractère de format %cest utilisé pour transformer une valeur de caractère en caractère. Ces valeurs proviennent de [*97..122]ce qui crée un tableau contenant les valeurs de 97 à 122. Et voilá!

Pyth , 1 caractère

G

Pyth prédéfinit certaines variables. G est prédéfini comme alphabet minuscule. Pyth imprime aussi implicitement chaque ligne avec une valeur de retour raisonnable.

JavaScript (100)

Non 'aeou':

this['\x61l\x65rt']('\x61bcd\x65fghijklmn\x6fpqrst\x75vwxyz')

Non je':

alert('abcdefgh\x69jklmnopqrstuvwxyz')

K, 9

_26#.Q.b6

K, 10

"c"$97+!26

K, 14

.:".Q.","c"$97

J, 26 23 17 16 caractères

Après une heure ou fouillant dans le tiroir de sous - vêtements de J Je l' ai finalement trouvé un moyen d'éliminer les a.et les u:verbes.

2(3!:4)96+#\26$1

Précédemment:

a.{~96++/\26$1
u:97+i.26

avec merci à randomra pour le #\tour.

R, 17 + 19 = 36 caractères

non ae (17):

intToUtf8(97:122)

non iou (19):

cat(letters,sep="")

Bash (38)

Pas de voyelles du tout.

/*/*/*ntf "/*/?ch? {\x61..z}"|/*/b?sh

C, 90 88 84 caractères

Compiler en utilisant gcc -nostartfiles

b;_exit(){for(;b<26;)printf("%c",b+++97);}    // 42 chars, works for a, u
b;_start(){putchar(b+++97)>121?:_start();}    // 42 chars, works for e, i, o

Golfscript, 10 caractères

26,{97+}%+

Ruby, 20 caractères

$><<[*97.chr..?z]*''

• 97.chr est une manière élaborée de dire 'a'
• .. spécifie une plage
• ?z est un moyen plus court de dire "z"
• la [*range]provoque la plage à splat al il est des valeurs dans un tableau
• *''est le même que join(''); il colle toutes les valeurs d'un tableau ensemble.
• $><< Perlicism: imprimer sur la sortie standard.

dc: 18 17 caractères

97[dP1+dBD>m]dsmx

Et il mourut un personnage courageux.

Powershell, 75 62 caractères

Edit: Utilisé -f (String.Format) et l'indexation de tableaux pour réduire considérablement la longueur du code.

'{0}bcd{1}fgh{2}jklmn{3}pqrst{4}vwxyz'-f"$(1|gm)"[8,10,0,5,31]

Comment ça fonctionne

gmest un alias pour get-members, donc 1|gmrenvoie les membres de la valeur 1, qui est du System.Int32type:

PS C:\> 1|gm
   TypeName: System.Int32
Name        MemberType Definition
----        ---------- ----------
CompareTo   Method     int CompareTo(System.Object value), int CompareTo(int value)
Equals      Method     bool Equals(System.Object obj), bool Equals(int obj)
GetHashCode Method     int GetHashCode()
...

"$(1|gm)"renvoie une représentation sous forme de chaîne de la liste ci-dessus, qui contient toutes les voyelles nécessaires pour compléter l'alphabet: " int C omp ar eTo (System.Object val ue) ..."

BASH: 40 caractères

• Non aeiouutilisé.
• Aucun caractère générique utilisé.

`tr c-y '\141-w'<<<'rtkpvh %s c'` {b..z}

Haskell, 12 ans

['\97'..'z']

Ou est-ce tricher? :)

MATLAB, 12 + 20 = 32 caractères

Non eiou (12):

char(97:122)

Non aeou (20)

fprintf('%s',97:122)

En Perl,

c'est aussi possible sans voyelles

mais beaucoup plus difficile qu'en Ruby, etc. Ceci utilise un total de 101 caractères mais ne nécessite pas d'invocation de ligne de commande (perl -e).

`\160\145\162\154\40\55\145\40\42\160\162\151\156\164\40\123\124\104\105\122\122\40\141\56\56\172\42`

=> Résultat: abcdefghijklmnopqrstuvwxyz

Contrairement à la solution PHP «similaire» , il s'agit d'un programme réel . Le programme décodé se lit comme suit:

perl -e "print STDERR a..z"

Après l’encodage en valeurs octales, un autre interpréteur Perl est appelé lors de l’exécution par le `` (backticks). Les backticks consomment la sortie, elle est donc imprimée sur STDERR.

L'encodage est fait par sprintf:

my $s = q{perl -e "print STDERR a..z"};
my $cmd = eval(
       '"' . join('', map sprintf("\\%o",ord $_), split //, $s) . '"'
       );

et le codage évalué est le programme posté (dans les backticks):

"\160\145\162\154\40\55\145\40\42\160\162"
"\151\156\164\40\123\124\104\105\122\122"
"\40\141\56\56\172\42"

Cordialement

rbo

Perl 5, 22 caractères

(1) ne contient que aet e, 10 caractères (nécessite 5.10+, exécuté à partir de la ligne de commande):

-Esay+a..z

(2) contient uniquement 'i', 12 caractères:

print v97..z

S'il n'est pas autorisé à s'exécuter à partir de la ligne de commande, vous devez utiliser use 5.01;say a..zla première, avec un coût de 7 caractères et une voyelle de plus, mais elle n'a toujours pas de 'i'. Il en résulte une entrée valide de 29 au total. personnages.

APL (Dyalog) ( 11 13)

Vous pourriez avoir besoin d'une police APL. Ceci est supposé être Unicode mais il n'y a pas de prévisualisation ...

Seulement U(et peut ⍳- être en comptant les voyelles grecques):

⎕UCS 96+⍳26

(C'est: [quad]UCS 96+[iota]26)

Seulement A:

⎕A

Python 2, 83

Non a , i , o ou u ; 47 :

x=97;s='';exec"s+=chr(x);x+=1;"*26+"pr\x69nt s"

Non e ; 36 :

print"abcd\x65fghijklmnopqrstuvwxyz"

Python 2, 175 caractères

Remarque: les impressions sont générées contrairement à la réponse précédente en python .

Utilisations 'e', ​​mais non a, i, o, u - 63 61 59 65 (correction du idéplacement erroné en minuscule) 115 caractères (suppression des espaces).

exec('fr%cm sys %cmp%crt*\nf%cr x %cn r%cnge(97,123):std%c%ct.wr%cte(chr(x)),'%(111,105,111,111,105,97,111,117,105))

(À l'origine, elle utilisait une virgule avec une virgule insérée; les lettres majuscules étaient également imprimées. Des exigences strictes étaient imposées pour 'abcdefghijklmnopqrstuvwxyz' en sortie; il fallait donc ajouter une déclaration d'importation).

N'utilise pas 'e' (utilise a, i, o, u; pourrait trivialement se débarrasser de a, u pour une petite extension) - 61 60 caractères

import string
print string.__dict__['low%crcas%c'%(101,101)]

JavaScript (154)

(1) contient uniquement i(99 caractères):

t=this;s=-t+t+t.b;z=s[1]+'bcd'+s[7]+'fghijklmn'+s[4]+'pqrst'+s[21]+'vwxyz';t[s[1]+'l'+s[7]+'rt'](z)

(2) contient uniquement aeou(55 caractères):

t=0;s=''+t.b;alert('abcdefgh'+s[5]+'jklmnopqrstuvwxyz')

Démo: http://jsfiddle.net/SvN5n/

Python 159 117

Comme mentionné dans l'autre publication Python, le plus difficile est de traiter le fait que le seul moyen de générer une sortie est d'utiliser printou sys.stdout.write, les deux contenant i. Il faut le faire avec 2 programmes (qui sont indépendants et n'utilisent pas le shell interactif python pour créer la sortie):

Celui-ci utilise uniquement i pour 55 caractères:

print"%cbcd%cfghijklmn%cpqrst%cvwxyz"%(97,101,111,117)

Celui-ci évite d'utiliser i pour 104 caractères:

eval("sys.stdout.wr%cte"%105,{'sys':eval("__%cmport__('sys')"%105)})("%c"*26%tuple(range(97,123))+"\n")

EDIT: percée massive !!! Je pensais qu'utiliser eval (ou même exec) était un peu un tricheur et pas vraiment dans l'esprit de la compétition. Quoi qu'il en soit, en parcourant les fonctions intégrées, j'ai trouvé un moyen d'obtenir la fonction d'impression sans utiliser i. Voici donc le programme Avoid-i (et o) pour 68 caractères:

vars(vars().values()[0])['pr%cnt'%105]("%c"*26%tuple(range(97,123)))

Mais parce que cela évite aussi o, cela peut être jumelé avec celui qui évite seulement a, e, u pour 49 caractères:

print"%cbcd%cfghijklmnopqrst%cvwxyz"%(97,101,117)

Rubis 196 164 44 47

$><<"\x61bcd\x65fgh\x69jklmn\x6Fpqrst\x75vwxyz"

Ruby, 22 ans

$><<[*?`..?{][1,26]*''

Aucune lettre que ce soit :)

VBA: 76 force brute, 116 sans "triche" (98 si les nouvelles lignes sont acceptables dans la sortie)

Fonctions standard

Grâce à la verbosité de VBA, je ne crois pas que cela puisse se faire sans "E" ou "U" dans un module de code standard ...

• " E nd"
• "F u nction"
• "S u b"

Fonctions immédiates

Sous l'hypothèse de mellamokb, voici sans la déclaration de fonction (laissant dehors SUBet FUNCTION) ( 116 caractères , 98 si les nouvelles lignes sont acceptables en sortie):

Le texte ci-dessous n'utilise ni 'e' ni 'a' ( 43 caractères , formatés pour être exécutés dans la fenêtre immédiate):

b=65:Do:z=z+Chr(b):b=b+1:Loop Until b=91:?z

Le texte ci-dessous n'utilise ni 'i' ni 'a' ni 'u' ( 33 caractères , formatés pour être exécutés dans la fenêtre immédiate):

For b=65 To 90:z=z+Chr(b):Next:?z

Le texte ci-dessous n'utilise ni 'a' ni 'o' ni 'u' ( 40 caractères , formatés pour être exécutés dans la fenêtre immédiate):

b=65:While b<91:z=z+Chr(b):b=b+1:Wend:?z

Si les caractères de nouvelle ligne sont autorisés dans la sortie, les exemples ci-dessus peuvent être plus courts:

( 37 caractères )

b=65:Do:?Chr(b):b=b+1:Loop Until b=91

( 27 caractères )

For b=65 To 90:?Chr(b):Next

( 34 caractères )

b=65:While b<91:?Chr(b):b=b+1:Wend

Force brute

Courir avec la réponse Ruby de w0lf

( 76 caractères , formatés pour être exécutés dans la fenêtre immédiate):

?Chr(65)&"BCD"&Chr(69)&"FGH"&Chr(73)&"JKLMN"&Chr(79)&"PQRST"&Chr(85)&"VWXYZ"

Rebmu : 15 caractères

Ctc'`L26[pn++C]

Lire Rebmu nécessite toujours un peu de désinvolture pour commencer:

c: tc '` l 26 [pn ++ c]

Ensuite, il est utile d’élargir les abréviations:

c: to-char-mu '`
loop 26 [
    prin ++ c
]

Il serait plus évident d'utiliser un littéral de caractère pour le prédécesseur de minuscule a:

c: #"`"
loop 26 [
    prin ++ c
]

Mais cela ne "va pas", donc convertir un mot littéral en un personnage passe dans le même but. Comme dans la plupart des autres entreprises Rebmu, ce qui me plaît, c’est qu’il a l’esprit d’un programme judicieux malgré la compression. (La réponse de Golfscript est plus courte mais ne correspond pas à la façon dont un programmeur penserait habituellement lors de la programmation.)

<> <(Poisson) - 22 caractères

Parce que <> <utilise le 'o' pour imprimer un personnage, ce défi semble impossible à relever. Heureusement, le poisson peut modifier son propre code en cours d'exécution. Cela m'a permis d'ajouter l'instruction d'impression au code.

Ce code n'utilise aucune des voyelles:

'`78'+11pv
:X:'z'=?;>1+

Vous pouvez exécuter le code ici