Это Hole-1 с осеннего турнира APL CodeGolf . Я являюсь первоначальным автором этой проблемы, и поэтому мне разрешено повторно публиковать ее здесь.

Учитывая список чисел, создайте горизонтальную гистограмму #символов для того, сколько чисел вписывается в каждую из десяти групп одинакового размера. Например, если данные колеблются от 0 до 100, диапазоны будут 0–9,9, 10–19,9,…, 90–100. (Формально, [0,10), [10,20),…, [90,100].). Вы можете предположить, что будет как минимум два числа и что не все числа будут одинаковыми.

Примеры:

[1,0,0,0,0,0,0,0,0,0] дает:

#########








#        

[0,1,2,3,4,5,6,7,8,9] дает:

#
#
#
#
#
#
#
#
#
#

[0,1,2,3,4,5,6,7,8,9,10] дает:

#
#
#
#
#
#
#
#
#
##

[0,1,2,3,4,5,6,7,8,9,10,11] дает:

##
#
#
#
#
#
#
#
#
##

[0,-0.5,-1,-1.5,-2,-2.5,-3,-3.5,-4,-4.5,0.5,0,-0.5,-1,-1.5,-2,-2.5,-3,-3.5,-4,1,0.5,0,-0.5,-1,-1.5,-2,-2.5,-3,-3.5,1.5,1,0.5,0,-0.5,-1,-1.5,-2,-2.5,-3,2,1.5,1,0.5,0,-0.5,-1,-1.5,-2,-2.5,2.5,2,1.5,1,0.5,0,-0.5,-1,-1.5,-2,3,2.5,2,1.5,1,0.5,0,-0.5,-1,-1.5,3.5,3,2.5,2,1.5,1,0.5,0,-0.5,-1,4,3.5,3,2.5,2,1.5,1,0.5,0,-0.5,4.5,4,3.5,3,2.5,2,1.5,1,0.5,0] дает:

###                
#######            
###########        
###############    
#########          
###################
###############    
###########        
#######            
###                

[9014,9082,9077,9068,8866,8710,9049,8364,8867,9015,9064,9023,9024,8804,8805,8800,8744,8743,8714,9076,8593,8595,9075,9675,8968,8970,8711,8728,8834,8835,8745,8746,8869,8868,9073,9074,9042,9035,9033,9021,8854,9055,9017,9045,9038,9067,9066,8801,8802,9496,9488,9484,9492,9532,9472,9500,9508,9524,9516,9474,8739,9079,8900,8592,8594,9053,9109,9054,9059] дает:

#                        
####                     
#########                
############             
######                   
#########################


###########              
#                        

[0,8,10,13,32,12,6,7,27,9,37,39,95,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,1,2,175,46,48,49,50,51,52,53,54,55,56,57,3,165,36,163,162,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,4,5,253,183,127,193,194,195,199,200,202,203,204,205,206,207,208,210,211,212,213,217,218,219,221,254,227,236,240,242,245,123,125,168,192,196,197,198,201,209,214,216,220,223,224,225,226,228,229,230,231,232,233,234,235,237,238,239,241,91,47,92,60,61,62,45,43,247,215,63,126,42,40,124,59,44,33,243,244,246,248,34,35,30,38,180,64,249,250,251,94,252,96,182,58,191,161,41,93,31,160,167] дает:

#############             
######################    
##########################
######################### 
######################### 
#                         
########                  
################          
########################  
##########################

Python 2 , 96 байт

l=input()
m=min(l)
w=max(l)-m
for i in range(10):print"#"*sum(w*i<=(x-m)*10<w*-~i+i/9for x in l)

Попробуйте онлайн!

Python 2 , 107 95 байт

l=input();m=min(l);s=(max(l)-m)/10.;c=0
exec'print"#"*sum(m<=v-c*s<m+s+c/9for v in l);c+=1;'*10

Попробуйте онлайн!

R , 77 81 байт

+4 байта для исправления некоторых тестовых случаев

for(i in hist(x<-scan(),seq(min(x),max(x),,11),r=F)$c)cat(rep('#',i),'\n',sep='')

Попробуйте онлайн!

Ссылка на версию кода, которая принимает ввод через запятую; эта версия занимает пробел

Читает из стандартного ввода, печатает на стандартный вывод.

R является статистическим языком программирования, который делает все возможное, чтобы давать высококачественные результаты, что иногда расстраивает:

histобъединяет входные данные в гистограмму со breaksвторым аргументом. Обычно можно ожидать, что вы можете указать, что количество разрывов равно 10. Действительно, это так:

breaks

один из:

• вектор, дающий точки останова между ячейками гистограммы,
• функция для вычисления вектора точек останова,
• одно число, дающее количество ячеек для гистограммы,
• символьная строка с именем алгоритма для вычисления количества ячеек (см. «Детали»),
• функция для вычисления количества клеток.

(выделение добавлено).

Однако в следующем предложении говорится:

В последних трех случаях число является только предположением; поскольку для точек останова будут заданы prettyзначения, число будет ограничено 1e6(с предупреждением, если оно больше).

Итак, я посмотрел на документацию, prettyи она просто не работает для нашей ситуации, потому что она таким образом выбирает точки останова:

Вычислить последовательность примерно n+1одинаково расположенных круглых значений, которые охватывают диапазон значений в x. Значения выбираются так, чтобы они в 1, 2 или 5 раз превышали степень 10.

Который просто не будет делать.

Таким образом, seq(min(x),max(x),,11)указывается 11 точек с равным интервалом, как breaks, hist(x,breaks,r=F)$cдает счет, r=Fгарантирует, что срезы имеют правильные интервалы, а forостальная часть позаботится о цикле.

C (gcc) , 241 байт

#define P(x)for(;x--;putchar('#'));puts("");
double a[999],u,l,x;i,j,n[9];main(k){for(;scanf("%lf",&x)>0;u=u>x?u:x,l=l<x?l:x,a[i++]=x);for(;j<i;++j)for(k=0;k<9;)if(a[j]<l+(++k)*(u-l)/10){n[k-1]++;break;}for(k=0;k<9;++k){i-=n[k];P(n[k])}P(i)}

Попробуйте онлайн!

Mathematica, 152 байта

(Do[Print[""<>Table["#",Length@Select[s=#,Min@s+(t=#2-#&@@MinMax@s/10)(i-1)<=#<Min@s+t*i&]]],{i,9}];Print[""<>Table["#",Length@Select[s,Max@s-t<=#&]]])&

Попробуйте онлайн!

JavaScript (ES6), 99 байт

Редактировать 2 байта сохранить thx @JustinMariner

Функция, возвращающая массив строк

l=>l.map(v=>o[i=(v-n)/(Math.max(...l)-n)*10|0,i>9?9:i]+='#',o=Array(10).fill``,n=Math.min(...l))&&o

Меньше гольфа

list => {
   var max = Math.max(...list),
       min = Math.min(...list),
       output = Array(10).fill(''),
       index;

   list.forEach( value => (
      index = (value - min) / (max - min) * 10 | 0,
      output [index > 9 ? 9 : index] += '#'
   ) )
   return output
}

Тестовое задание

var F=
l=>l.map(v=>o[i=(v-n)/(Math.max(...l)-n)*10|0,i>9?9:i]+='#',o=Array(10).fill``,n=Math.min(...l))&&o

var test=[
[1,0,0,0,0,0,0,0,0,0],
[0,1,2,3,4,5,6,7,8,9],
[0,-0.5,-1,-1.5,-2,-2.5,-3,-3.5,-4,-4.5,0.5,0,-0.5,-1,-1.5,-2,-2.5,-3,-3.5,-4,1,0.5,0,-0.5,-1,-1.5,-2,-2.5,-3,-3.5,1.5,1,0.5,0,-0.5,-1,-1.5,-2,-2.5,-3,2,1.5,1,0.5,0,-0.5,-1,-1.5,-2,-2.5,2.5,2,1.5,1,0.5,0,-0.5,-1,-1.5,-2,3,2.5,2,1.5,1,0.5,0,-0.5,-1,-1.5,3.5,3,2.5,2,1.5,1,0.5,0,-0.5,-1,4,3.5,3,2.5,2,1.5,1,0.5,0,-0.5,4.5,4,3.5,3,2.5,2,1.5,1,0.5,0],
[0,8,10,13,32,12,6,7,27,9,37,39,95,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,1,2,175,46,48,49,50,51,52,53,54,55,56,57,3,165,36,163,162,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,4,5,253,183,127,193,194,195,199,200,202,203,204,205,206,207,208,210,211,212,213,217,218,219,221,254,227,236,240,242,245,123,125,168,192,196,197,198,201,209,214,216,220,223,224,225,226,228,229,230,231,232,233,234,235,237,238,239,241,91,47,92,60,61,62,45,43,247,215,63,126,42,40,124,59,44,33,243,244,246,248,34,35,30,38,180,64,249,250,251,94,252,96,182,58,191,161,41,93,31,160,167],
[9014,9082,9077,9068,8866,8710,9049,8364,8867,9015,9064,9023,9024,8804,8805,8800,8744,8743,8714,9076,8593,8595,9075,9675,8968,8970,8711,8728,8834,8835,8745,8746,8869,8868,9073,9074,9042,9035,9033,9021,8854,9055,9017,9045,9038,9067,9066,8801,8802,9496,9488,9484,9492,9532,9472,9500,9508,9524,9516,9474,8739,9079,8900,8592,8594,9053,9109,9054,9059]];

output=x=>O.textContent+=x+'\n\n'

test.forEach(t=>output(t+'\n'+F(t).join`\n`))

<pre id=O></pre>

Python 2 , 126 121 байт

def f(a):
 m=min(a);r=range(10);A=[sum(x>=m+i*(max(a)-m)/10.for x in a)for i in r]+[0]
 for i in r:print'#'*(A[i]-A[i+1])

Попробуйте онлайн!

Желе , 21 байт

Монадическая ссылка возвращает список строк.

_Ṃµ÷Ṁ×⁵Ḟµ<⁵+ċЀ⁵R¤”#ẋ

Попробуйте онлайн!

Pyth ,  32  31 байт

*R\#_M.++msmgk+JhSQ*dc-eSQJTQTZ

Попробуй это здесь! или Проверьте все контрольные примеры. (с использованием симпатичной печатиj)

Как это работает

Это полная программа, которая принимает данные от STDIN. Это для 32-байтовой версии. Я скоро обновлю.

* R \ #_ M. ++ msmgk + hSQ * dc-eSQhSQTQTZ ~ Полная программа.

         m T ~ Отображение над [0, 10) с помощью var d.
           m Q ~ Отображение ввода с помощью var k.
            г ~ выше или равно?
             k ~ Текущий элемент ввода, k.
              + hSQ * dc-eSQhSQT ~ Разобьем это на части:
               hSQ ~ Самый низкий элемент списка ввода.
              + ~ Плюс:
                  * dc-eSQhSQT ~ Мы разберем это на несколько частей:
                  * ~ Умножение.
                   d ~ Текущий элемент [0, 10), d.
                    c T ~ Поплавковое деление на 10 из:
                     -eSQhSQ ~ Разница между максимумом и минимумом
                                        из списка ввода.
          сумма Посчитайте количество правдивых результатов.
        + Z ~ Добавить 0.
      . + ~ Получить дельты.
    _M ~ Получает -delta для каждой дельты в списке выше.
  \ # ~ Буквенный символ "#".
* R ~ Векторизация умножения. При желании вы можете
                                    используйте j, чтобы присоединиться к новым строкам (как это делает ссылка).
                                  ~ Вывод неявно.

Древесный уголь , 31 байт

≔Ｉ⪪Ｓ,θＥχ×#ΣＥθ⁼ι⌊⟦⁹⌊×χ∕⁻λ⌊θ⁻⌈θ⌊θ

Попробуйте онлайн! Ссылка на подробную версию кода. Ввод списков переменной длины кажется немного неудобным в Charcoal, поэтому мне пришлось обернуть список в массив, содержащий строку. Объяснение:

   Ｓ                            Input string
  ⪪ ,                           Split on commas
 Ｉ                              Cast elements to integer
≔    θ                          Assign to variable q
      Ｅχ                        Map from 0 to 9
           Ｅθ                   Map over the list
                      ⁻λ⌊θ      Subtract the minimum from the current
                          ⁻⌈θ⌊θ Subtract the minimum from the maximum
                     ∕          Divide
                   ×χ           Multiply by 10
                  ⌊             Floor
               ⌊⟦⁹              Take minimum with 9
             ⁼ι                 Compare to outer map variable
          Σ                     Take the sum
        ×#                      Repeat # that many times
                                Implicitly print on separate lines

Фортран 2003, 263 байта

Я написал его на GNU gfortran 5.4.0 и скомпилировал без каких-либо дополнительных флагов.

Он читает из STDIN по одному значению за раз и печатает в STDOUT.

Здесь это идет:

программа h; реальная, размещаемая :: a (:); символ f * 9; allocate (a (0)); do; read (*, *, end = 8) r; a = [a, r]; enddo; 9 формат ("(", i0, "(" "#" "))")
8 a = (a-minval (a)) + эпсилон (1.); A = потолок (10 * a / maxval (a)); do i = 1,10; j = количество (a == i); если (J == 0) печать *, если (J == 0) цикл; записи (е, 9) J;
печать f; enddo; конец

Нецензурное объяснение: (Я не знаю, может ли «гольф» применяться к фортрану, но в любом случае: P)

программа h
реальный, выделяемый :: a (:)! Создайте выделяемый массив, чтобы мы могли динамически перераспределять
символ f * 9! Массив символов для форматирования вывода
выделить (а (0))! Сначала выделите «а»
делать
  читать (*, *, end = 8) r! Читайте из STDIN. Если EOF, идет к 8, в противном случае
  a = [a, r]! Добавляется к "а"
ENDDO
9 формат ("(", i0, "(" "#" "))")! Метка формата
8 a = (a-minval (a)) + эпсилон (1.)! (8) Нормализует (добавляет эпсилон, чтобы избежать индексации нуля)
a = потолок (10 * a / maxval (a))! Нормализация и умножение на количество бинов
сделать я = 1,10! Цикл на всех бункерах
  j = считать (a == i)! Подсчет количества вхождений
  если (j == 0) напечатать *! Если нет, печатает пустую строку
  если (j == 0) цикл! И пропускает остаток цикла
  написать (е, 9) j! В противном случае записывает количество (j) для печати этикетки
  печать F! И печатает на STDOUT
ENDDO
конец

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

Perl 5 , 85 + 1 ( -a) = 86 байт

@F=sort{$a<=>$b}@F;map$r[($_-$F[0])/($F[-1]-$F[0])*10].='#',@F;$r[9].=pop@r;say for@r

Попробуйте онлайн!

Perl 5, 84 + 19 (-MList :: Util = min, max) байтов

$s=-($m=min@_=@ARGV)+max@_;$a[($_-$m)*10/$s]++for@_;$a[9]+=pop@a;print"#"x$_,$/for@a

Попробуйте онлайн

Perl 5, 102 байта

$l=(@n=sort{$a<=>$b}<>)[-1]-($f=$n[0]);$m=$f+$l*$_/10,say'#'x(@n-(@n=grep$_>=$m,@n))for 1..9;say'#'x@n

Попробуйте онлайн .

Ungolfed:

my @n = sort { $a <=> $b } <>;
my $f = $n[0];
my $l = $n[-1] - $n[0];
for (1 .. 9) {
    my $m = $f + $l * ($_ / 10);
    my $c = scalar @n;
    @n = grep { $_ >= $m } @n;
    say('#' x ($c - scalar @n));
}
say('#' x scalar @n);

Java (OpenJDK 8) , 246 221 209 207 206 163 162 161 157 байт

l->{String x="";double b=l[0],m=b,q,i;for(double d:l){b=d<b?d:b;m=d>m?d:m;}for(i=(m-b)/10,q=b;q<m;q+=i,x+="\n")for(double d:l)x+=d>=q&d<q+i?"#":"";return x;}

Попробуйте онлайн!

q / kdb +, 52 байта

Решение:

{sum[t=/:bin[m+.1*(t:(!)10)*max[x]-m:min x;x]]#'"#"}

Попробуйте онлайн! (Обратите внимание, что канал TIO - это 44-байтовый порт K (oK) этого решения, поскольку для q / kdb + нет TIO).

Примеры:

q){sum[t=/:bin[m+.1*(t:(!)10)*max[x]-m:min x;x]]#'"#"}1 0 0 0 0 0 0 0 0 0f
"#########"
""
""
""
""
""
""
""
""
,"#

q){sum[t=/:bin[m+.1*(t:(!)10)*max[x]-m:min x;x]]#'"#"}9014 9082 9077 9068 8866 8710 9049 8364 8867 9015 9064 9023 9024 8804 8805 8800 8744 8743 8714 9076 8593 8595 9075 9675 8968 8970 8711 8728 8834 8835 8745 8746 8869 8868 9073 9074 9042 9035 9033 9021 8854 9055 9017 9045 9038 9067 9066 8801 8802 9496 9488 9484 9492 9532 9472 9500 9508 9524 9516 9474 8739 9079 8900 8592 8594 9053 9109 9054 9059f
,"#"
"####"
"#########"
"############"
"######"
"#########################"
""
""
"###########"
,"#"

Объяснение:

Большая часть кода используется для создания сегментов, в которые binпомещаются входные данные.

{sum[t=/:bin[m+.1*(t:til 10)*max[x]-m:min x;x]]#'"#"} / ungolfed solution
{                                                   } / lambda function with implicit x as parameter
                                               #'"#"  / take (#) each-both "#", 1 2 3#'"#" => "#","##","###"
 sum[                                         ]       / sum up everything inside the brackets
         bin[                              ;x]        / binary search each x in list (first parameter)
                                    m:min x           / store minimum of list x in variable m
                             max[x]-                  / subtract from the maximum of list x
                  (t:til 10)*                         / range 0..9 vectorised multiplication against max delta of list
               .1*                                    / multiply by 0.1 (aka divide by 10)
             m+                                       / minimum of list vectorised addition against list
     t=/:                                             / match each-right against range 0..9 (buckets)

Желе , 19 байт

_Ṃµ÷Ṁ×⁵Ḟ«9ċЀ⁵Ḷ¤”#ẋ

Попробуйте онлайн!

Это основано на моем ответе APL на исходную проблему, который я опубликую после завершения этого конкурса.

Как? (Я не умею объяснять вещи)

_Ṃµ÷Ṁ×⁵Ḟ«9ċЀ⁵Ḷ¤”#ẋ
_Ṃ                  = subtract the minimum
  µ                 = Sort of like a reverse-order compose
   ÷Ṁ               = divide by the max
     ×⁵             = Multiply by 10
       Ḟ            = Take the floor
        «9          = x => min(x,9)
          ċЀ⁵Ḷ¤    = count occurrences of [0,...,9]
                ”#ẋ = create the list