Inspiração : em 1939, um homem chamado Ernest Vincent Wright escreveu um romance chamado Gadsby sem usar a letra 'e'.

Sua tarefa é escrever um conjunto de (até 5) programas em qualquer idioma (que tenha uma sintaxe baseada em texto *) para gerar todas as 26 letras do alfabeto em ordem. No entanto, para cada vogal aeiou, pelo menos um dos programas não deve incluir nenhuma ocorrência da vogal.

Então deve haver

• um programa que não usa ' a ' ou ' A ' em nenhum lugar da sintaxe do programa.
• um programa que não usa ' e ' ou ' E ' em nenhum lugar da sintaxe do programa.
• um programa que não use ' i ' ou ' I ' em nenhum lugar da sintaxe do programa.
• um programa que não usa ' o ' ou ' O ' em nenhum lugar da sintaxe do programa.
• um programa que não usa ' u ' ou ' U ' em nenhum lugar da sintaxe do programa.

Todos eles devem produzir abcdefghijklmnopqrstuvwxyz.

O vencedor será a solução em que a duração de todos os programas é a mais curta.

_{* como a restrição não seria um grande desafio para Piet ou Whitespace}

Classificações atuais (06 Mar 2014):

• A PL : 11
• B cinzas : 31
• E efunge : 26
• B urlesco : 12
• B rainfuck : 38
• C : 84
• C # : 278/149
• Atolamento C : 6
• C lojure : 81
• D c : 18
• E rlang escript : 75
• F # : 96
• Ator F : 264
• F emissão : 21
• F or : 46
• G olfscript : 8
• H askell (intérprete) : 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 (linha cmd) : 23
• P erl 5.10+ : 23
• P erl : 101
• P HP : 31
• P ostscript : 45
• P owershell : 62
• P concha ython : 48
• P jthon : 83
• R : 36
• R ebmu : 15
• R uby : 20
• R UBY 1,8 : 18
• S cala : 55
• S CLI idade : 42
• T cl : 49
• T -SQL : 120
• V BA : 70

Golfscript - 8 caracteres

123,97>+

Brainfuck, 38 caracteres

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

Obviamente, não há vogais (ou quaisquer outras letras) na sintaxe do cérebro .

PHP, 31 bytes

Não a, e, i, o, u:

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

A sequência binária após o til tem a seguinte representação hexadecimal:

\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

Como existe um placar de idiomas, também posso enviar este:

Ruby (v1.8) 18 bytes

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

Rubi ( 24 22)

Edit: parênteses podem ser omitidos, 2 caracteres a menos:

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

24 caracteres em Ruby:

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

Como funciona

$>é um alias para $stdoutou STDOUT. Você pode escrever usando o <<operador O termo '%c'*26repete a string '%c'26 vezes. O %operador é definido em String como um alias para sprintf, portanto, str % valé equivalente a escrever sprintf(str,val). O caractere de formato %cé usado para transformar um valor de caractere em um caractere. Esses valores vêm de [*97..122]onde cria uma matriz contendo os valores de 97 a 122. Et voilá!

Pitão , 1 Personagem

G

Pyth pré-define certas variáveis. G é predefinido como o alfabeto em minúsculas. Pyth também imprime implicitamente cada linha com um valor de retorno razoável.

JavaScript (100)

Não 'aeou':

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

Não 'i':

alert('abcdefgh\x69jklmnopqrstuvwxyz')

K, 9

_26#.Q.b6

K, 10

"c"$97+!26

K, 14

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

J, 26 23 17 16 caracteres

Depois de mais ou menos uma hora remexendo na gaveta de roupas íntimas de J, finalmente encontrei uma maneira de eliminar os verbos a.e u:.

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

Anteriormente:

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

com agradecimentos a randomra pelo #\truque.

R, 17 + 19 = 36 caracteres

não ae (17):

intToUtf8(97:122)

não (19):

cat(letters,sep="")

Bash (38)

Sem vogais.

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

C, 90 88 84 caracteres

Compile usando 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 caracteres

26,{97+}%+

Ruby, 20 caracteres

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

• 97.chr é uma maneira elaborada de dizer 'a'
• .. especifica um intervalo
• ?z é uma maneira mais curta de dizer "z"
• isso [*range]faz com que o intervalo divida seus valores em uma matriz
• *''é o mesmo que join(''); cola todos os valores da matriz juntos.
• $><< Perlicism: imprime em stdout.

dc: 18 17 caracteres

97[dP1+dBD>m]dsmx

E morreu um personagem corajoso.

Powershell, 75 62 caracteres

Editar: usado -f (String.Format) e indexação de matriz para reduzir significativamente o comprimento do código.

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

Como funciona

gmé um alias para get-members, portanto, 1|gmretorna membros do valor 1, que é do System.Int32tipo:

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)"retorna uma representação em string da lista acima, que contém todas as vogais necessárias para completar o alfabeto: " int C omp ar eTo (System.Object val ue) ..."

BASH: 40 caracteres

• Não aeiouusado.
• Nenhum curinga usado.

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

Haskell, 12

['\97'..'z']

Ou isso é trapaça? :)

MATLAB, 12 + 20 = 32 caracteres

Não eiou (12):

char(97:122)

Não aeou (20)

fprintf('%s',97:122)

No Perl,

também é possível sem vogais

mas muito mais difícil do que no Ruby etc. Isso usa um total de 101 caracteres, mas não requer a chamada de linha cmd (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`

=> Resultado: abcdefghijklmnopqrstuvwxyz

Em contraste com a solução PHP de 'aparência semelhante' , este é um programa real . O programa decodificado lê:

perl -e "print STDERR a..z"

Após a codificação para valores octais, outro intérprete perl é chamado durante a execução pelos `` (backticks). Os backticks consumiriam a saída, portanto, são impressos em STDERR.

A codificação é feita pelo sprintf:

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

e a codificação avaliada é o programa publicado (dentro de 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"

Saudações

rbo

Perl 5, 22 caracteres

(1) contém apenas ae e, 10 caracteres (requer 5.10+, executados na linha de comando):

-Esay+a..z

(2) contém apenas "i", 12 caracteres:

print v97..z

Se não for permitido executar a partir da linha de comando, você precisará usar use 5.01;say a..zo primeiro, com um custo de 7 caracteres e mais uma vogal, mas ainda não possui um 'i', resultando em uma entrada válida no total de 29 personagens.

APL (Dyalog) ( 11 13)

Você pode precisar de uma fonte APL. Supõe-se que seja Unicode, mas não há visualização ...

Somente U(e talvez ⍳contando as vogais gregas):

⎕UCS 96+⍳26

(Isso é [quad]UCS 96+[iota]26:)

Apenas A:

⎕A

Python 2, 83

Não a , i , o ou u ; 47 :

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

Não e ; 36 :

print"abcd\x65fghijklmnopqrstuvwxyz"

Python 2, 175 caracteres

Nota: imprime na saída diferente da resposta python anterior .

Usa 'e', ​​mas não a, i, o, u - 63 61 59 65 (corrigir imovimento incorreto para minúsculas) 115 caracteres (livrar-se dos espaços).

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

(Originalmente, usava impressão com uma vírgula que inseria um espaço; também imprimia letras maiúsculas. Agora via requisitos rigorosos para 'abcdefghijklmnopqrstuvwxyz' como saída; adicionando instrução de importação).

Não usa 'e' (usa a, i, o, u; pode se livrar trivialmente de a, u para pequenas extensões) - 61 60 caracteres

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

JavaScript (154)

(1) Contém apenas i(99 caracteres):

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) Contém apenas aeou(55 caracteres):

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

Demonstração: http://jsfiddle.net/SvN5n/

Pitão 159 117

Conforme mencionado no outro post do python, a parte mais difícil é lidar com o fato de que a única maneira de gerar saída é usar printor sys.stdout.write, ou ambos contendo i. É necessário fazer isso com 2 programas (que são independentes e não usam o shell interativo python para criar a saída):

Este usa apenas i por 55 caracteres:

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

Este evita o uso de i por 104 caracteres:

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

EDIT: avanço maciço !!! Eu estava pensando que o uso de eval (ou mesmo executivo) era um truque e não estava realmente no espírito da competição. De qualquer forma, vasculhando os componentes internos, encontrei uma maneira de obter a função de impressão sem usar i. Então, aqui está o programa evitar-i (e o) para 68 caracteres:

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

Mas como isso também evita o, isso pode ser associado a um que evita apenas a, e, u por 49 caracteres:

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

Rubi 196 164 44 47

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

Ruby, 22

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

Nenhuma letra :)

VBA: 76 força bruta, 116 sem 'trapaça' (98 se novas linhas forem aceitáveis ​​na saída)

Funções padrão

Graças à verbosidade do VBA, não acredito que isso possa ser feito sem 'E' ou 'U' em um módulo de código padrão ...

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

Funções imediatas

Correndo com a suposição de mellamokb, aqui está sem a declaração de função (deixando de fora SUBe FUNCTION) ( 116 caracteres , 98 se novas linhas são aceitáveis ​​na saída):

O texto abaixo não usa 'e' nem 'a' ( 43 caracteres , formatados para serem executados na janela imediata):

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

O texto abaixo não usa 'i' nem 'a' nem 'u' ( 33 caracteres , formatados para serem executados na janela imediata):

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

O texto abaixo não usa 'a' nem 'o' nem 'u' ( 40 caracteres , formatados para serem executados na janela imediata):

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

Se caracteres de nova linha forem permitidos na saída, os exemplos acima poderão ser mais curtos:

( 37 caracteres )

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

( 27 caracteres )

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

( 34 caracteres )

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

Força Bruta

Executando com a resposta Ruby do w0lf

( 76 caracteres , formatados para serem executados na janela imediata):

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

Rebmu : 15 caracteres

Ctc'`L26[pn++C]

A leitura do Rebmu sempre requer um pouco de silêncio para começar:

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

Então, ajuda a expandir as abreviações:

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

Seria mais óbvio usar um caractere literal para o predecessor de letras minúsculas a:

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

Mas isso não "mingau", portanto, converter uma palavra literal em um caractere passa para o mesmo objetivo. O que eu mais gosto, como na maioria dos Rebmu, é que ele tem o espírito de um programa sensato, apesar da compressão. (A resposta Golfscript é mais curta, mas não é mapeada para a maneira como um programador normalmente pensaria ao codificar.)

<> <(Peixe) - 22 caracteres

Como <> <usa o 'o' para imprimir um personagem, esse desafio parece impossível. Felizmente, o peixe pode alterar seu próprio código em tempo de execução. Isso me permitiu adicionar as instruções de impressão ao código.

Este código não usa nenhuma das vogais:

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

Você pode executar o código aqui