10行の棒グラフ

13

これは、APL CodeGolfのThe Autumn Tournamentの Hole-1 です。私はそこで問題の原作者であるため、ここに再投稿することができます。

数字のリストが与えられたら、#10個の同じサイズのグループのそれぞれに適合する数字の数を示す横棒グラフを作成します。たとえば、データの範囲が0〜100の場合、範囲は0〜9.9、10〜19.9、…、90〜100です。（正式には、[0,10）、[10,20）、…、[90,100]。）。少なくとも2つの数字があり、すべての数字が同じであるとは限りません。

例：

[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] 与える：

#############             
######################    
##########################
######################### 
######################### 
#                         
########                  
################          
########################  
##########################
code-golf  ascii-art  classification  statistics  apl 
— アダム
ソース
3
それで、最後のグループは少し大きいですか？最初の例のように、それは[0.9,1]（ではなく[0.9,1)）でしょうか？
— フェリックスパルメン
@FelixPalmenのような。無限に小さい量だけ大きくなります。
— アダム
[OK]を、知ることは重要なことは、それはだということでした確かに最後の両方のエンドポイントを含むべきであるグループ、感謝
— フェリックスPalmen
@FelixPalmenああ、私はそれがOPで完全に明確ではなかったことがわかります。私はそれを編集します。
— アダム
1
@Adám代わりに逆にする必要がありますか？上部の行である[0,1)のみを含む0最下行している間[9,10]の両方を含む9と10。
— user202729

回答:

4

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は、高品質の結果を得るために最善を尽くす統計的プログラミング言語です。

histbreaks2番目の引数として、入力をヒストグラムにビン化します。通常、ブレークの数が10になるように指定できると期待されます。実際、これが当てはまります。

breaks

の一つ：

  • ヒストグラムセル間のブレークポイントを与えるベクトル、
  • ブレークポイントのベクトルを計算する関数、
  • ヒストグラムのセル数を示す単一の数値、
  • セルの数を計算するアルゴリズムを命名する文字列（「詳細」を参照）
  • セルの数を計算する関数。

（強調を追加）。

ただし、次の文は次のとおりです。

最後の3つのケースでは、数字は単なる提案です。ブレークポイントはpretty値に設定されるため、数は制限されます1e6（大きい場合は警告が表示されます）。

だから私はのドキュメントを見て、pretty私たちの状況ではうまくいきません。

n+1の値の範囲をカバーする、ほぼ等間隔の「ラウンド」値のシーケンスを計算しxます。値は、10の累乗の1、2、または5倍になるように選択されます。

それは単にしないでしょう。

したがって、seq(min(x),max(x),,11)はbreaks、として11個の等間隔のポイントを指定しhist(x,breaks,r=F)$c、カウントを与えr=F、ビンが右開間隔であることを保証し、forループが残りを処理します。

— ジュゼッペ
ソース
3

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

オンラインでお試しください！

— フェリックス・パルメン
ソース
kグローバル（+ 1byte）として作成できますが、0に初期化されるため、から3バイトを節約できますk=0。
— user202729
また、あなたは切り替えることができますdoubleにfloatしてlfにf別の2バイトで保存、。（少なくともTIO上で動作する）
— user202729
@ user202729最初のコメント：いいえ、この初期化は外側のループ内で複数回必要です。floatかもしれない仕事、それはCに「標準」の浮動小数点型ではないと精度が減少するので、必ずこれが許可されていないので、私は...それを使用していませんでした
— フェリックスPalmen
— ceilingcat
3

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


オンラインでお試しください！

— J42161217
ソース
どのように機能しますか？TIOにはテキスト出力のみがあります。（「デニスはそれを修正します」の部分に返信）
— user202729
1
@ user202729私はこれを知らないと本当に信じますか？または...
— J42161217
2
気分を害するものではありませんが、Range[0,9]私が話をしている間にRange[0,10]理由はありません。しかし、実際には失敗しRange[0,10]ます：TIO。
— user202729
4
<=両端で使用しました。これは最後のセグメントで正しいが、他の9つのセグメントでは正しくありません。
— user202729
3
@ user202729ちょっと！これは、Range [0、n] = {0、.. n}という以前の情報と同じくらい助けてくれました。素晴らしいアドバイスを得るために+1。とにかくコードが正常に動作します
— J42161217
3

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>
スニペットを展開

— edc65
ソース
割り当てをi配列括弧に移動してコンマを続けることで、数バイトを保存できるはずです。これにより、マップ関数の本体の括弧を削除できます。オンラインで試してみてください！
— ジャスティンマリナー
@JustinMariner右、thx
— edc65
エイリアスiを使用Math.minして、削除して再度使用すると、実際にもう1バイトを保存できます。オンラインで試してみてください。
— ジャスティンマリナー
2

ゼリー、21バイト

モナドリンクは文字列のリストを返します。

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

オンラインでお試しください！

— user202729
ソース
行のリストを返すことは許可されていますが、表示される結果は決して分離されていません。それが有効かどうかはわかりません。
— user202729
それはJellyが文字列のリストを扱う方法だからです。結果を視覚化するために、フッターを追加するÇŒṘかÇY、フッターに追加できます。また、完全なプログラムの代わりに、あなたの提出物は単項リンクであると言うことができ、それは印刷ではなく戻り、自動的に有効にします。
— ミスターXcoder
2

パイス、 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で入力をマッピングします。
            g〜以上ですか？
             k〜入力の現在の要素、k。
              + hSQ * dc-eSQhSQT〜これを細分化します：
               hSQ〜入力リストの最下位要素。
              +〜プラス：
                  * dc-eSQhSQT〜これをさらに細かく分割します。
                  *〜乗算。
                   d〜[0、10）の現在の要素、d。
                    c T〜次の10による浮動小数点除算：
                     -eSQhSQ〜最大値と最小値の差
                                        入力リストの。
          s〜合計。真実の結果の数を数えます。
        + Z〜0を追加します。
      。+〜デルタを取得します。
    _M〜上記のリストの各デルタについて-deltaを取得します。
  \＃〜リテラル文字「＃」。
* R〜ベクトル化された乗算。オプションで、次のことができます
                                    jを使用して、（リンクが行うように）改行で結合します。
                                  〜暗黙的に出力します。
— Mr. Xcoder
ソース
2

炭、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
— ニール
ソース
2

Fortran 2003、263バイト

GNU gfortran 5.4.0で作成し、追加フラグなしでコンパイルしました。

一度に1つの値をSTDINから読み取り、STDOUTに出力します。

ここに行きます：

プログラムh; real、allocatable :: a（:); character f * 9; allocate（a（0））; do; read（*、*、end = 8）r; a = [a、r]; enddo; 9 format（ "（"、i0、 "（" "＃" "））"）
8 a =（a-minval（a））+ epsilon（1。）; a = ceiling（10 * a / maxval（a））; do i = 1,10; j = count（a == i）; if （j == 0）print *; if（j == 0）cycle; write（f、9）j;
print f; enddo; end

非ゴルフの説明：（「ゴルフ」がfortranに適用できるかどうかはわかりませんが、どちらの方法でも：P）

プログラムh
real、allocatable :: a（:)！動的に再割り当てできるように、割り当て可能な配列を作成します
文字f * 9！出力をフォーマットする文字配列
allocate（a（0））！最初に空の「a」を割り当てます
行う
  read（*、*、end = 8）r！STDINから読み取ります。EOFの場合は8に、それ以外の場合は8
  a = [a、r]！「a」に追加します
終わり
9 format（ "（"、i0、 "（" "＃" "））"）！フォーマットラベル
8 a =（a-minval（a））+ epsilon（1。）！（8）aを正規化します（ゼロインデックス付けを回避するためにイプシロンを追加します）
a = ceiling（10 * a / maxval（a））！ビンの数による正規化と乗算
i = 1,10を実行します！すべてのビンでループする
  j = count（a == i）！出現回数を数える
  if（j == 0）print *！存在しない場合は、空の行を出力します
  if（j == 0）cycle！そして、ループの残りをスキップします
  write（f、9）j！それ以外の場合、count（j）を印刷ラベルに書き込みます
  プリントf！STDOUTに出力します
終わり
終わり

おもしろい事実：昨日、ワイブル乱数ジェネレーターの実装をテストするために同様のコードを作成しました。

— フェリペ・オレニック
ソース
1

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

オンラインでお試しください。

ゴルフをしていない：

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);
— デニス・イバエフ
ソース
1

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)
— ストリートスター
ソース
0

ゼリー、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
— ザカリー
ソース
弊社のサイトを使用することにより、あなたは弊社のクッキーポリシーおよびプライバシーポリシーを読み、理解したものとみなされます。
Licensed under cc by-sa 3.0 with attribution required.