Sua tarefa é criar um programa (usando apenas caracteres ASCII imprimíveis e / ou guias e novas linhas) que imprima exatamente os caracteres no espaço ASCII imprimível ( 0x20para 0x7e) que não apareçam no código-fonte do programa (em qualquer ordem, no entanto) quantas vezes você quiser).

O código mais curto para fazer isso em qualquer idioma vence.

GolfScript, 15 12 caracteres

{`),32>^.}.~

Baseado na resposta de Jan Dvorak com algumas reviravoltas e também no estilo da de Peter Taylor .

Poliglota, 95

#undef X;A!"$%&'()*+-[,.]/0123456789:<=>?@BCDEFGHIJKLMNOPQRSTUVWYZ\^_`abcghijklmopqrstvwxyz{|}~

• Perl
• Perl 6
• Qualquer * shell nx-like ( tclsh, bash, sh, ksh, etc)
• Awk (GNU / POSIX)
• Brainfuck , Brian & Chuck , outros derivados
• Rubi
• Coffescript
• Golfscript
• Pitão
• R
• Julia
• Espaço em branco
• rk
• Gaot ++
• bc
• jq
• Alegria
• Tcl
• 99
• V (FMota)
• Acc !!
• C - se não main()for necessário. Graças ao urogênio
• Provavelmente mais.

Faz nada.

PHP 5.2, 4

<?<<

Salve como um arquivo chamado NYUIOMK()'DEAQRWVX[Z]\^@CBGFJqwv{z}|~`bgfkj203547698;=>!#"%$&+*-.phpem algum lugar /home. short_open_tagprecisa estar Onno seuphp.ini .

A saída é:

PHP Parse error:  syntax error, unexpected T_SL in /home/wherever/NYUIOMK()'DEAQRWVX[Z]\^@CBGFJqwv{z}|~`bgfkj203547698;=>!#"%$&+*-.php on line 1

JavaScript - 88

alert("BCDFGHIJKMNPQUVXYZ".toLowerCase())// !#$%&'*+,-0123456789:;<=>?@[\]^_`{|}~AERTOWS

imprime "bcdfghijkmnpquvxyz"

Espaço em branco, 61 57 caracteres

Não é o mais curto, mas provavelmente possui a lógica mais simples (na verdade, é apenas um loop).

Aqui está completamente comentado, onde S é espaço, T é tabulação, L é avanço de linha:

SSSTSSSSSL     # push 0x20
LSSSL          # label S
SSSTL          # push 1
TSSS           # add
SLS            # duplicate top of stack
SLS            # duplicate again
TLSS           # output ASCII character
SSSTTTTTTSL    # push 0x7E
TSST           # subtract (result - 0x7E)
LTTSL          # branch to label S if top of stack is negative
LLL            # end

Obrigado a @res pela correção do procedimento acima (duplicata extra necessária para a instrução de ramificação) e por números menores para empurrar a pilha.

C, 83 74 69 caracteres

main(z) {for(;++z<96;"\33iE!vk?}GkRP8z"[z/7]&1<<z%7&&putchar(z+32));}

Eu realmente tentei reduzi-lo para menos de 80 caracteres, mas não consegui fazê-lo. Finalmente, decidi postar o que tenho, supondo que eu (ou outra pessoa) descubra a solução de 79 caracteres dez minutos depois de postar isso. Ok, não foram dez minutos, mas funcionou em princípio.

Eu realmente queria postar uma versão que não precisasse ter um espaço gratuito no código-fonte, mas que aterrisse em uma órbita de atrator estranho, saltando entre várias soluções. Depois de muitos minutos tentando empurrar um deles para uma solução estável, desisti e adicionei o espaço.

Golfscript, 26 24 caracteres

"126,32>''+".~\-'.~\-"'-

Pega um script de geração de intervalo, duplica-o, executa-o, subtrai-o de seu resultado e depois subtrai o código de subtração de resultado e o outro caractere de citação.

Peixe - 80

zbcdjkpqruvwxaABCDEFGHIJKLMNOPQRSTUVWXYZ#!"'$%^&*()@!+-[]{},;:/\<>=?|~0123456789

Quando os erros de peixe são impressos "algo cheira a peixe ...". Como z é uma má instrução, ele erros imediatamente

Eu sei que não está ganhando nenhum concurso. Eu só queria experimentá-lo em um idioma que normalmente não é usado, apenas por diversão.

Java - 209 195 152 140 caracteres

class a{public static void main(String[]a){for(char c=0;;c++)System.out.print("publicas{tvodmn(Srg[])h=0;w+ye.\"\\xO<?:}".indexOf(c)<0?c:"");}}

Com quebras de linha e guias

class a{
    public static void main(String[]a) {
        for(char c=0;;c++)
            System.out.print("publicas{tvodmn(Srg[])h=0;w+ye.\"\\xO<?:} ".indexOf(c)<0?c:"");
    }
}

Cuidado se você executar: o programa não termina. Haha

Explicação

1. for(char c=0;;c++): Como um charpode ser tratado como um int, uso isso como vantagem aqui para incrementar todos os valores possíveis de c. Omiti a condição de término no loop (a que iria entre os dois pontos e vírgulas) para economizar caracteres, pois não foi especificado que o programa deveria terminar. :)
2. "publicas{tvodmn(Srg[])h=0;w+ye.\"\\xO<?:} ".indexOf(c)<0?c:"": Infelizmente, não é uma abordagem muito elegante, mas faz o trabalho. Liste manualmente todos os caracteres presentes no código-fonte como um Stringliteral e verifique se a corrente char cocorre nele indexOf(). Se a indexOf()chamada retornar -1, ela não existe e, portanto, devemos imprimi-la. O restante apenas usa o operador ternário para economizar caracteres e espaço.

Perl, 49 caracteres

say grep/[^+-246\[-^aceghmprsy]/,map chr,041..126

Esse é um desafio interessante - é uma espécie de anti-quine, e eu consegui encurtar o programa algumas vezes aumentando o intervalo de caracteres que aparecem nele.

Ruby, 81 78 68 66 62 57

(?!..?~).map{|a|$><<a if/[()ifmap{}|?!.~\/\\\[\]$><]/!~a}

Simplesmente se verifica. Caracteres duplicados removidos manualmente.

Agradecemos a Josh por salvar 4 caracteres e a minitech por salvar 5 caracteres!

Befunge (48)

<|::-1,+*88:<+3*87
6<@.**85
9>"()~&"/%$ |!#';=?}

Saídas: {zyxwvutsrqponmlkjihgfedcba` _ ^] [ZYXWVUTSRQPONMLKJIHGFEDCBA240

Não é muito sério, mas eu tive que tentar:

JSFuck (138152)

(fonte compilada aqui)

Fonte original:

for(x=0x7e;x>0x19;x--){
    console.log(String.fromCharCode(x).replace(/[\[\]!\+\(\)]/ig, ''))
}

Imprime todos os caracteres, exceto () + []!

Sua tarefa é criar um programa (usando apenas caracteres ASCII imprimíveis e / ou guias e novas linhas)

Puxa, você dificultou a APL (isso é delibarate?)
Então eu decido ignorar todas as regras !!!

APL (Dyalog), 3 10

⎕AV

Imprime o vetor atômico (que inclui todos os caracteres ASCII imprimíveis)

Acontece que eu esqueci completamente a parte "sem" ...
Mas isso é uma solução fácil

⎕AV~'AV'''

~'AV'''significa excluir ( ~) os caracteres A, V e aspas simples (escapou como aspas simples duplicadas)

Em relação à impressão não-ASCII, bem, estou ignorando todas as regras.

GolfScript ( 18 16 caracteres)

"),@`^^32>#.~".~

Demonstração online com uma linha extra que verifica a correção e gera o número de caracteres com erro.

(Eu tenho várias alternativas equivalentes. @`^Pode ser substituído por \\`; #pode ser substituído por `ou ]. A combinação certa pode ser usada com o truque de Howard para igualar sua pontuação de 15 porque as barras invertidas não precisam escapar em blocos da maneira que fazem nos literais de string: {),\`^32>].~}.~Mas Howard merece o crédito por esse truque).

Brainfuck, 173

+++++[->++++++<]>>>++[------<+>]<++++>>----[----<+>]>-[-------<+>]>-[---<+>]<------->>-[---<+>]<+++++++++>>--[-----<+>]<+++++>>+[---------<++>]+++++++++++++[<[.+<]>[>]<-]\=,

Por muito tempo, posso tentar novamente mais tarde.

J ( 52 40)

Edit: Duh, esqueci e.

'''(-@.e#[)~95{32}a'(-.@e.#[)~95{.32}.a.

Versão antiga:

(>@(*/@('(>@*/''&~:).#]32{95}a'&~:)&.>)#])95{.32}.a.

Outra variante (mesmo comprimento, mas menos saída):

([#~*/"1@('([#~*/"1@''&:0)95{.32}a'&~:"0))95{.32}.a.

Python 3 - 68 61

x=r"print(*set(map(chr,range(32,127)))-set(x+'=\"'))"
exec(x)

... obrigado a @WolframH pelas melhorias.

PowerShell: 96

Deve ser salvo e executado como um script.

diff([char[]](gc $MyInvocation.InvocationName))([char[]](32..126))-Pa|?{$_.SideIndicator-eq'=>'}

diffé um alias interno para Compare-Object.

gcé um alias interno para Get-Content.

$MyInvocation.InvocationName obtém o caminho completo para o script que está sendo executado.

32..126é o equivalente decimal para 0x20..0x7ee, portanto, cria uma matriz dos códigos ASCII decimais que estamos procurando.

[char[]]pega o conteúdo do próximo objeto e os coloca em uma matriz, dividindo-os e convertendo-os em caracteres ASCII. Portanto, agora temos duas matrizes de caracteres ASCII - uma extraída desse script, a outra definida pelo critério de desafio.

-Padefine Compare-Objectpara o formato "Passthru", para que apenas os itens que são encontrados diferentes entre as entradas sejam exibidos no console - indicadores de quais itens estavam em que entrada ainda são armazenados nos dados do objeto, mas não são exibidos.

|?{$_.SideIndicator-eq'=>'}Compare-Objectsaída de pipes para Where-Object, que o filtra apenas para os itens exclusivos da segunda entrada.

PHP - 92

<? //A"$%&'()*+[,.]0123456789:=-@ABCDEFGHIJKLMNOPQRSTUVWYZ\^_`abcdefghijklmopqrstuvwxyz{|}~#

Resultado:

nada

O OP pede para imprimir todos os caracteres não utilizados, bem, eu apenas os uso todos

Javascript, 92

(function f(){for(i=32;126>i++;)!~(""+f).indexOf(c=String.fromCharCode(i))&&console.log(c)})()

Java - 126 caracteres

minimizado:

class hjq{public static void main(String...w){for(char z='"'|0;++z!='a';)if("'()+.0;=OS".indexOf(z)==~0)System.out.print(z);}}

não minimizado:

class hjq {
    public static void main(String... w) { 
        for (char z = '"'|0; ++z != 'a';) {
            if ("'()+.0;=OS".indexOf(z) == ~0) {
                System.out.print(z);
            }
        }
    }
}

Esse é um problema interessante, porque os tokens individuais podem se beneficiar de sua forma mais longa porque reutilizam caracteres. Por exemplo, normalmente String[]seria mais curto, mas String...elimina a necessidade de colchetes na sequência condicional.

Descobri que o truque era tentar usar caracteres no início e no final do intervalo para que você possa excluí-los da saída simplesmente alterando o início e o fim do loop.

Para Java, um personagem-chave para excluir é ", porque ter que na seqüência requer escapar dela, que adiciona \ao seu programa, que precisa ir na corda, que acrescenta \\. Ao remover "da sua cadeia condicional, você remove 4 caracteres. Isto pode ser conseguido por ter certeza que você usa e !e iniciar o seu ciclo de #.

Todas as letras minúsculas aparecer perto do final do intervalo, com apenas {, |, }e ~atrás deles. Devido à verbosidade do Java, a maioria das letras minúsculas é usada apenas para o clichê. Da mesma forma, {e }são triviais para um programa Java, porque o clichê requer isso.

|pode ser usado se você tiver uma condição ou, mas não consegui encontrar uma maneira de tirar vantagem de uma que leva a um programa mais curto do que apenas usar |como um operador bit a bit. O |0que me faz sentir um pouco sujo, porque é a única parte que é um nop apenas para obter o personagem lá dentro.

~0rendimentos -1, o que é útil, porque é com isso que precisamos verificar indexOf. Combinar isso com o uso !=do loop condicional elimina <completamente o caractere, o que significa que ele não precisa entrar na sequência condicional.

sh (47)

tr</dev/urandom -cd \[:print:]|tr -d "`cat $0`"

Usa a abordagem auto-referencial. Assume/dev/urandom , eventualmente, produza todos os octetos pelo menos uma vez. Não termina.

Se assumirmos que manestá instalado, poderíamos fazer uso da página de ascii(7)manual (e, portanto, ter um programa de encerramento) ( 44 caracteres, obrigado @fennec).

man ascii|tr -cd \[:print:]|tr -d "`cat $0`"

BitShift , 1038 bytes

BitShift é uma linguagem que suporta apenas 0e 1como sintaxe. Imaginei que seria fácil imprimir todos os outros caracteres, mas, como ele realmente não suporta loop, ele ainda acabou com 1038 bytes.
No entanto, acredito que não é realmente possível ser menor do que isso ..

101001100101011011010100110111010100100101011001101111010100100101011001000101011011010100101100110110101001001010110010001010110110101000001101010010010101100100010101101101010000010000011001010110110101000010000101011011010100110111010100100101011111100101011011010100110111010100100101011001101111010100100101011001000101011011010100000000011010100100101011001000101011011010100110010000101011011010100110111010100100101011001101001101010010010101100100010101101101010011001000010101101101010011011101010010010101111011111110010101101101010011011101010010010101100101100101011011010100010001010110110101001000010101101101010011011101010010010101110111110010101101101010011011101010010010101111111100101011011010100110111010100100101011111011110101001001010110010001010110110101001000100000101011011010100110111010100100101011111010011010100100101011001000101011011010100100000101011011010100110111010100100101011001101111010100100101011001000101011011010100010000010101101101010011011101010010010101101001101101010010010101101001101010

Impressões

 !"#$%&'()*+,-./23456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~

Experimente aqui

Definitivamente a solução mais longa aqui, mas a codificação no Lino é sempre divertida:

L.in.oleum -655 523 caracteres

"libraries"/arch/cpu/base;/hmi/conout;/data/bytes;/data/string/t2s;/data/heap;/data/heap/connect/mgrab;"stockfile"a;"directors"displaystatus=engage;"injection"c=524;b<-bytes.bytesizeconvert:c;b<-heap.alloc:b;a<-heap.alloc:c;[filecommand]=readfile;[filename]=stockfile;[fileposition]=0;[fileblocksize]=c;[fileblockpointer]=b;arch.fileread;[string.psource]=b;[string.ptarget]=a;string.t2s;b<-heap.alloc:7fh;c=32;d=b;"f"[d_32]=c;+c;+d;?c<7fh>f;"w"d=[a];+a;?d=0>y;?d<32>w;?d>7eh>w;e=b;e+d;[e]=33;^w;"y"b+32;"v"conout.say:b;bye;

Sem comentários, apenas lê a fonte compilada em binário. Salvar como a.txtou não será compilado!

Brainfuck, 133 123 114 110 bytes

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

Um pouco mais de mexer com uma solução anterior (antes que eu percebesse que o abaixo era menor - embora isso tenha acontecido antes de fazer uma otimização pesada). Isso funciona armazenando 4 conjuntos de números ASCII, imprimindo-os com alguns ciclos complicados e fornecendo os caracteres ausentes posteriormente (ou seja, aqueles que estão entre números ASCII inválidos).

Submissão original

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

Faz o seguinte:

• Crie 4 registros contendo 11. 13, 28, 33
• Crie um quinto com o valor 31 para iniciar a impressão
• Imprimir ascii 32-42 (11)
• Imprimir ascii 44
• Imprimir ascii 47-59 (13)
• Imprimir ascii 61
• Imprimir ascii 63-90 (28)
• Imprimir ascii 92
• Imprimir ascii 94-126 (33)

Haskell (70)

import Data.List
main=putStrLn$[' '..'~']\\" \\\"$'.=DLS[]aimnoprstu~"

A solução chata de duplicar caracteres no programa em uma string e subtrair do conjunto universal. Longe de ser um vencedor do codegolf, embora seja surpreendentemente legível por sua extensão.

(Agora com subtração da lista em vez de filter/ notWith.)

J - 21

(u:32+i.97)-.1!:1<":5

escreva isso em um arquivo chamado 5no diretório atual. Em seguida, carregue execute o script com0!:1<'5'

Ou 25 sem o truque de arquivo:

(-.~".)'(":u:32+i.0-~95)'

Clojure (142, 106103)

(defn -main[](let[c"(fn[l](pr(reduce disj(set(map char(range 32 126)))l)));-\\\"o"]((load-string c)c)))

formatado:

(defn -main []
  (let [c "(fn[l](pr(reduce disj(set(map char(range 32 126)))l)));-\\\"o"]
    ((load-string c) c)))

Pense que isso acontece, pode precisar de alguns ajustes. resultado:

#{@ ` ! A B b # C $ D % E & F ' G H I * J + K k , L M . N / O 0 P Q q R S 4 T 5 U V v 7 W w 8 X x 9 Y y : Z z { < | = } > ^ ? _}

executa a sequência, que é um código clojável avaliável, por si só. A string possui alguns comentários no final para obter os caracteres usados ​​fora da string (método principal, etc.)

Python 2, 69

for x in range(38):print chr(x+59)#!"$%&'*,-./012467bdjklmqsuvwyz{|}~

Uso a sequência mais longa (que consigo encontrar) de caracteres contínuos que posso imprimir e adicionar os outros como um comentário após o código.