APL CodeGolf 의 가을 토너먼트 의 홀 1입니다 . 나는 거기에서 문제의 원래 저자이므로 여기에 다시 게시 할 수있었습니다.

숫자 목록이 주어지면, #같은 크기의 열 그룹 각각에 몇 개의 숫자가 들어가는가에 대한 가로 막대 그래프 문자를 만드십시오. 예를 들어, 데이터의 범위가 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] 제공합니다 :

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

파이썬 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)

온라인으로 사용해보십시오!

파이썬 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='')

온라인으로 사용해보십시오!

링크는 쉼표로 구분 된 입력을 사용하는 코드 버전에 연결됩니다. 이 버전은 공백으로 구분됩니다.

stdin에서 읽고 stdout으로 인쇄합니다.

R은 고품질의 결과를 제공하기 위해 최선을 다하는 통계 프로그래밍 언어이며 때로는 실망 스럽습니다.

hist입력을 breaks두 번째 인수로 히스토그램에 넣습니다 . 일반적으로 나누기 횟수를 10으로 지정할 수 있습니다. 실제로는 다음과 같습니다.

breaks

다음 중 하나 :

• 히스토그램 셀 사이에 중단 점을 제공하는 벡터
• 중단 점 벡터를 계산하는 함수
• 히스토그램에 대한 셀 수를 제공하는 단일 숫자
• 셀 수를 계산하는 알고리즘의 이름을 지정하는 문자열 ( '세부 사항'참조)
• 셀 수를 계산하는 함수.

(강조 추가).

그러나 다음 문장은 다음과 같이 말합니다.

마지막 세 경우의 숫자는 단지 제안 일뿐입니다. 중단 점이 pretty값 으로 설정 되므로 숫자가 제한됩니다 1e6(더 큰 경우 경고와 함께).

그래서 나는 문서를 보았고 pretty상황에 따라 작동하지 않습니다.

n+1의 값 범위를 포함하는 약 간격이 같은 '라운드'값 의 시퀀스를 계산합니다 x. 값은 10의 거듭 제곱의 1, 2 또는 5 배가되도록 선택됩니다.

단순히하지 않습니다.

그렇게 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<=#&]]])&

온라인으로 사용해보십시오!

자바 스크립트 (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>

파이썬 2 , 126121 바이트

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 ~ var d를 사용하여 [0, 10)에 매핑합니다.
           m Q ~ var k를 사용하여 입력을 매핑합니다.
            g ~ 이상입니까?
             k ~ 입력의 현재 요소 k.
              + hSQ * dc-eSQhSQT ~ 다음과 같이 세분화합니다.
               hSQ ~ 입력 목록의 가장 낮은 요소입니다.
              + ~ 플러스 :
                  * dc-eSQhSQT ~ 우리는 이것을 더 많은 조각으로 나눌 것입니다.
                  * ~ 곱셈.
                   d ~ [0, 10)의 현재 요소, d.
                    c T ~ 10의 부동 소수점 나누기 :
                     -eSQhSQ ~ 최대 값과 최소값의 차이
                                        입력 목록의.
          s ~ 합계 진실한 결과의 수를 세십시오.
        + 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; 할당 (a (0)); do; 읽기 (*, *, end = 8) r; a = [a, r]; enddo; 9 형식 ( "(", i0, "(" "#" "))")
8 a = (a-minval (a)) + epsilon (1.); a = 천장 (10 * a / maxval (a)); do i = 1,10; j = count (a == i); if (j == 0) 인쇄 *; if (j == 0) 사이클; 쓰기 (f, 9) j;
인쇄 f; 끝; 끝

Ungolfed 설명 : ( "golfed"가 포트란에 적용될 수 있는지는 모르겠지만 : P)

프로그램 h
실제, 할당 가능 :: a (:)! 할당 가능한 배열을 생성하여 동적으로 재 할당 할 수 있습니다
캐릭터 f * 9! 출력을 형식화하는 문자 배열
assign (a (0))! 처음에는 "a"를 비 웁니다.
하다
  read (*, *, end = 8) r! STDIN에서 읽습니다. EOF이면 8이되고 그렇지 않으면
  a = [a, r]! "a"에 추가
Enddo
9 형식 ( "(", i0, "(" "#" "))")! 형식 레이블
8 a = (a-minval (a)) + 엡실론 (1)! (8) a를 정규화합니다 (0 인덱싱을 피하기 위해 엡실론 추가)
a = 천장 (10 * a / maxval (a))! 구간 수의 정규화 및 곱하기
i = 1,10하세요! 모든 쓰레기통에 반복
  j = count (a == i)! 발생 횟수 계산
  if (j == 0) print *! 없는 경우 빈 줄을 인쇄합니다
  if (j == 0) 사이클! 그리고 나머지 루프는 건너 뜁니다
  쓰기 (f, 9) j! 그렇지 않으면 카운트 (j)를 인쇄 레이블에 씁니다.
  f를 인쇄하십시오! 그리고 STDOUT에 인쇄
Enddo
종료

재미있는 사실 : 나는 어제 Weibull 난수 생성기의 구현을 테스트하기 위해 비슷한 코드를 만들었으므로 약간의 적응 만 필요했습니다. :)

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

온라인 시도

펄 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

온라인으로 사용해보십시오 .

언 골프 드 :

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

자바 (오픈 JDK 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]]#'"#"}

온라인으로 사용해보십시오! ( q / kdb +에 대한 TIO가 없으므로 TIO 링크는 이 솔루션 의 44 바이트 K (oK) 포트입니다).

예 :

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