Desde que um dígito entre 0 e 9 (inclusive), sua função / sub-rotina imprima todos os números entre -100 e 100 (inclusive) que contenham o dígito fornecido.

Por exemplo:

Input: 9
Output: -99 -98 -97 -96 -95 -94 -93 -92 -91 -90 -89 -79 -69 -59 -49 -39 -29 -19 -9 9 19 29 39 49 59 69 79 89 90 91 92 93 94 95 96 97 98 99

Regras:

• Você não pode usar seqüências de caracteres (de qualquer maneira que elas estejam representadas no idioma escolhido) ou matrizes de caracteres. (Exceto para imprimir a resposta no console.)
• Você não pode usar matrizes.

Pontuação:

Pontuação = duração da sub-rotina / função (o espaço em branco não será contado)

A resposta com a menor pontuação vence.

Espaço em branco NÃO será contado. Formate seu código corretamente!

Algumas respostas estão usando expressões regulares, o que pode violar a regra no strings, como apontado por alguns membros. Essas respostas não serão aceitas.

Teste seu código 0antes de postar.

Espaço em branco, 834 caracteres (0 se você subtrair espaços em branco)

Utilizou este intérprete para testá-lo.

Isso levou cerca de 4 horas de trabalho duro e depuração horrível para criar. Mas está feito!

EDIT : Texto selecionável fornecido com truques em HTML. Se você copiar e colar daqui para outro lugar, verifique se chegou exatamente [space][tab][linefeed][linefeed][linefeed]ao final com 100 ou 101 linhas (dependendo se o seu editor conta ou não uma nova linha se o último terminar com um avanço de linha).

No caso de você não poder usá-lo dessa maneira, considerando espaço como S, avanço de linha como Le tabulação como Te quebrando linhas após os L, aqui está:

SSSTSSSSTSL
SSSTSSSSTSL
TL
TSSSSTSSSSTSL
TTTSSSTTSSSSL
TSSTTTSSSSTSSSSTTL
SSTTTSSSTTL
TTSSSSTSSSSSTL
SSSL
TTSSSSTSSSSTSL
TTTL
TSSTSSTSTTL
SSSTSSSSTSL
TTTSSSTL
TSSTL
TSSTSSTSTTL
L
SSSTSSSTSSL
SSSTSSSSTTL
TTTSL
SSSSTTSSTSSL
TSSTL
TSSTSSSTSTL
SL
SSSTTL
TSSL
L
TTSTSSSTTTL
SSTTL
TSSL
L
SSSTSSSTTTL
SL
SSSSTSSSSTSL
TTTL
TSSTSSTSSSL
SSSTSTSL
TSTSSSSTSSSSTSL
TTTTSSTL
TSSTSSTSSTL
L
SSSTSSTSSSL
SSSTSTSL
TSTTSSSTSSSSTSL
TTTTSSTL
TSSTSSTSSTL
L
SL
STSSTSTSL
L
SSSTSSTSSTL
SSSTSSSSSTL
TTTL
TSSTSSSTTSL
SSSTSSSSSL
TL
SSL
SSSTSSSTTSL
SSSTSSSSSTL
SSSTL
TTSSSSTSSSSTTL
TTTTL
STL
SSSTSSTSTSL
SSSTSSSSTTL
SSSTSSSSTTL
TTTSSSTL
TSSSTTSL
SL
STSSSTSSL
L
SSSTSSSTSTL
SSSTSSSSTSL
TTTL
TSSTSSTTSSL
SSSTSSSSTSL
TTTSSSTL
TSSTL
TSSTSSTTSSL
L
L
L
L
SSSTSSTSTTL
SSTTTSSTSSL
TL
STSSSTSSSSSL
TL
SSL
SL
STSSSTSSL
L
SSSTSSTTSSL
SSSTSSSSSL
TL
SSSSSTTSSTSSL
TL
STL
L
L

Bash + utils - 20

seq -100 100|grep 9

Ou 21 bytes se em um script

seq -100 100|grep $1

Para executar o script:

sh myscript 9

JavaScript 133 - 1 = 132

Certamente não poderia haver nada de errado com esta versão agora ...?

for(k=prompt(),c=console,j=-100;100>=j;j++)if(i=j,0==j&j==k)c.log(0);else for(;i;)if(h=i%10,h=0>h?-h:h,i=i/10|0,h==k){c.log(j);break}

PROMPT: 2
CONSOLE.LOG:
-92
-82
-72
-62
-52
-42
-32
-29
-28
-27
-26
-25
-24
-23
-22
-21
-20
-12
-2
 2
 12
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 32
 42
 52
 62
 72
 82
 92

CONTROL, using zero
PROMPT: 0
CONSOLE.LOG:
    -100
    -90
    -80
    -70
    -60
    -50
    -40
    -30
    -20
    -10
      0
     10
     20
     30
     40
     50
     60
     70
     80
     90
    100

GolfScript [24 bytes]

`:x;201,{100-}%{`x?-1>},

Descrição:

`:x;             - save input value to variable 'x' and remove from the stack
201,{100-}%      - create range from -100 to 100
{`x?-1>},        - filter the range by "index-of" condition

DEMO: http://golfscript.apphb.com/?c=MwoKYDp4OzIwMSx7MTAwLX0le2B4Py0xPn0sYA%3D%3D

Ruby: 92 caracteres

s=gets.to_i
$><<(-100..100).select{|n|a=n.abs;loop{break""if a%10==s;break if 0==a/=10}}*" "

Versão legível:

searchfor = gets.to_i
$><< (-100..100).select { |number|
  absnumber = number.abs
  loop {
    break "" if absnumber % 10 ==s
    break if 0 == absnumber /= 10
  }
} * " "

Exemplo de execução:

bash-4.2$ ruby -e 's=gets.to_i;$><<(-100..100).select{|n|a=n.abs;loop{break""if a%10==s;break if 0==a/=10}}*" "' <<< 9
-99 -98 -97 -96 -95 -94 -93 -92 -91 -90 -89 -79 -69 -59 -49 -39 -29 -19 -9 9 19 29 39 49 59 69 79 89 90 91 92 93 94 95 96 97 98 99

Execução de teste:

bash-4.2$ for i in {0..9}; do diff -w <(ruby -e 's=gets.to_i;$><<(-100..100).select{|n|a=n.abs;loop{break""if a%10==s;break if 0==a/=10}}*" "' <<< $i) <(seq -100 100|grep $i|tr \\n \ ) > /dev/null; echo "$i : $?"; done
0 : 0
1 : 0
2 : 0
3 : 0
4 : 0
5 : 0
6 : 0
7 : 0
8 : 0
9 : 0

K - 45 char

Não ganhando nenhum prêmio, mas o golfe K está sub-representado. K não fica mais bonito com espaçamento adequado, então deixarei como está, porque K fica muito exigente sobre qual espaço em branco é importante e o que não é.

{|a@&x _in'@[10_vs'_ _abs a:100-!201;100;0,]}

Explicado:

• a:100-!201- Faça uma lista de 0 a 200 inclusive, e subtraia-a de 100. Agora temos os números de -100 a 100 inclusive, mas ao contrário das especificações da pergunta. Sempre podemos consertar isso mais tarde, então, por enquanto, atribuiremos isso a a.
• _ _abs - Tome como base o valor absoluto desses números, porque, por qualquer motivo, K pensa que _abs deva dar resultados de ponto flutuante. Felizmente, pavimentá-los os transforma em números inteiros.
• 10_vs'- Expanda cada 'número inteiro ( ) como um número base 10 (_vs significa "vetor do escalar"). Observe que não precisamos usar o operador Each 'nas funções acima, porque elas operam em átomos.
• @[...;100;0,] - Altere o item da nossa lista no índice 100 (uma lista vazia, que é o resultado da expansão de 0 para a base 10) pela função 0, , que antecede um zero à frente. Sem essa correção, esta função falhará na entrada 0.
• &x in'- Agora, retorne os índices ( &) onde xestá um dígito em ( _in) cada (' ) das expansões que construímos com tanto cuidado acima.
• |a@ - Por fim, use esses índices para indexar a e inverta a lista na ordem correta.

O uso é óbvio, apesar de boa sorte colocar um intérprete em K. (Existe uma implementação de código aberto no Github que você pode compilar.)

  {|a@&x _in'@[10_vs'_ _abs a:100-!201;100;0,]} 0
-100 -90 -80 -70 -60 -50 -40 -30 -20 -10 0 10 20 30 40 50 60 70 80 90 100
  {|a@&x _in'@[10_vs'_ _abs a:100-!201;100;0,]} 5
-95 -85 -75 -65 -59 -58 -57 -56 -55 -54 -53 -52 -51 -50 -45 -35 -25 -15 -5 5 15 25 35 45 50 51 52 53 54 55 56 57 58 59 65 75 85 95

bater 55 49 caracteres:

(sem contar espaços em branco &&)

for i in {-100..100}
do
  [[ $i =~ $1 ]] && echo $i
done

Executando-o dizendo:

bash filename 9

produziria:

-99
-98
-97
-96
-95
-94
-93
-92
-91
-90
-89
-79
-69
-59
-49
-39
-29
-19
-9
9
19
29
39
49
59
69
79
89
90
91
92
93
94
95
96
97
98
99

PHP 67 bytes:

for($i=-100;$i<101;++$i)if(strpos($i,$_GET[n])!==!1)echo$i,PHP_EOL;

Sim, há uma chamada de "strpos", mas estou usando apenas números!

Aqui está uma versão 'ungolfed':

for($i=-100;$i<101;++$i)
{
    if(strpos($i,$_GET[n])!==false)
    {
        echo $i,PHP_EOL;
    }
}

Para que isso funcione, você pode testá-lo aqui: http://writecodeonline.com/php/

Lembre-se de adicionar $_GET[n]='<number>';ao início do código.

Ou, em um servidor lamp ou xampp, você pode criar uma página e acessá-la no navegador, com o parâmetro ?n=<number>após o nome do arquivo.

Mathematica 28

Desculpe, eu simplesmente não pude resistir.

:)

As instruções são: "Desde que um dígito entre 0 e 9 (inclusive), sua função / sub-rotina imprima todos os números entre -100 e 100 (inclusive) que contenham o dígito fornecido".

A seguir, imprime todos esses números em ordem.

f@n_ :=Print/@Range[-100,100]

Como um bônus especial, ele imprime esses números no mesmo intervalo que não contêm o dígito especificado. :)

Minha primeira tentativa aqui, então talvez eu esteja fazendo algumas coisas erradas, desculpe;)
Então, eu não tinha certeza se tinha que adicionar toda a classe ou apenas a lógica interna.

Java - 199 caracteres

intx=System.in.read()-48;for(inti=-100;i<101;i++){if((i<10&&i==-x)||(i>-10&&i==x)||(i<-9&&((i/100==x&&i<-99)||i%10==-x||i/10==-x))||(i>9&&((i/100==x&&i>99)||i%10==x||i/10==x)))System.out.println(i);}

Aqui uma forma mais legível:

int x = System.in.read() - 48;
for(int i = -100; i < 101; i++) {

    if((i < 10 && i == -x) || (i > -10 && i == x)
        || (i < -9 && ((i / 100 == x && i < -99 ) || i % 10 == -x || i / 10 == -x))
        || (i > 9 && ((i / 100 == x && i > 99) || i % 10 == x || i / 10 == x)))

        System.out.println(i);

}

Eu acho que a idéia básica não era tão ruim, mas precisava de muitas exceções, para finalmente funcionar em todos os casos ...: /

C - 104 107 114 caracteres - 0 = 104 107 114

a,b;main(i){i=getchar()-48;for(a=-100;a<101;a++){for(b=a;a&&abs(a%10)!=i;a/=10);if(a|!i&!b)printf("%i ",b);a=b;}}

Ungolfed:

#include <stdio.h>

int a, b;

int main(int i) {
    i = getchar() - '0';
    for( a = -100 ; a < 101 ; a++ ) {
        for( b = a ; a && abs(a % 10) != i ; a /= 10 );
        if( a | !i & !b )
            printf("%i ", b);
        a = b;
    }
}

R 87 93

Aqui está uma melhoria:

a=scan();r=-100:100;s=abs(r);r[(!a&!r%%10)|a&(a==s%%10|a==floor(s/10)|a==floor(s/100))]

(Potencialmente) Mais legível, com notas:

a=scan() # take user input of selected digit
r=-100:100 # define our scanning range
s=abs(r) # copy the range as the absolute value for proper floor() calculation
#r[<criteria>] is functionally the same as subset(r,<criteria>)
r[ # when any of the criteria below are met, use that value from the range
    (!a & !r%%10) # case when input is 0, !a is evaluated as "a when a<>0 == true"
    | a & # all other digits below
    a==s%%10
    |
    a==floor(s/10)
    |
    a==floor(s/100)
    ] # R does not require a print command, so this as-is will display the corresponding values

Prolog: 75

f(D) :-
  between(-100,100,N) ,
  number_chars(N,Ds) ,
  member(D,Ds) ,
  writeln(N) ,
  fail
  .

Resposta C em 98 caracteres

Esta é uma das coisas mais sexy que eu já codifiquei

main()
{
    int t=getchar()-48,i=100,j=-i;
    while ((i=t-i%10?i/10:!printf("%d\n",j)) || (i=++j<0?-j:j)<101  );
}

A versão mais antiga, com 104 caracteres não em branco:

int main()
{
    int t=getchar()-48,i,j=-101;
    while(++j<101)
    {
        i=j<0?-j:j;
        while(i = t-i%10?i/10:!printf("%d\n",j));
    }
}

"Funciona para mim" usando o GCC e o CLANG.

Coreutils GNU (44)

read N
seq -100 100 | grep $N | tr '\n' ' '
echo

onde tré usado para converter novas linhas em espaços e echofornece uma nova linha final.

$ bash ./script
9
-99 -98 -97 -96 -95 -94 -93 -92 -91 -90 -89 -79 -69 -59 -49 -39 -29 -19 -9 9 19 29 39 49 59 69 79 89 90 91 92 93 94 95 96 97 98 99

Javascript 116

   a = 0
        for(i=-100;101>i;i++){
        m=Math
        f=m.floor
        j = m.abs(i)
        if((j>10&&f(j/10)==a)||j-f(j/10)*10==a||j/100==a){

             console.log(i)

        }
        }

J - 27 caracteres

Todo o espaço em branco é removível com segurança, o que significa 27 caracteres. Os números negativos na saída terão _um sinal negativo: é exatamente assim que J escreve seus números negativos.

((e. 10 #.^:_1 |)"0 # ]) & (i: 100)

Explicado:

• V & (i: 100)- Vincule ( &) o conjunto de números de -100 a 100 inclusive ( i:100) como o argumento correto do verbo principal ( V). O argumento único do verbo inteiro é canalizado para o lado esquerdo.
• (U"0 # ])- Use o resultado do verbo Usobre cada número do argumento correto ( "0) para selecionar ( #) itens do argumento correto ( ]).
• (e. 10 #.^:_1 |)- Dado o dígito a ser testado como argumento à esquerda e o número a ser verificado como argumento correto, expanda na base 10 ( 10 #.^:_1) o valor absoluto do número ( |) e verifique se o dígito é um elemento dessa expansão ( e.).

Uso:

   ((e. 10 #.^:_1 |)"0 # ]) & (i: 100) 0
_100 _90 _80 _70 _60 _50 _40 _30 _20 _10 0 10 20 30 40 50 60 70 80 90 100
   ((e. 10 #.^:_1 |)"0 # ]) & (i: 100) 5
_95 _85 _75 _65 _59 _58 _57 _56 _55 _54 _53 _52 _51 _50 _45 _35 _25 _15 _5 5 15 25 35 45 50 51 52 53 54 55 56 57 58 59 65 75 85 95

Groovy, 127

def x = args[0].toInteger()
for (k in -100..100)
    if (k == x)
        print " ${k}"
    else
        for (n = Math.abs(k); n > 0; n = (int) n / 10)
            if (n % 10 == x) {
                print " ${k}"
                break
            }

Sem strings (exceto para produzir os espaços entre os números), sem matrizes de caracteres ou outras matrizes, sem expressões regulares. Testado com 0. Saída:

-100 -90 -80 -70 -60 -50 -40 -30 -20 -10 0 10 20 30 40 50 60 70 80 90 100

Javascript - 108

Não tenho certeza se a resposta javascript existente será levada em consideração porque ela usa regex, então criei uma sem ela:

for(x=+prompt(i=-100);i<101;i++)if((j=i<0?-i:i)&&j%10==x||((j/100==x||(0|j/10)==x)&&x)||j==x)console.log(i)

Também pode ser reduzido para 101 se a variável x for colocada diretamente, como:

for(x=5,i=-100;i<101;i++)if((j=i<0?-i:i)&&j%10==x||((j/100==x||(0|j/10)==x)&&x)||j==x)console.log(i)

Ele basicamente verifica se os valores absolutos das operações div ou mod são iguais ao dígito (que também funciona para 100).

GW Basic: 107 caracteres, excluindo espaço em branco

1 input n
2 for i=-100 to 100
3 j=abs(i):a=j mod 10
4 if a=n then 8
5 b=j\10
6 if (b=n) and b then 8
7 if (b<10) or n<>1 then 9
8 print i
9 next

Usar dígitos únicos para os números de linha ajuda e eliminar o espaço em branco significa que não há realmente a necessidade de ter várias instruções em uma linha mais de uma vez para manter os números chegando a 10.

GROOVY, 71

f={z->
  _=10
  (-_*_.._*_).grep {
    a=it.abs()
    b=a%_==z
    a<_?b:b||(int)(a/_)%_==z
  }
}

println f(0)
println f(9)

Resulta em

[-100, -90, -80, -70, -60, -50, -40, -30, -20, -10, 0, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100]
[-99, -98, -97, -96, -95, -94, -93, -92, -91, -90, -89, -79, -69, -59, -49, -39, -29, -19, -9, 9, 19, 29, 39, 49, 59, 69, 79, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99]

Javascript 96

Usando bit a bit ou:

b=Math.abs;
a=prompt();
for(i=-100;i<101;)
    if(!(b(i++/10)^a && b(i%10)^a)||b(i)/a==100)  console.log(i)

Haskell, 86 75 (78 com espaços em branco necessários)

f 0=[-100,-90..100]
f d=[b|b<-[-100..100],abs(b`quot`10)==d||abs(b`rem`10)==d]

Ungolfed:

f dig =
  if dig == 0
    then [-100, 90 .. 100]
    else [num | num <- [-100 .. 100], abs (num `quot` 10) == d || abs (num `rem` 10) == d]

Python - 172 caracteres

def f(x,y,z):
    if x%10==y or (x>9 and x/10==y) or (x==100 and y==1):
        print z
def g(x,y):
    f(abs(x),y,x)
    if x<100:
        g(x+1,y)
def h(y):
    g(-100,y)

Para testar no Python:

>>> h(4)
-94
-84
-74
...
-49
-48
...

VBA 121

(nenhum espaço em branco ou Subdefinição é contado):

Sub t(d)
For n = -100 To 100
m = Abs(n)
o = o & IIf(d = 0, IIf(d = n Mod 10, " " & n, ""), IIf(d = n Or d = m Mod 10 Or d = Int(m / 10) Or d = Int(m / 100), " " & n, ""))
Next
MsgBox o
End Sub

perl, 117 com caracteres de espaço em branco não significativos removidos

Eu acho que você estava procurando algo mais parecido com isto. Lê de stdin, gera uma linha por partida. Sem regexps, matrizes (ou conjuntos ou hashes ou qualquer outra coisa que seja uma matriz oculta) ou cadeias, implícitas ou não, exceto as cadeias transmitidas para impressão:

chomp($x=<>); for($y=-100;$y<101;++$y) { $a=abs $y; print "$y " if $a % 10 == $x || $a > 9 && int( $a/10 ) == $x || $a==100 && $x==1}; print "\n"

por exemplo:

ski@anito:~$ echo 0 | perl -e 'chomp($x=<>); for($y=-100;$y<101;++$y) { $a=abs $y; print "$y " if $a % 10 == $x || $a > 9 && int( $a/10 ) == $x || $a==100 && $x==1}; print "\n"'
-100 -90 -80 -70 -60 -50 -40 -30 -20 -10 0 10 20 30 40 50 60 70 80 90 100 

ski@anito:~$ echo 1 | perl -e 'chomp($x=<>); for($y=-100;$y<101;++$y) { $a=abs $y; print "$y " if $a % 10 == $x || $a > 9 && int( $a/10 ) == $x || $a==100 && $x==1}; print "\n"'
-100 -91 -81 -71 -61 -51 -41 -31 -21 -19 -18 -17 -16 -15 -14 -13 -12 -11 -10 -1 1 10 11 12 13 14 15 16 17 18 19 21 31 41 51 61 71 81 91 100 

ski@anito:~$ echo 2 | perl -e 'chomp($x=<>); for($y=-100;$y<101;++$y) { $a=abs $y; print "$y " if $a % 10 == $x || $a > 9 && int( $a/10 ) == $x || $a==100 && $x==1}; print "\n"'
-92 -82 -72 -62 -52 -42 -32 -29 -28 -27 -26 -25 -24 -23 -22 -21 -20 -12 -2 2 12 20 21 22 23 24 25 26 27 28 29 32 42 52 62 72 82 92 

F # 87 92 - 7

let f n = {-100..100}
|>Seq.filter(fun x->abs x%10=n||abs x/10=n&&n>0)
|>Seq.iter(printf"%d ")

adicionou 5 caracteres porque 0 não foi tratado corretamente. (Todos os valores de um dígito seriam retornados.)

Esta é a minha primeira vez jogando código de golfe. Isso parece bem interessante. Não posso vencer, mas tentei e queria mostrar o que poderia fazer.

Python: 104 (89 se eu puder mulligan a importação) - se os resultados tiverem que ser impressos exatamente como mostrado no exemplo

from math import *

def g(x):
    t = 10
    p = lambda i: x == i % t or i >= t and p(i / t)
    for i in range(-100, 101):
        if p(abs(i)):
            print i,
    print
# g(0)
# -100 -90 -80 -70 -60 -50 -40 -30 -20 -10 0 10 20 30 40 50 60 70 80 90 100

Python: 71 - se a saída puder ser executada fora da função e a única restrição para a saída é que nenhum número violador é impresso

f = lambda x: [(-i, i) for i in range(101) for j in (10, 100) if i % j == x or i >= j and i / j == x]
# print f(0)
# [(0, 0), (0, 0), (-10, 10), (-20, 20), (-30, 30), (-40, 40), (-50, 50), (-60, 60), (-70, 70), (-80, 80), (-90, 90), (-100, 100), (-100, 100)]

JavaScript 125 char

Desculpe pelas várias edições que tenho tido problemas ao fazer isso no meu telefone :)

function c(n,i){o=i||0;h=100;j=o-h;f=Math.abs(j);m=f/10|0;if((m==n&&m!=0)||n==f%10||f/h==n)console.log(j);if(o<h*2)c(n,o+1);}

Dogelang, 42 caracteres que não são em branco

f=n->for i in(-100..101)=>if n in str i=>print i

O mesmo que minha solução Python, convertida em dogelang .