プログラミングのお題スレ Part13
レス数が1000を超えています。これ以上書き込みはできません。
お題1: 現在地の緯度、経度を出せ
緯度:、、、、
経度:、、、、
お題2: 東京都新宿区西新宿2丁目8-1 の緯度、経度を出せ
緯度:、、、
経度:、、、
お題3: お題2で求めた緯度経度から住所を出せ
郵便番号:、、、
住所:東京都、、、、 >>2 python (pythonista)
#お題1
import location
location.start_updates() # GPSデータ更新を開始
gps=location.get_location() # GPSデータを取得する
location.stop_updates()# GPSデータ更新を終了
print('お題1')
print('緯度:'+str(gps['latitude']))
print('経度:'+str(gps['longitude']))
#お題2
address_dict = {'Street': '西新宿2丁目8-1'}
gc = location.geocode(address_dict)[0]
print('お題2')
print('緯度:'+str(gc['latitude']))
print('経度:'+str(gc['longitude']))
#お題3
adr = location.reverse_geocode(gc)[0]
#print(adr)
print('お題3')
print('郵便番号:'+str(adr['ZIP']))
print('住所:'+str(adr['State'])+str(adr['City'])
+str(adr['Street']))
#結果
お題1
緯度:35.7----略
経度:139.6---略
お題2
緯度:35.689504
経度:139.6916833
お題3
郵便番号:160-0023
住所:東京都新宿区西新宿2丁目8番1号 平方数の判定は、たとえばmod 10だと、
1と4と5と6と9に限るってのを利用すると、違う場合は判定が速いんだろ。
mod n で複数やる。
1=1^2
4=2^2
9=3^2
6=4^2
5=5^2
6=6^2
9=7^2
4=8^2
1=9^2 >>4
平方根求められる関数と、少数を整数にする関数があれ 途中で送っちゃった。。。
あれば簡単。
def isSqr(x):
if sqrt(x) - int(sqrt(x)) == 0:
return True
else:
return False
def sqrt(x):
return (x ** 0.5) >>7 ならば
a=12345.678*12345.678
print('答え',a == (a**0.5) **2)
#結果 True たとえば1000桁のを1000回、判定するとかsqrtでは時間かかるやつの高速化だろ >>8
なにが「ならば」か分からんけど。。。
引く必要なかったし、ifの中身をそのまま返せば良かった。
def isSqr(x):
return (sqrt(x) == int(sqrt(x))) >>9 だったらそういう問題の出し方にしないと。
例えば、1から1億までの間の数字で平方根数は何個あるか。 かかった時間と、PC 環境を示せ
また、処理できる最大に近い数字を示せ。
とかかな。 浮動小数経由する実装だと整数部が53bit超えると判定出来ない(つまり64bit整数以上だと不適切)
だから自前で浮動小数を経由せずに平方根の整数部分を求めることを考えるわけだけどナイーブにやると計算量が線型になるから二分探索やNewton(-Raphson)法で計算量減らすことを考えるわけだ >>13
>>7で64ビット以上の数も判定出来てるけど。。。
(0が偶数ならTrue、奇数ならFalse)
小数点以下が0か(n.0かn.41421356みたいな形か)どうか見てるだけだし。
この辺はsqrt関数の性能に依存するだろうけど。
n = 100000000000000000000
m = 10000000000000000000
print(isSqr(n))
print(isSqr(m))
出力
True
False >>14
100000000000000000001がtrueになったりはしない？ >>14
無能
たまたま判定出来るケースだけ抽出してるだけじゃねぇか >>13 それもわかる。 だったら解き方の最初にこういう目的で解いたとか書かないとね。
だから、解ける最大数値も書いたら良いと書いたんだが。
ちなみに、>>1 の1億までの数字は、iPhoneで28秒だった。
>>15 False になるよ。iphone のpythonista
また、言われたようにバイナリサーチ法や、巨大数のバイナリー検索も試してみたが、単純検索よりずっと時間がかかった。 ま、これは言語にもよると思うから何とも言えないが。 スクリプト系はステップ数が短い方が効率は良さそうだな。
>>18 だからさ、どこまでやるか条件を出せよ。 そしてサンプルを示してみたら？ 実行時間も入れて。
プログラムと言うのは、使う現場で目的が違うんだから目的がわからなければ良い悪いなんて言えないだろ。 アホ過ぎて話になんねー
線型探索と二分探索のどっちが速いかが言語によるとか頭腐ってんのか
線型探索: ttps://ideone.com/De3SOQ
二分探索: ttps://ideone.com/v9Twjx >>19
寝てる間にフォローありがとう。
>>15
こっちはiPhoneのモバイルC内蔵のPythonだが、trueなった。
Haskellは63ビットだからかもう少し早い段階でなる。
ただ、>>19 の言う通り実用上問題無いのでは。
(階乗と違って入力より巨大な数が帰るわけじゃないし、Cとかだと十分実用かと)
64ビットまでの数では効率的なバージョンと、それ以上の数も対応するバージョンという感じではどうか。
sqrtも、n乗根は似た作りになるし。
# n√x
def sqrtn(n,x):
return (x ** (1/n)) どちらかと言うと**演算子(Cで言うpower関数)の実装に興味あるな。 CRC 16bit 左送り 初期値 0x0000 生成多項式0x11021
テーブル使用せず演算でなるべくスマートに 平方数 64ビット以上の巨大数
pythonista iPhone XS Max
def chk2(v1,v2):
c = 0
for i in range(v1, v2+1):
if i == (i**0.5) **2: c += 1
return c
v = 100000000000000000000
r = 10000000
v1= v-r
v2= v+r
start_time=time.clock()
c = chk2(v1,v2)
end_time=time.clock()
print('#結果',end_time-start_time,'秒','count=',c)
print('#範囲 ',v1,v2)
#結果 5.777779999999893 秒 count= 525
#範囲 99999999999990000000 100000000000010000000 >>26 同じ条件でバイナリサーチをやってみると若干だけ早かったが、誤差の範囲
#結果 5.770102000000406 秒 count= 525
#範囲 99999999999990000000 100000000000010000000 >>26-27
99,999,999,999,990,000,000~100,000,000,000,010,000,000の範囲には10,000,000,000しかないんだからcount=525ってのは演算誤差が出てるってことだよな？
99,999,999,980,000,000,001 (9,999,999,999^2)
100,000,000,020,000,000,001 (10,000,000,001^2) いや、intにしてないからそれを調べてるってわけじゃないのか >>28 言われてみればフロートまでカウントするのはおかしいから判定を変えた。
for i in range(v1, v2+1):
if (i**0.5).is_integer(): c += 1
return c
Core i3 3.2GHz Windows10 python3.7
#結果 8.15625 秒 count= 49151
#範囲 99999999999990000000 100000000000010000000
iPhoneの方が倍くらい早いかな。
#結果 4.180858 秒 count= 49151
Core i7のマシンもあるが大して期待できなさそうだな。
検算の意味で、1から1000までをカウントして31だったから正しいだろう。
なお、Python3の整数int型に最大値はない（上限なし）からどんな数でも扱える。 >>30
これ(count=49151)って99999999999999975424から100000000000000024575 (64bit浮動小数点数の16進表記で0x4415AF1D78B58C3Fから0x4415AF1D78B58C41)の平方根が、
10000000000 (64bit浮動小数点数の16進表記で0x4202A05F20000000)になって全部Trueになってるってことだろ 99,999,999,980,000,000,001 = 999,999,999^2
100,000,000,000,000,000,000 = 10,000,000,000^2
100,000,000,020,000,000,001 = 10,000,000,001^2
なんだから[99'999'999'999'990'000'000, 100'000'000'000'010'000'000]の区間に入る平方数はただ一つ100,000,000,000,000,000,000しかない
「32bit符号なし整数にしか対応してません」っつうなら分かるがまともに判定出来てないのに「判定出来てる」主張する無能
やれ前提書けだの環境書けだの時間書けだのクソみてぇな御託並べる前に自分の頭の悪さを自覚しろ >>34 申し訳ない。 2～3日前にpython をiPhoneに入れて使い始めてただただ練習のためにお題を使わせてもらってた。
整数と、浮動小数の最大値にまで頭が回らなかった。
今日初めてWindowsにpythonを入れた状態で本当に気が回らなかった。
本当に申し訳ない。
バイナリサーチの方は1個と出るが、時間が膨大にかかる。 自然数の割り算関数mydivと余り関数mymodを作れ。 >>36
これでいいの？javascript
const myDiv = (a, b) => ~~(a / b)
const myMod = (a, b) => a % b modをみる
nが平方数なら、n=x^2 だが、n=x^2 (mod m)でもある
逆にmod で平方数でなければ、元々も平方数ではない
mod 3だと0 1 は平方数だが、2はちがう。3i + 2 は平方数にはならない >>38
元は小学生にプログラミングを通じて、割り算への理解を深めてもらえないかと考えたんで、単純に演算子を置き換えて欲しくないかも。。。 小学生の時テストで0点をもらった間違った割り算の
やり方をプログラムにしてみた。
--Lua
function myDivMod(a, b)
local r = 0
while a > 0 do
a = a - b
r = r + 1
end
return r, -a
end
print(myDivMod(10,3))
実行結果
4 2 >>35 結局 整数のsqrt を作って、範囲の中に納まる最小最大の整数のsqrt を取り出し、その差（+1）がその範囲の中にある平方数の個数と言う作りにした。
ポイントとなった整数のsqrt が秀逸だったのでここに書いておく。 どんなに巨大な数字でも数回のシフト操作だけで終わるから極端にスピードが速い。
ソースは、gist.github.com/bnlucas/5879594
# integer square root
def isqrt_2(n):
if n < 0:
raise ValueError('Square root is not defined for negative numbers.')
x = int(n)
if x == 0:
return 0
a, b = divmod(x.bit_length(), 2)
#divmod(a, b)は(a // b, a % b)のタプルを返す。
#平方数は半分のビット数以下だからそれを最大値で計算開始
n = 2 ** (a + b)
while True:
y = (n + x // n) >> 1 #1bit右にシフト
if y >= n:
return n
n = y
-----------------
#結果 0.0 秒 count= 1000000000
#範囲 999999999000000000000000000000000000 1000000001000000000000000000000000000
#入力bit_length()=120 入力bit_length()=120
平方数範囲 999999999500000000 1000000000499999999
上の二乗 999999999000000000250000000000000000 1000000000999999998249999999000000001 掛け算は簡単だけど除算は結構面倒
ttps://ideone.com/EheeYM >>42 の isqrt_2 を使ったパフォーマンステスト。
次のようなのを継ぎ足してテストした。 例によってインデント部は全角空白に変換してるから、逆変換しないと動かない。
def isSqrt(n):
return n == isqrt_2(n)**2
v0 = 12345678901234567890
v = v0**2 # 整数平方される対象の数値
loopc = 100000 # をこの回数繰り返す。
isqr=0
start =time.process_time()
for i in range(loopc): isqr=isqrt_2(v)
end =time.process_time()
print('#整数平方(v)の結果',end-start,'秒')
print(' 繰返し数の回数',loopc),print(),print('#v0 ',v0)
print('#v=v0**2=',v),
print('#isqrt(v)',isqr)
print('#上の**2',isqr**2)
print('対象数vのビット数',v.bit_length(),'bit')
print('vが平方数かどうかの判定',isSqrt(v))
-----
#整数平方(v)の結果 0.22398700000002236 秒
繰返し数の回数 100000
#v0 12345678901234567890
#v=v0**2= 152415787532388367501905199875019052100
#isqrt(v) 12345678901234567890
#上の**2 152415787532388367501905199875019052100
対象数vのビット数 127 bit
vが平方数かどうかの判定 True >>45 同じ条件で2分探索法でやると 5.5秒かかった。 Wikipediaに Integer square root
https://en.wikipedia.org/wiki/Integer_square_root
があり、その中の 2.1 Using bitwise operations
の二つを試してみたが、
最初のrecursive call を使った方が 1.65秒
次の方が 2.05秒
早いことは早いが、>>42 >>45 のビットシフト法の方がかなり早い。
0.22秒
gmpのisqrt は早そうだが Pythonistaでは使えないので試していない。 >>4 そう言う記述を度々見るんだが、具体的なプログラムを提示してくれない？ なんでも放題にすればいい
お題
平方数は 256で割るとあまりの
パターンが44種類になるという。
この44種類を求める。 python
{(x**2) % 256 for x in range(0,256)} Ruby
p 0x100.times.map{|i| i*i&0xFF}.uniq.sort
# => [0, 1, 4, [...], 233, 241, 249] javascript
[...new Set(function*(){for(let i=0;i<256;i++)yield i*i%256}())].sort((a,b)=>a-b) >>50 その44種(mod256)の中に x%256 が一致するか
python
mod256=sorted({(i**2)%256 for i in range(256)})
x=123*123
print(x%256 in mod256)
# True
これでmod の話が理解できた。 要は完全な平方数じゃないのは平方根の計算をしないと言う話ね。 >>50 Perl5
%a = map{$_=>1} map{$_*$_%256} 0..256;
@a = keys %a;
print "@a\n";
実行結果
~ $ perl 13_50.pl | wc -w
44
$ perl 13_50.pl
137 89 161 57 1 4 100 17 36 49 121 64 68 144 201 177 65 185 16 9 193 169 129
105 196 132 25 73 249 209 33 233 225 97 41 81 241 164 145 228 217 0 153 113 >>50 Perl5 その2
use List::MoreUtils 'uniq';
@a = uniq map{$_*$_%256} 0..255;
print "@a\n"; >>49 有難う。
python だが、
# 256, 9, 5, 7, 13, 17 97
のmodであらかじめカットしたら、5倍くらい早くなった。
因みに >>50 のお題で
mod256=sorted({(i**2)%256 for i in range(256)})
と
modn = lambda n:set((i**2)%n for i in range(n))
mod256 = modn(256)
では下のsetを使った方が3割くらいスピードが速かった。 >>59
# 256, 9, 5, 7, 13, 17 97
なんて順番ははおかしいんじゃねと思って、
大きい順にカットしたら、更に2割以上早くなった。 >>50 J
64個の平方数を調べれば44種類のパターンはそろうようだ。
/:~ ~. 256| *: i. 64 お題
ある数 n とする。
下位から24bit区切りの数を足し合わせてからmod 2^24-1 した数が、元の数nのmod 2^24-1 と一致することを確認しなさい。 >>62
任意の n に対してある自然数 N, 自然数列{a_k} が存在して
n = Σ_{k = 0}^{N} a_k * 2^(24 * k) と書けるので mod 2^24 - 1 として
n = Σ_{k = 0}^{N} a_k * 1^k
= Σ_{k = 0}^{N} a_k ■ >>59,60
256はmodじゃなくて&255を取る
確率的には大きい順じゃなくて9,97,17,13,7,5が良いのでは？
9,97,17,13,7,5でmodを取る場合、大きい数からそのままmodを取るのではなく2^48-1でmodを取った数値に対してmod
これで速度どうなる？ mod 255にしたら遅くなるんじゃねーの
0 < n mod 255 < 254
だぞ 0 <= n mod 255 <= 254 だった >>62 python
# n%(2**24-1) を求める
def mod224get(n):
bn=(n.bit_length()+7)//8 #byte長
bb=n.to_bytes(bn,'little')
s= sum([int.from_bytes(bb[i:i+3],'little')
for i in range(0,bn,3) ]) #24bit毎の合計
return s%(2**24-1)
v0=12345678901234567890
#v0=0
n=v0**2
loop = 100000
print('テスト範囲は ',n,'～',n+loop-1,'loop回数=',loop)
start =time.process_time()
for i in range(n,n+loop):
if mod224get(n) != n%(2**24-1) :print('間違い見っけ',n)
end =time.process_time()
print('全問正解 かかった時間は、',end-start,'秒')
#
―― 結果
テスト範囲は 152415787532388367501905199875019052100 ～ 152415787532388367501905199875019152099 loop回数= 100000
全問正解 かかった時間は、 0.2963889999999765 秒 >>64 アドバイスありがとう。 それは思ったんだけど、現代の言語がそんなところで手抜きはしていないだろうと信じてテストしていなかった。
今、&255 に変えてテストしてみたけど、スピードの差はなかった。 そう言う発想は昔は非常に重要だったけど、今は言語の中で吸収してるみたいだね。
その下のアドバイスに対しては、何故ご自分では試されないのですか？
あまりやるつもりはないのは、mod 2**24-1 と言うのが理解できていないからです。 これで早くなるのなら色々試してみたいんですが、このリストを作るだけでもかなりの時間がかかりめげてます。 >>70
剰余の順番に関しては確率がこんなんだからやで
3 / 5 = 0.600000
4 / 7 = 0.571429
4 / 9 = 0.444444
7 / 13 = 0.538462
9 / 17 = 0.529412
49 / 97 = 0.505155
テーブルは9, 97, 17, 13, 7, 5の物で良いんやで？
多倍長整数の剰余より32bit整数/64bit整数の剰余のほうが計算量が少ないから、
(32bitの場合) 2^24-1で剰余を取ったものに対して9, 17, 13, 7, 5の剰余で平方数かどうかを調べる
(64bitの場合) 2^48-1で剰余を取ったものに対して9, 97, 17, 13, 7, 5の剰余で平方数かどうかを調べる
なしてこんなことができるかってーと、
2^24-1(=16777215)の因数に5, 7, 9, 13, 17が、2^48-1(=281474976710655)の因数に5, 7, 9, 13, 17, 97含まれているからやで >>71 あまり深入りするつもりはないけど、mod 2**24-1 でチェックしたら、
mod 9, 97, 17, 13, 7, 5 でチェックする必要はないと言う事？
ま、数学を解いてるつもりは全くなく、プログラムの練習だからいかに沢山の人が素晴らしいプログラムを見せてくれるかにしか興味はない。
プログラムを書かない人は自分にとってはなんの意味もない。 >>72
ちゃうねん
mod 2**24-1をした数値に対してmod 9, 17, 13, 7, 5 でチェックするねん
もしくはmod 2**48-1をした数値に対してmod 9, 97, 17, 13, 7, 5 でチェックするねん >> 73
2重に剰余を取るのはGMPみたく多倍長なら意味があるけど, 32/64bit固定長ならあまり意味はない
複数回剰余を確認する必要があるから多倍長から固定長(32/64bit)にしていて, 更に因数を使えば剰余を求めるための除算の代わりに乗算が使えるから因数の多い2^24 - 1や2^48 - 1を採用してる >>62
ガウス少年が見出したように
Σ1,2,…,n-2,n-1＝n *(n +1) /2
なので、
n の mod 2^24-1
と
Σ1,2,…,n-2,n-1 ＝n *(n +1) /2 の mod 2^24-1
が等しいのは自明だと思うけど、
そういう、ちょっとした数学を使わず
Σ1,2,…,n-2,n-1
をloopで和を算出し mod 2^24-1 して比較する
n の mod 2^24-1 と比較する
プログラムを作れという題なんだろうか… >>75
「比較する」を二度書いちゃった、訂正
Σ1,2,…,n-2,n-1
の和をloopで算出し mod 2^24-1 して
n の mod 2^24-1 と比較する >>75 お題をよく読んだら？ 24bit = 3バイト毎に取り出してその合計に対して 2**24-1 をしなさいと言う問題だよ。
数学なんて関係ない。 ただ出されたお題をプログラムで解いてくれ。 >>75 ごめん
Σ1,2,…,n-2,n-1＝n *(n +1) /2
は間違えた。こうだ
Σ1,2,…,n-2,n-1＝n *(n -1) /2 ある数nのビット表記方法によって一致する／しないを答えればいいのかな >>62 Perl5
use bignum (l=>GMP);
use feature say;
sub sum24 {
my $v = $_[0];
if ($v > 0) {
my $d = int($v / 2**24);
my $m = $v % 2**24; # $v - $d * $f6;
$m + sum24($d);
} else {
0;
}
}
$n = 12345678901234567890;
say $n % (2**24 -1);
say sum24($n) % (2**24 -1);
実行結果
~ $ perl 13_62.pl
13189905
13189905 >>81
8行目後半の#から右
# $v - $d * $f6;
は削除し忘れたcommentです ｽﾏｿ >>83 自明もへったくれもない。 プログラムが正しいかどうかの確認だよ。
プログラムも書かないで能書きだけ垂れてもなんの足しにもならない。 ここはプログラムのお題スレだよ。
>>62 のお題は前スレのGMP の整数平方根の説明の文章の中から取り出したもの。
つまり、ここまでできると、次は n**2%(2**24-1) のリストを作れと言うお題になるんだろうけど、時間がかかりすぎるからお題にするのはやめた。
このリストができないと実際の平方数の高速チェックが出来ないじゃん。 しかしここまで複雑な処理をして本当に早くなるのかどうか疑問だけどな。 mod 2**24-1 って結構時間がかかりそうな気がする。 >>85
一番能書き垂れてんのお前だろ
クソみたいな御託並べる前に自分のことを考えろっつったろうが
GMPが一体どこで
> n**2%(2**24-1) のリスト
なんか使ってんだ？91で割った場合のテーブルでさえ12byte必要だってのにどうやってそんな巨大なテーブル用意するんだ？
GMPの中身なんか数学の成果の塊だぞ？お前が数学したくないだか出来ないだか知らんがアルゴリズム考えるようなスレでクソみたいなこと喋ってんじゃねぇよ
お前はコードを書いても価値がない 単なるbitmaskで済まない様な場合
あるいは除算して剰余を求めるなら
さんざ研究されていると思うから自力で１から考える前に
先人の業績を知れってことだろ
ｱﾊﾞﾖ ﾉｼ お題：ポーカーダイス
通常のサイコロを5個振って出た目をポーカーの役になぞってそれぞれの出現確率を求める。
役は、5カード、4カード、ストレート、フルハウス、3カード、2ペア、1ペア、ブタ（ノーペア）
例えば出た目が 1,1,3,1,4 ならスリーカード。2,5,4,6,3 ならストレート。
5カードは6/(6^5)、4カードは(5*5*6)/(6^5)というように数学的に
求めても難しくはないのですが、ここはプログラミングのスレなので
全通り力技でチェックして求めてみてください。
解答例：C言語 https://ideone.com/4X62Am 6^5総当りせよってか…
native compiler系言語で力技か python3
https://ideone.com/k6Ea4j
最後の出力部分はpython 3.6以降だと
for k,v in hand.items(): print("{} :\n {} / 7776 ({} %)".format(k,v, round(100*v/7776,2)))
でいけるけど実行環境が3.5なのでやむなく なんか数学でもできる力技お題増えてきたな
もっとプログラミングじゃないとできないような良いお題無いんだろうか 確率の問題でも特定の疑似乱数と種を使った偏りを求めるとかは数学では難しい お題: 日本語文字とカッコ { } とスラッシュ(/)で構成された入力文字列Sが与えられる。{ }で囲まれ、かつ
スラッシュで区切られた部分文字列について、それぞれ場合分けを行って、複数の文字列のリストに展開して改行区切りで出力せよ。
カッコの対応が間違っている場合はERRORを出力せよ。
(例1) {ひまわり/あさがお}は{植物/花}です。
(出力結果)
ひまわりは植物です。
あさがおは植物です。
ひまわりは花です。
あさがおは花です。 なお、展開の順序については問わない。カッコがなくなるまで繰り返し展開せよ。 (1) {あ{いう/え}/お{か/き}/く}け{こ}
(2) さ{し/す}せそ{{た/ち}つ/て}と ヒント: まず、適当な場所でブツ切りにしてノードに分ける。 (1)の答え(※ソート済み)
あいうけこ
あいうけこ
あえけこ
あえけこ
おかけこ
おかけこ
おきけこ
おきけこ
くけこ
くけこ
くけこ
くけこ (2)の答え(※ソート済み)
さしせそたつと
さしせそちつと
さしせそてと
さしせそてと
さすせそたつと
さすせそちつと
さすせそてと
さすせそてと これでいいのか？
> (1) {あ{いう/え}/お{か/き}/く}け{こ}
あ いう け こ
あ え け こ
お か け こ
お き け こ
く け こ
> (2) さ{し/す}せそ{{た/ち}つ/て}と
さ し せそ た つ と
さ す せそ た つ と
さ し せそ ち つ と
さ す せそ ち つ と
さ し せそ て と
さ す せそ て と ごめんなさい。間違えました。重複は単一化して下さい。 単純に場所分けを樹木図で考えると重複ができるようだ。すみません。 お題：Aが真であるならばBが真である ことをプログラムしなさい。 バカなのか？AとBに因果関係があるわけじゃないし、この世の全てがプログラム言語でマッピングできるわけじゃない、数学徒は帰れ const A = true;
const B = A === true ? true : false;
console.log(B); >>113
If A = True Then
B = True
End if {あ{いう/え}/お{か/き}/く}けこ
あいうけこ
あえけこ
おかけこ
おきけこ
くけこ
さ{し/す}せそ{{た/ち}つ/て}と
さしせそたつと
さしせそちつと
さしせそてと
さすせそたつと
さすせそちつと
さすせそてと >>113
> Bが真である
をどう解釈するかによる
文字通りの解釈なら
If A Then Assert(B)
かな
Bを真にすると解釈するなら>>117が正解かな
>>116と>>119はAが偽の時にBを偽にしちゃうので誤りやね >>117も間違い。偽のときは未定義なんだからエラー吐かなきゃ Aが偽の時はエラー吐かなきゃいけないとかBを偽にしてはいけない
とかいうのは勝手な拡大解釈でしかない >>125
アホかお前
AならばBでAが偽ならばそれは真だっつーの
義務教育からやり直せよ >>128
> AならばBでAが偽ならばそれは真だっつーの
えっ、どういうことなの？
それは
AならばB
のとき
AでないならばB
ということ？
BはAに関わらず真ということ？
> AならばBでAが偽ならばそれは真だっつーの
の意味がよくわからん… >>129
論理としては A => B (AならばB)は対偶論理 ￢B => ￢A (BでないならばAでない)を成り立たせるために通常 ￢A∨B (AでないかまたはBである) で定義される
つまり A => B という論理式は A が偽であれば B の真偽に依らず真になる
だから何だという話ではある >>129
そう決まってるじゃん
前提が偽ならどんな推論でも導けるし真になる
論理学の初歩 「AならばB」
と言う命題は
「Aが真でBが真である
Aが偽であればBは真である」という命題の
上の文の３行目のはじめの部分をプログラムしろということだぞ A: 自然数 ： 1,2,3,・・・・・
B: 整数 ： ・・・・・ , -2,-1,0,1,2,3,・・・・・
AならばBである
AでなければBでもない
BでなければAでもない >>135 間違い
A: 自然数 ： 1,2,3,・・・・・
B: 整数 ： ・・・・・ , -2,-1,0,1,2,3,・・・・・
AならばBである
Aでなければ不定
BでなければAでもない >>130
ありがとうこれは分かりやすい。
高校出てないけど義務教育は真面目にやったんだがなぁ…こんなのあったっけ？ >>136
よくできました。
お題: ひらがなで与えられた五段活用動詞の五段活用を表示しなさい。
明らかに五段活用動詞でない場合は、ERRORと表示しなさい。 >>138
義務教育ではやらない
というか高校数学でも明示的に教えはしない(証明ではしばしば暗に使う)
そして大学の数学科では何をおいてもまず最初に学ぶ >>145
必要な感じがするのであれば高認受けて高卒と同等にでもなりなさい。昔の大検と違ってそれだけでも高卒扱いになる。
その後大学行くかどうかはご自由に。金と時間があまりないなら通信制ってのもあるよ。
この頃はネットの大学もあるな。よく知らんけど。
まあしかし既に社会人になって何十年も稼いできてしまった人の場合はもはやどうでも良い話かな。 >>138 理解したいと思った気持ちが大事。深入りの必要はない。
プログラムの世界というのは、客のニーズを知らなくてもなんでも解決しないといけないから、その時々で勉強するしかない。 実践の世界。
素地がある方が理解は早いとは思うが、気にすることは無い。
その時に必要なものを勉強すれば(理解できれば)良い。 全ての学問を習得するなんて不可能なんだから、学問なんてあまり気にしない方が良い。
ただ、論理的な思考訓練はやった方が良いとは思うが、大学でできるとは思わない方が良い。 ひたすらプログラムを続けた方が思考訓練になると思うぞ。 >>113 しかしさ、この日本語は日本語として成り立っていないんじゃないの？
日本語としても論理学としても
日本語の曖昧さを残したまま、お題にする方がおかしい。
これを自分の顧客に提示して見なさい。 バカじゃないのと言われるよ。 理解力がないと思われるだろうな。 >>132
その2つの意味後違うって言うならそうなるセマンティクスを提示してみせろや
「普通は」同等に扱うだろ チコ 「A->Bの意味も知らずにボーっとコードかいているんじゃねよ！」 >>99 Ruby
def hoge(str)
return str if str.match?(/\A[^{}\/]*\z/)
raise 'ERROR' if str.match?(/\A[^{]*}|{[^}]*\z/)
a, *b = str.scan(/(?<={|\A)[^{}]*(?=}|\z)/).map{|s| s.empty? ? [''] : s.split(?/)}
s = str.gsub(/(?:{|\A)[^{}]*(?:}|\z)/, '%s')
a.product(*b).flat_map{|e| hoge(s % e)}.uniq.sort
end
%w[
{あ{いう/え}/お{か/き}/く}け{こ}
さ{し/す}せそ{{た/ち}つ/て}と]
].each{|s| puts hoge(s), $/}
# =>
あいうけこ
あえけこ
おかけこ
おきけこ
くけこ
さしせそたつと
さしせそちつと
さしせそてと
さすせそたつと
さすせそちつと
さすせそてと >>133
＞「Aが真でBが真である
＞Aが偽であればBは真である」
完璧に間違っていますね…Aが偽であってBが偽であってもいいのです
あなた、もう馬鹿としかいいようがないですね、論理学の教科書が読めなかったの？いや、日本語が読めなかったの？
生きていること自体が罪悪といわずして何といえばいいのか…
死ね お題
print(a)
のように変数の宣言や代入なしで
使用するとどうなろか EXCELシート名が1文字のシートが数シートある。これをwindows10でVB6を使いデータベースで読み取ってみせよ。 >>154
だから>>134で４行目間違えたって書いてあるだろ
よく読め >>155
AならばBと
Aが真ならばBが真
が同じならば
AならばBと
Aが偽ならばBが真
と同じ
AならばBと
Aが偽ならばBが偽と
同じ
ということになるぞ？
これは同じじゃないから君の言ってることは
間違ってるということだな >>160
糞コテの肩は持ちたくないがなんだこのくっそみたいな日本語は
「AならばB」と「Aが真ならばBが真」が同値ならば
「AならばB」と「Aが偽ならばBが真」と「Aが偽ならばBが偽」が同値
って言いたいのか？
同値になるわけねえだろ
ABの真偽は4パターンしかねえんだから、いくらお前が無能でも全4パターンくらい考えてからレスしろよ
大体、任意の命題Pに対して「P」と「Pは真である」が同値にならないケースってなんだよ
馬鹿も休み休み言えよホント >>162
>>161に「よく考えたら同じだな」って書いてあるじゃん 「よく考えたらやっぱり同じだな」だけでは何と何が同じだと思ったのかわからない
悪びれた様子もなく前後の文脈からも推論不可
とてもまともとは思えない >>156 Lua
print(a)
実行結果
nil 言語とか使えるライブラリとか制限しないと
意味が無くなっている希ガス
言語指定した場合でも特定の文法を使っては
ならないとか制限加えると面白いものが
出来るような,,, >>165
お前の場合、わかりにくいんじゃなくてわかりえないの
日本語もおかしいし >>168
俺の文が不親切すぎたよな
ごめんねごめんねー >>167 制限なんかしなくてよいよ。 ライブラリが嫌いならあまりライブラリが使えそうにないお題を出せばよいだけだし。
例えば正規表現ライブラリなんて装備されていない言語は殆どないだろうし、標準装備している言語とそうでない言語で不公平になるし。
使えるものはすべて駆使して解けばよいだろ。 >>113 python
if A: B=A
結果
Aが True の時 B(結果)＝ True
Aが False の時 B(結果)＝ None (変わらず)
Aが False の時 B(結果)＝ False (変わらず)
Aが False の時 B(結果)＝ True (変わらず) >>113 Lua
functio naraba(A, B)
if A == B then
return true
else
return B
end
end >>172 それちゃうよ。
A が False の時 B がFalseに限定される >>156
C言語のようなコンパイルする言語だとだいたいはコンパイル時にエラーになって実行不能だろうなあ(そうでない言語もあるかも知れないが)。
更に print がない言語もある。少なくともCの標準的なライブラリにはない。printf()やputs()のようなものはある。
なので変数宣言すればコンパイルは通るが今度はリンクで関数が見つからなくてエラーになりこれまた実行不能。
まあでも言語や環境で起こることは違って来るので答えは沢山出てくるかも知れない。(またはほとんど相手にされないかだ)。 お題
長方形のサイズが指定された時、その長方形に敷きつめられるパターン全て列挙
回転もおkかは好きに定めていい
例: 2 3
#
###
#
#
###
### 回転もOKの場合は↓も入るってことかの？
##
# >>176 なんか図が良くわからないな。
2 x 3 なら、そのパーツは, / は空きだとすると
*//
***
と
/**
――-
*//
*//
と
/**
/**
―――
*//
**/
と
/**
//*
――
***
***
――-
みたいな感じかな。パーツの回転を許す許さないは自由という事。
3 x 3 の時は斜めのパーツも許すんだろうね。
*//
/*/
//*
これが一つのパーツ？ >>178 斜めのパーツは現実的には作れないし、組み合わせが膨大になるから、許さない方が良いのかも。
縦、横に繋がっていないパーツは除外かな。 これはかなり難しいお題になるんじゃないの。
パーツを少なくするためには、穴開きパーツも許さない方が良さそうだし。
パーツは、空白は 0 基本図形は 1として表した方が良いのかな。 2 x 3 なら
100
110
と
011
001
とか >>178
同じ形のパーツだけで指定の長方形に敷き詰められる物を探すんじゃろ プログラミング超初心者です
自動で2ちゃんにコピペを書き込むようになりたいんですがそれってかなりレベル高いスキルですかね？ >>10うわぁww眉毛剃っとるwwwwww
流石やな....ヤクザやんw >>176
回転なしなら縦の長さの因数と横の長さの因数それぞれの組み合わせの四角を列挙すればええんよな？
回転ありだとどうすればええんじゃろ >>176 必要なパーツの種類と個数を出せば良いんだろう。
回転させて使おうがどうしようが自由。 >>178
パターン全てって書いてあるから単に 2^ドット数 だと思ってたんだが、人間が見た時に何らかの意味がありそうなパターンって事なの？
しかし何に意味がありそうと感じるかは主観の問題だからここでのお題としては適切ではないよね。 >>156 R
cat(a)
Error in cat(a) : object 'a' not found
Execution halted パーツの対称性を見るくらいしかなさそうだけどなぁ
90度回転で不変ならパーツ自体が正方形の場合しか充填し得ないし180度回転で不変なら長方形しかない
問題は対称性なしの場合で, 回転で得られる4通りの図形の組み合わせで少なくとも適当な長方形が作れる必要がある。 出題者です、同じ1種類のパーツのみで敷き詰めるのを意図してた
回転なしは因数でおk、有りは一応解法は浮かんだが証明詰めきれなかったので好きに定めて良いって書いた >>192 2x3 の時は、1種類のパーツのみで埋めるとすると
111
111
の時は 111 x2個
1,1,1
1,1,1
の時は 1,1(2段) x3個
11,1
1,11
の時は 110,100(2段) 2個とするのか
11 が 2個と 1 が2個 は2種類のパーツだからダメ？ >>195 90度回転を認めると、11が、3個で良いね。
回転なしなら、111 2個と 1が6個
1
1
2段のパーツが3個
の3種類が解？ 上でもう出てんだろ
回転なしなら辺の約数の組み合わせで全部だっつーの abcd
badc
abab
cdcd
aaba
babb
abbb
aaab
同じパターンで埋めるのって色々できそうだけどこういうの全部いいの？ >>199 それ何種類も使ってるじゃん。
最低何れかの縦横が連続していないとダメだろ。 パズソーのピースじゃないの？
先ずは2x3で1種類のパーツのみで探せという問題の回答を決めてほしい。 いや全部一種類だよ
マスがくっついてないだけで
連続してるとは書かれてなかったし お題を正しく理解できてない模様 >>176をもう1度確認
1つ目の#は6個、2つ目の###は2個、
3つ目の# 4つ目の###
#は3個、 ###は1個で2行3列が全て埋まります >>210
例えば、 最初の基本バーツは何？ どうしてこれが1種類なのかな？
abcd
badc
-----| >>202 全く理解できない。
>>176 はどうして一つ目が6個なのかな？ 1個しかないじゃん？
一つ目って何？ 二つ目って何？
https://i.imgur.com/GzvMfWg.jpg
自分が今見てるのは、iPhone BB2C 回答の良し悪しだけじゃない、良問悪問ってあるよね… >>204
1つ目の # は6個で2行3列が全て埋まります
###
###
2つ目の ### は2個で2行3列が全て埋まります
###
###
3つ目の #
# は3個で2行3列が全て埋まります
###
###
4つ目の ###
### は1個で2行3列が全て埋まります
###
### >>203
回転を許す立場なら
@_
_@
って言うパーツ一種類だけからできてんじゃん
頭大丈夫か？ >>207 b と d が同じに見えるそっちこそ頭大丈夫か？
abcd
badc
これのどこが、
--@
@―
なんだよ。 90度回転ありなら
# # # #
# と # と # と #
で敷きつめられる(＝全て埋まる)という意味だろうけど
>>179に抵触するので、これは無しでしょ >>208
回転を許すっつってんだろ氏ねよ糞無能が
@_
_@
を90度回転させたら
_@
@_
だろうが
市ね糞野郎 >>209 ようやくわかった。
a_
_a
_b
b_
などと並んでるものは、全て同じパーツとみなすという意味か。
>>176 のお題をよく見ると、2 x 3 の正解の回答が書かれてる。 斜めは許していないからダメだろ。
また、回転も許していない。
回転を許すなら
■
■ ■
というパーツも入るがそれは除外されてるから、回転も無しだ。 >>199のような飛び飛びのパターンまで含めると5x5くらいのサイズなら解けそうでも
10x10くらいの大きさになるとほぼ解けなくなるか？ ...
d0<-a
a->b
b->c
c->d
c'<-d
b'<-c'
a<-b'
d->a2
d<-a2
a2->b2
....
に対して
任意の英数字から初めて右向きの矢印をnこ進んだ英数字を一瞬で割り出す簡単な計算方法を教えろ
左向きの矢印のときも答えろ
ここで英数字には好きな整数の値を対応させろ 新問題
...
g0<-a
a->b
b->c
c->d
c'<-d
b'<-c'
a<-b'
d->e
e->f
f->g
f'<-g
e'<-f'
g->a1
g<-a1
a1->b1
....
に対して
任意の英数字から初めて右向きの矢印をnこ進んだ英数字を一瞬で割り出す簡単な計算方法を教えろ
左向きの矢印のときも教えろ
ここで英数字には好きな整数の値を対応させろ 自己解決しました
この問題には答えなくていいです
>>217
これからは英語で書くので許して下さい しかしこの問題は回転を考えないと、曲がったパーツは不可能だね。
かなり単純化される。 なんかスレが新しくなってから湧いてきたPythonのクソみたいなコード連投してる日本語がめちゃくちゃのやつうざい 2行3列で回転無しなら以下の4つが答え
#
###
#
#
###
###
回転ありなら更に以下の2つも
##
#
#
## >>226
> ##
> #
>
> #
> ##
この二つは90度回転した同じものやが 煽りではなく本当に発達障害またはそれに準ずる知的ボーダーを疑うレベルで頭悪いな >>228 煽りじゃん。 プログラムを出してくれた方が良い。 >>230 Perl5
use feature qw{current_sub say};
sub bblsort {
for (0..@_) {
sub {
if (@_ >= 2) {
__SUB__->(@_[1..$#_]);
($_[1], $_[0]) = ($_[0], $_[1])
if $_[0] > $_[1]
}
}->(@_[$_..$#_]);
}
}
use List::Util shuffle;
@a = shuffle 1..20;
say "1) @a";
bblsort @a;
say "2) @a";
実行結果
~ $ perl 13_230_bblsort.pl
1) 13 6 18 7 15 1 11 8 20 16 14 4 9 10 12 17 2 19 5 3
2) 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 お題：数値Xを4つの方法で整数に丸めよ
(1) 0に向かう
(2) 0から遠ざかる
(3) 正の無限大に向かう
(4) 負の無限大に向かう
X = 0.5
=> 0 1 1 0
X = -1.1
=> -1 -2 -1 -2
X = 3
=> 3 3 3 3 ふたたび、円の内部の整数点を求めるやつ。個数ごとその最小半径を求める。
41個、47個とかが難し目だった気が。 >>232 組み込み使っていいんだよね? (面倒になるけど、使わなくても書けるけどｻ…)
Perl5
use POSIX qw(floor ceil);
for (0.5, -1.1, 3) {
@a = ("$_ => ",
sprintf('%d', $_), #int($_),
($_ > 0 ? ceil($_) : ceil($_-1)),
ceil($_),
floor($_)
);
print "@a\n";
}
実行結果
~ $ perl 13_232_round.pl
0.5 => 0 1 1 0
-1.1 => -1 -2 -1 -2
3 => 3 3 3 3 >>230 Ruby
def bs(ary)
ary.tap do |a|
(a.size**2).times do
(a.size - 1).times do |i|
a[i + 1], a[i] = a[i, 2] if a[i] > a[i + 1]
end
end
end
end
p bs([3, 1, 4, 15, 92]) # => [1, 3, 4, 15, 92]
>>232
sgn = -> n {n <=> 0}
r4 = -> n {n.floor}
r3 = -> n {-r4[-n]}
r2 = -> n {sgn[n] * r3[n.abs]}
r1 = -> n {sgn[n] * r4[n.abs]}
[0.5, -1.1, 3].each{|i| puts 'x = %p => %p %p %p %p' % [i, r1[i], r2[i], r3[i], r4[i]]}
# =>
x = 0.5 => 0 1 1 0
x = -1.1 => -1 -2 -1 -2
x = 3 => 3 3 3 3 >>236 これだと
入力が０のとき
>(2) 0から遠ざかる
が-1になっちゃう。
($_ > 0 ? ceil($_) : ceil($_-1)),
↓を
($_ >= 0 ? ceil($_) : ceil($_-1)),
とすべきでしょうね。ｽﾏｿ >>262 J
f =: (**<.@|),(**>.@|),<.,>.
f 0.5
0 1 1 0
f _1.1
_1 _2 _1 _2
f 3
3 3 3 3 >>240
間違えました
262ではなく>>232でした >>232 をやろうとおもって、IEEE754 の float/double を直接触る方法を探しているのですが、なにかいい方法はないでしょうか… >>233
これ
「Nに対し平面上の円で、その円周上の整数点がちょうどN個となる円の最小半径を求めよ」
例)
x^2 + y^2 = 1の整数点は4つだが、最小半径ではない。
(x-0.5)^2 + (y-0.5)^2 = 0.5の方が小さい。 >>248
網羅的は、きりがなく一つの予想をたてた。
一つ半径を求めたら、次のような操作で半径を縮めたものと、真の最小半径が一致する予想。
半径rの整数点がNだとして。 rを整数比で縮小して中心をずらす。
たとえば上の例だと、r=1で、r → 2/4 r で、
(2x -1)^2 + (2y -1)^2 = 2r
両辺4倍して中心ずらした式 整数比かけるので有理数半径ならすべて作り出せるから当たり前か
無駄なく高速に半径縮められる手法が大事か あと半径は間違いで、半径でなく右辺、半径^2 だった >>252 Perl5 (効率の良いｱﾙｺﾞﾘｽﾞﾑではないけれど、まずは…)
use List::Util shuffle;
@a = shuffle 1..20;
print "shuffled) @a\n";
sub flip {
($m, $n) = @_;
@a[0..$m] = reverse @a[0..$m];
@a[0..$n] = reverse @a[0..$n];
}
for $i (reverse 1..$#a) {
$k = undef;
for (0..$i) {
$k = $_ if (!defined($k) or $a[$k] < $a[$_])
}
flip($k, $i) if $k < $i;
}
print "sorted ) @a\n";
実行例
~ $ perl 13_252_clumsy_pancake_sort.pl
shuffled) 18 6 2 13 16 1 12 15 10 4 17 20 9 7 19 14 5 11 3 8
sorted ) 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 ; Common Lisp
(defun flip (seq n)
(concatenate (type-of seq) (nreverse (subseq seq 0 (1+ n))) (subseq seq (1+ n))))
(defun pancake-sort (seq predicate)
(loop for s = seq
then (if j (flip (flip (flip (flip s (1- j)) (1- i)) i) j) s)
for i from 1 to (1- (length seq))
for j = (position (elt s i) s :end i :test predicate)
finally (return s))) お題:1から8までのカードを混ぜ、2枚そこから引いた時1枚目*10+2枚目が素数になる確率を求める。
ただし、
1. 小数第3位で四捨五入した後に回答すること。
2. 数学的な証明は禁止。
3. 各カードは9-その数字の数だけ存在する。 (例:1ならば8枚存在する)
4. 各カードが出る確率はまだ引かれていないカードの枚数に比例する。 >>255 Perl5
$R = 0.0;
@s = map{($_) x (9-$_)} 1..8; #say "@s";
$t = @s; #say $t;
for (qw{11 13 17 23 31 37 41 43 47 53 61 67 71 73 83}) {
@o = split'';
my %h;
$h{$_}++ for @s;
my $r = $h{$o[0]}-- / $t;
$r *= $h{$o[1]}-- / ($t - 1);
$R += $r;
}
printf "%3.2f\n", $R;
実行結果
~ $ perl 13_255.pl
0.31 お題: URLで場所を指定された、インターネット上のテキストファイルをダウンロードするプログラム。 >>258 Perl5
require LWP::UserAgent;
$ua = LWP::UserAgent->new;
$ua->agent('Mozilla/5.0 (compatible; MSIE 10.0; Windows NT 6.2; Win64; x64; Trident/6.0)');
use HTTP::Cookies;
$ua->cookie_jar(HTTP::Cookies->new(file => 'lwp-cookies.txt', autosave => 1));
$url = 'http://ftp.iij.ad.jp/pub/linux/centos/7.6.1810/isos/x86_64/0_README.txt';
$file = './0_README.txt';
$res = $ua->mirror($url, $file);
print $res->status_line, "\n";
実行例
~ $ perl 13_258.pl
200 OK
（※こういうのは、別に今急に考えたわけじゃなく、日常的に作って使っているのですぐ投稿できました） >>260
wget.exe か curl 使えば？ >>260 download.js
var xmlhttp = new ActiveXObject("Msxml2.XMLHTTP");
xmlhttp.Open("GET", "http://ftp.iij.ad.jp/pub/linux/centos/7.6.1810/isos/x86_64/0_README.txt";, false);
xmlhttp.Send();
var stream = new ActiveXObject("Adodb.Stream");
stream.Type = 1;
stream.Open();
stream.Write(xmlhttp.responseBody);
stream.SaveToFile("0_README.txt", 2); pythonista stash 反則？
$ wget http://ftp.iij.ad.jp/pub/linux/centos/7.6.1810/isos/x86_64/0_README.txt
$ ls -la *.txt
0_README.txt (2.4K) 2019-02-20 02:21:45 >>255
;; Common Lisp
(let ((prime (list 2)))
(defun primep (n)
(loop for i from (1+ (car prime)) upto n
unless (find-if (lambda (j) (zerop (mod i j))) prime :from-end t)
do (push i prime))
(find n prime)))
(defun nearest (i j)
(/ (floor (+ (* i (expt 10 j)) 0.5)) (expt 10 j)))
(loop with cards = (loop for i from 1 to 8 nconc (make-list (- 9 i) :initial-element i))
and n = 0 and p = 0
for one in cards
do (loop for two in (remove one cards :count 1)
do (incf n)
if (primep (+ (* 10 one) two)) do (incf p))
finally (format t "~,3F~%" (nearest (* (/ p n)) 3))) わーい、これでダウンロード制限された端末でDLできるぞ。やったー！ >>265
できるかなあ？どういう制限しているかにもよるぞ。 PowerShell にも、curl, wget ある
get-alias (gal)
curl -> Invoke-WebRequest
wget -> Invoke-WebRequest
と言うことは、Ruby からも、そのコマンドを呼べる なんと、コマンドプロンプトで、
where curl と入力すると、
C:\Windows\System32\curl.exe
PowerShell の、curl, wget は、Invoke-WebRequest のエイリアスだけど、
curl.exe は、本物のcurl ！ >>258 >>265 なんだ下心があったのか。
pythonista stash は以下のコマンドが使える。
help(StaSh) v0.7.1
alias, cat, cd, clear, cowsay, cp, crypt, curl, cut, dropbox_setup, du, easy_config, echo, edit, exit, fg, find, ftpserver, gci, gh, git, grep, head, httpserver,
jobs, kill, latte, ls, mail, man, mc, md5sum, mkdir, monkeylord, more, mount, mv, openin, pbcopy,
pbpaste, ping, Usage, pip, printenv, printhex, ptinstaller, pwd, py-tree, python, python3, quicklook, rm, rmdir, scp, selfupdate, sha1sum, sha256sum,
sort, source, sqlite, ssh, ssh-keygen, stashconf, tail, tar, telnet, totd, touch, umount, uniq, unzip, version,
wc, webviewer, wget, whatis, which, wol, xargs, zip
ftpserver や、httpserverは簡易的なサーバーになる。
ssh やscp 、tar zip などは使い道多そう。
webviewer てpython の下でブラウザが立ち上がってるみたいなんだがどんな使い道があるんだろう？
なお、標準python用のシェルは、xonsh と言うのがあるらしい。 xonsh では、標準的なshellコマンドと並行してpython スクリプトも実行できるから強力。
stash ではそれはできない。 WSH はわからないけど、Ruby では、
require 'nokogiri'
html = `ｃｕｒｌ http://www.example.com/`
# ｃｕｒｌ は書き込めないので、全角に変換した
doc = Nokogiri::HTML( html )
elements = doc.css( "h1" )
puts elements.first.content #=> Example Domain >>269
なんかね。UNIX系OSで昔からよく使われてたコマンドを移植したようで、tarとか他にも色々あったと思った。 >>263 今度は反則なしで。python
import requests as r
url = 'http://ftp.iij.ad.jp/pub/linux/centos/7.6.1810/isos/x86_64/0_README.txt'
g= r.get( url )
print('読んだサイズは',len(g.text) )
# 読んだサイズは 2495 >>276 ありがとう。 そんな言語も出てきてたんだ。 でも普及は難しいのかも。 お題：リスト等を", "で結合して表示せよ。ただし最後は" and "で結合する。
https://ideone.com/pVuO7T >>279 JavaScript
const arr = ['apple', 'banana', 'orange', 'mango'];
const last = ' and ' + arr.pop();
console.log(arr.join`, ` + last);
//=> apple, banana, orange and mango >>279 python
l = [ 1,2,3,4,5]
print( *l[0:-1] ,'and' , l[-1])
# 1 2 3 4 and 5 >>279
Haskell
main = putStrLn.concat.concat $ [map addCanma (init lst),["and,"],[last lst]]
addCanma s = s ++ ","
lst = ["apple","banana","orange","mango"]
output:
apple,banana,orange,and,mango 題意は
list = ["red","green","black","white"]
print(", ".join(list[:-1]),"and",list[-1])
# red, green, black and white
だろ そこそこ優秀なのに肝心なところでいい加減だから試験に落ちるタイプだな >>283
あ、そうか。
不恰好だけどこれで一応対応。
(putStrLn.concat.concat) [init $ map addCanma $ init lst,[last $ init lst],[" and "],[last lst]]
スマートな解答も考えてみるよ。 >>283 ごめん、俺もカンマが抜けてた。
数字の場合の模範解答をよろしく。 スマートかは兎も角、一応マシな形に。
空リストや要素数1にも対応。
Haskell
main = putStrLn $ last2 lst
last2::[String] -> String
last2 [] = []
last2 [x] = x
last2 [x,y] = concat [x," and ", y]
last2 (x:xs) = x ++ "," ++ last2 xs
lst = map show [0..5]
output:
0,1,2,3,4 and 5 >>286
list = [str(x) for x in range(1,5)]
とか
map(lambda x : str(x), list)
でもおk
要素数が1個以下の場合はifで分離するだけなので略 >>279 Common Lisp
(format t "~{~@{~A~^~#,1^, ~}~^ and ~A~}~%" (list 1 2 3 4))
https://ideone.com/6DcwO9 intとstrが混在してる場合でも大丈夫で入力数が1以下ならそのまま返すワンライナー
python
print("".join(reversed(" ,".join(reversed([str(x) for x in list])).replace(",","dna ",1))))
JS+正規表現
console.log(list.join(", ").replace(/(.*),(.*?)+/,"$1 and $2"))
冷静に考えるとこの正規表現を使い回せばどの言語でもワンライナーなのでは ラティス、再び。
お題: >>99 の場合分けのラティス構造を使って、複数の入力文字列について、共通部分をまとめ、１つの文字列に凝縮せよ。
(例)
ああい
ああ
あう
→あ{{あ{い/}}/う} よく考えたらreversedなんか使わんでも
print((" ,".join([str(x) for x in list][::-1]).replace(",","dna ",1))[::-1])
でいけるか。join削減できるし 出力文字列の長さは最短でなければならない。
場合分けの順序は問わないが、場合分けの項目について、ソートすることが望ましい。 一番外側の { } は省略可能。
共通部分がないときは、/で区切って出力せよ。 このラティス構造っていうの、言語学ではよく使うらしいが、専門じゃないからよくわからない。 >>279
>>292
Haskellでもワンライナー出来たけど、読みやすいとは思えない。(横長だし)
発想としては(要素数2以上なら)最後以外の要素(文字列)の頭に','追加して、全部結合して(大きな文字列にして)最後に頭の','を省く。
main = putStrLn.tail.concat $ if length lst < 2 then lst else [(concat.(map (\x -> ',':x)).init) lst," and ",last lst]
lst = map show [0..5]
個人的に >>287 の方が発想も読みやすさも好みの書き方。
(読み難くなるなら関数分ける派)
pythonのはワンライナーでも比較的読みやすくて、ちょっと羨ましい。 >>297
弄ってるうちに要素一以下だとバグ出てた。
正しいコードはこっち。
putStrLn.concat $ if length lst < 2 then lst else [(tail.concat.(map (\x -> ',':x)).init) lst," and ",last lst] >>282 Perl5
sub f {
my $a = shift;
@_ ? (@_ > 1 ? "$a, " : "$a and ").f(@_) : $a
}
use feature say;
say f(qw[red green black white]);
say f(qw[apple banana]);
say f(qw[one]);
実行結果
~ $ perl 13_279_and.pl
red, green, black and white
apple and banana
one >>279 Squeak/Pharo Smalltalk
(0 to: 3) asCommaStringAnd "=> '0, 1, 2 and 3' " >>299
ｱﾝｶｰ間違えた >>279 宛だった…orz
>>279 もう一丁 Perl5
sub g {
my $z = ' and '.pop @_ if @_ > 1;
join(', ', @_).$z;
}
use feature say;
say g(qw[red green black white]);
say g(qw[apple banana]);
say g(qw[one]);
実行結果
~ $ perl 13_279_and_2.pl
red, green, black and white
apple and banana
one >>302
ｸﾞｸﾞﾙとあるみたいよ。
組み込みMethodを山のように持っていそう >>279
Smalltalk (Pharo 7)
#('apple' 'banana' 'orange' 'mango') asCommaStringAnd
==> 'apple, banana, orange and mango'
#('apple' 'banana') asCommaStringAnd
==> 'apple and banana'
#('apple') asCommaStringAnd
==> 'apple' >>279 python
def f(lst): return ('空だ' if not lst else
','.join([str(x) for x in lst[:-1]])
+ (' and ' if len(lst)>1 else'')
+ str(lst[-1])
)
print(f( [ 1,'二',3,4,'五'] )) # 1,二,3,4 and 五
print(f( [1,'二'] )) # 1 and 二
print(f( [1] )) # 1
print(f([])) # 空だ >>279 Ruby
f = -> a {a[0..-2].join(', ').sub(/.\K\z/, ' and ') << a[-1].to_s}
(-1..3).each{|r| puts f[[*0..r]]} # =>
0
0 and 1
0, 1 and 2
0, 1, 2 and 3 >>291
あ{{あ{い/}}/う} // 12文字
ああい/ああ/あう // 9文字
あ{あい/あ/う} // 9文字 ラティス構造って要するに正規表現を生成すりゃーいいのか？ >>313 JavaScript
console.log(Array.from({length: 21}, (v, i) => i + 1).reduce((acc, v) => acc * v)); お題：
長方形のフィールドが与えられる。フィールド上では上下左右に移動することができる。
各マスの数字はそのマスに入るためのコストを表す。
SからGに向かうときの最小コストを求めよ。(SとGのコストは0とする)
S5111
1115G
=> 6
S1111
98642
G1111
=> 9
13457689768914512071934123457
G4578901258901212890361125312
37890423076834712378998725463
16890102569615902061456259893
34582934765923812893461515232
57896123896741378915691551697
89013897456123457162501835479
21389046013845610034623405686
8902346203948612341356362342S
=> ? >>279
>>289
Common Lispで~#[...~]を使ってみた
(format t "~{~S~#[~; and ~:;, ~]~}" '(apple banana orage mango)) こういう文章題好き。
でも実力不足で解けない…
a*かな？ >>313 Perl5
use bignum (l=>GMP);
$n = 1;
$n *= $_ for 2..21;
print "$n\n";
実行例
~ $ perl 13_313.pl
51090942171709440000 >>313 JavaScript
console.log((f=n=>n?n*f(n-1):1)(21)) >>313 python
#階乗1
import math
print('階乗1',math.factorial(21))
#階乗2
def f(n): return f(n - 1)*n if n > 1 else n
print('階乗2',f(21))
#階乗3
print('階乗3',(lambda x:f(21))( globals().update({"f": lambda n: n*f(n - 1) if n > 2 else n }))) >>279
Kotlin script
最後のカンマを正規表現の文字列置換で and にしただけ。
println(listOf("abc", "def", "xyz").joinToString(", ").replace(",([^,]*)$".toRegex(), " and$1"))
出力
abc, def and xyz lispって組み込みで素数かどうか判定するやつ提供されてるのか、、、面白い！ >>313
bc
n = 2; for (i = 3; i <= 21; i++) n*=i; n
出力
51090942171709440000 >>313 dc
~$ echo 21 20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 ********************p | dc
51090942171709440000 bcのってjsでもそのまま動くんだな。どっちもc由来文法だからか…
for(i=s=1;i<22;)s*=i++;s >>326
恥ずかしながらdcコマンド知らなかった…いいねこれ。
~$ echo "$(seq -s' ' 1 21)$(printf '* %.0s' {1..20})p" | dc
51090942171709440000 >>313
;; Common Lisp
(loop for i from 1 to 21 for r = i then (* r i) finally (print r)) >>316
これは、本格的だな
ダイクストラ・A* みたいな、順位キュー(priority queue)を使わないと、いけないかも >>313
Smalltalk (Pharo 7)
21 factorial
==> 51090942171709440000 >>313
Ruby
( 1..21 ).inject( 1, :* ) python3
標準ライブラリ内の数学関数の例
import math
print(math.factorial(21))
そうじゃない例
from functools import reduce
print(reduce(lambda x,y:x*y,range(1,22)))
ちょっと高度化したお題
素数階乗n#を実装せよ
ただし素数階乗とは与えられた整数n以下のすべての素数の積である
例
1#=1
3#=4#=6
5#=30 例がちょっと意味分からない
1#=1
1以下の素数の積なのに1？
3#=4#=6
何これ？
5#=30
これだけ分かる >>337
掛けるもののがないときは1として扱うのが普通だよ
0!とかΠの項数が0の時とか
ただこの出題者はそのへん理解してないだろうから解く気がしない >>339
ありがとう。
数学と同じとは限らないんだね。
1も素数としてやってみます。 というか数学でも0!=1!=1と定義されているのが普通だと思うし
高校でも大学でもそうじゃない問題を見たことがないのだが >>340
いや、むしろ数学の世界での慣習なんですけど… 単位元(初期値)だろ。
足し算は0、掛け算は1 が、単位元
Ruby で、
( 1..21 ).inject( 1, :* )
1 が初期値で、:* で掛け算メソッドを渡している >>342
> ただし素数階乗とは与えられた整数n以下のすべての素数の積である
と書いてあるので、
「与えられた整数n」が1
のとき、
「与えられた整数n以下のすべての素数の積」
は、
「1以下のすべての素数の積」
となり、
1以下に素数はないのになんで例で答がが1になってるんだろう、と思った次第です。
お騒がせしました。 できた
JavaScript
const prodPrimes = n => {
const primes = [1];
for (let m = n; m > 1; m--) {
let prime = 0;
for (let i = 2; i <= m - 1; i++) {
if (m % i === 0) prime = i;
}
primes.push(prime || m);
}
return [...new Set(primes)].reduce((acc, p) => acc * p);
}
console.log(prodPrimes(1)); //=> 1
console.log(prodPrimes(3)); //=> 6
console.log(prodPrimes(4)); //=> 6
console.log(prodPrimes(5)); //=> 30
今夜はPythonで>>316に挑戦したい >>335 J
f =: 3 : 0
*/ 1 , I. 1 p: i. >:y
)
f@> 1 3 4 5 21
1 6 6 30 9699690 Jどこで覚えればいいの？
Effective J的な読みやすい書籍ないの？ >>313 Common Lisp
(defun ! (n)
(apply #'* (loop for i from 1 upto n collect i)))
CL-USER> (! 21)
51090942171709440000
CL-USER> (! 0)
1
CL-USER> >>316 Perl5 Dijkstra法による最短経路探索 (priority queueを用いない実装)
https://ideone.com/XcsBQe >>316
python(pypy) https://ideone.com/DV1w4s
本線： キュー使用したダイクストラ (+ 経路復元)。
サンプル程度なら、ワーシャルフロイド(頂点^3)でも回る、と同方も追加。
さすがにpythonには少々きつく、pypyに逃げた。 >>354 pypy に逃げたという話は、その方がかなりスピードが早いからという事？ どの位のスピード差になるんだろう？ >>313
Kotlin script
println("%.0f".format((2..21).map { it.toDouble() }.reduce { n1, n2 -> n1 * n2 })) >>355
何も変えずpython3で実行 https://ideone.com/IArwja
約6秒 vs 約0.2秒
まぁ、本当はpython3向けにもう少し治せそうだが お題: ３分タイマーを作れ。３分間待って、音を鳴らすか、画面に「BEEP!」と表示せよ。ただし、CPU時間を無駄に消費してはならない。 お題: 玉入れ競争のシミュレーションを作れ。1チームに玉50個で園児3人。2チームある。園児それぞれが10秒に玉1個投げる。
一回投げると、3秒後に1/2の確率で玉が入る。イベントのたびに「チーム#1の園児#1が玉を投げました」「チーム#2の園児#1の玉が入りました」などと表示する。 >>313
@Mathematica
ライブラリ版
Factorial[21]
非ライブラリ版
Range[21] // Apply[Times, #] & >>335
Smalltalk (Pharo 7)
[:n | (Integer primesUpTo: n+1) inject: 1 into: [:p :x | p * x]] value: 5
==> 30 >>335
@Mathematica
Range[5] // Select[#, PrimeQ] & // Apply[Times, #] & お題
与えられた文字列を縦に表示する
入力
hello
出力
h
e
l
l
o >>364
ruby -e "'hello'.split('').each do |c| puts c end" >>364 Perl5
~ $ echo -n hello | perl -naF -E 'say for @F'
h
e
l
l
o >>358 Perl5
sleep 3*60;
print "BEEP!\n"; >>346
Pythonじゃ緩すぎだろｗ
Brainfu*kとかＪで挑戦したいと言わないと
世のマゾヒスト達からマサカリ投げられるぞｗ >>359 Perl5
use List::Util shuffle;
@a = shuffle 1..5;
print "shuffled) @a\n";
use threads;
use threads::shared;
my @b: shared;
sub f {
my $n = shift;
sleep $n;
push @b, $n;
}
push @thr, threads->create(\&f, $_) for @a;
$_->join() for @thr;
print "sorted ) @b\n";
実行結果
~ $ perl 13_359.pl
shuffled) 5 3 1 2 4
sorted ) 1 2 3 4 5 >>370 しまった、＆nbsp;がそのまま表示されている…orz 全角スペースに置換して修正
>>359 Perl5
use List::Util shuffle;
@a = shuffle 1..5;
print "shuffled) @a\n";
use threads;
use threads::shared;
my @b: shared;
sub f {
my $n = shift;
sleep $n;
push @b, $n;
}
push @thr, threads->create(\&f, $_) for @a;
$_->join() for @thr;
print "sorted ) @b\n";
実行結果
~ $ perl 13_359.pl
shuffled) 5 3 1 2 4
sorted ) 1 2 3 4 5 Smalltalk (Pharo 7)
String cr join: 'hello'
==> 'h
e
l
l
o' >>364
@Mathematica
"hello" // Characters // Riffle[#, "¥n"] & // StringJoin >>351
いや、21 factorialをSmalltalk-76で実際に計算したものですよ！
動画にしたほうがよかったですか？^^; >>335 Squeak Smalltalk (このコードは Pharo では動かない)
| fn |
fn := [:n | (Integer primesUpTo: n + n isPrime asBit) inject: 1 into: #*].
#(1 3 4 5) collect: fn. "=> #(1 6 6 30) " >>364 Squeak Smalltalk (同じく Pharo とは互換性がないコードで)
'hello' joinSeparatedBy: Character cr.
"= 'h
e
l
l
o' " >>359 Pharo/Squeak Smalltalk
| sleepsort |
sleepsort := [:arr |
| queue |
queue := SharedQueue new.
arr do: [:x | [(x * 2) milliSeconds asDelay wait. queue nextPut: x] fork].
(1 to: arr size) inject: #() into: [:acc :idx | acc, {queue next}]
].
sleepsort value: #(2 1 5 10 7 8 3 6 4 9)
"=> #(1 2 3 4 5 6 7 8 9 10) " >>358 puthonista ( iPhone )
# iPhoneのシステムサウンドを使ってアラームを出す。
import sound,time
alarm = '/System/Library/Audio/UISounds/alarm.caf'
time.sleep(3*60)
id = sound.play_effect(alarm) >>359 Bash
#!/usr/bin/bash
N=5
IFS=$'\n'
a=(`seq $N | shuf | sed -e 's/\([0-9]\+\)/(sleep \1; echo \1 >> result)/'`)
IFS="$'\n'$'\t' "
[ -f ./result ] && rm ./result
for s in "${a[@]}"; do
echo "$s"
sh -c "${s}" &
done
wait
cat ./result
~ $ sh 13_359.sh
(sleep 2; echo 2 >> result)
(sleep 5; echo 5 >> result)
(sleep 4; echo 4 >> result)
(sleep 1; echo 1 >> result)
(sleep 3; echo 3 >> result)
1
2
3
4
5 >>364
Kotlin script
while (readLine()?.map { it }?.joinToString("\n")?.let { println(it); it } != null); >>358
sh
sleep 180 ; echo 'BEEP!' >>364
ruby -e "'hello'.each_char do |c| puts(c) end" お題: スリープと複数のスレッドを使って素数を10個求めよ。１つのスレッドは素数倍数のループを意味する。 >>384
ヒント: 一秒ごとにリセットするカウンターを使う。 模範解答があるんでしょ
だからヒントを作れる
なら最初から正解を出せと スリープタイマに番号付けてON/OFF出来ればエラトステネスの篩で素数が出来る。 >>364 J
smoutput@>'hello' >>364 JavaScript
[...'hello'].forEach(c=>console.log(c))
または
for(let c of 'hello')console.log(c)
または
console.log([...'hello'].join`\n`) >>364 Ruby
puts "Hello".split("") >>394
Linux等、UNIX系OSの場合コマンドラインから以下を入力するだけで GNU/Linux 等と出てくるが、
どうしてもプログラムにしたいのならシェルスクリプトの中でこれだけ実行するようにしておけばよい。
uname -o >>394
Windows のコマンドプロンプトの場合はこれ。ただしバージョンも一緒に出てくる。
ver
これもどうしてもプログラムにしたいならバッチファイルでこれだけ実行するようにしておけばよい。 pythonista
import os,sys
print(os.uname() )
# posix.uname_result(sysname='Darwin', nodename='iPhoneXsMAX', release='18.2.0', version='Darwin Kernel Version 18.2.0: Wed Dec 19 20:28:53 PST 2018; root:xnu-4903.242.2~1/RELEASE_ARM64_T8020', machine='iPhone11,6')
print(os.uname()[0],os.uname()[4],sys.platform )
# Darwin iPhone11,6 ios
from distutils.util import get_platform
print(get_platform())
# darwin-18.2.0-iPhone11,6 >>394 J
osname =: 3 : 0
a =. 9 !: 12 y
if. a = 5 do. 'unix'
else. a = 6 do. 'windows'
else. do. 'other'
end.
) >>394
Perl5
print "$^O\n"; >>364 Lua
io.write((io.read("*a"):gsub(".","%0\n"))) お題： 任意のn-オミノを全種類出力するプログラム >>364
標準出力から与えられる場合
import sys
for x in sys.stdin.read() : print(x)
>>394と混合
import os
for x in os.getenv("OS"): print(x) >>384 Squeak/Pharo Smalltalk
| tick start primes sema sieveMaker processes ans |
tick := 1 second.
start := DateAndTime now.
primes := SharedQueue new.
sema := Semaphore new.
sieveMaker := [:x | [[(tick * x) asDelay wait. sema signal] repeat]].
processes := SharedQueue new.
tick asDelay wait.
processes nextPut: [
[ tick asDelay wait.
sema isSignaled ifFalse: [
| prime sieve |
prime := primes nextPut: (DateAndTime now - start / tick) asInteger.
sieve := sieveMaker value: prime.
processes nextPut: sieve fork
].
sema initSignals
] repeat
] fork.
ans := (1 to: 10) collect: [:idx | primes next].
1 to: processes size do: [:idx | processes next terminate].
ans "=> #(2 3 5 7 11 13 17 19 23 29) " お題： （Aが真 または Bが真） ならば Cが真である。 であるをプログラムしなさい。 お題: 円の最大重複数を求めよ
例題 以下画像の場合、最大重複数は4です。
https://imgur.com/pbh3VSE.png
円の重複数え方は、2つの円が重なっていたら、重なっている数は2とします。
また、円の重複判定の際、2つの円が円周上の1点のみで重なる場合、それらの円は重なっていないとします。
(理由は重複している面積は0だから。)
以下、本題。
画像のようなNo.0からNo.99までの100個の円があります。
これの円の最大重複数を整数で答えなさい。
https://imgur.com/WiRHA1F.png
入力データ:
https://drive.google.com/open?id=1kl8bS3GOr8Ot2OMMACdCG0SJMpEKxLO3
入力データはx座標 y座標 r(半径)の順で記述されたリストで、すべて実数です。
与えられる入力データは
-800.0 ≦ x ≦ 800.0
-800.0 ≦ y ≦ 800.0
100.0 ≦ r ≦ 400.0
の条件を満たします。
画像は自作、多分正しい。 お題： 自分自身のコードのコメントと非コメントを入れ替えたコードを出力するプログラムの
コードが自分自身のコメントの非コメントを入れ替えたプログラムのコードに
なっているプログラム お題
整数N(N>=6)を相異なる3つの整数(0<a<b<c)の和で表すことを考える。
数列(a,b,c)として考えられるもののうち、辞書式順序で最小のものと最大のものを求めよ
N=6
=> (1,2,3)/(1,2,3)
N=100
=> (1,2,97)/(32,33,35) お題
英今文字からなる文字列が与えられる。
各文字の大文字、小文字の組み合わせをすべて求める。
"ab"の場合
ab
aB
Ab
AB >>409
これって要するにcombinationのfirstとlastじゃねえの
next_combination()の一番最初と最後だよ >>410 JavaScript
const acorn = s => {
for (let i=0; i < 2**s.length; i++) {
console.log([...s]
.reduce((acc, c, j) => acc+String.fromCharCode(c.charCodeAt() - 32 * i.toString(2).padStart(s.length, 0)[j]), '')
);
}
}
acorn('ab'); // の実行結果:
ab
aB
Ab
AB
acorn('ufo'); // の実行結果:
ufo
ufO
uFo
uFO
Ufo
UfO
UFo
UFO >>410 Ruby
s = "ufo"
a = []
s.each_char do |c| a.push([c, c.upcase]) end
b = a[0]
a[1..-1].each do |e| b = b.product(e) end
b.each do |e| puts(e.join) end >>410 Squeak Smalltalk（#perform: を二変数ブロックにすればPharoでも動く）
| fn |
fn := [:str |
| ans |
ans := OrderedCollection new.
#(asLowercase asUppercase) asDigitsToPower: str size do: [:comb |
ans add: (str with: comb collect: #perform:)
].
ans asArray
].
fn value: 'ab'. "=> #('ab' 'aB' 'Ab' 'AB') "
fn value: 'ufo'. "=> #('ufo' 'ufO' 'uFo' 'uFO' 'Ufo' 'UfO' 'UFo' 'UFO') " uppercaseメソッドのことスッカリ忘れてた>>414
const acorn = s => {
for (let i=0; i < 2 ** s.length; i++) {
console.log([...s]
.reduce((acc, c, j) => acc + (+i.toString(2).padStart(s.length, 0)[j] ? c.toUpperCase() : c), '')
);
}
} >>410 Ruby
def f(s)
a=s.chars.map{|c|[c,c.upcase]}
a.shift.product(*a).map(&:join)
end
p f("abc")
["abc", "abC", "aBc", "aBC", "Abc", "AbC", "ABc", "ABC"] 簡単な問題にはものすごい勢いでこたえるのに、難しい問題には見てみぬふりをするのなｗｗｗｗ
難しい問題にはわかりませんだろ >>420
わからないとかやる気が起きないお題に対してわざわざわからないだのなんだのとみんなで書いてたらそういった書き込みでこのスレはすぐに一杯になるだろう。
そんなの無駄で邪魔だから一々書かんでスルーしてくれた方が良い。 >>421
別の問題を答えるときに一緒にわかりませんと書けば1行消費するだけで済むだろ？
それも嫌なのか？ >>422
で、もちろんお前自身はそれを実践しているんだよね？
全答しているなら別にいいんだけどさｗｗｗ >>423
自分の都合のいい問題にしか答えないのはわがままとしかいいようがない >>422
たまたまわからない問題が連続したらわかりませんしか書けないだろうが。 >>426
自分に都合の悪いことは無かったことにするのは良くない
現実と向き合って自分の非を認めるべき >>427 まだ誰も回答していない問題があるが、君はわかりませんと言っていないね。 まだ考え中かな？ >>1-1000
ほとんどの問題が難しくてわかりませんでした
これで満足か？wwww >>427
便所の落書きに時たま書かれる問題にうんこしながら答えを書くか書かないかで都合が良くなったり悪くなったりする者は居ない。 しかし最近は便所の落書きは亡くなったに等しいな。
それにもかかわらず2chには便所の落書きが多い。
ここはまだましだけどな。 うちの近くの公園にはまずないな。
十人くらいしか遊べない公園も、数千人も遊べる公園も同じ。 ああいうのもブロークンウィンドウズ理論通りに汚くなればなるほど余計に汚くなって尚且つその地区の犯罪率も上昇しちゃうんだろうな。 ID:7nNuTdUM が便所の落書きしかしてないのは分かる >>437 もちろんどんな公園にもバカな書き込みをする奴はいるだろう。 でも管理された公園では、次の日には修復されてるから書かれてたことにすら気づかなくて、誰も描かなくなる。
10年に1度くらいアホが便器を壊すなんて馬鹿なことをする事件もあるが、バカはどこにでもいるから仕方ない。 お題
四角形の羅列を、'#'と'.'を使った表現から罫線を使った表現に変換せよ
(例)等幅フォントで見てください
#
↓
┌┬┐
├┼┤
└┴┘
#..###.####.
..#.....##.#
#.#....#.#.#
....#.#...#.
┌┬┐ ┌┬┬┬┬┬┐ ┌┬┬┬┬┬┬┬┐
├┼┤ ├┼┼┼┼┼┤ ├┼┼┼┼┼┼┼┤
└┴┘ ┌┬┼┴┴┴┴┴┘ └┴┼┼┼┼┼┴┼┬┐
├┼┤ ├┼┼┼┤ ├┼┤
┌┬┐ ├┼┤ ┌┬┼┴┼┼┤ ├┼┤
├┼┤ ├┼┤ ├┼┤ ├┼┤ ├┼┤
└┴┘ └┴┘ ┌┬┐ ┌┬┼┴┘ └┴┼┬┼┴┘
├┼┤ ├┼┤ ├┼┤
└┴┘ └┴┘ └┴┘ >>410 ruby
https://ideone.com/lGQ1lX
f = -> s {[''].product(*s.chars.map {|c| [c, c.upcase]}).map(&:join)}
p %W(#{} a ab).map {|s| [s, f.(s)]}
↓
[["", [""]], ["a", ["a", "A"]], ["ab", ["ab", "aB", "Ab", "AB"]]] というか >>441 の問題が意味不明。 スクリーンショットで示してみなよ。 俺はやらんだろうけど。 >>441 なんかプログラムの練習の前に、日本語のおさらいをした方が良い人間が見受けられるな。
プログラムはチームワークだから、他人に仕様が正確に伝えられなければその時点でそのプロジェクトは失敗。
理解しやすい言葉で混乱が起きない様に示すのが当たり前では？
それができない人はプログラムで問題を出しなさいよ。 なぜ#1つで4つの4角形になるんた？
#を図形として見た場合一致しないと思うんだが 記号を罫線ので作った四角にしろってことでこの場合は#だったってだけでは？
なんだったら「田」から変換するようにすれば雰囲気がマッチして良いかも知れんな。気分の問題だが。 >>441 でたらめだろ。 ＃が田形3マスになるのは良いとして、ドットが何で3マスになったり、1マスになってるんだよ。
#..###.####.
..#.....##.#
#.#....#.#.#
....#.#...#.
１２３４５６７８９いろはにほ１２３４５６７８９へと
┌┬┐ ┌┬┬┬┬┬┐ ┌┬┬┬┬┬┬┬┐
├┼┤ ├┼┼┼┼┼┤ ├┼┼┼┼┼┼┼┤
└┴┘ ┌┬┼┴┴┴┴┴┘ └┴┼┼┼┼┼┴┼┬┐
├┼┤ ├┼┼┼┤ ├┼┤
┌┬┐ ├┼┤ ┌┬┼┴┼┼┤ ├┼┤
├┼┤ ├┼┤ ├┼┤ ├┼┤ ├┼┤
└┴┘ └┴┘ ┌┬┐ ┌┬┼┴┘ └┴┼┬┼┴┘
├┼┤ ├┼┤ ├┼┤
└┴┘ └┴┘ └┴┘ >>455 ごめん、罫線だから、0.5ずれてたのか。 しかしわかりにくい問題だな。
もしかして自分の仕事を人に押し付けようとしていないか？ 専用ブラウザじゃ等副フォントなんて選べないのがあるのを知らないのか？
BB2Cでは、英字は等幅が選べても、漢字にはフォント設定すらない。
Jane Doe View も MSゴシックを選択しても等幅にならない。
読み手の設定を変えさせる問題なんて2chにはふさわしくない。 俺は等幅で見てくれってあったら、設定を変えるんじゃなくてメモ帳にコピペして見るけどなー >>459 そうやって見たけど面倒くさい。 やるならどこかのサイトに張り付けるか画像で出題すべきだろ。 問題とかずに問題への文句ばかり垂れるってお前らにしては珍しいな
問題とけよクズども この広い日本のどこかに同じ時に同じレスに反応してしまった二人がいる。
プログラミングの世界は奥が深いな…… >>457
なるほど
>>411 Common Lisp (>>457の移植)
https://ideone.com/OTuTMy
すごいなあ、こんなの全然思いつけない
文字を文字のままどうにかしようとしてぐちゃぐちゃになったのが>>454でした >>471
自分の好みじゃないと面白くないなんて小学生か。
黙ってスルーするか、自分が好みの問題だして盛り上げたらどうだ？ お題：2つの円が重なった時、重なった部分の面積を求めなさい。 >>475
分からない人は答えなくていいし黙って見ていればいいよ >>476
ttps://detail.chiebukuro.yahoo.co.jp/qa/question_detail/q1263968897
このサイトは具体的な座標と半径について手計算で解いた例だけど、
座標と半径を一般化して連立二次方程式を解いて交点を求め、
三角形と円弧の面積の差を求めれば重なり合う2円弧の面積が算出できる。
小さい円の中心が大きい円の内側にある場合は、
三角形と円弧の面積の差の求め方を逆にする。
小さい円が大きい円の完全に内側にある場合は、小さい円の面積とする。
x,y座標で式を立てるより、曲座標で表して三角関数使うほうが楽かもしれない。
これをプログラム化すれば良い、筈【だと思う。
以上。 2つの中心を通る線をX軸としてX軸と交わる点の端っこを原点して円の交点と半径で
円一個ずつ積分して面積を出して合わせるしかないだろ。 半径と中心間の距離から円の交点間の距離（＝弦）がわかるから
正弦定理とarcsinで中心角を求めればあとはただの掛け算と引き算だろ プログラム的には円同士の位置関係で場合分けして、あとは計算一発だから二次方程式をいやがる必要もなくない？ >>473 C
ttps://ideone.com/trIqHx
画像も参照。
ttps://imgur.com/i2G9Ahd >>485
条件分岐が間違っていたので修正。おそらくあってると思う
https://ideone.com/DjZqEY
余弦定理を使う方法しか思いつかなかったから、それでやった お題：不等間隔で与えられる関数表から１次とか２次で補間をしなさい。 お題： ２つの任意の英数字からなる芸術的なアスキーアートを出力しろ お題： アスキーアートで芸術的な木のアスキーアートを出力しろ お題 全角空白区切のCSV
カレントディレクトリにあるCSVファイルを読み込み、指定されたカラム名のデータの合計を求める。
1レコード目にはカラム名がある。
区切り記号は全角空白とする。 データの数字は全てASCII数字だとする。
CSVファイル内のデータ例
カラム1 カラム2 カラム3 カラム4
1,0 2.0 3.0 4.0
2.1 3.1 4.1 5.1
------データ例終わり
出題 カラム3 の合計を求めよ。
解答例 カラム3 = 7.1 >>494 間違い
データに 1,0 という間違いがあるけど問題ないだろ。
ついでに、この状態でカラム1の様にデータフォーマットが違う場合には正しくデータエラーを報告せよ。 日本やアメリカでは、ピリオドは文の終わりや小数点として使う。
カンマは文章途中の区切りや複数の項目の区切りに使う。 >>494
awk。-F オプションで指定しているのが全角スペースね。OSやシェルの違いによってはシングルクオーテーションではなくダブルクォーテーションにする必要がある。入力はファイル名指定するか標準入力から読ませる。
awk -F' ' 'BEGIN{getline}{n+=$3}END{print n}' awkはデータフォーマットがおかしくても適当に0ってことにしちゃったりしてエラーにならんのでデータ異常まで調べたいなら他の言語使った方が良いだろうな。 >>499 カラム名を指定してよ。カラム名は指定された名前であり固定ではない。 お題：端末の横幅が与えられるので(*´ω｀*)を端末の中央に表示せよ >>503 Ruby
w = 120
printf("%s%s\n", " " * ((w - 10) / 2), "(*´ω｀*)") 茨木 保健
貴老沢 風花
鬼塚 海鈴
鬼埜 可恋
儀賀沢 一愛
嫌沢 宮子
己問 彩姫
寺沢 七彩
寿川 瑞紀
樹木山 美咲
宗田 純
女ケ沢 美優
女ケ澤 飛鳥
女鹿沢 祐奈 >>494
Ruby で
require 'csv'
# 全角空白区切りで、ヘッダー有り
options = { :headers => true, :col_sep => " " }
# CSV ファイルを、1行ずつ処理する
puts CSV.foreach( "input.csv", options )
.map{ |row| row[ 2 ].to_f }.inject( :+ ) >>507 カラム名サーチが入っていないみたいだけど。
例えば ”カラム3” と言うカラム名が指定されたとして書いてみて。3列目と言うことじゃないからね。
カラム4 カラム2 カラム1 カラム3
かも知れない。 変な流れが続いていたから、バカっぽいお題をいくつか出した後に一見まともそうなお題のふりして宿題をやってもらおうという腹かと勘ぐってしまう。 >>509
お前の思いちゃんと伝わったよ
問題解けクズ お題１： テトリスタイリング問題を解決しろ
ここでテトリスタイリング問とは任意の図形のアスキーアートを入力すると
全てのテトリスのブロックに隣接するブロックの種類が異なるようにタイリングしたアスキーアートを出力する
問題である
お題２： テトリスタイリングNブロックス問題を解決しろ
ここでこの問題は上の問題でブロックの種類の数Nを最小にする問題である
例：
入力：
****
****
****
出力：
1002
1002
1122 >>515
これじゃダメなのか?
1011
1001
1101 >>515 ボクちゃんわかんない。
何で縦の列は1とか同じ種類が許されてるの？ なんか上から下へとか言う動きを前提にしてるの？ >>518
https://upload.wikimedia.org/wikipedia/commons/9/9a/Tetrominoes_letter_oriented.png
片面テトロミノ(画像参照)を回転させて指定の形に詰め込め
ただし、同じテトロミノを隣接させてはいけない。 ってことじゃろ
515の出力例でいうと、
0は画像の水色、1は黄色、2は紫色の奴ってこと >>515 その出力例だと、タイルの種類は3種類じゃないの？
1と2を同じだとみなせば、同じ種類と隣接するからダメだろ？
>>516 だと完全に2種類だが。 >>521
だからこそ出題例>>515は3種類のブロックを使ってるんだろ？
2種類で出来ていないから問2に対しては不正解では？ >>522
例がお題２とお題１両方の答えになっているなんてことはどこにも書いてないだろ
例を見ればだれでもどのお題の答えかわかるだろ >>523 誰でも解ると言うのは言い過ぎ。 何が正しいのかを示すのが例なんだし。
なんにせよお題の出し方が独断すぎるよ。
テトリスタイリングなんて知らない人にとっては説明不足だし
>>519 の説明があって初めて平面上の回転図形は同じとみなし、裏表の回転は許さないと解るけど。
それでも519のブロックは4個の組み合わせのブロックしかないが、どうして4個固定なのか？ 最大辺の個数を単位とするのか？
この場合は5個固定？
***
***
***
***
*** >>524
釣りだろ？
本当にわからないのなら病院に行くレベルｗ >>199と>>441が理解できなかったってやつと同一人物なのは分かる >>524
>どうして4個固定なのか？
テトリスってゲームがあってそれに出てくるブロックが>>519
>>515
>全てのテトリスのブロック
https://ja.wikipedia.org/wiki/%E3%83%86%E3%83%88%E3%83%AA%E3%82%B9
テトリス
>4つの正方形を組み合わせて作られた、片面型テトロミノ状のブロックピース
>（以下の7種、本作ではこれらを「テトリミノ」（Tetrimino）と呼ぶ）
>がフィールド上方からランダムに1種類ずつ落下してくる。 >>441は分からんかった
問題を考えさせてほしい
問題文を考えさせるんじゃなく >>530 片面テトリミノの基本は4個だけどこれを使う前提なら、３ｘ５とか4の倍数の面積にならない図形は解けないよね。
聞いてるのは３ｘ５はどうするのと言う話。 >>532
この問題は君の思ってる小学校の算数とは違うんだよ 問題の難しさと、問題の曖昧さは関係ないけどな。
難しい問題の条件が曖昧だと鼻から解く気になれない。 考えればわかることまでいちいち書かないのは常識
それを曖昧とは言わない 当たり前のことでもいちいち全部書くのがこの業界の常識だが 仕様書をやりとりしてみれば如何に他人に解らせることが難しいか理解できると思うけどな。 多分出題者は余り経験していないんだろう。
仕様をいい加減で進めても後で痛い目を見るのは自分。
(最初は完全でないのは当然、打ち合わせで抜けを詰めていけば良い話) >>538
テトリスがなにかなんて自分でググって調べればいいことだろ
そんなことまで面倒みれない そういや安かったのでPS4用のテトリスを何気なく買って連日やってたら慣れてきちゃってレベル15の40ライン消しが楽にできるようになってしまったなあ。
今さらテトリスうまくなってどうすんだ俺w >>494
Kotlin
https://paiza.io/projects/w5ywqyfGfQpwllH68rmt5A
入力はカラム名の行が最初にあり、次の行からはデータが続き「# カラム名」の行で終わり、
そこで指定したカラム名の列の合計値が出力される。
エラーはデータが数値として解釈できない文字列、項目数がカラム名の数と一致しない行、
同一カラム名があった場合に出る。一度エラーになると # の行まで読み飛ばされる。 お題
R言語にandmaginsとうう関数がある。
m行n列の行列を渡すと行ごとの合計と列ごとの合計を追加して
(m+1)行(n+1)列の行列を返す。
同様の関数をつくる。
1 2 3
4 5 6
が
1 2 3 6
4 5 6 15
5 7 9 21
となる >>544 Squeak/Pharo Smalltalk
| fn |
fn := [:arr | arr, {arr sum} collect: [:row | row, {row sum}]].
fn value: #(
(1 2 3)
(4 5 6)
).
"=> #(
(1 2 3 6)
(4 5 6 15)
(5 7 9 21)
) " 大文字小文字だけが異なる、ファイル名を見つける
入力
aB.txt
Ab.txt
xx
cd
cD
CD
出力
aB.txt : Ab.txt
cd : cD : CD #!/bin/sh
infile="aB.txt Ab.txt xx cd cD CD"
for f in ${infile}; do
echo $f $(echo $f | tr [:lower:] [:upper:])
done | awk '
{ save[$2] = save[$2] " : " $1 }
END {
for (i in save) print save[i]
}' | sed 's/^ : //' | sort | awk 'NF > 1 {print}' >>547 Squeak Smalltalk
| fn |
fn := [:arr |
| groups |
groups := arr groupBy: #asLowercase having: [:group | group size > 1].
groups values collect: #asArray
].
fn value: #('aB.txt' 'Ab.txt' 'xx' 'cd' 'cD' 'CD').
"=> #(('cd' 'cD' 'CD') ('aB.txt' 'Ab.txt')) " >>547
それはWindowsとかでは試せないのでは？ディレクトリが違うならできるだろうけど。
(まあWindowsでもWSLでUbuntuとか動かせばできるが) 同一フォルダ内での、大文字小文字だけが異なるファイル名は、Windows では作れないけど、
Linux では作れてしまうので、それをチェックする目的です
Linuxでも、こういうファイル名は作らない方がよい 時々死ねと言うやついるけど同じやつなのか？ いい加減で大人になれ。 >>555 それは言語によるんじゃないの？ 論理的にはあり得ない。
一般的には、0がFalse でそれ以外がTrueと言うだけでは？ 整数のオーバーフロー使えば楽に証明できるけど、それはもはや基礎数学の整数じゃないし。 お題：
N人の人物がある部屋に出入りしています。
i番目の人は時刻a[i]に入室し、時刻b[i]に退室します。(1 <= a[i] < b[i])
すべての人は入退室時に以下の通り行動します。
・入室時に、照明がOFFならば照明をONにする。
・退室時に、室内に自分以外に誰もいなければ照明をOFFにする。
最初は照明がOFFになっていて室内には誰もいません。
複数の人物が同時に入退室することはないものとします。
照明がONになっている時間の合計を求めなさい。
a={1,3,5}
b={2,4,6}
=> 3
a={1,2}
b={5,6}
=> 5
a={100,1,2}
b={105,3,4}
=> 8 >>364
brainf*ck
>++++++++++<+[,.>.<] >>410 J
f =: 3 : 0
> , { ;/(,. toupper) y
) >>559 ruby
すこーしすっきり
f = ->a, b {a.zip(b).map {|c| (c.first...c.last).to_a}.inject(:|).size}
↓
f = ->a, b {a.zip(b).map {|c, d| [*c...d]}.inject(:|).size} >>564
たった2行とは、素晴らしい！
JavaScript(JS)とか、関数型プログラミングだね
f(&:upcase), f(&:chomp)
関数型でも、こういうように呼ぶ関数名が明確にわかる点では、Ruby はJS をしのぐ！
漏れが以下で作ったけど、手続き型の処理で、10行以上も掛かったw
情けない
Ruby 初心者スレッド Part 65
https://mevius.5ch.net/test/read.cgi/tech/1545421414/234 アンダースコア_はprologの時点であるんじゃね
それに記号なら恣意的だろ >>544
Haskell
main = mapM_ print $ newxss ++ [zipWith (+) (newxss!!0) (newxss!!1)]
xss = [[1,2,3],[4,5,6]]
newxss = map (\xs -> xs ++ [sum xs]) xss お題：文字列と数値nが与えられるのでn番目の文字とそれ以外の文字を上下にスライドさせて表示する
入力
abc 2
出力
*b*
a*c お題か出力のどっちかが間違っている
日本語勉強した方がいい >>544,570
任意の数の行列だったか。。。
修正
main = mapM_ print $ newxss ++ [lastxs]
xss = [[1,2,3],[4,5,6],[7,8,9]]
newxss = map (\xs -> xs ++ [sum xs]) xss
lastxs = map sum $ retsu newxss
retsu ([]:xs) = []
retsu xss = map head xss:retsu (map tail xss) >>557
オーバーフローは数学ですらないだろ。こっちは数学。
宇宙を支えていたのは、驚異のたし算だった
私がこのたし算を知ったのは20歳のころでした。その衝撃は、私の運命を変えるまでの威力を持っていました。
私の大学は2年生で所属学科を決めるシステムになっており、私はアインシュタインに憧れて物理学科に進もうとしていました。
その私が出会ったのがラマヌジャン（1887-1920）です。彼が描いた2つの絵を見た瞬間、私の中で何かが変わりました。
http://jbpress.ismedia.jp/mwimgs/4/b/400/img_4b7f33022b840f792a0324a10b89a24d369437.jpg
http://jbpress.ismedia.jp/articles/-/46939 >>574
応用数学ではオーバーフローも数学の一種。 >>364
Haskell
main = mapM_ (\c -> putStrLn $ c:[]) "hello" >>544
kotlin
https://paiza.io/projects/cL6xIQA--yDFZ1pjndvzAw
Double型でやったら出力に小数点以下が付加されたが値として間違ってるわけではないのでそのままにする。 >>544 Python
import numpy as np
# 何行何列でも良い
ar =[
[1,2,3,4],
[4,5,6,7],
[7,8,9,10]
]
#縦に足して行を追加
r=np.vstack((ar,np.sum(ar,axis=0)))
#横に足して列を追加
ans=np.hstack((r,np.sum(r,axis=1).reshape((-1,1))))
print('ans=\n',ans)
'''
ans=
[[ 1 2 3 4 10]
[ 4 5 6 7 22]
[ 7 8 9 10 34]
[12 15 18 21 66]]
''' >>571 ruby
s = "abc"
n = 2
t = "*" * s.length
t[n - 1] = s[n - 1]
u = s.clone
u[n - 1] = "*"
puts(t, u) >>571 J
f =: 4 : 0
|: ((,. -.) (<:x) = i. # y ) {"1 '*' ,. y
)
2 f 'abc'
*b*
a*c >>571
Haskell
main = do
putStrLn $ seclet "abc" (==) 2
putStrLn $ seclet "abc" (/=) 2
seclet lst func num = seclet' lst func 1 num
where
seclet' [] _ _ _ = []
seclet' (x:xs) f n a | f n a = x: seclet' xs f (n + 1) a
seclet' (_:xs) f n a = '*': seclet' xs f (n + 1) a >>571
>>581
引数の順序入れ替えてmapM_ 使って、main部分を一行にまとめた。
main = mapM_ (putStrLn.seclet "abc" 2) [(==),(/=)]
seclet lst num func = seclet' lst 1 num func
where
seclet' [] _ _ _ = []
seclet' (x:xs) n a f | f n a = x: seclet' xs (n + 1) a f
seclet' (_:xs) n a f = '*': seclet' xs (n + 1) a f >>571 Perl5
($s, $n)= qw{abc 2};
@s = split'',$s;
@t = qw{*} x @s;
$n--;
($s[$n], $t[$n]) = ($t[$n], $s[$n]);
print @t, "\n", @s, "\n";
実行結果
~ $ perl 13_571.pl
*b*
a*c >>544 Perl5
@a = ([1, 2, 3,],
[4, 5, 6]);
use List::Util sum;
push @$_, sum(@$_) for @a;
for $i (0..$#{$a[0]}) {
push @b, sum(map{$a[$_][$i]} 0..$#a)
}
print "@$_\n" for @a;
print "@b\n";
実行結果
~ $ perl 13_544.pl
1 2 3 6
4 5 6 15
5 7 9 21 >>571 ruby
https://ideone.com/6NM2Z2
>>567
String#lines ←これの存在知らなかった
勉強になりました >>588
余談だが、Ruby のString#lines の所を見たら、chomp: true で改行も削除できる！
Rubyは、色々と便利なものを作っている
p ary = <<"EOT".lines( chomp: true ) # 配列
a
b
EOT
#=> ["a", "b"] >>571 Squeak/Pharo Smalltalk。nを複数指定可で
| fn |
fn := [:str :ns |
| ans |
ans := (String new: str size withAll: $*), String cr, str.
ns do: [:n | ans swap: n with: n + str size + 1].
ans
].
fn value: 'abc' value: #(2). "=>
'*b*
a*c' "
fn value: 'abcdef' value: #(2 3 5). "=>
'*bc*e*
a**d*f' " >>547 Perl5
https://ideone.com/Mbj5Hz
push @{$h{lc $_}}, $_ for <STDIN>;
print "@{$_}" for grep{@$_ > 1} values %h; >>571 Python
def split3(s,p=1) :
r0= s[:p]+'*'+s[p+1:]
r1= '*'*p + s[p] + '*'*(len(s)-(p+1))
return r0+'\n'+r1
print(split3('abcd',2))
print(split3('abc',0))
'''結果
ab*d
**c*
*bc
a**
''' お題： 下の例のような入力から例の出力のアスキーアートを出力する。それ以外は自由
例：
入力： >>>>>vvvvv<<<<^^^^
出力：
>>>>>
^****v
^****v
^****v
^****v
<<<<v >>571 Io
f := method(s,n,
"*" repeated(s size)atPut(n - 1, s at(n - 1)) println
s asMutable atPut(n - 1, 42)println
)
f("abc",2)
実行結果
*b*
a*c >>601
それ3番目と4番目は必ず1番目と2番目の長さ-1になってるの？ >>602
>>604
そういうめんどくさい質問がこないように、
それ以外は自由と付け加えてある >>605
仕様をきっちり決めないと解釈の違いから沢山の違った回答が出てくる可能性があるのだが、それで良いと。 >>604
そもそも4方向にいくらかずつ進んで四角形で終わりという形とは限らないのでは？
ランダムに方向や距離を生成して既に通った道も上書きするような入力を許容すると考えたっていいはず。 >>605 何でこれ以外の形は許さんと言えないんだ？
自由にどうぞなんて問題じゃ無いだろ。 >>606,608
こいつらホント掃き溜めのゴミだな >>607
なるほど。しかしそれならばその事を書いておいて欲しかったな。
>>609
何を作れば良いのかよくわからないから質問しているだけなのだが。それが君にとって何か不都合なのか？ >>601
出力おかしくねぇ？最初と最後の行は5列だけど
間の行ぜんぶ6列になってるぞ？
出力：
>>>>>
^****v
^****v
^****v
^****v
<<<<v
こうじゃね？
>>>>>
^***v
^***v
^***v
^***v
<<<<v >>601 javascript
長くなっちった
https://ideone.com/vzncKq
入力： <<<<^^^^>>>>>vv<<<<<<<<<<<vvv>>>^^^^^^^>>>>>>>>>>vvvvvv
出力：
***^>>>>>>>>>>
***^*********v
***^**^>>>>>*v
***^**^****v*v
<<<^<<<<<<<v*v
v**^**^******v
v**^**<<<<***v
v>>>********** お題
m×nマスのチェス盤を考える。
1つのナイトが最も左上のマスにあり、そこから任意の回数動かすことができる。
ナイトが訪れることのできるマスの個数を求めよ。
m=1, n=1
=> 1
m=3, n=3
=> 8 (真ん中のマスを訪れることができない)
m=4, n=4
=> 16 >>614 説明がないと何をどうやってるのかわけわからん。
先ずは入力と出力をどう解釈して作ったのか？
形にも一貫性があるとは思えないけど。
しかしこんなのがどんどん出てきたら、煩わしいだけ。 出題通り以外の回答はやめてほしいな。
それ以外の回答をする場合は、解説文も日本語で書いてくれよ。
不慣れなプログラムもあることだろうし、長いプログラムなんて見る気にもならないし、プログラムを見ればわかるというのは無し。 >>618
ソースの中身まではちゃんと確認してないけど、ちゃんと出題通りにできてると思う。
出題の"入力例"通りではないが、複雑な入力パターンに対して正しく動いてそうと思える実行例だと思うぞ。 >>>v<^^>>
の場合
*^>>
>^>
*<v >>571 octave 複数列指定可能版
https://ideone.com/UqKcNb
h = @(m, n) cell2mat(arrayfun(@(c, i) {['*'; c] [c; '*']}(1 + (i == n)), m, 1:numel(m)));
↓
h = @(m, n) cell2mat(arrayfun(@(c, i) {['*'; c] [c; '*']}(1 + any(i == n)), m, 1:numel(m))); 以下の整形式の.ini ファイルから、すべての値を取得して、
「セクション名 : キー名 : 値」で表示する
[sec1]
key1=val1
[sec2]
key2=val2 >>623 Perl5
while (<DATA>) {
$s = $1 if /\[(\w+)\]/;
print "$s:$k:$v\n"
if ($k, $v) = /(\w+)=(\w+)/;
}
__DATA__
[sec1]
key1=val1
[sec2]
key2=val2
実行結果
~ $ perl 13_623.pl
sec1:key1:val1
sec2:key2:val2 >>625 も少し簡潔に書けるんだった…
while (<DATA>) {
$s = $1 if /\[(\w+)\]/;
print "$s:$1:$2\n" if /(\w+)=(\w+)/;
}
__DATA__
[sec1]
key1=val1
[sec2]
key2=val2 >>623 javascript(es2018 named capture groups)
`
[sec1]
key1=val1
[sec2]
key2=val2
`.replace(/\[(?<section>.+)\]\n(?<key>.+)=(?<value>.+)\n/g, '$<section>：$<key>：$<value>').trim();
結果：
sec1：key1：val1
sec2：key2：val2 >>547
Haskell
import Data.Char
main = (mapM_ print.filename) ["a","aB.txt","Ab.txt","xx","aBc.txt","cd","cD","CD","ab.txt","z"]
filename [] = []
filename (xs:xss)| length a > 1 = a:filename b
where
a = func (==)
b = func (/=)
func f = filter (f (map toUpper xs).map toUpper) (xs:xss)
filename (_:xss) = filename xss >>615
0 <= m，n <=10億 と仮定して
int64_t cal(int m, int n){
if( m>n ) swap(m, n);
if( m<=1 ) return m;
if( m==2 ) return (n + 1) / 2;
if( n==3 && m==3) return 8;
return (int64_t)n * m;
} >>623 Io
f := method(s,
s split("\n\n")map(splitNoEmpties("[","]","\n",=")join(":"))
) >>619
出題通りなのかどうかがわからんのだが。どう解釈したら出題通りとなるのか？ お題
数列a[i]を考える。
a[0] = p
a[i+1] = q * a[i] + r
[入力]
p q r n
(p,q,r,nは整数)
(0≦p,q,r≦99)
(0≦n≦10^10)
[出力]
a[n] mod 13 を求めよ
1 2 0 8
=> 9 (2^8 mod 13)
1 0 99 0
=> 1
1 2 3 2
=> 0 (a[0]=1, a[1]=2*1+3=5, a[2]=2*5+3=13)
1 3 5 10000000000
=> ? >>619
>>547に対して、ナチュラルソートされて無くても(普通のソートでも正しい答えが得られるとは限らない)正しい答えを出せるとか、出題者の意図を踏まえながら、意図を超えた範囲もカバーするのはいいんじゃ無いか？
意図を無視するのは論外だが。 >>632
マシンパワーがあれば式を入れればいいだけってのはね。。。
解くのに頭使う。解いてみたら案外簡単(アルゴリズムが浮かぶのがキモ)。あえて難しくて最適化の道がある。とかが望ましい。
いあ、無茶振りだろうから、どれか2つ満たせればおkだが。 例えば[[1,2,3],[4,5,6],[7,8,9]]みたいな任意のn*nなリスト(または配列)を非破壊的に作れ。とか。 >>636
一般的なミューテートするカウンタも使っちゃダメってことかな？ >>623
お題を修正
[ ] = の3つは、特別な記号です。
それらを含まない行は、無視して
[sec1]
key1=val1
[sec2]
key2=val2
x=y
>>627
セクション名・キー名・値は、特定の文字列ではありません！
特別な記号以外の、任意の文字列です お題
現行規格のISBN (ISBN-13) のcheck digit は、JANコードと同じく、
「モジュラス10 ウェイト3・1（モジュラス10 ウェイト3）」という計算法にて算出される
一番右側の? の所のcheck digitを除いて、数字以外は無視して、
一番左側の桁から順に、1、3、1、3…を掛けて、それらの和を取る。
和を10で割って出た余りを、10から引く。
ただし、10で割って出た余りの下1桁が0の場合は、check digitを0とする
ISBN 978-4-10-109205-?
9×1 + 7×3 + 8×1 + 4×3 + 1×1 + 0×3 + 1×1 + 0×3 + 9×1 + 2×3 + 0×1 + 5×3
= 9 + 21 + 8 + 12 + 1 + 0 + 1 + 0 + 9 + 6 + 0 + 15 = 82
82 ÷ 10 = 8 あまり 2
10 - 2 = 8
幾つかのISBN-13 で、計算してみて！ >>632 C
https://ideone.com/m3vejt
エクセルとかで実際に数列を計算してみると、長さ12(剰余の数-1)以下の周期になるっぽいのでそれで求められる。
普通に計算するとq * a[i] + r はどんどん大きくなるけど、
毎回 (q * a[i] + r) mod 13としても、計算に影響はないようなので、オーバーフローもせずに計算できる。
だたし、数学的に正しいか保証しかねるが。 >>640
12 0 11 1
=> 11
というコーナーケースが… >>643
確かに、
コメントアウト(bf2)するときに誤ってしまったようだ、
("if(n==0)" だったのだが、いらないなぁ)
どっちにしろ、0や1のテストは、やってない >>637
だめ。
そこが関数型言語と手続き型言語の考え方の大きな違いだし。
皮肉にも？それ作った時、入門書の関数より考え方の違いが分かった。 >>638
> セクション名・キー名・値は、特定の文字列ではありません！
> 特別な記号以外の、任意の文字列です
えぇ…
入力：
[あああ]
いいい=ううう
[えええ]
おおお=かかか
出力：
あああ：いいい：ううう
えええ：おおお：かかか
少なくとも任意の文字列には対応してるじゃん。不当指摘だ！ >>645 javascript
const seqSqArr = n => Array.from({length: n}).map((v, i) => Array.from({length: n}, (v, j) => n * i + j + 1));
console.log(seqSqArr(3));
//=> [[1,2,3],[4,5,6],[7,8,9]]
console.log(seqSqArr(7));
//=> [[1,2,3,4,5,6,7],[8,9,10,11,12,13,14],[15,16,17,18,19,20,21],[22,23,24,25,26,27,28],[29,30,31,32,33,34,35],[36,37,38,39,40,41,42],[43,44,45,46,47,48,49]] >>646
スマン。漏れの間違い！
key, val などの特定の文字列を置換しているのかと、勘違いしていた >>639 J
f =: 3 : 0
10 | 10 - 10 | +/ (12 $ 1 3) * "."0 }: y -. '-'
)
f '978-4-10-109205-8'
8
f '978-4873115870'
0 >>636,637,645,647
Haskell
main = ps 3 >> putStrLn "" >> ps 7
where ps = print.seqSqList
seqSqList n = (take n.iterate (map (+ n))) [1..n]
out:
[[1,2,3],[4,5,6],[7,8,9]]
[[1,2,3,4,5,6,7],[8,9,10,11,12,13,14],[15,16,17,18,19,20,21],[22,23,24,25,26,27,28],[29,30,31,32,33,34,35],[36,37,38,39,40,41,42],[43,44,45,46,47,48,49]] こうかな？
;; Common Lisp
(defun seq-sq-list (n)
(labels ((sub (i r)
(if (zerop i)
r
(sub (1- i) (if (zerop (mod i n))
(cons (list i) r)
(cons (cons i (car r)) (cdr r)))))))
(sub (* n n) nil))) お題: ピリオド区切りの二つのバージョン番号を比較し、大小関係を判定した結果を-1, 0, 1のいずれとして返せ。
0.1.2 > 0.0: 1
1.2.3 < 1.3: -1
0.0.0 == 0.0: 0 >>653
手抜きHaskell
main = mapM_ pc $ [("0.1.2", "0.0"), ("1.2.3", "1.3"), ("0.0.0", "0.0")]
where pc = print.uncurry mycompare
mycompare "0.0.0" "0.0" = 0
mycompare "0.0" "0.0.0" = 0
mycompare xs ys |xs `compare` ys == EQ = 0
|xs `compare` ys == GT = 1
|xs `compare` ys == LT = -1 >>601 Perl5
$s = '>>>>>vvvvv<<<<^^^^';
($i, $y) = (0, 0);
for (split'',$s) {
$i++ if />/;
$i-- if /</;
$j++ if /v/;
$j-- if /\^/;
push @t, [$i, $j, $_];
}
use List::Util qw{min max};
($i, $j) = (min(map{$$_[0]} @t), min(map{$$_[1]} @t));
$$_[0] -= $i, $$_[1] -= $j for @t;
($i, $j) = (max(map{$$_[0]} @t), max(map{$$_[1]} @t));
push @m, [('*')x($i + 1)] for 0..$j;
$m[$$_[1]][$$_[0]] = $$_[2] for @t;
use feature say;
say @$_ for @m;
実行結果
~ $ perl 13_601.pl
>>>>>
^***v
^***v
^***v
^***v
<<<<v >>638 Perl5
$r = qr/[^][=]/;
while (<DATA>) {
chomp;
$s = $1 if /\[($r+)\]/;
print "$s:$1:$2\n" if /($r+)=($r+)/;
}
__DATA__
[sec1]
key1=val1
[sec2]
key2=val2
実行結果
~ $ perl 13_638.pl
sec1:key1:val1
sec2:key2:val2 >>653 javascript
const vComp = (a, b) => {
const [semA, semB] = [a, b].map(v => {
const {major, minor = 0, patch = 0} = /(?<major>\d+)(\.(?<minor>\d+)(\.(?<patch>\d+))?)?/.exec(v).groups;
return {major, minor, patch};
});
const majorComp = semA.major - semB.major;
if (majorComp) return Math.sign(majorComp);
const minorComp = semA.minor - semB.minor;
if (minorComp) return Math.sign(minorComp);
const patchComp = semA.patch - semB.patch;
return Math.sign(patchComp);
};
console.log(vComp('0.1.2', '0.0'));
console.log(vComp('1.2.3', '1.3'));
console.log(vComp('0.0.0', '0.0'));
結果：
1
-1
0
（おまけ）ソート：
console.log(['0.1.2', '0.0', '1.2.3', '1.3', '0.0.0', '0.0'].sort(vComp));
結果：
["0.0", "0.0.0", "0.0", "0.1.2", "1.2.3", "1.3"] >>653
大小関係の定義をまじめに考えましょう。
>>659
JavaScriptならsplit使えるはず。桁数の制限は要らない。 LaTeXのバージョンシステムはちょっと特殊で、円周率に近付くようになってる。この場合は文字列として比較しないといけない。
一般的なバージョンシステムはドットで区切られた整数を先頭から順に互いに比較して大小関係を定義する。
まれにアルファとかベータとか「限定版」とか訳のわからない文字列が付くことがあるが、これは常識がなければ大小関係を機械的に判定するのは難しい。 一番確実なバージョン大小判定方法は、リリースごとに年月日とバージョン情報を記録しておくことだ。 >>547
Haskell
内包表記の方が何をやってるか分かり易いと気付いて書き換えた。
import Data.Char
main = (mapM_ print.filename) ["aB.txt","Ab.txt","xx","cd","cD","CD","ab.txt"]
filename [] = []
filename (xs:xss)| length a > 1 = a:filename b
where
a = func (==)
b = func (/=)
func f = [xs' | xs' <- (xs:xss), map toLower xs `f` map toLower xs']
filename (_:xss) = filename xss お題： 何も出力しないプログラム自身のコードをソートするとhello worldを出力するプログラムを作れ >>653 # Python
def cmp(v0,v1):
if v0==v1: return 0
else: return 1 if (v0 > v1) else -1
print(cmp('1.2.3','1.2') , cmp('1.2.3','1.1.1') ,
cmp('1.1', '1.1') ,
cmp('1.2.3','1.3')
)
# 1 1 0 -1 >>667
バージョン番号の各整数の数字は2個以上になることがある。'10.0'と'9.1'を比較せよ。 >>667
print( cmp('1.1.0', '1.1') )
# 1 >>667 訂正 Python
def cmp(v0,v1):
v0 = list( map(int , v0.split('.') ) )
v1 = list( map(int , v1.split('.') ) )
if v0==v1: return 0
else: return 1 if (v0 > v1) else -1
print(cmp('1.2.3','1.2') , cmp('1.2.3','1.1.1') ,
cmp('1.1.0', '1.1') ,
cmp('10.0','9.1') ,
cmp('1.1', '1.1') ,
cmp('1.2.3','1.3') ,
cmp('1.1', '1.1.0') ,
)
# 1 1 1 1 0 -1 -1 >>670
残念だが不正解。比較できる桁がなければゼロと見なす、すなわち、2.0.0は2に等しいと見なす決まりがある。 ソフトウェア開発におけるバージョン管理は、製造メーカーにおける型番管理と同じくらい重要である。
検査逃れのために型番や履歴をごまかしたり、型番管理がなっていないメーカーはメーカー失格である。
インターネット全盛の現在では、型番はウェブ検索しやすいものでなければ、国際競争に負けてしまう。 >>660 javascript
const vComp = (a, b) => {
const verA = a.split`.`;
const verB = b.split`.`;
const shorter = verA.length - verB.length < 0 ? verA : verB;
const cmps = shorter.map((v, i) => Math.sign(verA[i] - verB[i]));
return cmps.reduce((acc, v, i) => Math.sign(acc + v * 2 ** (shorter.length - i)), 0);
};
console.log(vComp('0.1.2', '0.0'));
console.log(vComp('1.2.3', '1.3'));
console.log(vComp('0.0.0', '0.0'));
結果：
1
-1
0
（おまけ）ソート：
console.log(['0.1.2', '0.0', '1.2.3', '1.3', '0.0.0', '0.0'].sort(vComp));
結果：
["0.0", "0.0.0", "0.0", "0.1.2", "1.2.3", "1.3"] >>671 どこにそんな決まりがあるの？
普通 ver.1 が出て、その後ver.1.0 が出れば、ver.1.0 の方が新しいのは明らかだろ。
総称として、ver.1という場合もあるが、その場合はver.1.9も含まれる。 見つけた
RPM::VersionSort - RPM version sorting algorithm, in perl XS - metacpan.org
https://metacpan.org/pod/RPM::VersionSort とにかくバージョン番号が異なれば別のバージョンとみなすのが普通だろ。
同じと思う方がおかしい。 お題：“木”という漢字を使って以下のようなフラクタル図形を描け
n=0
木
n=1
-木
木木
n=2
---木
--木木
-木--木
木木木木
n=3
-------木
------木木
-----木--木
----木木木木
---木------木
--木木----木木
-木--木--木--木
木木木木木木木木
※ハイフンはスペースだと思ってください >>678
Win32の固定幅のバージョン情報では４つの整数をドットで区切ったものを使用する。VerInstallFile関数はバージョン番号を比較する。0.0と0.0.0.0が違うバージョンだとアウトだ。 >>682 そんなローカルールなんて知るかよ。 もしそういう意図なら問題を訂正しろよ。 いちいち誰かのいちゃもんに付き合ってる暇はない。 >>660 の修正
const vComp = (a, b) => {
let verA = a.split `.`;
let verB = b.split `.`;
const len = Math.max(verA.length, verB.length);
verA = [...verA, ...'0'.repeat(len - verA.length)];
verB = [...verB, ...'0'.repeat(len - verB.length)];
const cmps = verA.map((v, i) => Math.sign(verA[i] - verB[i]));
return Math.sign(cmps.reduce((acc, v, i) => acc + v * 2 ** (len - i)), 0);
};
console.log(vComp('0.1.2', '0.0'));
console.log(vComp('1.2.3', '1.3'));
console.log(vComp('0.0.0', '0.0'));
console.log(['0.1.2', '0.0', '1.2.3', '1.3', '0.0.0', '0.0'].sort(vComp));
//いいかげん結果省略 >>683
例に0.0.0と0.0が等しいって書いてあるんだが >>683
> いちいち誰かのいちゃもんに付き合ってる暇はない。
ならスルーしろよ
お前の頓珍漢な解釈なんて要らんし >>653 Squeak Smalltalk
| fn |
fn := [:strs | (strs collect: [:str | (str subStrings: '.') polynomialEval: 1/1e4]) reduce: #<=>].
fn value: #('0.1.2' '0.0'). "=> 1 "
fn value: #('1.2.3' '1.3'). "=> -1 "
fn value: #('0.0.0' '0.0'). "=> 0 " >>653 Perl5
use feature current_sub;
@is = (['0.1.2', '0.0'], ['1.2.3', '1.3'], ['0.0.0', '0.0']);
for (@is) {
($l, $r) = @$_;
@l = split'\.', $l;
@r = split'\.', $r;
$z = sub {
my $a = shift @l;
my $b = shift @r;
if (defined $a or defined $b) {
$a //= 0;
$b //= 0;
$a <=> $b or __SUB__->()
} else {
0
}
}->();
%d = (-1 => ' <', 0 => '==', 1 => '> ');
print "$l $d{$z} $r : $z\n";
}
実行結果
~ $ perl 13_653.pl
0.1.2 > 0.0 : 1
1.2.3 < 1.3 : -1
0.0.0 == 0.0 : 0 >>673 Perl5
@f = (0, 1);
push @f, $f[-2] + $f[-1] while @f < 10;
print "@f\n";
実行結果
~ $ perl 13_673_fib10.pl
0 1 1 2 3 5 8 13 21 34
Prel6、いいな… >>666 I
行単位で昇順にソートする場合
exit
"hello world" println
文字単位のソートの場合は難しそう。 >>673 Squeak Smalltalk
| fibGen |
fibGen := [:a :b | Generator on: [:g | [g yield: a. b := a + b. a := b - a] repeat]].
(fibGen value: 0 value: 1) next: 10.
"=> an OrderedCollection(0 1 1 2 3 5 8 13 21 34) " >>681 Squeak Smalltalk
| sp fn |
sp := $-. "sp := Character space."
fn := [:n |
| tree |
tree := [:lines :count |
(lines collectWithIndex: [:line :idx |
line, (String new: idx - 1 * 2 withAll: sp), line
]), lines
].
(((1 to: n) inject: #('木') into: tree) collectWithIndex: [:line :idx |
(String new: idx - 1 withAll: sp), line
]) reversed asStringWithCr
].
fn value: 0. "=>
'木' "
fn value: 1. "=>
'-木
木木' "
fn value: 2. "=>
'---木
--木木
-木--木
木木木木' " >>673 javascript
const take = n => function*(iterable) {
const iterator = iterable[Symbol.iterator]();
for (let i = 0; i < n; i++) {
const {value, done} = iterator.next();
if (done) break;
yield value;
}
};
const fibo = function*() {
const memo = [0n, 1n];
const fib = n => n in memo ? memo[n] : memo[n] = fib(n - 2) + fib(n - 1);
for(let i = 0; ; i++) yield fib(i);
}();
console.log([...take(10)(fibo)]);
結果：
[0n, 1n, 1n, 2n, 3n, 5n, 8n, 13n, 21n, 34n] >>696
よく考えたら配列で出力する必要もなかった
console.log(...take(10)(fibo));
結果：
0 1 1 2 3 5 8 13 21 34 >>666 Lua
a=ture
a=a or print("hello world") >>673
Haskell
main = (print.take 10) fibs
where fibs = 0:1:zipWith (+) fibs (tail fibs) >>670 訂正 Python
def ver (v):
s = list( map(int , v.split('.') ) )
for _ in s:
if s[-1] == 0 :s.pop(-1)
return s
def cmp(v0,v1):
v0 = ver(v0)
v1 = ver(v1)
if v0==v1: return 0
else: return 1 if (v0 > v1) else -1
print(cmp('1.2.3','1.2') , cmp('1.2.3','1.1.1') ,
cmp('10.0','9.1') ,
cmp('1.1', '1.1') ,
cmp('1.2.0.0','1.2.0') ,
cmp('1.2.3','1.3')
)
# 1 1 1 0 0 -1 >>666
「ソートすると」ではなく「ソートしてからその出力を実行またはコンパイルして実行すると」なのでは？ お題： プログラムのコードの文字を縦読みしたコードが実行可能なコード お題
2桁16進数化したものをつなげた形でIPアドレスが与えられる。（例:192.168.0.1 -> C0A80001）
与えられたIPアドレスからホスト名を逆引きせよ。
例
08080808 -> google-public-dns-a.google.com
9da6e21a -> www.cnn.com >>706 node
const reverse = hexIP => require('dns').reverse(hexIP
.split(/^(..)(..)(..)(..)$/g)
.map(xx => parseInt(xx, 16) || '')
.join('.').replace(/^\.|\.$/g, ''),
(err, hostnames) => {
console.log(hostnames);
});
console.log(reverse('08080808')); //=> [ 'google-public-dns-a.google.com' ]
console.log(reverse('9da6e21a')); //=> [ 'www.cnn.com' ] >>688 もっと簡潔に書けるんだった…
>>653 Perl5
use feature current_sub;
@is = (['0.1.2', '0.0'], ['1.2.3', '1.3'], ['0.0.0', '0.0']);
for (@is) {
($l, $r) = @$_;
@l = split'\.', $l;
@r = split'\.', $r;
$z = sub {
my $a = shift @l;
my $b = shift @r;
(defined $a or defined $b) ? ($a <=> $b or __SUB__->()) : 0
}->();
%d = qw{-1 < 0 == 1 >};
print "$l $d{$z} $r : $z\n";
}
実行結果
~ $ perl 13_653.pl
0.1.2 > 0.0 : 1
1.2.3 < 1.3 : -1
0.0.0 == 0.0 : 0 >>666
Haskell
空文字は出力しないと動かないから許して。(動く場合はmain =でパターンマッチして出力文埋め込むだけだけど)
ソートした自身の書き込み先、実行先は自身じゃ無いといけないとは書いてない。
import System.Process
main = putStr "" >> readFile "runmyself.hs" >>= \f -> writeFile "runmyself2.hs" ((replace.unlines.qsort.lines) f) >> callCommand "runghc runmyself2.hs"
replace [] = []
replace (p:u:t:s:t2:r:x:y:z:xs) | (p:u:t:s:t2:r:x:y:z:[]) == "putStr \"\"" = "putStrLn \"Hello World\"" ++ replace xs
replace (a1:a2:a3:a4:a5:a6:a7:a8:a9:a10:a11:a12:a13:a14:a15:a16:a17:a18:a19:a20:a21:a22:a23:a24:a25:a26:a27:a28:a29:a30:a31:a32:a33:a34:a35:a36:a37:xs) |
(a1:a2:a3:a4:a5:a6:a7:a8:a9:a10:a11:a12:a13:a14:a15:a16:a17:a18:a19:a20:a21:a22:a23:a24:a25:a26:a27:a28:a29:a30:a31:a32:a33:a34:a35:a36:a37:[]) == ">> callCommand \"runghc runmyself2.hs\"" = "" ++ replace xs
replace (x:xs) = x:replace xs
qsort [] = []
qsort (x:xs) = qsort [s| s <- xs, s <= x] ++ [x] ++ qsort [l| l <- xs, l > x] >>681 Perl5
use feature say;
$n = 0;
@t = ('木');
say "n=$n\n$t[0]";
for $n (1..2) {
$l = '-' x 2**($n-1);
@u = map{$l . $_ . $l} @t;
@w = map{$t[$_].$t[$_]} 0..$#t;
@t = (@u, @w);
say "n=$n";
say for @t;
}
実行例
~ $ perl 13_681.pl
n=0
木
n=1
-木-
木木
n=2
---木---
--木木--
-木--木-
木木木木
注) 正直者には、-はスペースに見えます。 お題： プログラム言語をなにも知らない人にもプログラムの意味が理解できるコメント無しのhello worldを出力するコプログラム お題： 文字列に丁度いい具合にグリッチを入れて超かっこいい文字列を作るプログラム グリッチは広辞苑には載っていません。説明して下さい。 グリッチってアレでしょ？
あの、整いました！ってやつ。
最近みないな。
https://glitch.com >>706
C
https://paiza.io/projects/ZW4sJq_ea_wQQxe_vOlGjQ
gethostbyname() や gethostbyaddr() ではなく getnameinfo() 使ってみました。 2桁までの足し算の筆算を表示せよ。
例:
29
+15
----
14
3
----
44
29
+ 5
----
14
2
----
34 お題
実数a,b (0<a<b)が与えられたとき、平面座標(a,b),(0,0),(a,-b)の3点を通る円の半径を求める。 >>727
居るけど、そういう人って機械自体が苦手な人。
機械と数学に強くてコードに落とせない人には会ったことがない。
機械には強いけど数学苦手だからコードに落とせないって人は(自分含め)沢山いるが。 自転車修理屋さんが機械に強いけどコードなんて、かけなさそう >>723 Perl5
for (<DATA>) {
($l, $o, $r) = split;
@l = $l =~ /(\d?)(\d)/;
@r = $r =~ /(\d?)(\d)/;
$a1 = $l[0] + $r[0];
$a0 = $l[1] + $r[1];
@a1 = $a1 =~ /(\d?)(\d)/;
@a0 = $a0 =~ /(\d?)(\d)/;
$a = 10*$a1 + $a0;
$" = '';
print <<"EOF";
@l
$o@r
---
@a1
@a0
---
$a
EOF
}
__DATA__
29 + 15
29 + 5 >>730 の実行結果
~ $ perl 13_723.pl
29
+15
---
3
14
---
44
29
+5
---
2
14
---
34
せっかくのスペース調整が詰まっちゃって残念なのでアンカーでポップアップして見てね
>>731 >>723
掛け算に対応したり、1桁どうしの計算用フォーマット作ったりしてたら規模がでかくなった(・ω・｀)
1
* 2
-----
2
10
* 0
-----
0
Haskell
https://ideone.com/SCzGKq >>723 ネタ回答: WolframAlpha API / node
// index.js
const {get} = require('http');
const appid = '<<YOUR WolframAlpha APP ID>>';
process.stdin.on('data', data => {
get(`http://api.wolframalpha.com/v2/query?appid=${appid}&input=${encodeURIComponent(data.toString().trim())}&podstate=Result__Step-by-step+solution&format=image&output=json`, res => {
res.setEncoding('utf8');
let body = '';
res.on('data', chunk => {body += chunk;});
res.on('end', () => {
get(JSON.parse(body).queryresult.pods.filter(({title}) => title === 'Results')[0].subpods.filter(({title}) => title === 'Possible intermediate steps')[0].img.src, res => {
res.on('data', data => {process.stdout.write(data)});
});
});
});
});
$ echo 29+15 | node . > ./test1.gif
https://i.imgur.com/QxolfNz.gif
$ echo 29+5 | node . > ./test2.gif
https://i.imgur.com/D0r3sSg.gif
$ echo 29*15 | node . > ./test3.gif
https://i.imgur.com/imvQO5g.gif
試しに一桁×一桁やってみたらなんだか微妙な計算過程に…
$ echo 5*5 | node . > ./test.gif
https://i.imgur.com/8z3kZPf.gif
あと割り算はAPIからでは計算過程のURL取れなかった >>735
こうやって足し算の筆算とは言え、人間の思考過程をプログラムで再現してみると小学生から結構複雑な処理してるんだなと思う。
もっと人間の処理に近づけるなら文字列として認識して、1桁目を数字に変換して～みたいになるんだろうけど。 >>494 >>496 Perl5
use feature say;
@data = <DATA>;
chomp @data;
@tags = split' ', shift @data;
%idx = map{$_ => $n++} @tags;
@sum = 0 x $n;
for (@data) {
@fs = split' ';
for (0..$n-1) {
$v = $fs[$_];
if ($v =~ /^(\d+\.\d*|\d*\.\d+|\d+)$/) {
$sum[$_] += $v;
} else {
warn "変なデータが紛れ込んでいます＿ノ乙(､ﾝ､)_`$v'\n";
}
}
}
for (@tags) {
say "$_ の合計 = ", $sum[$idx{$_}];
}
__DATA__
カラム1 カラム2 カラム3 カラム4
1,0 2.0 3.0 4.0
2.1 3.1 4.1 5.1
~ $ perl 13_494.pl
変なデータが紛れ込んでいます＿ノ乙(､ﾝ､)_`1,0'
カラム1 の合計 = 2.1
カラム2 の合計 = 5.1
カラム3 の合計 = 7.1
カラム4 の合計 = 9.1 >>738
マンコ・カパックは、インカ神話によるクスコ王国の初代国王である。 >>675
Kotlin
https://paiza.io/projects/SlCrKgxVJRghtvESdUMR_A
リストの中の最小値をループして探し出しように作っただけなんだけど、こんなんで良いのか？
(MutableListなのでsort()しちゃうという手抜きワザもあったがそれだと表面上分岐が一つもない状態になるので止めた)。 >>494 Squeak Smalltalk。コンマを分割と見なしそれぞれについての和を出力させてみた
| fn |
fn := [:columnName |
FileStream oldFileNamed: 'data.txt' do: [:file |
| index sum |
index := (file nextLine subStrings: ' ') indexOf: columnName.
sum := 0.
[file atEnd] whileFalse: [
| next |
next := ((file nextLine subStrings: ' ') at: index) subStrings: ','.
sum := sum + (next size = 1 ifTrue: [next anyOne] ifFalse: [next])].
sum
]
].
fn value: 'カラム3'. "=> 7.1 "
fn value: 'カラム1'. "=> #(3.1 2.1) " お題
長方形の盤で左上から上下左右に一マスずつ移動して全てのマスを
辿る。
移動の順番を表した数字を向きと終点を表す文字(↑↓←→★、
上下左右終、UDLRG、^V<>Gなど)に変換する。
入力
1 4 5 6
2 3 8 7
15 14 9 10
16 13 12 11
出力
↓→→↓
→↑↓←
↓←→↓
★↑←← >>746 Perl5
@a = map{[split]} <DATA>;
for $y (0..$#a) {
$h{$a[$y][$_]} = [$y,$_,''] for 0..$#a;
}
@s = keys %h;
%r = qw{-1,0 ↑ 1,0 ↓ 0,-1 ← 0,1 →};
for $i (1..@s) {
if ($i == @s) {
$d = '★'
} else {
$y = $h{$i+1}->[0] - $h{$i}->[0];
$x = $h{$i+1}->[1] - $h{$i}->[1];
$d = $r{"$y,$x"}
}
$h{$i}->[2] = $d;
}
($y, $x, $d) = @$_, $a[$y][$x] = $d for values %h;
use feature say;
say "@$_" for @a;
__DATA__
1 4 5 6
2 3 8 7
15 14 9 10
16 13 12 11
実行結果
~ $ perl 13_746.pl
↓ → → ↓
→ ↑ ↓ ←
↓ ← → ↓
★ ↑ ← ← >>723 Squeak Smalltalk
| fn |
fn := [:int1 :int2 |
| strings width digits interms ans max line |
strings := {int1. int2} collect: #asString.
width := (strings detectMax: #size) size.
digits := strings collect: [:str |
(str forceTo: width paddingStartWith: $0) reversed asArray collect: #asString].
interms := (digits reduce: #+) collectWithIndex: [:interm :idx |
interm, (String new: idx-1 withAll: Character space)].
ans := interms polynomialEval: '10'.
strings atLast: 1 put: '+ ', strings last.
max := ((strings, {ans}) collect: #size) max.
line := String new: max withAll: $-.
(strings, {line}, interms, {line. ans} collect: [:str |
(str forceTo: max paddingStartWith: Character space) withoutTrailingBlanks
]) asStringWithCr
].
fn value: 987 value: 65. "=>
' 987
+ 65
----
12
14
9
----
1052' " >>746 Squeak Smalltalk
| fn |
fn := [:str |
| map range sign goal position next atEnd |
map := str lines collect: [:line | line subStrings collect: #asInteger].
range := 1@1 extent: map first size @ map size.
sign := (0 asPoint fourNeighbors with: #(→ ↓ ← ↑) collect: #->) as: Dictionary.
goal := #★.
position := 1@1. next := 2. atEnd := false.
[atEnd] whileFalse: [
| found |
found := position fourNeighbors detect: [:neighPos |
(range containsPoint: neighPos) and: [((map at: neighPos y) at: neighPos x) = next]
] ifNone: [atEnd := true. Float nan].
(map at: position y) at: position x put: (sign at: found - position ifAbsent: goal).
position := found. next := next + 1.
].
(map collect: #join) asStringWithCr
].
fn value: '1 4 5 6
2 3 8 7
15 14 9 10
16 13 12 11'
"=>
'↓→→↓
→↑↓←
↓←→↓
★↑←←' " まだ見にくいなあ。線を繋いで矢印を入れることはできないかな。 罫線
│┌─┐
└┘┌┘
┌┐└┐
★└─┘
直線部に矢印
│┌→┐
└┘┌┘
┌┐└┐
★└←┘
こんな感じ？ スタート部も矢印に出来るやん…
↓┌→┐
└┘┌┘
┌┐└┐
★└←┘ 罫線や矢印が半角で★が全角で表示されてしまうとずれるな。
ま、しょうがないか。 >>754 Squeak Smalltalk
| fn |
fn := [:str |
| map range signs sign goal position from next atEnd |
map := str lines collect: [:line | line subStrings collect: #asInteger].
range := 1@1 extent: map first size @ map size.
goal := #★. signs := #(┌ ┌ ← → └ └ ┐ ┐ ↑ ↓ ┘ ┘) readStream.
sign := Dictionary new.
0 asPoint fourNeighbors combinations: 2 atATimeDo: [:combi |
sign at: combi copy put: signs next; at: combi reversed put: signs next].
position := 1@1. from := nil. next := 2. atEnd := false.
[atEnd] whileFalse: [
| found delta |
found := position fourNeighbors detect: [:neighPos |
(range containsPoint: neighPos) and: [((map at: neighPos y) at: neighPos x) = next]
] ifNone: [atEnd := true. Float nan].
delta := found - position.
(map at: position y) at: position x put: (sign at: {from ifNil: [delta negated]. delta} ifAbsent: goal).
position := found. from := delta negated. next := next + 1].
(map collect: #join) asStringWithCr
].
fn value: '1 4 5 6
2 3 8 7
15 14 9 10
16 13 12 11' .
"=>
'↓┌→┐
└┘┌┘
┌┐└┐
★└←┘' " >>759 758の入力例を拝借
fn value: '1 2 3 4 5
16 17 18 19 6
15 24 25 20 7
14 23 22 21 8
13 12 11 10 9'.
"=>
'→→→→┐
┌→→┐↓
↑┌★↓↓
↑└←┘↓
└←←←┘' "
fn value: '1 4 5 8 9 12
2 3 6 7 10 11'.
"=>
'↓┌┐┌┐★
└┘└┘└┘' "
fn value: '1 4 5 6
2 3 8 7
16 14 9 10
15 13 12 11' .
"=> 繋げられるところまでで終点にする。
'↓┌→┐
└┘┌┘
16★└┐
15└←┘' " S : Start
E : End
X : 行けない所
で、表す方がよいかも お題 ：次のようなジョブパラメータで表されるジョブ（製造工程）があります。全て完成するための最小時間とマシンスケジュールを求めてください。貧乏なので同じ番号のマシンは一台しかありません。｛A, B｝とあれば；Aマシン番号、B:所要時間
int job_param[JOBNUM][STP][2] = {
{{3, 10}, {4, 10}, {2, 12}, {0, 18}, {1, 4}},
{{1, 11}, {2, 6}, {3, 2}, {4, 8}, {0, 15}},
{{2, 10}, {4, 16}, {3, 2}, {1, 8}, {0, 14}},
{{2, 15}, {1, 12}, {0, 16}, {3, 6}, {4, 17}},
{{4, 14}, {0, 2}, {1, 15}, {2, 6}, {3, 10}}}; >>765
順序に対する制限とかは？
それとなんで5つに分かれているのか？
全部一塊で25個のマシン番号と所要時間のペアがある状態だと順序の関係で何かまずいのか？ >>766
5つのタスクでそれぞれ5つの工程があるってことだろう >>767
その辺の制限やルールが書かれていないからどうやれば良いのかが分からない、ということ。
順序も何もかも(マシン番号と所要時間も)入れ替えて構わないなら0～4のマシン全体に所要時間を平均的に
詰め込むだけになると思うが、わざわざジョブとか分けてるんだからどうやらそうではなさそうだよな。
どうやら順序や入れ替えには制限があるように見える。しかしその制限が書かれていない。 >>765
>>766
>>767
ジョブショップスケジューリング問題です。この問題はジョブや機械が増加すると調べなければならない組み合わせが爆発的に増加してしまうため、現実的な時間で最適解を求めることが難しいとされています(NP困難として知られています)。
マシンを配列順に使用することで1つの製品ができます。
私の実験では10分ぐらい待っても９５で終わりませんでした。 >>769
途中結果
Solution 4
COST_TIME: 95
0 : ( 3, 0, 10), ( 4, 15, 25), ( 2, 27, 39), ( 0, 46, 64), ( 1, 65, 69)
1 : ( 1, 0, 11), ( 2, 40, 46), ( 3, 54, 56), ( 4, 57, 65), ( 0, 80, 95)
2 : ( 2, 16, 26), ( 4, 27, 43), ( 3, 44, 46), ( 1, 47, 55), ( 0, 65, 79)
3 : ( 2, 0, 15), ( 1, 16, 28), ( 0, 29, 45), ( 3, 47, 53), ( 4, 66, 83)
4 : ( 4, 0, 14), ( 0, 15, 17), ( 1, 29, 44), ( 2, 47, 53), ( 3, 57, 67)
MACHIN Schedule
0 : (46, 64), (80, 95), (65, 79), (29, 45), (15, 17)
1 : (65, 69), ( 0, 11), (47, 55), (16, 28), (29, 44)
2 : (27, 39), (40, 46), (16, 26), ( 0, 15), (47, 53)
3 : ( 0, 10), (54, 56), (44, 46), (47, 53), (57, 67)
4 : (15, 25), (57, 65), (27, 43), (66, 83), ( 0, 14) >>770
ttps://imgur.com/upBqhWN.png
手動で調べたら90時間(単位は適当)まで縮んだ。最小時間か知らんが。
こういうのガントチャートっていうんだな ちなみに、
>>746
の問題で、行列の周りに、番兵を作って、処理した人はいる？
漏れは、いつもこの手の問題では、番兵で周りを囲む ……プログラミングやっててガントチャートしらないヤツもいるのか
勉強になった ロシア国防省「東アジアの地震の多い某国は数十年にわたり、地震を偽装した地下核実験を繰り返している」
https://rosie.5ch.net/test/read.cgi/liveplus/1550888671/l50
自衛隊の中に熊本人工地震を発生させた連中がいることは震源地が自衛隊駐屯地地下であることから自明。
http://open.mixi.jp/user/38378433/diary/1953066799
そればかりか、いま熊本の地下から出ている放射線量が「謎の赤丸急上昇中」だというのだ。
https://quasimoto2.exblog.jp/22729487/
今、自民党政権が、原発再稼働を進めている本当の理由は、核武装計画だけである。
経済的にとっくに破綻した原子力発電など、最初から眼中にないのだ。
東海アマブログentry-688.html いちいちガントチャートなんて銘打たんしな
進捗管理するときには普通に使うもんだ みんな名前知らないけど気づいたら作ってるようなものじゃないか？ お題1: 整数値に対して K, M, G 等の単位を付けて人間に読みやすく文字列に変換して出力する。(ls -lh の時の容量の出力と同じで良い)。2^10 = K, 2^20 = M, 2^30 = G とする。
小数点以下を何桁にするかはご自由に。但しあまりあり過ぎると人間には分かり辛いので1桁か2桁が望ましい。
お題2: お題1の逆変換。但し欠落した下位桁があったとしても考慮しなくて良い。
お題3: お題1, お題2 の10^3 = K, 10^6 = M, 10^9 = G 版。
回答のプログラムはまとめた形でも良い。例えばお題1を処理する関数のオプションとして0を与えると2^10単位、1を与えると10^3単位にするなど。
また、K, M, G よりも上の単位ができても良い。 いまどき容量系の接頭辞はKi, Mi, Gi使えや お題1と3まとめてswitch-case文って
筋悪いですかねえ
あるいはお題1とお題2をまとめて、enum型でINVERSEとか作るとか、あるいは TRUE / FALSE で分岐とか 誰でも頭が良くなる、プログラムが書けるようになる方法が発見される 95286
https://you-can-program.hatenablog.jp >>779 c
https://ideone.com/N64nDG
・十分に小さい値のときしか動かない
・大きい値を与えたときの挙動もケアされない Windows付属のshlwapi.dllにStrFormatByteSizeという関数があるようだね。 >>765
乱数使ったプログラム書いてみたけど動かした瞬間90まで行くけど
そこから何分待っても動かなさそう >>790
「たとえば表示画面が640x400なら、一辺が400の正三角形を描画する」ことではないのか
貴殿が想定する「最大の定義」とやらを示してもらえんかの？ ん？
その場合、一辺は400*2/sqrt(3)になるんじゃない？ >>791
高さ400の正三角形だと一辺461.88じゃね？ コンソール画面なら、画面の横幅と縦幅を取得しなきゃならんから言語によってはめんどくさいだろうな
標準でcurses使える言語ってなにがあるかな ﾘｰﾏﾝ幾何の多様体上で計算しとけ
なお、ｻﾗﾘｰﾏﾝのﾘｰﾝﾏﾝ じゃないからな。 Windows環境だとdirectx叩くことになるのかな
VT100とかXとかは全く知らないけど DisplayWidth とか DisplayHeight とか使うのか
あるいは何らかのクラスのメンバー関数を呼ぶのか >>795
pdcursesがあるじゃないか（あらゆる環境で使えるとは言ってない エスケープシーケンスで座標指定とか文字色変更って、今はできないんだっけ？ エスケープシーケンス powershell
で、ググってみ >>801
文字を出す端末による。
WindowsだったとしてもWSLでUbuntu動かした時のbashの端末では使えてるので多分設定次第なんだろうな。
逆に言うと設定によっては意図した通りに動かない。 お題
アミダくじの作成、表示、及び余力があれば実行
・縦線の本数と横線の最大本数は入力できるようにする。
・左右の縦線への横線だけでなく飛び越えて他の縦線へ移動する横線もオプションで作れるようにする。
・表示方法は罫線キャラクタを使っても良いがGUI等他の方法でも良い。
・実行時はアニメーションでも良いし、いきなり結果が出るだけでも良い。
・面倒なら作成して表示するだけで実行しなくても良い。 ・PC-8001で動作すること。
いや、動かんでもいい。 DEFINTA-Z:PRINT"HOW MANY COLUMNS":INPUTA:A0=160/A お題：要素数が同じふたつの数値配列を受け取り、要素ごとに足した配列を返す。
中級：同様に、三つの配列を受け取る。
上級：同様に、三つの配列を受け取り、掛けて割ったもの返す。
ocaml
https://ideone.com/GyC6yJ
octave
https://ideone.com/NwYyqs >>811 Squeak/Pharo Smalltalk
#(1 2 3) + #(4 5 6). "=> #(5 7 9) "
#((1 2 3) (4 5 6) (7 8 9)) sum. "=> #(12 15 18) "
#(1 2 3) * #(4 5 6) / #(7 8 9). "=> {(4/7) . (5/4) . 2} " お題そのものは簡単でも、マイナー言語での解き方を見るのは面白いね >>811
main = do
print $ zipWith (+) [1,2,3] [4,5,6]
print $ zipWith3 (\a b c -> a + b + c) [1,2,3] [4,5,6] [7,8,9]
print $ zipWith3 (\a b c -> a * b / c) [1,2,3] [4,5,6] [7,8,9]
Out:
[5,7,9]
[12,15,18]
[0.571428571428571,1.25,2.0] >>813
Haskellでは％記号が分数を表すので、Data.Ratioをインポートして
import Data.Ratio
main = do
print $ zipWith (+) [1,2,3] [4,5,6]
print $ zipWith3 (\a b c -> a + b + c) [1,2,3] [4,5,6] [7,8,9]
print $ zipWith3 (\a b c -> a * b % c) [1,2,3] [4,5,6] [7,8,9]
Out:
[5,7,9]
[12,15,18]
[4 % 7,5 % 4,2 % 1] お題：円の中心の座標と、円の半径の2乗が与えられる。
この円の円周上にある格子点の数を求めよ。
(X座標 Y座標 半径の2乗)
9/22 5/22 138125/242 => 7
7/38 5/38 785817263725/722 => 77
17/38 13/38 13603053979519731025/722 => 777
9/38 6/38 23959256988683736880737131790625/1444 => ?
12/38 7/38 23959256988683736880737131790625/1444 => ?
15/38 14/38 23959256988683736880737131790625/1444 => ? 宿題じゃないんやけどなー
12/38 7/38 23959256988683736880737131790625/1444 => ? の答えと円周上の格子点一覧…俺が間違えてなければ
https://pastebin.com/pnGbWPfM プログラムでの解き方が思い付かないわ
円の方程式に整数代入して満たすかみればいいのか？ 解法を考えるのも回答能力のうちだからね
今の時代、参照・検索も当然 可だけれど >>817
割り算が%とか、そのモジュール書いた奴、頭腐ってんじゃないの？ >>825
？
>>816 見てないの？
Haskellでは少数を返す割り算は「/」、整数を返す割り算は「`div`」と返す型で使い分ける。
「%」が返すのは分数型(Rational) お題: 日本語の文章の句読点を , や . に置き換える。
ただし、, や . の直後には半角のスペースを置き、さらに改行の手前や文末のスペースは削除すること。
例:
In < これは、日本語の文章です。ふひひ。
Out > これは, 日本語の文章です. ふひひ. お題: 簡易なテーブルを綺麗に整形する
余力があればカラムの左揃え、右揃えをオプションで選択できるようにする（出力は中央揃え）
入力:
a|aaaaa|bb
ccc|ddd|ee
出力:
**a***|*aaaaa*|***bb*
------+-------+------
*ccc**|**ddd**|***ee* >>831
×（出力は中央揃え）
〇（例は中央揃え） >>831
入出力のエンコードは？
ASCII以外はあるのか？ >>834
いやバグってなかったわ
>>831
が正常
| の前後に*が一つ入るから
| の前後の*は入れても入れなくてもいいけど入れたほうが綺麗になるかもしれん 何がキレイなのか定義出来ず言うことが主観でコロコロ変わる、マジで今の日本のサイコパス上司そのものだ
「オレの心情をさっしろ」みたいな屑がいいそうなこと
頭が悪いから定義が出来ないし自分の言ってることが支離滅裂になってる
曖昧な用語（綺麗）で押し通そうとする
コレ全部サイコパスの特徴 >>843
プラトンのスュンポスィオーンって本で定義されてたぞ >>845
変数に日本語が使えないとか書いてあるな。
Javaとか普通に使えるんだがな。 >>844
倉橋由美子のが面白かったと思っています >>847
そんなに日本語使いたいならなでしこでも書いとけ >>847 そんな大昔の話をするなよ。 今はPython3 なんだから日本語も使えるよ。
なな = 7
print(なな)
# 7 >>831
Kotlin
https://paiza.io/projects/RCbBPGrxaB1uoB-tj_1hJg
入力は1行目に 0, 1, 2 の何れかのオプションを指定する。
意味は 0=中央、1=左寄せ、2=右寄せ になっている。
2行目からは | 区切りで文字列を入れる。
空行またはファイルの終わりで表を出力する。
空行だった場合はまた次の表の最初のオプションから入れられる。 >>853
ほとぼりが冷めたと思ってんのか屑？
お前が>>839だろ
ID変わったからっていい気になんなよ
ゴミみたいな出力のまさにゴミだ
全然綺麗じゃない >>854
違うよ。俺はもっと上の方であみだくじのお題を出したやつだよ。
自分でもプログラム作るには作ったけど表示するところまでだな。
しかしブラウザの実行環境で表示すると罫線の幅の問題でずれるので画像で出力しようかと思っている。
これな。
https://paiza.io/projects/2mINZHiEB6ciPWHEpkCJig お題：ジョブショップスケジューリングの問題です。
int job_param[JOBNUM][STP][2] = {
{{4, 342}, {1, 244}, {2, 351}, {3, 293}, {0, 342}}, // 1572
{{2, 306}, {4, 342}, {3, 386}, {1, 386}, {0, 413}}, // 1833
{{3, 168}, {0, 266}, {2, 182}, {1, 106}, {4, 368}}, // 1090
{{3, 368}, {2, 151}, {4, 284}, {0, 84}, {1, 164}}, // 1051
{{4, 240}, {1, 191}, {0, 351}, {3, 408}, {2, 275}}, // 1465
{{2, 342}, {3, 351}, {4, 191}, {0, 333}, {1, 426}}, // 1643
{{0, 93}, {1, 235}, {2, 422}, {3, 244}, {4, 151}}, // 1145
{{0, 75}, {4, 217}, {1, 111}, {3, 195}, {2, 435}}, // 1033
{{2, 173}, {4, 435}, {3, 186}, {1, 137}, {0, 53}}, // 984
{{1, 93}, {2, 231}, {4, 71}, {3, 115}, {0, 315}}}; // 825 適当に詰めて行くプログラムで2928まではなった
h0 0-75 g0 75-168 c1 168-434 e2 434-785 j4 1002-1317 d3 1505-1589 f3 1696-2029 b4 2029-2442 a4 2442-2784 i4 2875-2928
j0 0-93 e1 240-431 h2 457-568 a1 799-1043 g1 1043-1278 c3 1385-1491 b3 1607-1993 d4 1993-2157 f4 2157-2583 i3 2738-2875
f0 0-342 j1 342-573 b0 573-879 i0 879-1052 d1 1052-1203 c2 1203-1385 a2 1385-1736 g2 1736-2158 e4 2158-2433 h4 2433-2868
c0 0-168 d0 168-536 f1 536-887 j3 887-1002 h3 1002-1197 b2 1221-1607 e3 1607-2015 a3 2015-2308 g3 2308-2552 i2 2552-2738
e0 0-240 h1 240-457 a0 457-799 j2 799-870 b1 879-1221 d2 1221-1505 f2 1505-1696 c4 1696-2064 i1 2064-2499 g4 2552-2703 今2889になってたけどSegmentation faultで落ちてた
前回のやつでJOBNUMとかSTPとかをわざわざ直接5 5とか書いてて
今回どんなコードかもう忘れて片方を適当に10に直したからか元からバグがあったのか分からないけど
結果自体は間違ってなそうだと思うけど >>856
COST_TIME: 2932
0 : ( 4, 457, 799), ( 1, 800, 1044), ( 2, 1275, 1626), ( 3, 2017, 2310), ( 0, 2417, 2759)
1 : ( 2, 573, 879), ( 4, 880, 1222), ( 3, 1223, 1609), ( 1, 1610, 1996), ( 0, 2004, 2417)
2 : ( 3, 0, 168), ( 0, 784, 1050), ( 2, 1093, 1275), ( 1, 1279, 1385), ( 4, 2389, 2757)
3 : ( 3, 168, 536), ( 2, 942, 1093), ( 4, 1586, 1870), ( 0, 1920, 2004), ( 1, 2473, 2637)
4 : ( 4, 0, 240), ( 1, 241, 432), ( 0, 433, 784), ( 3, 1609, 2017), ( 2, 2221, 2496)
5 : ( 2, 0, 342), ( 3, 536, 887), ( 4, 1395, 1586), ( 0, 1587, 1920), ( 1, 2047, 2473)
6 : ( 0, 75, 168), ( 1, 1044, 1279), ( 2, 1799, 2221), ( 3, 2310, 2554), ( 4, 2757, 2908)
7 : ( 0, 0, 75), ( 4, 240, 457), ( 1, 458, 569), ( 3, 892, 1087), ( 2, 2496, 2931)
8 : ( 2, 1626, 1799), ( 4, 1954, 2389), ( 3, 2554, 2740), ( 1, 2741, 2878), ( 0, 2879, 2932)
9 : ( 1, 0, 93), ( 2, 342, 573), ( 4, 799, 870), ( 3, 1087, 1202), ( 0, 1203, 1518)
MACHINE Schedule
0 : ( 7, 0, 75), ( 6, 75, 168), ( 4, 433, 784), ( 2, 784, 1050), ( 9, 1203, 1518), ( 5, 1587, 1920), ( 3, 1920, 2004), ( 1, 2004, 2417), ( 0, 2417, 2759), ( 8, 2879, 2932)
1 : ( 9, 0, 93), ( 4, 241, 432), ( 7, 458, 569), ( 0, 800, 1044), ( 6, 1044, 1279), ( 2, 1279, 1385), ( 1, 1610, 1996), ( 5, 2047, 2473), ( 3, 2473, 2637), ( 8, 2741, 2878)
2 : ( 5, 0, 342), ( 9, 342, 573), ( 1, 573, 879), ( 3, 942, 1093), ( 2, 1093, 1275), ( 0, 1275, 1626), ( 8, 1626, 1799), ( 6, 1799, 2221), ( 4, 2221, 2496), ( 7, 2496, 2931)
3 : ( 2, 0, 168), ( 3, 168, 536), ( 5, 536, 887), ( 7, 892, 1087), ( 9, 1087, 1202), ( 1, 1223, 1609), ( 4, 1609, 2017), ( 0, 2017, 2310), ( 6, 2310, 2554), ( 8, 2554, 2740)
4 : ( 4, 0, 240), ( 7, 240, 457), ( 0, 457, 799), ( 9, 799, 870), ( 1, 880, 1222), ( 5, 1395, 1586), ( 3, 1586, 1870), ( 8, 1954, 2389), ( 2, 2389, 2757), ( 6, 2757, 2908) COST_TIME: 2868
0 : ( 4, 457, 799), ( 1, 800, 1044), ( 2, 1212, 1563), ( 3, 2017, 2310), ( 0, 2410, 2752)
1 : ( 2, 573, 879), ( 4, 880, 1222), ( 3, 1223, 1609), ( 1, 1610, 1996), ( 0, 1997, 2410)
2 : ( 3, 0, 168), ( 0, 169, 435), ( 2, 1030, 1212), ( 1, 1213, 1319), ( 4, 2326, 2694)
3 : ( 3, 168, 536), ( 2, 879, 1030), ( 4, 1523, 1807), ( 0, 1857, 1941), ( 1, 2703, 2867)
4 : ( 4, 0, 240), ( 1, 241, 432), ( 0, 435, 786), ( 3, 1609, 2017), ( 2, 2158, 2433)
5 : ( 2, 0, 342), ( 3, 536, 887), ( 4, 1332, 1523), ( 0, 1524, 1857), ( 1, 1996, 2422)
6 : ( 0, 75, 168), ( 1, 1319, 1554), ( 2, 1736, 2158), ( 3, 2310, 2554), ( 4, 2694, 2845)
7 : ( 0, 0, 75), ( 4, 240, 457), ( 1, 458, 569), ( 3, 887, 1082), ( 2, 2433, 2868)
8 : ( 2, 1563, 1736), ( 4, 1891, 2326), ( 3, 2379, 2565), ( 1, 2566, 2703), ( 0, 2752, 2805)
9 : ( 1, 0, 93), ( 2, 342, 573), ( 4, 799, 870), ( 3, 1082, 1197), ( 0, 1198, 1513)
MACHINE Schedule
0 : ( 7, 0, 75), ( 6, 75, 168), ( 2, 169, 435), ( 4, 435, 786), ( 9, 1198, 1513), ( 5, 1524, 1857), ( 3, 1857, 1941), ( 1, 1997, 2410), ( 0, 2410, 2752), ( 8, 2752, 2805)
1 : ( 9, 0, 93), ( 4, 241, 432), ( 7, 458, 569), ( 0, 800, 1044), ( 2, 1213, 1319), ( 6, 1319, 1554), ( 1, 1610, 1996), ( 5, 1996, 2422), ( 8, 2566, 2703), ( 3, 2703, 2867)
2 : ( 5, 0, 342), ( 9, 342, 573), ( 1, 573, 879), ( 3, 879, 1030), ( 2, 1030, 1212), ( 0, 1212, 1563), ( 8, 1563, 1736), ( 6, 1736, 2158), ( 4, 2158, 2433), ( 7, 2433, 2868)
3 : ( 2, 0, 168), ( 3, 168, 536), ( 5, 536, 887), ( 7, 887, 1082), ( 9, 1082, 1197), ( 1, 1223, 1609), ( 4, 1609, 2017), ( 0, 2017, 2310), ( 6, 2310, 2554), ( 8, 2379, 2565)
4 : ( 4, 0, 240), ( 7, 240, 457), ( 0, 457, 799), ( 9, 799, 870), ( 1, 880, 1222), ( 5, 1332, 1523), ( 3, 1523, 1807), ( 8, 1891, 2326), ( 2, 2326, 2694), ( 6, 2694, 2845) >>863
3 : ( 2, 0, 168), ( 3, 168, 536), ( 5, 536, 887), ( 7, 887, 1082), ( 9, 1082, 1197), ( 1, 1223, 1609), ( 4, 1609, 2017), ( 0, 2017 , 2310), ( 6, 2310, 2554), ( 8, 2379, 2565)
( 6, 2310, 2554), ( 8, 2379, 2565)
ここが重複してるから間違ってる お題：ジョブショップスケジューリングの問題です。
int job_param[JOBNUM][STP][2] = {
{{4, 100}, {1, 100}, {2, 100}, {3, 100}, {0, 100}}, // 500
{{2, 100}, {4, 100}, {3, 100}, {1, 100}, {0, 100}}, // 500
{{3, 100}, {0, 100}, {2, 100}, {1, 100}, {4, 100}}, // 500
{{3, 100}, {2, 100}, {4, 100}, {0, 100}, {1, 100}}, // 500
{{4, 100}, {1, 100}, {0, 100}, {3, 100}, {2, 100}}, // 500
{{2, 100}, {3, 100}, {4, 100}, {0, 100}, {1, 100}}, // 500
{{0, 100}, {1, 100}, {2, 100}, {3, 100}, {4, 100}}, // 500
{{0, 100}, {4, 100}, {1, 100}, {3, 100}, {2, 100}}, // 500
{{2, 100}, {4, 100}, {3, 100}, {1, 100}, {0, 100}}, // 500
{{1, 100}, {2, 100}, {4, 100}, {3, 100}, {0, 100}}}; // 500 >>866
時間全部同じなら1にしちゃってえーんちゃう？ 死んで良し。こんな長たらしいのを貼るなんて迷惑。
どこかに貼ってリンクだけにしろ。 >>831
C https://ideone.com/UPx6IS
もうどうでもいいかもしれんが、各列で幅調整ができるようにした COST_TIME: 2903
0 : ( 4, 799, 1141), ( 1, 1141, 1385), ( 2, 1385, 1736), ( 3, 2023, 2316), ( 0, 2477, 2819)
1 : ( 2, 0, 306), ( 4, 457, 799), ( 3, 1114, 1500), ( 1, 1500, 1886), ( 0, 1980, 2393)
2 : ( 3, 368, 536), ( 0, 913, 1179), ( 2, 1203, 1385), ( 1, 1385, 1491), ( 4, 2122, 2490)
3 : ( 3, 0, 368), ( 2, 1052, 1203), ( 4, 1838, 2122), ( 0, 2393, 2477), ( 1, 2639, 2803)
4 : ( 4, 0, 240), ( 1, 240, 431), ( 0, 562, 913), ( 3, 1615, 2023), ( 2, 2593, 2868)
5 : ( 2, 306, 648), ( 3, 763, 1114), ( 4, 1141, 1332), ( 0, 1332, 1665), ( 1, 1886, 2312)
6 : ( 0, 75, 168), ( 1, 568, 803), ( 2, 1736, 2158), ( 3, 2508, 2752), ( 4, 2752, 2903)
7 : ( 0, 0, 75), ( 4, 240, 457), ( 1, 457, 568), ( 3, 568, 763), ( 2, 2158, 2593)
8 : ( 2, 879, 1052), ( 4, 1403, 1838), ( 3, 2316, 2502), ( 1, 2502, 2639), ( 0, 2819, 2872)
9 : ( 1, 0, 93), ( 2, 648, 879), ( 4, 1332, 1403), ( 3, 1500, 1615), ( 0, 1665, 1980)
MACHINE Schedule
0 : ( 7, 0, 75), ( 6, 75, 168), ( 4, 562, 913), ( 2, 913, 1179), ( 5, 1332, 1665), ( 9, 1665, 1980), ( 1, 1980, 2393), ( 3, 2393, 2477), ( 0, 2477, 2819), ( 8, 2819, 2872)
1 : ( 9, 0, 93), ( 4, 240, 431), ( 7, 457, 568), ( 6, 568, 803), ( 0, 1141, 1385), ( 2, 1385, 1491), ( 1, 1500, 1886), ( 5, 1886, 2312), ( 8, 2502, 2639), ( 3, 2639, 2803)
2 : ( 1, 0, 306), ( 5, 306, 648), ( 9, 648, 879), ( 8, 879, 1052), ( 3, 1052, 1203), ( 2, 1203, 1385), ( 0, 1385, 1736), ( 6, 1736, 2158), ( 7, 2158, 2593), ( 4, 2593, 2868)
3 : ( 3, 0, 368), ( 2, 368, 536), ( 7, 568, 763), ( 5, 763, 1114), ( 1, 1114, 1500), ( 9, 1500, 1615), ( 4, 1615, 2023), ( 0, 2023, 2316), ( 8, 2316, 2502), ( 6, 2508, 2752)
4 : ( 4, 0, 240), ( 7, 240, 457), ( 1, 457, 799), ( 0, 799, 1141), ( 5, 1141, 1332), ( 9, 1332, 1403), ( 8, 1403, 1838), ( 3, 1838, 2122), ( 2, 2122, 2490), ( 6, 2752, 2903) COST_TIME: 2868
0 : ( 4, 970, 1312), ( 1, 1312, 1556), ( 2, 1807, 2158), ( 3, 2177, 2470), ( 0, 2470, 2812)
1 : ( 2, 0, 306), ( 4, 557, 899), ( 3, 1197, 1583), ( 1, 1583, 1969), ( 0, 1969, 2382)
2 : ( 3, 0, 168), ( 0, 394, 660), ( 2, 1474, 1656), ( 1, 1969, 2075), ( 4, 2222, 2590)
3 : ( 3, 168, 536), ( 2, 1656, 1807), ( 4, 1938, 2222), ( 0, 2382, 2466), ( 1, 2696, 2860)
4 : ( 4, 292, 532), ( 1, 532, 723), ( 0, 723, 1074), ( 3, 1583, 1991), ( 2, 2158, 2433)
5 : ( 2, 306, 648), ( 3, 731, 1082), ( 4, 1312, 1503), ( 0, 1512, 1845), ( 1, 2133, 2559)
6 : ( 0, 75, 168), ( 1, 723, 958), ( 2, 1052, 1474), ( 3, 2470, 2714), ( 4, 2714, 2865)
7 : ( 0, 0, 75), ( 4, 75, 292), ( 1, 292, 403), ( 3, 536, 731), ( 2, 2433, 2868)
8 : ( 2, 879, 1052), ( 4, 1503, 1938), ( 3, 1991, 2177), ( 1, 2559, 2696), ( 0, 2812, 2865)
9 : ( 1, 0, 93), ( 2, 648, 879), ( 4, 899, 970), ( 3, 1082, 1197), ( 0, 1197, 1512)
MACHINE Schedule
0 : ( 7, 0, 75), ( 6, 75, 168), ( 2, 394, 660), ( 4, 723, 1074), ( 9, 1197, 1512), ( 5, 1512, 1845), ( 1, 1969, 2382), ( 3, 2382, 2466), ( 0, 2470, 2812), ( 8, 2812, 2865)
1 : ( 9, 0, 93), ( 7, 292, 403), ( 4, 532, 723), ( 6, 723, 958), ( 0, 1312, 1556), ( 1, 1583, 1969), ( 2, 1969, 2075), ( 5, 2133, 2559), ( 8, 2559, 2696), ( 3, 2696, 2860)
2 : ( 1, 0, 306), ( 5, 306, 648), ( 9, 648, 879), ( 8, 879, 1052), ( 6, 1052, 1474), ( 2, 1474, 1656), ( 3, 1656, 1807), ( 0, 1807, 2158), ( 4, 2158, 2433), ( 7, 2433, 2868)
3 : ( 2, 0, 168), ( 3, 168, 536), ( 7, 536, 731), ( 5, 731, 1082), ( 9, 1082, 1197), ( 1, 1197, 1583), ( 4, 1583, 1991), ( 8, 1991, 2177), ( 0, 2177, 2470), ( 6, 2470, 2714)
4 : ( 7, 75, 292), ( 4, 292, 532), ( 1, 557, 899), ( 9, 899, 970), ( 0, 970, 1312), ( 5, 1312, 1503), ( 8, 1503, 1938), ( 3, 1938, 2222), ( 2, 2222, 2590), ( 6, 2714, 2865) ここはプログラミングのお題スレであって結果と思われる出力を書き込むスレではない。 コラッツ数列を作る関数chainを書け
コラッツ数列の定義
任意の自然数から開始する
数が 1ならば 、終了
数が偶数なら 、 2で割る
数が奇数なら 、 3倍して 1を足す
新しい値でこのアルゴリズムを繰り返す
使用例
>chain 10
[ 1 0 , 5 , 1 6 , 8 , 4 , 2 , 1 ]
>chain 1
[ 1 ]
>chain 30
[ 3 0 , 1 5 , 4 6 , 2 3 , 7 0 , 3 5 , 1 0 6 , 5 3 , 1 6 0 , 8 0 , 4 0 , 2 0 , 1 0 , 5 , 1 6 , 8 , 4 , 2 , 1 ] お題: 改行とスペースを含むASCII文字列が与えられる。
改行とスペース以外の各印字可能文字の位置を以下のように順番に出力せよ。
(入力)
a b c
d
(出力)
[a, 0, 0]
[b, 2, 0]
[c, 5, 0]
[d, 0, 2] >>875
python
def chain(n):
lst = []
if n < 1: raise ValueError("Please n > 0 number")
while n != 1:
lst.append(n)
if n % 2 == 0: n //= 2
else: n = n * 3 + 1
lst.append(1)
return lst
for i in [10,1,30,0]: print(chain(i)) >>875
Haskell
main = mapM_ (print.chain) [10,1,30,0]
chain 1 = [1]
chain n | n < 1 = error "Please n > 0 number"
chain n | even n = n:chain (n `div` 2)
chain n = n:chain (n * 3 + 1) >>875
C
https://ideone.com/mBt0yE
1未満の値の判定はchain関数に実装すべきなのかどうなのか…… >>877
[c, 5, 0]？
[c, 4, 0]じゃなくて？ >>877
出力は、行列番号が0から始まるとして
文字,列番号、行番号 だと思うから c の列番号は間違ってるんじゃないの？
(入力)
a b c
d
(出力)
[a, 0, 0]
[b, 2, 0]
[c, 4, 0] ＜＜ 5じゃなくて4だろ。
[d, 0, 2] >>876,880
この問題、入門書から抜粋したけど次に1ー100の間に長さ15以上は何個あるかとか出てるから、
Cだとリストから作らないといけないのは分かるが、リスト返す様にした方が仕様変更に強いと思う。 >>877 python
st = '''a b c
d
'''
line = 0 ; col = 0
for c in st :
__if c == '\n' :
____line += 1
____col = 0
____continue
__if c != ' ' :
____print ('['+c, col,str(line)+']', sep=',')
__col += 1 >>886 出力フォーマットが
['a', 0, 0]
['b', 2, 0]
['c', 4, 0]
['d', 0, 2]
でもよければ print文は簡単になる
print ([c, col,line]) >>875
与えられた数の3倍以上の個数を持つ系列を
を3個示せ。 >>875,884 Squeak Smalltalk
| chain |
chain := [:n |
Array streamContents: [:ss |
ss nextPut: n.
[n > 1] whileTrue: [ss nextPut: (n := n even ifTrue: [n / 2] ifFalse: [n * 3 + 1])]
]
].
chain value: 10. "=> #(10 5 16 8 4 2 1) "
(1 to: 100) count: [:n | (chain value: n) size >= 15] "=> 71 " >>875
Perl のワンライナー。
perl -ne '$n=$_;chomp($n);@d=($n);while($n!=1){$n=$n&1?($n*3+1):($n/2);push(@d,$n)}print "[".join(", ", @d)."]\n"'
実行する場合はbash等のシェルから行う(シングルクォートの中がそのままperlに引き渡されさえすれば他のシェルでも良い)。
標準入力から1行1データで入力して結果を出力するようにした。 >>890
27のとき112個
31のとき107個
10億くらいまで回したけど、これら以外なくね？
数列の初期値と長さは、初期値が小さいうちは同じくらいだが、初期値を大きくしても数列の長さはさほど伸びない。
ttps://imgur.com/wm0kCEQ
グラフはxが大きくなるほど飛ばす間隔も大きくしてあるからあまり正確ではない。 >>875 Perl5
sub chain {
my $i = shift;
$i == 1 ? $i : ($i, ($i & 1 ? chain(3*$i + 1) : chain($i / 2)))
}
for (qw{10 1 30}) {
@a = chain $_;
print "[@a]\n";
}
実行
~ $ perl 13_875_collatz.pl
[10 5 16 8 4 2 1]
[1]
[30 15 46 23 70 35 106 53 160 80 40 20 10 5 16 8 4 2 1] >>877 Perl5
@in = map{[split'']} map{split '\n'} <<EOF;
a b c
d
EOF
for $j (0..$#in) {
for $i (0..$#{$in[$j]}) {
$c = $in[$j][$i];
print "[$c,$i,$j]\n" if $c =~ /\w/;
}
}
実行
~ $ perl 13_877.pl
[a,0,0]
[b,2,0]
[c,4,0]
[d,0,2] >>875
Ruby で
module Collatz
def self.next_number( num )
if num.even? # 偶数
num / 2
else # 奇数
num * 3 + 1
end
end
def self.chain( num )
@@results = [ ]
tmp = num
while true
@@results.push tmp
break if tmp == 1
tmp = next_number( tmp )
end
@@results
end
end
[ 1, 27 ].each do | num |
p Collatz.chain( num )
end ideone.comはMATLABに対応してないのね。
書いてみた後で気がついた。 >>877
Kotlin
https://paiza.io/projects/Aab0mA1WSwXHnHL2049hCA
for や while ループ使わずに forEachIndexed で入れ子にしてみました。 >>877
Ruby で
text = <<"EOT"
a b c
d
EOT
re = /[^ ]+/ # 空白以外
text.each_line.with_index do | line, idx | # 1行ずつ処理する
line.strip! # trim
# $~.begin は、マッチした先頭文字の位置
line.scan( re ) { puts "[" + [ $~.to_s, $~.begin(0), idx ].join( ", " ) + "]" }
end >>886 をスッキリ修正してみた
改行コード指定をやめ、for loop のカウンタを利用
>>877 の解
st = '''a b c
d
'''
for line,l in enumerate(st.splitlines()) :
for col,c in enumerate(l):
if c != ' ' : print('['+c, col,str(line)+']',sep=',') >>877 Squeak Smalltalk
| fn |
fn := [:str |
((str lines collectWithIndex: [:line :lIdx |
(line reject: #isSeparator) asArray
collect: [:chr | {chr. (line indexOf: chr) - 1. lIdx - 1}]]
) concatenation select: #notEmpty) asStringWithCr
].
fn value: 'a b c
d'
"=>
'#($a 0 0)
#($b 2 0)
#($c 4 0)
#($d 0 2)' " >>908 smalltalk って全く知らないけど、最後が出力のつもり？
だったらお題の出力フォーマットと似ても似つかないじゃん。 >>877 Squeak/Pharo Smalltalk
出力はともかく同行に同文字があるとダメだった^^;ので>>908 差し替え
| fn |
fn := [:str |
((str lines collectWithIndex: [:line :lIdx |
(line asArray collectWithIndex: [:chr :cIdx | {chr. cIdx - 1. lIdx - 1}]
) reject: [:each | each first isSeparator]]
) concatenation
select: #notEmpty thenCollect: [:each | '[{1}, {2}, {3}]' format: each]) asStringWithCr
].
fn value: 'a b c
d'
"=>
[a, 0, 0]
[b, 2, 0]
[c, 4, 0]
[d, 0, 2] " >>907
re = /[^ ]+/
空白以外だから、上のようにしたけど、空白"類"以外なら、\S+ でよい
問題の意図がどちらなのか、よく分からない >>914
具体的にはどの処理のどの部分を冗長に感じられたのでしょうか？
たとえばRubyの回答がどう冗長か（あるいはどう書けば良いか）教えてください！ >>913 故意にpython 外しはずるい。
>>877 python
https://ideone.com/yvFuOl
printフォーマットは、コメントにしたpython3.6のf文字列の方がシンプルだが、ideone は3.5しかないのでformat文にした。 お題
整数の数列が与えられるので、各値の大小関係を変えないように値をなるべく小さくせよ
ただし1番小さい要素は1にすること
入力
-6 3 9 5 3 -7
出力
2 3 5 4 3 1 >>920
＞値をなるべく小さくせよ
絶対値を小さく、という意味ですか？ >>920 Pharo/Squeak Smalltalk
| fn |
fn := [:arr |
| sorted |
sorted := arr asSet sorted.
arr collect: [:x | sorted indexOf: x]
].
fn value: #(-6 3 9 5 3 -7). "=> #(2 3 5 4 3 1) " >>877 ocaml
https://ideone.com/waZZh7
・自分に正直になってrefとforループで書いた
>>914
じょ、助長…
>>916
外しと言うより、たんに不勉強
python書けないんよね（´・ω・｀） >>923 Perl5
@a = qw{-6 3 9 5 3 -7};
$h{$_}=1 for @a;
%o = map{$_=>++$i} sort{$a<=>$b} keys %h;
@b = map{$o{$_}} @a;
print "@a => @b\n";
実行
~ $ perl 13_920.pl
-6 3 9 5 3 -7 => 2 3 5 4 3 1 >>925
アンカーしくった、>>920 宛だった…orz >>888 Pharo/Squeak Smalltalk
| fn |
fn := [:arr |
String streamContents: [:ss |
| cIdx lIdx |
cIdx := lIdx := 0.
arr do: [:spec |
spec third > lIdx ifTrue: [
ss nextPutAll: (String new: spec third - lIdx withAll: Character cr).
lIdx := spec third.
cIdx := 0
].
ss nextPutAll: (String new: spec second - cIdx withAll: Character space).
ss nextPutAll: spec first.
cIdx := spec second + 1.
]
]
].
fn value: #(
(a 0 0)
(b 2 0)
(c 4 0)
(d 0 2)).
"=>
a b c
d " >>927
重複除去でソート後のインデックスを返す関数？
チート過ぎてわろたｗ >>888
s = '''\
[a, 0, 0]
[b, 2, 0]
[c, 4, 0]
[d, 0, 2]
'''
from parse import * #pip install
col2 = 0 ; line2 = 0
for l in s.splitlines():
col = col2 ; line = line2
r=parse('[{},{},{}]',l)
c= r[0]
col2 = int(r[1]) ; line2 = int(r[2])
{print() for _ in range(line2-line) }
{print(' ',end='') for _ in range(col2-col)}
print(c, end='')
col2 += 1
print()
'''#出力
a b c
d
''' >>932 parse に型指定追加
>>888 Python
s = '''\
[a, 0, 0]
[b, 2, 0]
[c, 4, 0]
[d, 0, 2]
'''
from parse import * #pip install
col2 = 0 ; line2 = 0
for l in s.splitlines():
col = col2 ; line = line2
(c,col2,line2) = parse('[{},{:d},{:d}]',l)
{print() for _ in range(line2-line) }
{print(' ',end='') for _ in range(col2-col)}
print(c, end='')
col2 += 1
print()
'''#出力
a b c
d
''' >>920
は、ランク付けの問題だろ
入力データ
-6 3 9 5 3 -7
出力・ランク
2 3 5 4 3 1
入力データの最も小さい数字を、ランク1 にして、
数字が大きくなるほど、ランクも大きくしていく
同値の場合は、同じランクにして、次のランクも間隔を空けない。
ランク3 が2つあっても、次は、ランク4
つまり、ランクが欠けることはない！ 難しく書いてたけど結局これだけなのか
問題文をわざと複雑に見せかける現代文読解と同じ仕組みじゃないか プログラム作る前に気づいたので>>931のリンク先のブログラムのタイトルは密かに「順位」にしといたw >>936
わざと難しく見せかけているというより、たんに説明が下手なだけだと思う そうですね
難易度は主観ですね
なら短さ長さを比べるとこうなります
・各値の大小関係を変えないように値をなるべく小さくせよ
・ランク付けせよ
もしかしたらこれが要するにただのランク付けだと分かるまで何人が挑戦するかを試してみる社会調査だったのかもしれません >ランク付けだと分かるまで何人が挑戦するかを試してみる
まさにそうじゃないの？ >>920 J
f =: >: @ (i.~ /:~ @ ~.)
f _6 3 9 5 3 _7
2 3 5 4 3 1 さすがにいちゃもん付け過ぎだろ
元の問題文読めば普通はわかるだろ お題：自然数を隙間なく自分自身以外の数に対応させよ。 >>949 先生、対応させると言う日本語がわかりません。
日本人には難しいです。 偶数なら1引く
奇数なら1足すとかでいいんじゃないの >>953 良いんじゃないのじゃなくて、他の人が理解できる言葉に翻訳してよ。
これじゃ小学校の国語で平均点以下だろ。
日本語が不自由ならプログラム例を示せば良い。変な言語はダメだけど、C系の素直な言語なら万国共通 要はf: N -> N の∀n∈N f(n) ≠ n かつ全単射な写像を求めろってことでしょ >>955 あのさ、それで人に通じると思ってるの？
そんな仕様書を書いて誰がコーディングするんだよ。
日本語に翻訳して明後日出直してこい。
言語能力にかけてるやつは、自分の頭の中が周りの人からスケスケに見えてると言う妄想を持ってる。
狭い世界で通用しても社会では通用しない。 ここまで何人もの人がわからんと言ってるのは、その仕様を出した人間の素質が失格という事だろ。
それを何で庇うんだ？ 庇う理由を説明してみろよ。 ここがバカばかりと思うならバカに解るように説明しろよな。
バカにわからせなければ、PLは務まらないよ。
と言うか、仕事は一般人としてるのに何をトチ狂ってるんだ？ かなり精神を疑うな。 >>947
桃白白改めミスターポポ改めピラフ改めピッコロさん、くだらない出題はやめてください >>959 で、どんな問題なんだ？ プログラミングできる仕様として出してくれよ。 >>956
単射でないとなると、n に対して n % 10 を対応付けるとかもありになりますね…
>>957
全射、単射、全単射とかは普通に使う単語ですよ、知らないのなら、これらの術語を含む数学の本…代数ですかね？解析ですかね？よくわからないや、を一冊読んでみるのがいいですね >>961
出題者に言えよ
>>962
％じゃ全射にも単射にもならんぞ
上で誰かが言ってた遇奇を入れ替えたりだとか
f(n) = n - 1, f(0) = 0以外の任意の値
とかなんでもありだね。つまらんけど >>963
＞％じゃ全射にも単射にもならんぞ
そうですね、じゃ、割り算の商の整数部分「/」とかはどうでしょう >>965
そりゃなんでもありよ
その場合は0の時だけ別の値を定義すれば良し 920だが、ランク付けだと解が236531と解釈される可能性が有ったので避けた
もっと簡単な書き方があるはそう思う、座圧+1とかでも伝わるだろうし…… 数値のリストを入力し、値の小さい順に1から順位を付けて、
順位のリストを出力する。同じ値は同じ順位とする >>949
やっぱりどういう入出力の具体例になるのか分からない
どういうことなんだよ >>971
あくまで俺の推測だが
一例として、自分自身の数が3のとき自然数から3を除去して
(1) 1, 2, 3, 4, 5, 6, ...
↓
(2) 1, 2, NULL, 4, 5, 6, ...
NULLになった部分をなくすために4以降を左へシフトする
(3) 1, 2, 4, 5, 6, 7, ...
こんな感じで(1)の入力を(3)のような出力にする関数じゃないか?
ただお題の条件としてはもっとゆるくて、入力はオーバーフローしない範囲の自然数、出力は「自分自身の数」を含まない自然数になれば何でもよくて、
定数関数でもハッシュ関数でもいいはず。
ただし、ある入力に対して必ず決まった値にならなければならず、同じ入力で呼び出すたびに出力が違うのはダメ。 >>972 何をアホな事を言ってるんだ？ そんなの小学生に数を数えなさいと言ってるのと等しいぞ。
それのどこがプログラミングのお題なんだ？
バカじゃないのか？ >>920 Python
ol = [-6, 3, 9, 5, 3, -7]
print([ sorted(set(ol)).index(x)+1 for x in ol ] )
# [2, 3, 5, 4, 3, 1] >>971
1. すべての自然数nに対してf(n)≠n
2. 自然数m,nがm≠nを満たすときf(m)≠f(n)
を満たすような関数f(n)を作れってこと
例えば
1. 入力が1のとき出力は1以外
2. 入力が1のときと2のときで出力が同じになってはダメ >>978
2はいらんやろ
適当なコト抜かすなごかすぞぼけ 難しすぎて全くわからん…
ハローワールド始めて間もない男にも分かる問題を出してくれぬか
優しく教えて欲しい >>949
これがあれば1Mbyteのファイルが2byteになっちゃうのか？ >>978 これのどこがプログラムの問題なのかさっぱりわからん。 小学生の練習問題か？
例えば自然数が 1から4までとした場合、f(n) の出力配列は
f(1) 2,3,4
f(2) 1,3,4
f(3) 1,2,4
f(4) 1,2,3
と言う事だろ？ どうしてこんな問題を出したかさっぱり分からん、何か勘違いしてる？ >>979
「隙間なく」を満たすには全射である必要があるけど、今回は定義域と終域が等しいから単射なら自動的に全射になる
全射の条件より単射の条件のほうが説明が楽だから許してくれ
>>983
出題者じゃないから意図は分からんが、自然数を自身以外の自然数に変換するのが題意だからその例は間違っている
f(n)が返すのは自然数であってベクトル(配列)ではない >>980
＞単射である必要はない。全射でさえあればよい
？？？
>>978
2. 自然数m,nがm≠nを満たすときf(m)≠f(n)
これって単射の定義そのものなのでは？
だから単射である必要があるのでは？
f が単射でない場合 f:a->z, f:b->z だった場合に a != b にもかかわらず f(a)=f(b) で 2 を満たさない def f(n)
n + 1
end
一応>>978は満たしてる >>985
追記
単射なら全射になるのは有限集合の場合だったわ
お詫びにお題
入力n(2≤n≤2^31-1)を素因数分解してそれを表示せよ
入力例）
28
2002
216653
出力例）
2^2*7
2*7*11*13
216653 >>888 Perl5
@a=([a, 0, 0],
[b, 2, 0],
[c, 4, 0],
[d, 0, 2]);
sub {$t[$_[2]][$_[1]] = $_[0]}->(@$_) for @a;
@b = map{[map{$_ // ' '} @$_]} map{[@$_]} @t;
undef $";
$s = join'', map{"@$_\n"} @b;
print $s;
実行
~ $ perl 13_888.pl
a b c
d >>988 Pharo/Squeak Smalltalk
| fn |
fn := [:n |
| m bag |
m := n.
bag := Bag new.
Integer primesUpTo: n sqrt + 1 do: [:prime |
[m isDivisibleBy: prime] whileTrue: [m := m / (bag add: prime)]
].
m > 1 ifTrue: [bag add: m].
String streamContents: [:ss |
bag valuesAndCounts associations sort do: [:assoc |
ss nextPutAll: assoc key asString.
assoc value > 1 ifTrue: [ss nextPutAll: '^', assoc value asString]
] separatedBy: [ss nextPut: $*]
]
].
fn value: 28. "=> '2^2*7' "
fn value: 2002. "=> '2*7*11*13' "
fn value: 216653. "=> '216653' " >>987 何か落とし穴があるとしたら、巨大数かなと思い、自然数を増やしてみると、python( iOSのpythonista , ideon )では配列数は 10**7 までだった。
大きな連続数の配列なんて作るバカはいないだろうし、ますます問題の意図がわからん。
一応書いてみたが、lambda 1行のみ ,(def でも何でも良いが)
f978 = lambda x,n:[i for i in range(1,n+1) if i != x]
xが自分の数字、n は自然数の数
https://ideone.com/iMUZ96
呼び出しは、f978(3,10**6) の様に
出力の配列数が大きくなると全ての数のPrint はアホらしいので、
10以上は配列数だけを出してる( これも n-1 だからアホらしいのだが )
out(1,4)
out(2,4)
out(4,4)
out(10**2,10**7)
stdout
個数 n= 4 自数 x= 1 自数以外の数= 3
[2, 3, 4]
個数 n= 4 自数 x= 2 自数以外の数= 3
[1, 3, 4]
個数 n= 4 自数 x= 4 自数以外の数= 3
[1, 2, 3]
個数 n= 10000000 自数 x= 100 自数以外の数= 9999999 問題をひねって、不連続のランダムの整数としてもほとんど変わらないだろ。 このスレッドは１０００を超えました。
新しいスレッドを立ててください。
life time: 104日 10時間 9分 43秒 5ちゃんねるの運営はプレミアム会員の皆さまに支えられています。
運営にご協力お願いいたします。
───────────────────
《プレミアム会員の主な特典》
★ 5ちゃんねる専用ブラウザからの広告除去
★ 5ちゃんねるの過去ログを取得
★ 書き込み規制の緩和
───────────────────
会員登録には個人情報は一切必要ありません。
月300円から匿名でご購入いただけます。
▼ プレミアム会員登録はこちら ▼
https://premium.5ch.net/
▼ 浪人ログインはこちら ▼
https://login.5ch.net/login.php レス数が1000を超えています。これ以上書き込みはできません。
