При наличии цифры от 0 до 9 (включительно) ваша функция / подпрограмма должна печатать все числа от -100 до 100 (включительно), которые содержат данную цифру.

Например:

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

Правила:

• Вы не можете использовать строки (какими бы они ни были представлены на выбранном вами языке) или массивы символов. (За исключением печати ответа на консоль.)
• Вы не можете использовать массивы.

Подсчет очков:

Оценка = длина подпрограммы / функции (пробелы не учитываются)

Ответ с самым низким счетом выигрывает.

Пробелы НЕ будут засчитаны. Пожалуйста, отформатируйте ваш код правильно!

В некоторых ответах используются регулярные выражения, которые могут нарушать правило без строк, на что указывают некоторые члены. Эти ответы не будут приняты.

Пожалуйста, проверьте ваш код 0перед публикацией.

Пробел, 834 символа (0, если вычесть пробелы)

Использовал этот интерпретатор для проверки.

Это заняло у меня около 4 часов тяжелой работы и ужасной отладки. Но это сделано!

РЕДАКТИРОВАТЬ : Выбираемый текст предоставляется с трюками HTML. Если вы копируете и вставляете его отсюда в другое место, проверьте, точно ли вы получили [space][tab][linefeed][linefeed][linefeed]в конце 100 или 101 строку (в зависимости от того, считает ли ваш редактор новую строку или нет, если последняя заканчивается переводом строки).

В случае, если вы не можете использовать его таким образом, рассматривая пробел как S, перевод строки как Lи табуляцию как T, и разрыв строки после L, вот оно:

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

Баш + утиль - 20

seq -100 100|grep 9

Или 21 байт, если в скрипте

seq -100 100|grep $1

Чтобы запустить скрипт:

sh myscript 9

JavaScript 133 - 1 = 132

Конечно, теперь не может быть ничего плохого в этой версии ...?

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 байта]

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

Описание:

`: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

ДЕМО: http://golfscript.apphb.com/?c=MwoKYDp4OzIwMSx7MTAwLX0le2B4Py0xPn0sYA%3D%3D

Рубин: 92 персонажа

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

Читаемая версия:

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

Образец прогона:

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

Тестовый забег:

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

К - 45 символов

Не выигрывая никаких наград, но К гольфу недостаточно представлен. K не становится красивее с надлежащим интервалом, поэтому я просто оставлю это как есть, потому что K очень разборчив в том, какой пробел важен, а какой нет.

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

Разъяснение:

• a:100-!201- Составьте список от 0 до 200 включительно, затем вычтите его из 100. Теперь у нас есть числа от -100 до 100 включительно, но в обратном направлении от спецификаций вопроса. Мы всегда можем исправить это позже, поэтому сейчас мы просто назначим это a.
• _ _abs - Возьмите слово абсолютных значений этих чисел, потому что по какой-то причине К считает, что _abs должно дать результаты с плавающей запятой. К счастью, настил их превращает их обратно в целые числа.
• 10_vs'- Расширить каждое ( ') целое число как базовое число 10 ( _vsозначает «вектор из скаляра»). Обратите внимание, что нам не пришлось использовать оператор Each' в вышеприведенных функциях, потому что они работают с атомами.
• @[...;100;0,] - Изменить элемент в нашем списке с индексом 100 (пустой список, который является результатом расширения 0 в основание 10) с помощью функции 0, , которая добавляет ноль вперед. Без этой коррекции эта функция не будет работать на входе 0.
• &x in'- Теперь верните индексы ( &), где xесть цифра в ( _in) каждый (' ) из расширений, которые мы так тщательно построили выше.
• |a@- Наконец, используйте эти индексы для индексации aи переверните список в правильном порядке.

Использование очевидно, хотя удачи вам в переводчике. (На Github есть реализация с открытым исходным кодом, которую вы можете скомпилировать.)

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

удар 55 49 символов:

(не считая пробелов вокруг &&)

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

Выполняя это, говоря:

bash filename 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

PHP 67 байт:

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

Да, есть вызов strpos, но я использую только номера!

Вот версия «без гольфа»:

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

Чтобы это работало, вы можете проверить это здесь: http://writecodeonline.com/php/

Просто не забудьте добавить $_GET[n]='<number>'; в начало кода.

Или на сервере лампы или xampp вы можете создать страницу и затем открыть ее в браузере с параметром ?n=<number>после имени файла.

Mathematica 28

Извините, я просто не смог устоять.

:)

Инструкции: «При условии, что цифра от 0 до 9 (включительно), ваша функция / подпрограмма должна печатать все числа от -100 до 100 (включительно), которые содержат данную цифру».

Далее печатаются все такие числа по порядку.

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

В качестве специального бонуса он печатает те числа в том же диапазоне, которые не содержат данную цифру. :)

Моя первая попытка здесь, так что, возможно, я делаю что-то не так, пожалуйста, извините;)
Итак, я не был уверен, нужно ли мне добавлять весь класс или только логику внутри.

Java - 199 символов

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

Вот более читаемая форма:

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

}

Я предполагаю, что основная идея была не так уж плоха, но требовалось слишком много исключений, чтобы, наконец, сработать для всех случаев ...: /

C - 104 107 114 символов - 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

Вот улучшение:

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

(Потенциально) Более читабельно, с примечаниями:

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

Пролог: 75

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

С ответом в 98 символов

Это одна из самых сексуальных вещей, которые я когда-либо кодировал

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

Старая версия, с 104 непробельными символами:

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

«Работает для меня», используя GCC и CLANG.

GNU coreutils (44)

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

где trиспользуется для преобразования новых строк в пробелы и echoпредоставляет один последний символ новой строки.

$ 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 символов

Все пробелы безопасно удаляются, что означает 27 символов. Отрицательные числа в выводе будут иметь _отрицательный знак: именно так J записывает свои отрицательные числа.

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

Разъяснение:

• V & (i: 100)- Bind ( &) набор чисел от -100 до 100 включительно ( i:100) в качестве правого аргумента основного глагола (V ). Единственный аргумент всего глагола попадает в левую сторону.
• (U"0 # ])- Используйте результат глагола Uнад каждым числом из правого аргумента ( "0), чтобы выбрать ( #) элементы из правого аргумента ( ]).
• (e. 10 #.^:_1 |)- Учитывая цифру для проверки в качестве левого аргумента и число для проверки в качестве правого аргумента, разверните в базе 10 ( 10 #.^:_1) абсолютное значение числа ( |) и проверьте, является ли цифра элементом этого расширения ( e.).

Использование:

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

Никаких строк (кроме вывода пробелов между числами), никаких массивов символов или других массивов, никаких регулярных выражений. Проверено с 0. Выход:

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

Javascript - 108

Не уверен, будет ли принят во внимание существующий ответ javascript, потому что он использует регулярное выражение, поэтому я создал его без него:

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)

Также может быть сокращено до 101, если переменная x указана напрямую, например:

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)

Он в основном проверяет, равны ли абсолютные значения операций div или mod цифре (что также работает для 100).

GW Basic: 107 символов без пробелов

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

Использование однозначных чисел для номеров строк помогает, и удаление пробелов означает, что на самом деле нет необходимости иметь несколько операторов в строке более одного раза, чтобы числа достигали 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)

Результаты в

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

Используя побитовый или:

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 с необходимыми пробелами)

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]

Питон - 172 символа

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)

Чтобы проверить в Python:

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

VBA 121

(пробелы или Subопределения не учитываются):

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 с удаленными бессмысленными пробелами

Я думаю, что вы искали что-то более подобное. Читает из стандартного ввода, выводит одну строку за матч. Никаких регулярных выражений, массивов (или наборов или хэшей или чего-либо еще, что является массивом под обложками) или строк, неявных или иных, кроме строк, передаваемых для печати:

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"

например:

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

добавил 5 символов, потому что 0 не был обработан правильно. (Однозначные значения все будут возвращены.)

Я впервые играю в гольф в коде. Это выглядит довольно интересно. Я не могу победить, но я пытался и хотел показать, на что я способен.

Python: 104 (89, если я могу проверить импорт) - если результаты должны быть напечатаны точно так, как показано в примере

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 - если вывод может быть сделан вне функции, и единственным выходом является то, что не печатаются нарушающие числа

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

Извините за несколько правок, у меня были проблемы с этим с моего телефона :)

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 непробельных символа

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

То же, что и мое решение на Python, только что преобразовано в dogelang .