プログラミングのお題スレ Part22

**デフォルトの名無しさん** · 2025/01/31(金) 22:10:00.47

普通は問題発生前に気がつく

**デフォルトの名無しさん** · 2025/01/31(金) 22:17:10.46

**デフォルトの名無しさん** · 2025/01/31(金) 22:38:00.61

>>518
グローバル変数を排他制御せずに使ってしまっていたりするミスなどよく見かけるような
一般的にも巨大なコードになったり複数人で共通認識なかったりで見逃しミスは必ず出てくる
そしてタイミング次第によって稀にバグが起こるパターンとか負荷が高くなって起きてバグ発覚とか

**デフォルトの名無しさん** · 2025/01/31(金) 23:44:08.10

全て自分で出来る気付くミスらない
って自己過信な人がセキュリティホールを招いてるからね
自動的にサポートしてくれる言語を使うのが安全で開発効率もいいよ

**デフォルトの名無しさん** · 2025/02/01(土) 00:00:30.73

ちゃんとルールを守って運転すれば
事故も起きないし､違反で捕まらない
それと同じ

**デフォルトの名無しさん** · 2025/02/01(土) 00:26:30.15

>>517
せっかくだからRustで>>516やってきなよ

**519** · 2025/02/01(土) 17:22:30.12

>>510 c
https://ideone.com/tdT1q2
・若干の高速化
　部分文字列を一文字ずつズラして検証していたのを
n = strcspnで探してn文字スキップへ

**デフォルトの名無しさん** · 2025/02/01(土) 22:42:58.39

>>516
横からだがその仕様ならベクタをリングバッファとして使った両端キューで十分だな
多くの実用例でもこの方が速いことが知られている

use std::collections::VecDeque;
// 空のキュー
let mut deque: VecDeque<T> = VecDeque::new();
// 先頭に挿入
deque.push_front(t);
// 最後に挿入
deque.push_back(t);
// 指定位置に挿入
deque.insert(index, t);
// 先頭を削除して得る
let first: Option<T> = deque.pop_front();
// 最後を削除して得る
let last: Option<T> = deque.pop_back();
// 指定位置を削除して得る
let element: Option<T> = deque.pop_back();

**デフォルトの名無しさん** · 2025/02/01(土) 22:57:16.48

ズルしてどうするんよ…

**デフォルトの名無しさん** · 2025/02/01(土) 23:00:12.86

Rustのメモリ安全性を確認するためにプログラム書きたいんでしょ、だったら循環リストをフルスクラッチするしかないよね

**デフォルトの名無しさん** · 2025/02/02(日) 19:41:14.89

リンクリストならindex番目の操作(挿入or切除)は
index番目で分解して操作して合体するだけなのでこれで動くよ

use std::collections::LinkedList;

trait LinkedListExt<T> {
fn insert_at(&mut self, index: usize, value: T);
fn remove_at(&mut self, index: usize) -> Option<T>;
}

impl<T> LinkedListExt<T> for LinkedList<T> {
fn insert_at(&mut self, index: usize, value: T) {
let mut tail = self.split_off(index);
self.push_back(value);
self.append(&mut tail);
}
fn remove_at(&mut self, index: usize) -> Option<T> {
let mut tail = self.split_off(index);
let value = tail.pop_front();
self.append(&mut tail);
value
}
}

**デフォルトの名無しさん** · 2025/02/03(月) 21:15:02.53

>>510
R
https://ideone.com/0Hr1lU

C++ (>>524と同じ巨大文字列での繰り返しあり)
https://ideone.com/7fJXjB

**デフォルトの名無しさん** · 2025/02/03(月) 22:57:52.37

>>510 c
https://ideone.com/L4xIAy
・f_529 は529さんのパクり
・f_strcspn_chr は strchr してから strcspn すると単純ながら若干の速度向上

**530** · 2025/02/04(火) 21:13:55.63

>>510 c
https://ideone.com/Mar3S7
・f_529direct は出現位置集めるのやめた
　*min = strchr(*min + 1, **min)) でそのまま次へ

**531** · 2025/02/05(水) 20:39:11.49

>>510 c
https://ideone.com/jeAf1a
・デバッグと若干の整理

**532** · 2025/02/05(水) 23:28:39.35

>>510 java
https://ideone.com/EdHfzN

**デフォルトの名無しさん** · 2025/02/06(木) 22:16:32.16

>>510
C++
https://ideone.com/ywT3qw

>>529からの変更点
・sへのtの文字の出現位置を高速取得（1バイト文字のみに対応）
・sにtの同一文字が3回以上連続して出現する場合に最初と最後以外の位置を省略

**デフォルトの名無しさん** · 2025/02/07(金) 19:14:17.64

>>500
Wolfram Language

str = "ATGAT"
>> Out[1]= ATGAT

duplicates = str // Characters \
(* { A, T, G, A, T } *) \
// Counts \
(* <| A -> 2, T -> 2, G -> 1 |> *) \
// Select[Function[ 1 < # ]] \
(* <| A -> 2, T -> 2 |> *) \
// Keys \
(* { A, T } *) \
// StringJoin (* "AT" *)
>> Out[2]= AT

**デフォルトの名無しさん** · 2025/02/07(金) 21:12:13.92

テス

9 · 2025/02/07(金) 21:20:22.98

>510 Perl5

https://ideone.com/lceN9R

**デフォルトの名無しさん** · 2025/02/07(金) 22:53:14.41

>>510 c
https://ideone.com/uYlPLX
・f_537 は537さんのパクリ

9 · 2025/02/07(金) 23:00:25.46

>>537
しくった、これ一番短い範囲ではなく間違って一番長い範囲を検出してる。
サンプルデータではたまたま同じ解になるようで、間違いを見落としてしまった。

それから、一番長い（短いにすべきだったが）範囲の検索にわざわざ候補listをsortして[0]番目を
取得しているが無駄だし規模が大きくなると効率よくない

時間あったら直しますわ～

9 · 2025/02/07(金) 23:02:20.43

>>538
あーでも527の方式がいまんとこ一番早いんだな、検証ｔｈｘ

9 · 2025/02/07(金) 23:04:01.40

>>540 527 じゃなくて 537ね。ｽﾏｿ

**538** · 2025/02/07(金) 23:08:45.80

>>540
>>537さん方式は動的にメモリとらなくていいのがいいよね、清々しくていいよね
あと実行時間の値はまぁアテにはならんので参考程度にｗ

**デフォルトの名無しさん** · 2025/02/07(金) 23:41:05.56

>>500
PowerShell

"T", "CG", "ATA", "CGGA", "ATGAT", "GTTGCA", "CCCCGGG", "ACTGCGAG ", "ATCAGAATA", "TGCCATGACA" |% {
　　"$_ → $(-join ([char[]]$_ | group -case |% {$_.name[$_.count -le 1]}))"
}

[実行結果]
T →
CG →
ATA → A
CGGA → G
ATGAT → AT
GTTGCA → GT
CCCCGGG → CG
ACTGCGAG → ACG
ATCAGAATA → AT
TGCCATGACA → TGCA

9 · 2025/02/08(土) 00:22:55.52

>>510 Perl5、>>537 の修正版

https://ideone.com/klqLux

修正点
・>>537では間違って一番長い範囲を検出していたが、一番短い範囲に修正した。（サンプルデータではそれらの解はたまたま一致）
・パターンが3文字であることに依存する定数「2(=3 -1 )」をハードコードしている箇所があったので、パターン文字数次第で処理するように修正
・検出した候補文字列リストのうち一番短い物の検索のためにわざわざ候補リスト全体をsortするのをやめて
　reduceによって長さが一番短い文字列を検索するように修正

List::Utils は言語処理系にデフォルトで付属のコアモジュール、
List::MoreUtils はCPANのオプションノジュールだがideoneのperlにはｲﾝｽｺされていたので使っちゃいましたﾃﾍﾍﾟﾛ

なお、候補文字列リストを作らず、ループの最内ifの中で一番短い文字列だけを記録していく様に記述すれば
大規模問題で若干効率が良くなるだろうけど、
まあいいや、もういいや。

9 · 2025/02/08(土) 00:26:07.95

>>544 List::Utils → List::Util ね。ｽﾏｿ

**デフォルトの名無しさん** · 2025/02/08(土) 08:27:20.39

>>510
Wolfram Language

s = "DHBICEJAFG"
>> Out[1]= DHBICEJAFG
pattern = "EIC"
>> Out[2]= EIC

shortestMatch = \
(* 全通りの部分文字列を生成する *) \
ReplaceList[ Characters[ s ], {___, x__, ___} -> {x} ] \
(* 短い順、先頭に近い順に並べる *) \
// Sort \
(* 検索文字列の文字を全て含むものを選ぶ *) \
// Select[ ContainAll[ Characters[ pattern ] ] ] \
(* 1つ目を文字列として返す *) \
// Extract[ 1 ] // StringJoin
>> Out[3]= ICE

9 · 2025/02/08(土) 17:50:15.20

>>510 Perl5、>>544 をもう一回だけ改良

https://ideone.com/YkuK1w

改良点：
・検出された範囲の候補を一通りリストに蓄えて、あとでその中から最短のものを探す方式を止めて、
　範囲を検索するループ内のifでその時点までの最短な範囲の判定と記録を行うようにした。
・CPANモジュールList::MoreUtilsのminmaxを使わない。
・コアモジュールList::Utilはminだけ使う。reduceは使わない。

なんだかPerlのコードらしい感じが減って、ベタな感じのコードになってしまいました

**デフォルトの名無しさん** · 2025/02/08(土) 19:59:09.70

>>510
C++
https://ideone.com/7EHx0H

>>534からの変更点
・minmax_elementを呼び出さずに済むようにして高速化

**デフォルトの名無しさん** · 2025/02/08(土) 20:02:06.41

>>510
C++
https://ideone.com/TluWQi

>>548では検索文字列が短くて高速化されたか分かりにくかったので、長くして529, 534, 548の
実行時間を比較してみると、効果が顕著に現れた。

警備員[Lv.19] · 2025/02/09(日) 03:18:28.07

>>485
Kotlin
https://paiza.io/projects/RtyGxT2PXZScHW6eucI5ng

警備員[Lv.19] · 2025/02/09(日) 03:56:54.57

>>500
Kotlin
https://paiza.io/projects/eipNjg4meAtA7__e3JTRdg

**デフォルトの名無しさん** · 2025/02/09(日) 12:47:59.38

>>510 c
https://ideone.com/D2AZMK
・両端に着目し、両端のみを更新しつつ調べていく（が、これといってパっとせず）
・f_both_ends はあくまで元の文字列s上を調べていく
・f_both_ends_v2 は「次」「隣」にアクセスしやすくした構造の上を調べていく
・あと実行時間の値ははげしくブレブレなので参考程度にとどめておいてね

**デフォルトの名無しさん** · 2025/02/09(日) 21:29:55.65

>>485
R
https://ideone.com/wuW5oV

**デフォルトの名無しさん** · 2025/02/09(日) 21:31:24.58

>>510
C++
https://ideone.com/bwvs06

>>548からの変更点
・データ構造を単純化したら速くなった

**デフォルトの名無しさん** · 2025/02/09(日) 21:35:08.87

>>510
https://ideone.com/46Tb28
>>549の実行速度比較に554を追加。548は不要な2行を削除した。検索文字列が短いのと長いのの両方をテスト。

警備員[Lv.19] · 2025/02/10(月) 13:21:24.86

>>510
Kotlin

出来たことは出来たが、もっと簡単に出来そうな気がしてきた。

https://paiza.io/projects/RwNXYMH6q3P6v0vx9zbZng

**デフォルトの名無しさん** · 2025/02/10(月) 21:24:31.20

>>485
C# (IEnumerableとして列挙)
https://ideone.com/UBY8bl

**デフォルトの名無しさん** · 2025/02/11(火) 03:27:04.16

動画再生回数、登録者数、評価数、コメント数

上2桁、下2桁に04、13、40、44、71、74など
（＋生年月日、IDの数字など）の組み合わせ

業者による忌み数字、不吉数字の嫌がらせ&精神攻撃がキモすぎ

警備員[Lv.20] · 2025/02/11(火) 05:48:25.27

それはお題なのか？それともただの誤爆か？

**デフォルトの名無しさん** · 2025/02/11(火) 06:03:36.08

糖質でしょ
忌み数字不吉数字とか意味不明なこと言ってるし，それを業者が特定個人を狙って表示する意味も分からんし

**デフォルトの名無しさん** · 2025/02/11(火) 10:54:21.93

お題
数列が入力されます
ニ番目に小さい数を出力してください

入力：4, 5, 1, 7, 1, 2, 8, 9, 2, 7
出力：2

**デフォルトの名無しさん** · 2025/02/11(火) 11:46:37.94

こんちゃ
質問いいでしょうけ
プルダウン（ポップアップ）をUIとしてだすとして
見えている項目名と、実際にパラミータとして出す値を変えたい時はどうしたらよか

9 · 2025/02/11(火) 14:53:15.78

>>561 Perl5

$h{$_} = $_ for 4, 5, 1, 7, 1, 2, 8, 9, 2, 7;
@s = sort keys %h;
print "$s[1]\n";

実行結果
~ $ perl 22_561_second.pl
2

Perl5.26以降に付属のList::Utilにはuniq関数があるのでそれを使えば:

use List::Util qw(uniq);
@s = uniq sort 4, 5, 1, 7, 1, 2, 8, 9, 2, 7;
print "$s[1]\n";

警備員[Lv.20] · 2025/02/11(火) 16:33:48.19

>>562
環境や言語やフレームワークを書いて限定しないと色々な環境や言語やフレームワークでの答えが適当に沢山湧いて出て来る可能性あるぞ。
しかも分からない所は適当に解釈してだ。なぜならここはお題スレだから。

**デフォルトの名無しさん** · 2025/02/11(火) 16:37:12.05

>>561 ruby
https://ideone.com/OI7hWs

>>561 octave
https://ideone.com/36aKUO

>>561 c
https://ideone.com/eDmlMM

**デフォルトの名無しさん** · 2025/02/11(火) 16:40:21.13

>>561
#!ruby
puts $stdin.gets.chomp.split(",").map{|e| e.to_i}.uniq.sort[1]

**デフォルトの名無しさん** · 2025/02/11(火) 17:43:14.68

>>510 lisp
https://ideone.com/qm4PsV

**デフォルトの名無しさん** · 2025/02/11(火) 17:48:30.95

>>561 lisp
https://ideone.com/g6m1EK

**デフォルトの名無しさん** · 2025/02/11(火) 18:19:05.70

>>568
全然だめでした
取りあえずテスト追加済

**デフォルトの名無しさん** · 2025/02/11(火) 20:45:09.89

>>561
R
https://ideone.com/3beF1j

C++
https://ideone.com/A8hp2f

それぞれ3通りの方法で、大きなデータでの実行時間を比較

**デフォルトの名無しさん** · 2025/02/11(火) 23:21:03.54

数列が入力されるので
整数の数列だけでなく浮動小数点数の数列にも対応してくださいね

ニ番目に小さい数がない時
例えば同じ数しか存在しない時や数列の長さが1の時には
解がないことを返してくださいね
例えばその時にMAX値が返ってきたら失格ですよ

**565** · 2025/02/11(火) 23:28:05.14

>>561 ocaml
https://ideone.com/aV59Yd

>>561 java
https://ideone.com/PdgusX

9 · 2025/02/11(火) 23:36:31.53

先に言えよって、感じｗ

**デフォルトの名無しさん** · 2025/02/11(火) 23:48:25.56

>>571は出題者ではないよ
出題者として申し上げるなら>>571は観点がダサい

**デフォルトの名無しさん** · 2025/02/11(火) 23:50:12.69

小数対応はともかく
max値を返してしまう人はプログラマ失格かな
あとsortを使ってしまう人は計算量を知らない初心者

**デフォルトの名無しさん** · 2025/02/11(火) 23:53:59.73

そういうこだわりはアスペルガーにしか思えないな、どうでも良いじゃないですかそんなこと

**デフォルトの名無しさん** · 2025/02/11(火) 23:56:29.96

こだわりは自分の胸のうちに留めていただきたい、他人に求めたら回答の幅を狭めるだけ、多様性のある回答こそ美しい

**デフォルトの名無しさん** · 2025/02/11(火) 23:57:23.71

>>576
多くの人はちゃんとnilとかemptyとかNoneなどを返しているよね
プログラマならそこだけは守らなければならない必須事項

**デフォルトの名無しさん** · 2025/02/11(火) 23:59:56.87

だからそういう、こうじゃないとダメだという態度がアスペルガー仕草なんだってばよ、君が思うのは勝手だが他人に求めるものじゃない

**デフォルトの名無しさん** · 2025/02/12(水) 00:01:10.34

プログラミングはもっと自由なものなんだよ、思ったとおりにかけば良い

9 · 2025/02/12(水) 00:03:23.15

そういう条件は回答を見て思いついた後から言わず先に書くべきでは？
そうでなければ、与えられた短い文とテストデータから、
処理対象データの範囲や要求仕様を読み手が色々解釈しても仕方ないだろ。
後からいろいろ言って批判なんてでもってのほかだと思うが。

9 · 2025/02/12(水) 00:05:30.21

出来たもの見て実はこういう条件がありましたってケチつけるのはクソクライアントと一緒だな

**デフォルトの名無しさん** · 2025/02/12(水) 00:13:52.34

ざっと見たけどmax()を返してるのはC++の人だけで他は皆まともだ
普段からまともなコード書いてるかどうかバレてしまうから自由が面白い

**デフォルトの名無しさん** · 2025/02/12(水) 00:18:10.68

好きにしたら良いんやで吉田松陰もそんなこと言ってた気がする

**デフォルトの名無しさん** · 2025/02/12(水) 00:20:24.72

まともとかバレるとかそういう当て擦りの嫌味ったらしい言い方どこで身につけてきたのあんた、母ちゃんは悲しいよ

**デフォルトの名無しさん** · 2025/02/12(水) 00:22:24.96

>>583
関数がINT_MAXを返すのはまともなコードだろ。2番目に小さい数はINT_MAXではありえないから、
返り値がINT_MAXの場合は「なし」と表示すれば良いだけ。

9 · 2025/02/12(水) 00:28:30.94

「データが二個未満の場合にはnilを返す。」とか書いとくべき。
でもそういう細かい条件をちまちま指定した窮屈な課題は、つまんなくて回答を造る意欲が減るんだよな。

シンプルで純な課題に対してどういうエレガントでエッセンシャルな回答があるか考えるのが楽しいのであって、
細かいいろんな条件を守る周辺コードで固めるような作業はつまんないから趣味の世界ではやりたくないな

**デフォルトの名無しさん** · 2025/02/12(水) 00:31:16.47

普段はプログラム載せるだけだけど、みんな意外と饒舌なんだなw

9 · 2025/02/12(水) 00:33:57.88

ここはある意味、回答のｺｰﾄﾞでもって語るスレだからな

**デフォルトの名無しさん** · 2025/02/12(水) 00:35:35.77

お題にそんな指定ないのに
みんなnilなどを返してるからこのスレの住人たちはセンスいいな

**デフォルトの名無しさん** · 2025/02/12(水) 19:12:16.26

>>561 lisp (sbcl)
https://ideone.com/Bct7bC

>>561 lisp (clisp)
https://ideone.com/yqfmzh

clispだと何故かsort版の方が速い

**デフォルトの名無しさん** · 2025/02/12(水) 20:45:54.96

>>561 ruby
https://ideone.com/svMSSw

>>561 sqlite
https://ideone.com/W02Q5r

**デフォルトの名無しさん** · 2025/02/12(水) 22:44:39.40

>>561, 571
>>570のC++のf3をint型の最大値を含むデータにも対応させた。

C#にはint?型があるのですっきり書けるが、
https://ideone.com/oRhDL1

C++ではまあまあすっきり書くにはintへのポインタを返すしかないか。
https://ideone.com/xYnTSD
(該当値が複数の位置に存在する場合にそれらのうちのどれへのポインタを返すかについては
こだわらないものとする)

**デフォルトの名無しさん** · 2025/02/13(木) 12:04:43.08

お題：ランダムな数列から任意の並んでいる二つの数同士を足して、その二つの数の間に挿入せよ。
その新しい数が一桁ならそのまま挿入し二桁なら桁同士を足してその二桁の間に挿入せよ。

< 123456789 3 4
> 1237456789

(3+4=7)

< 123456789 6 7
> 123456143789

(6+7=13 1+3=4)

**デフォルトの名無しさん** · 2025/02/13(木) 12:31:31.25

問題文の記述が下手かよ

**デフォルトの名無しさん** · 2025/02/13(木) 13:27:16.37

>>594 ruby
a=$stdin.gets.chomp.split(" ")
b=a[1].to_i+a[2].to_i
c=(b<9 ? a[1]+b.to_s+a[2] : a[1]+"#{b/10}#{b/10+b%10}#{b%10}"+a[2])
puts a[0].gsub(a[1]+a[2],c)

9 · 2025/02/13(木) 17:35:13.67

>>594　Perl5、見易くするためインデントは全角スペースに置換してあります

for (<DATA>) {
　($s, $a, $b) = split;
　$c = $a + $b;
　$c = $1 . ($1 + $2) . $2 if $c =~ /(\d)(\d)/;
　$s =~ s/$a$b/$a$c$b/g;
　print "$s\n";
}
__DATA__
123456789 3 4
123456789 6 7
123456789 8 9
3141592653589793238462643383279502884197169399375105820974944 9 7

実行結果
~ $ perl 22_594.pl
1237456789
123456143789
123456781879
3141592653589176793238462643383279502884191767169399375105820917674944

**デフォルトの名無しさん** · 2025/02/13(木) 20:12:01.16

>>594
題意が以下の通りだとして、PowerShell (エラーチェックは省略)

　自然数x, i, j (i + 1 = jを満たす) が与えられる。xの上i桁目の数字をx[i]で表す。
　x[i]とx[j]の和をyとして、

　・yが1桁のとき、yをx[i]とx[j]の間に挿入せよ
　・yが2桁のとき、y[1]とy[2]の和をy[1]とy[2]の間に挿入してから、yをx[i]とx[j]の間に挿入せよ

function f($x, $i, $j)
{
　　$s = [string]$x
　　$y = [int][string]$s[$i - 1] + [int][string]$s[$j - 1]
　　if ($y -lt 10) {
　　　　$s.insert($i, $y)
　　} else {
　　　　$s.insert($i, 11 * $y)
　　}
}

(123456789, 3, 4), (123456789, 6, 7) |% {
　　"< $($_[0]) $($_[1]) $($_[2])"
　　"> $(f $_[0] $_[1] $_[2])", ""
}

[実行結果]
< 123456789 3 4
> 1237456789

< 123456789 6 7
> 123456143789

9 · 2025/02/13(木) 20:24:48.49

数学屋さんかいなｗ
i,jの「3 4」とか「６ 7」は桁の位置をしていしているのではなく数値列の中にある数字を指定するんジャマイカ
とオレは解釈したが

**デフォルトの名無しさん** · 2025/02/13(木) 20:34:25.67

>>599
そうか。だとすれば、

function f($x, $i, $j)
{
　　$s = [string]$x
　　$y = $i + $j
　　if ($y -ge 10) {$y *= 11}
　　$s -replace "$i$j", "$i$y$j"
}

(123456789, 3, 4), (123456789, 6, 7), (123456789, 8, 9), ("3141592653589793238462643383279502884197169399375105820974944", 9, 7) |% {
　　"< $($_[0]) $($_[1]) $($_[2])"
　　"> $(f $_[0] $_[1] $_[2])", ""
}

[実行結果]
< 123456789 3 4
> 1237456789

< 123456789 6 7
> 123456143789

< 123456789 8 9
> 123456781879

< 3141592653589793238462643383279502884197169399375105820974944 9 7
> 3141592653589176793238462643383279502884191767169399375105820917674944

**デフォルトの名無しさん** · 2025/02/13(木) 20:45:01.39

>>561 c
https://ideone.com/ZyWoVM

>>594 ruby
https://ideone.com/gp9Fvp

9 · 2025/02/13(木) 20:52:32.26

なんでこの人はコーデイングするのがこんなに早いんだろう…

**デフォルトの名無しさん** · 2025/02/13(木) 22:58:07.29

>>594　Rust

fn f(input: &str, a: u32, b:u32) -> String {
let src = format!("{a}{b}");
let dst = if a + b < 10 {
format!("{a}{x}{b}", x = a + b)
} else {
format!("{a}{x}{y}{z}{b}", x = 1, y = 1 + a + b - 10, z = a + b - 10)
};
use itertools::Itertools;
input.split(&src).join(&dst)
}

fn main() {
assert_eq!(f("123456789", 3, 4), "1237456789");
assert_eq!(f("123456789", 6, 7), "123456143789");
assert_eq!(f("3141592653589793238462643383279502884197169399375105820974944", 9, 7),
"3141592653589176793238462643383279502884191767169399375105820917674944");
}

**デフォルトの名無しさん** · 2025/02/13(木) 23:47:12.83

>>561　Rust

fn second_smallest<T: Copy + Ord>(input: &[T]) -> Option<T> {
use std::cmp::Ordering::{Equal, Greater, Less};
input
.iter()
.copied()
.fold(None, |state, t| match state {
Some((_t0, Some(t1))) if t >= t1 => state,
Some((t0, _)) => match Ord::cmp(&t, &t0) {
Less => Some((t, Some(t0))),
Equal => state,
Greater => Some((t0, Some(t))),
},
None => Some((t, None)),
})
.and_then(|(_t0, t1option)| t1option)
}

fn main() {
assert_eq!(second_smallest(&[4, 5, 1, 7, 1, 2, 8, 9, 2, 7, 1]), Some(2));
assert_eq!(second_smallest(&[1, 1, 1]), None);
assert_eq!(second_smallest(&[] as &[i32]), None);
}

**デフォルトの名無しさん** · 2025/02/14(金) 17:55:06.91

わけがわからん
アセンブラじゃあるまいし

**デフォルトの名無しさん** · 2025/02/14(金) 18:42:18.21

わからないのはどのへんなんだろう？
・型がジェネリックになっている点
・代入文がないなど関数型プログラミングになっている点
・パターンマッチングが使われている点
いずれも最近は対応している言語が増えてるような

**デフォルトの名無しさん** · 2025/02/14(金) 23:21:45.00

可読性の良さから高階関数を使ったメソッドチェーンが一般的になってきたね
マイクロソフトがC#などでLINQ広めたのがきっかけで各言語もその有用性から導入するようになった

**デフォルトの名無しさん** · 2025/02/14(金) 23:42:29.57

お題：ランダムな英文字列が与えられる。隣り合う英文字が同じ大文字だった場合、その間にその大文字の小文字を挿入せよ

In < abcDDefGG
Out > abcDdDefGgG

**デフォルトの名無しさん** · 2025/02/15(土) 00:16:29.67

>>608 ruby
while 1
s=DATA.gets.chomp
exit if s==""
t=s.gsub(%r|([A-Z])\1|){$1+$1.downcase+$1}
puts "IN < #{s}\nOUT > #{t}"
end
__END__
abcDDefGG

**デフォルトの名無しさん** · 2025/02/15(土) 00:16:34.18

>>594 dart
https://ideone.com/uQxzo1

>>608 ruby
https://ideone.com/pwoRRH

**デフォルトの名無しさん** · 2025/02/15(土) 00:28:45.42

>>606
正規表現みたい非人間的な書式はやめようぜっての

**デフォルトの名無しさん** · 2025/02/15(土) 00:39:27.81

>>608
PowerShell

function f($s)
{
　　-join $(
　　　　foreach ($i in 0..($s.length - 2)) {
　　　　　　$s[$i]
　　　　　　if ($s[$i] -ne $s[$i + 1]) {continue}
　　　　　　if ($s[$i] -lt [char]"A" -or $s[$i] -gt [char]"Z") {continue}
　　　　　　([string]$s[$i]).ToLower()
　　　　}
　　　　$s[$i + 1]
　　)
}

"abcDDefGG", "abcDDDfGG" |% {"$_ → $(f $_)"}

[実行結果]
abcDDefGG → abcDdDefGgG
abcDDDfGG → abcDdDdDfGgG

**デフォルトの名無しさん** · 2025/02/15(土) 01:01:01.24

>>608　Rust

fn f(input: &str) -> String {
　let mut output = String::new();
　let mut pre_uppercase = None;
　for char in input.chars() {
　　if Some(char) == pre_uppercase {
　　　output.push(char.to_ascii_lowercase());
　　}
　　output.push(char);
　　pre_uppercase = char.is_ascii_uppercase().then_some(char);
　}
　output
}

fn main() {
　assert_eq!(f("abcDDefGG"), "abcDdDefGgG");
　assert_eq!(f("abcDDDfGG"), "abcDdDdDfGgG");
}

**デフォルトの名無しさん** · 2025/02/15(土) 09:21:24.60

>>608 ruby
https://ideone.com/nHcphN

>>608 dart
https://ideone.com/NxwW8Y

**614** · 2025/02/15(土) 10:02:25.10

>>608 dart
https://ideone.com/2E5Rxy

9 · 2025/02/15(土) 10:36:35.12

>>608 Perl5、肯定先読みと置換の小文字変換

s/([A-Z])(?=\1)/\1\l\1/g, print for <DATA>;
__DATA__
abcDDefGG
abcDDDefGGG

実行結果
C:\Home>perl 22_608_ins_l.pl
abcDdDefGgG
abcDdDdDefGgGgG

9 · 2025/02/15(土) 10:39:20.52

>>611
お断り～します～♪
　　　ハハ
　　　(ﾟωﾟ)
　((⊂ﾉ　ﾉつ))
　　 (＿⌒ヽ
εﾆ≡　)ﾉ`Ｊ

**デフォルトの名無しさん** · 2025/02/15(土) 10:40:34.16

>>594 >>608 lisp
https://ideone.com/W5gGfD

**615** · 2025/02/15(土) 13:20:38.24

>>608 java
https://ideone.com/YfufZz

>>616
＿人人人人人人人人人人人人＿
＞　置換の小文字変換！？　＜
￣Y^Y^Y^Y^Y^Y^Y^Y^Y^Y^Y^Y^￣

勉強になりました

**デフォルトの名無しさん** · 2025/02/15(土) 21:05:44.70

>>612は文字列長が1文字の場合にバクがあった。PowerShellの0..-1は空(から)ではなく0, -1になるのが
原因 (Rの0:-1も同様)。修正するには、fの最初に if ($s.length -lt 2) {return $s} を挿入する。

**デフォルトの名無しさん** · 2025/02/15(土) 21:06:37.89

>>561
C++
https://ideone.com/bQBKIM
C#のヌル許容型と同じ挙動のnullable型を自作し、>>593のC#のmin2関数をジェネリック化、
ポインタ参照化して移植した。

https://ideone.com/p2LNC9
593のC++のmin2関数と実行速度を比較する¹と30%ほど遅い。文字列型や可変長数値型と
違って最大値が存在する固定長数値型では、それを利用するf593の方が良い。

──
¹ Microsoft C++では100回繰り返しテストが最適化され1回しか実行されない

**デフォルトの名無しさん** · 2025/02/15(土) 21:52:48.39

>>621
最大値をundefined代わりに使ってはいけないと指摘があったのにまだ使っているのかいな
そのコードで入力数列がこうだった場合
vector<int> a = {IntMax - 1, IntMax};
2番目に小さい数として正解のintMaxを返さなければならない

**デフォルトの名無しさん** · 2025/02/15(土) 22:00:12.34

>>622
>>593のC++プログラムの実行結果を参照。入力数列にINT_MAXが含まれる場合でも問題ない。

**デフォルトの名無しさん** · 2025/02/15(土) 22:09:09.66

>>623
それはm1とm2を間接にポインタで持つために遅くなっているf593()
m1とm2を直接に整数で持つため速いf3()はIntMaxに対応できていない

**デフォルトの名無しさん** · 2025/02/15(土) 22:24:28.09

>>624
>>621の速度比較テストに>>570のf3も追加
https://ideone.com/scnfdu

ポインタで持つf593との比で、整数で持つf570は6%速いだけ。一方、null許容型のf621は29%も遅い。
最大値が存在する型ではそれを利用する方が良いという結論に変わりはない。

**デフォルトの名無しさん** · 2025/02/15(土) 22:29:41.23

まあ、同じ値の要素が大量に存在する入力データではf570は遅くなるが、平均的な速度はf570の方が速い。

**デフォルトの名無しさん** · 2025/02/15(土) 22:31:16.05

>>626はf570じゃなくてf593だった。

**デフォルトの名無しさん** · 2025/02/15(土) 22:42:01.35

f593でローカル変数へのポインタを返し得るのは如何かと

**デフォルトの名無しさん** · 2025/02/15(土) 23:34:59.77

>>628
返しえないでしょ。

**デフォルトの名無しさん** · 2025/02/15(土) 23:46:12.83

>>625
まずnullableのコードがおかしい
例えばoverload(op)のこれ

if (y.isNull) return false; \
return x op y.value; \

Nullだとfals eとなり
opの計算結果次第でもfal seとなり
両者を区別できない

**デフォルトの名無しさん** · 2025/02/15(土) 23:47:32.80

>>625
あとvector扱うコードは倫理的に際どいかな
長さ0でないことを調べずに
いきなりint *m1 = &a[0], m2 = &y;
今回は長さ0の時に*m1をアクセスしないから論理的にギリセーフだけど際どい

そのへんのトリッキーさも含めて
(もしあれば)最小値も返す場合
(もしあれば)3番目の最小値も返す場合など
このIntMax方式は破綻すると思う

**デフォルトの名無しさん** · 2025/02/15(土) 23:52:31.08

>>630
>>621に書いた通り、C#のヌル許容型T? (Nullable<T>のエイリアス) の挙動に従っただけだから。
文句があるならMicrosoftに言ってくれ。

9 · 2025/02/16(日) 06:28:07.79

qa0m30Tb の回答はどれよ？

**デフォルトの名無しさん** · 2025/02/16(日) 08:09:49.66

いるよねえ他人の回答に文句だけつけて自分では回答しないやつ

**デフォルトの名無しさん** · 2025/02/16(日) 08:16:54.29

他人の回答が間違いとなるようにお題を解釈するのは知的なことではないよバカの所業だよ

**デフォルトの名無しさん** · 2025/02/16(日) 08:20:29.71

そんなことより>>616のワンライナーがカッコよくてほれぼれする

**デフォルトの名無しさん** · 2025/02/16(日) 10:58:48.51

帰ったと思ったらまたやってんのｗ

**デフォルトの名無しさん** · 2025/02/16(日) 15:14:38.18

コンパイラ警告無視するのが知的な事だと思ってそうだな

9 · 2025/02/16(日) 15:45:59.98

回答のｺｰﾄﾞでもって語ってほしいなぁ

**デフォルトの名無しさん** · 2025/02/17(月) 13:08:08.60

お題：ランダムな数列が与えられる。隣り合う数字が偶数同士の時、あいだに0を。奇数同士の時は1を挿入し、それ以外は何も挿入しない

In < 123346
Out > 12313406

**デフォルトの名無しさん** · 2025/02/17(月) 13:47:54.59

>>640 ruby
DATA.readlines(chomp:1).map{|e|
a=e.split("").map{|f| f.to_i}
(0..a.size-2).each{|n|
a[n]=a[n]*10 if (a[n]%2==0 && a[n+1]%2==0)
a[n+1]=a[n+1]+10 if (a[n]%2==1 && a[n+1]%2==1)}
puts "IN < #{e}\nOUT > #{a.map{|f| f.to_s}.join}"}
__END__
123346

**デフォルトの名無しさん** · 2025/02/17(月) 20:02:39.61

>>640 lisp
https://ideone.com/DV9DeR

**デフォルトの名無しさん** · 2025/02/17(月) 20:47:46.22

>>640
PowerShell (一般的な文字コードを想定)

function f([string]$s)
{
　　$rprev = 2
　　-join ([char[]]$s |% {
　　　　$r = $_ % 2
　　　　if ($r -eq $rprev) {$r}
　　　　$rprev = $r
　　　　$_
　　})
}

123346, 12333468, 1, "" |% {"$_ → $(f $_)"}

[実行結果]
123346 → 12313406
12333468 → 123131340608
1 → 1
→

**デフォルトの名無しさん** · 2025/02/17(月) 20:48:16.10

正規表現置換なら、

function f($s)
{
　　$s -replace "[02468](?=[02468])", "$&0" -replace "[13579](?=[13579])", "$&1"
}

1回で済ますなら、

function f($s)
{
　　[RegEx]::Replace($s, "[02468](?=[02468])|[13579](?=[13579])", {$_ = $args[0].value[0]; "$_$($_ % 2)"})
}

**デフォルトの名無しさん** · 2025/02/17(月) 20:58:11.16

>>640　Rust

fn f(input: &[u8]) -> Vec<u8> {
　input.windows(2).fold(Vec::new(), |mut vec, w| {
　　if vec.is_empty() {
　　　vec.push(w[0]);
　　}
　　if (w[0] ^ w[1]) & 1 == 0 {
　　　vec.push(w[0] & 1 + b'0');
　　}
　　vec.push(w[1]);
　　vec
　})
}

fn main() {
　assert_eq!(f(b"123346"), b"12313406");
　assert_eq!(f(b"12333468"), b"123131340608");
}

**デフォルトの名無しさん** · 2025/02/18(火) 10:32:01.38

>>645
そうやればいいのか、なるほどね

**デフォルトの名無しさん** · 2025/02/18(火) 17:51:16.96

Vecのnewやpushなど普通にcollectに任せる手もあるね
条件付き挿入は汎用にOptionで取捨を示してflat_mapとflattenでも可能
前値など状態を保ちつつ1つにまとめるならfoldでイテレータに流すならscan
一例としてこんな感じ

fn f(input: &[u8]) -> Vec<u8> {
　input
　　.iter()
　　.scan(None, |pre, &x| {
　　　Some([
　　　　pre.replace(x & 1)
　　　　　.and_then(|p| (p == x & 1).then_some(p + b'0')),
　　　　Some(x),
　　　])
　　})
　　.flat_map(|list| list.into_iter().flatten())
　　.collect()
}

>>640
Rust

**デフォルトの名無しさん** · 2025/02/19(水) 21:30:14.30

>>640
>>643-644の3つのfを上から順にf1, f2, f3とし、長い文字列を引数として呼び出したときの
実行時間を比較すると、

$s = -join (1..10000)
$t = 1..3 |% {(iex "measure-command {f$_ $s}").ticks}
$tmin = ($t | measure -min).minimum
1..3 |% {"f$_`: {0:0.00}倍" -f ($t[$_ - 1] / $tmin)}

[実行結果の一例]
f1: 34.78倍
f2: 1.00倍
f3: 14.93倍

大差でf2 < f3 < f1となった。インタプリタ言語のコード実行は遅いので、処理を自分で
書くほど遅くなり、ライブラリ関数等に丸投げすれば速くなることによる。

https://ideone.com/GVewWL
コンパイラ言語のC#で同様の比較をすると (PowerShellより速いので文字列を長くし、
f1の改良版としてStringBuilder使用のf4を追加した)、当然f4< f1 < f2 < f3になった。

**デフォルトの名無しさん** · 2025/02/19(水) 21:58:22.55

>>647
関数型でタブーの可変な変数宣言してもよいなら、もっと簡単になるね。

fn f(input: &[u8]) -> Vec<u8> {
　let mut pre = None;
　input
　　.iter()
　　.flat_map(|&x| {
　　　[
　　　　pre.replace(x & 1)
　　　　　.and_then(|p| (p == x & 1).then_some(p + b'0')),
　　　　Some(x),
　　　]
　　　.into_iter()
　　　.flatten()
　　})
　　.collect()
}

**デフォルトの名無しさん** · 2025/02/20(木) 23:25:43.81

mutableの使用は必要最小限が望ましいが
mutableを使えない言語は実用的ではない

警備員[Lv.21] · 2025/02/22(土) 15:11:12.54

>>640
Perl5
https://paiza.io/projects/gW_sI1_VqokddmYSJ6Lj2A

警備員[Lv.21] · 2025/02/22(土) 15:42:54.65

>>640
Kotlin
https://paiza.io/projects/mAEXhhFdJiHVQWYtHvIP-g

警備員[Lv.21] · 2025/02/22(土) 15:53:04.03

>>640
C
https://paiza.io/projects/7L9vpqOvFcbZfv9vO5GPvA

**デフォルトの名無しさん** · 2025/02/22(土) 23:33:07.08

>>640
Haskell
https://ideone.com/U3SvTZ

警備員[Lv.21] · 2025/02/24(月) 18:11:14.44

>>608

>>651とかとアルゴリズムはほぼ同じ。これといった捻りはない。
よく分からないが5chに書き込みがブロックされたのでURLのコロンまでは削った。

Perl
//paiza.io/projects/zAqms-VVEWIMhcgr8AV6Pw
Kotlin
//paiza.io/projects/iu8mTSyKsxqWx_T51Wpj4Q
C
//paiza.io/projects/bDkj3tRF_KmiBL67miRxyA

**デフォルトの名無しさん** · 2025/02/26(水) 21:33:47.93

お題: Python の int.bit_count()

65535 → 16
15 → 4
6 → 2
1 → 1
0 → 0
-1 → 1
-6 → 2
-15 → 4
-65535 → 16

**デフォルトの名無しさん** · 2025/02/26(水) 23:29:03.38

>>656
C++20
https://paiza.io/projects/R-sSq9oCAOmG17wk6c5naw

**デフォルトの名無しさん** · 2025/02/27(木) 00:23:41.10

>>656
Rust

fn bit_count(x: i64) -> usize {
const MAGIC_1: u64 = 0x5555555555555555; // 0101..0101
const MAGIC_2: u64 = 0x3333333333333333; // 0011..0011
const MAGIC_3: u64 = 0x0f0f0f0f0f0f0f0f;
const MAGIC_4: u64 = 0x00ff00ff00ff00ff;
const MAGIC_5: u64 = 0x0000ffff0000ffff;
const MAGIC_6: u64 = 0x00000000ffffffff;

let x = x.unsigned_abs();
let x = (x & MAGIC_1) + ((x >> 1) & MAGIC_1);
let x = (x & MAGIC_2) + ((x >> 2) & MAGIC_2);
let x = (x & MAGIC_3) + ((x >> 4) & MAGIC_3);
let x = (x & MAGIC_4) + ((x >> 8) & MAGIC_4);
let x = (x & MAGIC_5) + ((x >> 16) & MAGIC_5);
let x = (x & MAGIC_6) + ((x >> 32) & MAGIC_6);
x as usize
}

fn main() {
assert_eq!(bit_count(65535), 16);
assert_eq!(bit_count(15), 4);
assert_eq!(bit_count(6), 2);
assert_eq!(bit_count(1), 1);
assert_eq!(bit_count(0), 0);
assert_eq!(bit_count(-1), 1);
assert_eq!(bit_count(-6), 2);
assert_eq!(bit_count(-15), 4);
assert_eq!(bit_count(-65535), 16);
}

**デフォルトの名無しさん** · 2025/02/27(木) 08:26:19.30

>>656 Rust

trait BitCount {
　fn bit_count(&self) -> usize;
}
impl BitCount for i32 {
　fn bit_count(&self) -> usize {
　　self.unsigned_abs().count_ones() as usize
　}
}
use num::{BigInt, One};
impl BitCount for BigInt {
　fn bit_count(&self) -> usize {
　　self.iter_u64_digits().map(|x| x.count_ones() as usize).sum()
　}
}

fn main() {
　for (input, output) in [(65535, 16), (15, 4), (6, 2), (1, 1), (0, 0), (-1, 1), (-6, 2), (-15, 4), (-65535, 16)] {
　　assert_eq!(input.bit_count(), output);
　}
　assert_eq!(BigInt::from(-1).bit_count(), 1);
　assert_eq!((BigInt::from(2).pow(1_000_000_000) - BigInt::one()).bit_count(), 1_000_000_000);
}

**デフォルトの名無しさん** · 2025/02/28(金) 01:30:55.49

intは処理単位のことなんだけどな
何ビットで表現できるかという意味ではない

9 · 2025/02/28(金) 03:12:43.15

負の場合に表現可能なビット数を配慮しないとPython の int.bit_count()と同じ結果にならないんジャマイカじゃまいか
たぶんPythonの整数がbigintのせいだとおもう
絶対値とってpopcountとかやらないと意外とあれこれ書いてﾌﾟﾁ長めのコードになりそうなおかん

**デフォルトの名無しさん** · 2025/02/28(金) 23:07:16.17

よく見たらみんな絶対値をとったりbigintを使ったりしてるな

**デフォルトの名無しさん** · 2025/03/01(土) 20:18:20.34

>>656
PowerShellのBigIntなら、

$b = @(0)
1..8 |% {$b += $b |% {$_ + 1}}

function bit_count([BigInt]$n)
{
　　($b[[BigInt]::Abs($n).ToByteArray()] | measure -sum).Sum
}

65535, 15, 6, 1, 0, -1, -6, -15, -65535, [BigInt]::Pow(123, 45) |% {
　　"$_ → $(bit_count $_)"
}

[実行結果]
65535 → 16
15 → 4
6 → 2
1 → 1
0 → 0
-1 → 1
-6 → 2
-15 → 4
-65535 → 16
11110408185131956285910790587176451918559153212268021823629073199866111001242743283966127048043 → 159

**デフォルトの名無しさん** · 2025/03/01(土) 20:19:24.06

お題：1からnまでの自然数のビット単位での総排他的論理和1 ⊕ 2 ⊕ 3 ⊕ … ⊕ nを求める
関数を作り、n = 123456789, 12345678901234567890のときの値を表示せよ。

**デフォルトの名無しさん** · 2025/03/01(土) 21:19:28.22

A003815かな

**デフォルトの名無しさん** · 2025/03/01(土) 21:32:49.43

数学の試験で中間式を省いて解答だけ書くタイプw

**デフォルトの名無しさん** · 2025/03/01(土) 23:41:19.76

まあ数列の問題ならOEISを見てみるよな

**デフォルトの名無しさん** · 2025/03/02(日) 01:21:29.93

>> 664 　Rust
fn f(n: u64) -> u64 {
　// f(n) = 1⊕2⊕3⊕...⊕n とすると (2k)⊕(2k+1)=1 であるから 1⊕1=0 より
　// f(4k+1) = (4k+1)⊕(4k)⊕(4k-1)⊕(4k-2)⊕f(4k-3) = f(4(k-1)+1) = ... = f(1) = 1
　// f(4k+3) = (4k+3)⊕(4k+2)⊕f(4k+1) = 0
　// f(4k) = (4k)⊕f(4k-1) = 4k
　// f(4k+2) = (4k+2)⊕f(4k+1) = (4k+2)⊕1 = 4k+3
　match n % 4 {
　　0 => n,
　　1 => 1,
　　2 => n + 1,
　　3 => 0,
　　_ => unreachable!(),
　}
}

fn main() {
　for n in [123456789, 12345678901234567890] {
　　println!("f({n}) = {fn}", fn = f(n));
　}
}
出力
f(123456789) = 1
f(12345678901234567890) = 12345678901234567891

**デフォルトの名無しさん** · 2025/03/11(火) 21:18:30.26

>>656
PowerShellでもPopCountがいつの間にか使えるようになっていた。Version 7.5.0で動作確認。

function bit_count($n)
{
　　[BigInt]::PopCount([BigInt]::Abs($n))
}

65535, 15, 6, 1, 0, -1, -6, -15, -65535, [BigInt]::Pow(123, 45) |% {
　　"$_ → $(bit_count $_)"
}

実行結果は>>663と同じ。

**デフォルトの名無しさん** · 2025/03/13(木) 20:35:03.45

お題：数列が入力される。元の数列に逆順にした数列を減算したときの値を出力せよ

In < 12345
OUt > -41976 (12345 - 54321)

**デフォルトの名無しさん** · 2025/03/13(木) 21:13:53.77

>>670
PowerShell

function f([BigInt]$n)
{
　　$c = [char[]][string]$n
　　$n - [BigInt]-join $c[-1..-$c.length]
}

12345, [BigInt]::Pow(12, 34) |% {"$_ → $(f $_)"}

[実行結果]
12345 → -41976
4922235242952026704037113243122008064 → 314233029528909439273950854852378624

**デフォルトの名無しさん** · 2025/03/14(金) 02:10:51.25

>>671
12の34乗は合っているけどその後の差がおかしくない？
4922235242952026704037113243122008064 から
4608002213423117304076202592425322294 を引いて
314233029528909399960910650696685770 が正解のところ
314233029528909439273950854852378624 となっているよ
正解は1の位が「4 - 4 = 0」になるはずだよね

>>670 Rust 逆文字列を生成する版

use num::BigInt;

fn odai(input: &str) -> Option<String> {
　let rev_input: String = input.chars().rev().collect();
　let x: BigInt = input.parse().ok()?;
　let y: BigInt = rev_input.parse().ok()?;
　Some((x - y).to_string())
}

fn main() {
　assert_eq!(odai("12345"), Some("-41976".to_string()));
　assert_eq!(odai("4922235242952026704037113243122008064"), Some("314233029528909399960910650696685770".to_string()));
}

**デフォルトの名無しさん** · 2025/03/14(金) 02:30:00.58

>>670 Rust 逆文字列を生成しない＆整数ジェネリック版
use num::{BigInt, CheckedAdd, CheckedMul, CheckedSub, FromPrimitive};

fn chars_to_integer<X>(input: impl Iterator<Item = char>) -> Option<X>
　where X: FromPrimitive + CheckedMul + CheckedAdd,
{
　let (zero, ten) = (X::from_u32(0).unwrap(), X::from_u32(10).unwrap());
　input
　　.map(|c| X::from_u32(c.to_digit(10)?))
　　.try_fold(zero, |acc, x| acc.checked_mul(&ten)?.checked_add(&x?))
}

fn odai<X>(input: &str) -> Option<X>
　where X: FromPrimitive + CheckedMul + CheckedAdd + CheckedSub,
{
　let x = chars_to_integer::<X>(input.chars())?;
　let y = chars_to_integer::<X>(input.chars().rev())?;
　x.checked_sub(&y)
}

fn main() {
　assert_eq!(odai::<i64>("12345"), Some(-41976));
　assert_eq!(odai::<BigInt>("4922235242952026704037113243122008064"), Some("314233029528909399960910650696685770".parse::<BigInt>().unwrap()));
}

**デフォルトの名無しさん** · 2025/03/14(金) 20:19:17.17

>>672
確かに間違っていた。PowerShellの旧ヴァージョンでは [BigInt]文字列と書くだけで
文字列をBigInt型に正確に変換できるから>>671のプログラムでも正しい結果が得られるが、
新ヴァージョンではdouble経由での変換に仕様変更されたようで誤差が生じてしまうから
[BigInt]::Parse(文字列) と書かなければならなくなった。

**デフォルトの名無しさん** · 2025/03/14(金) 21:36:16.55

数列の長さは指定されていない。

10 INPUT "0-9";I
20 PRINT "0"
30 END

**デフォルトの名無しさん** · 2025/03/15(土) 19:04:58.28

>>673
これらのwhere~は何という名称ですか？

>　where X: FromPrimitive + CheckedMul + CheckedAdd,
>　where X: FromPrimitive + CheckedMul + CheckedAdd + CheckedSub,

9 · 2025/03/16(日) 00:12:31.12

>>670 Perl5

use bigint;
print $_ - reverse($_), "\n" for 12345, 4922235242952026704037113243122008064;

実行結果

$ perl 22_670_reverse_minus_biginit.pl
-41976
314233029528909399960910650696685770

警備員[Lv.23] · 2025/03/16(日) 17:25:01.96

>>670
Kotlin

文字列にしてひっくり返しているだけの何の捻りもないプログラム

https://paiza.io/projects/VBq2l9lhzmUxVo6xAMuAHg

**デフォルトの名無しさん** · 2025/03/16(日) 22:59:41.54

>>670
PowerShellでジェネリック化(もどき?)
途中式や結果が入力値の型で表せない場合は$nullを返す。

function f($n)
{
　　$T = $n.GetType()
　　$s = [string]$n
　　try {
　　　　$n - $T::Parse(-join $s[-1..-$s.Length]) -as $T
　　} catch {
　　　　$null
　　}
}

12345, [BigInt]::Pow(12, 34), [byte]12, [sbyte]12, [sbyte]123, -123 |% {
　　"[$($_.GetType())]$_ → $(f $_)"
}

-- 実行結果 --
[int]12345 → -41976
[bigint]4922235242952026704037113243122008064 → 314233029528909399960910650696685770
[byte]12 →
[sbyte]12 → -9
[sbyte]123 →
[int]-123 →

**デフォルトの名無しさん** · 2025/03/16(日) 23:01:39.52

お題：36桁以下の負でない整数で16進表記が10進表記の部分文字列であるものをすべて求めて下さい。

(例)
・1の16進表記1は10進表記1の部分文字列です
・123の16進表記7Bは10進表記123の部分文字列ではありません
・357440の16進表記57440は10進表記357440の部分文字列です

※遅い言語では15桁以下で解いても構いません

**デフォルトの名無しさん** · 2025/03/16(日) 23:59:39.36

>>676
where句だよ
型Xのトレイト境界を宣言してる

9 · 2025/03/18(火) 16:05:22.66

>>680 Perl5、ナイーブな処理方式だと時間がかかり過ぎで最後まで解けないおそれがあるが、なかなかほかに回答者が現れないし、
出現傾向を見るだけでも…と思って、16進数の桁にa-fの現れる値をskipするナイーブな処理方法で。

$m = sprintf '%x', 9 x 15; # 10進で15桁まで
print $m . ' '. hex($m)."\n";
$m =~ s/[a-f]/9/g;
print "1 .. 0x$m\n";
print "".localtime."\n";
for (1 .. $m) {
　$d = hex($_);
　if (0 <= index($d, $_)) {
　　$n++;
　　print "$d, 0x$_\n";
　}
}
print "".localtime."\n";
print "$n count found";

9 · 2025/03/18(火) 16:07:07.28

>>682
実行結果 (改行数を減らすため適度につなげてます)
$ perl 22_680_hex_substr_1.pl
38d7ea4c67fff 999999999999999
1 .. 0x3897994967999
Tue Mar 18 09:15:31 2025
1, 0x1　　 2, 0x2　　 3, 0x3　　 4, 0x4　　 5, 0x5　　 6, 0x6　　 7, 0x7　　 8, 0x8　　 9, 0x9
357440, 0x57440　　 357441, 0x57441　　 357442, 0x57442　　 357443, 0x57443　　 357444, 0x57444
357445, 0x57445　　 357446, 0x57446　　 357447, 0x57447　　 357448, 0x57448　　 357449, 0x57449
1079653, 0x107965　　 1081713, 0x108171　　 1122966, 0x112296　　 1123079, 0x112307　　 1123080, 0x112308
2246166, 0x224616　　 3369253, 0x336925　　 3371313, 0x337131　　 3412566, 0x341256
4494393, 0x449439　　 4494400, 0x449440　　 4535653, 0x453565
5658739, 0x565873　　 5658740, 0x565874　　 5660793, 0x566079　　 5660800, 0x566080　　 5702166, 0x570216
6783879, 0x678387　　 6783880, 0x678388　　 6784000, 0x678400
6825253, 0x682525　　 7948339, 0x794833　　 7948340, 0x794834　　 7950393, 0x795039　　 7950400, 0x795040
2182104640, 0x82104640　　 2182104641, 0x82104641　　 2182104642, 0x82104642　　 2182104643, 0x82104643　　 2182104644, 0x82104644
2182104645, 0x82104645　　 2182104646, 0x82104646　　 2182104647, 0x82104647　　 2182104648, 0x82104648　　 2182104649, 0x82104649
1263629042727, 0x12636290427　　 1307655353654, 0x13076553536　　 2573583194436, 0x25735831944　　 2617616245848, 0x26176162458
3330782168640, 0x30782168640　　 3330782168641, 0x30782168641　　 3330782168642, 0x30782168642　　 3330782168643, 0x30782168643
3330782168644, 0x30782168644　　 3330782168645, 0x30782168645　　 3330782168646, 0x30782168646　　 3330782168647, 0x30782168647
3330782168648, 0x30782168648　　 3330782168649, 0x30782168649　　 3883544086630, 0x38835440866　　 3927569962533, 0x39275699625
3927570397557, 0x39275703975

Core i7-8559U で6時間ほど実行してここまで高々13桁。
やはり想定通り気の利いた高速解放が要りますﾃﾍﾍﾟﾛ。

**デフォルトの名無しさん** · 2025/03/18(火) 16:35:06.57

>>680
ruby
(0..10**16-1).each{|e| puts "#{e},0x#{e.to_s(16)}" if %r|[a-f]|!~e.to_s(16)}

**デフォルトの名無しさん** · 2025/03/18(火) 21:39:06.90

>>683
14桁と15桁には該当値がないので、そこに列挙された数に0を追加した72個が15桁以下の答で
結果的には合っているよ。

出題時に作ったC++プログラムはideoneで36桁以下を0.43秒で完了した。これをPowerShellに
移植したプログラムは15桁以下を0.5秒未満、36桁以下を数分で完了した。

その後、改良したC++プログラムではideoneで36桁以下を0.23秒に短縮できた。

9 · 2025/03/18(火) 21:41:48.53

>>683
>やはり想定通り気の利いた高速解放が要りますﾃﾍﾍﾟﾛ。

そのﾋﾝﾄになるかいな…？
・16進数を10進数に変換すると桁数は同じまたは高々1桁増えるのみ（だともう、証明略）
・桁数が同じ場合、16進数と10進数が同じということはあり得ない、自明
・一桁増える場合は先頭または末尾に一桁増える。残りが16進数と同じ部分文字列であるかが評価対象となる

9 · 2025/03/18(火) 21:42:49.00

>>685
あそうなんだ。じゃオレ様が一番乗りということでヨロ
ﾉｼ

9 · 2025/03/18(火) 21:52:10.05

>>686
>・一桁増える場合は先頭または末尾に一桁増える。残りが16進数と同じ部分文字列であるかが評価対象となる

二桁増える場合があるのでこれは誤りでした

**684** · 2025/03/19(水) 06:18:11.44

ようやく題意は理解したけど良い解法が思いつかない
ちなみに36桁以下だと答えはいくつありますか？

**デフォルトの名無しさん** · 2025/03/19(水) 08:44:27.79

>>680
ruby 遅いけど
i=0
while i<10**16
if %r|[a-f]|=~i.to_s(16)
i=i.to_s(16).gsub(%r|[a-f].*|){|e| e.gsub(%r|.|,"f")}.hex
else
puts "#{i},0x#{i.to_s(16)}" if %r|#{i.to_s(16)}|=~i.to_s
end
i+=1
end

9 · 2025/03/19(水) 16:33:58.47

>>686
> ・桁数が同じ場合、16進数と10進数が同じということはあり得ない、自明

大間違い。16進数と10進数で桁数が同じ値のうち、一桁のものは、16進も10審も同じだった…orz

結局、高速解放はあるんだろうか？
あるいはコラッツ予想みたいに「無いかもしれない」類の、考えるだけ無駄な問題なのだろうか？

**デフォルトの名無しさん** · 2025/03/19(水) 21:08:24.40

>>689
167個で最大値は697786638998562641695629924526065234

>>691
時間をかけて64桁以下で解いたら、405個で最大値は

　2714476666993915057605587441263923823484611431446449961712093492

だった。これはナイーヴな解法ではC++ですら到底求められない値だから、高速解法が
実在する証になっているだろう。

解答例は1週間くらい経ったら載せるので、それまでよく考えてみて下さい。

**デフォルトの名無しさん** · 2025/03/19(水) 22:39:07.36

お題：単位分数のエジプト風分解(2進数風味)
1/aを、1/a=1/b+c/dを満たす1/bとc/dに分解する。
aは1以上の整数とする。
c, dは整数とし、bは2の整べき乗(1, 2, 4,...)とする。
c/dは絶対値が最小である事(負数であってもよい)。

例：
1/3→1/4+1/12 : b=4, c=1, d=12
1/7→1/8+1/56 : b=8, c=1, d=56
1/9→1/8-1/72 : b=8, c=-1, d=72(c=1, d=-72も可)
1/13→1/16+3/208 : b=16, c=3, d=288
1/60→1/64+1/960 : b=64, c=1, d=960

**693** · 2025/03/19(水) 22:42:43.02

aは2以上の整数とする。
に訂正します。

**デフォルトの名無しさん** · 2025/03/19(水) 23:16:25.83

>>693
R
https://ideone.com/TaaAw2

aが2の整べき乗の場合の出力形式に指定がなかったので適当に決めた。

**デフォルトの名無しさん** · 2025/03/20(木) 08:21:38.87

>>693 Rust
fn f(a: i64) -> String {
　let b = (a as u64).next_power_of_two() as i64;
　let b = if 3 * a > 2 * b { b } else { b >> 1 };
　let (c, d) = (b - a, a * b);
　let shift = c.trailing_zeros().min(d.trailing_zeros());
　let (c, d) = (c >> shift, d >> shift);
　if a == b {
　　format!("1/{a}=1/{b}")
　} else {
　　format!("1/{a}=1/{b}{c:+}/{d}")
　}
}

fn main() {
　assert_eq!("1/3=1/4+1/12", f(3));
　assert_eq!("1/7=1/8+1/56", f(7));
　assert_eq!("1/9=1/8-1/72", f(9));
　assert_eq!("1/13=1/16+3/208", f(13));
　assert_eq!("1/60=1/64+1/960", f(60));
　assert_eq!("1/64=1/64", f(64));
　assert_eq!("1/6718464=1/8388608+1631/55037657088", f(6718464));
　assert_eq!("1/123456789=1/134217728+10760939/16570089725755392", f(123456789));
}

**デフォルトの名無しさん** · 2025/03/21(金) 12:56:29.73

>>680 　Rust
fn odai_680() -> Vec<i128> {
　let mut answer = vec![0];
　let n_max = (0..).find(|&n| pow16(n + 1) > pow10(36)).unwrap();
　for s in (0..).take_while(|&s| pow16(n_max) >= pow10(n_max + s + 1)) {
　　let c = (0..=n_max).map(|i| pow16(i) - pow10(i + s)).collect::<Vec<_>>();
　　let rmax = c.iter().scan(0, |s, &c| { *s += if c > 0 { c * 9 } else { 0 }; Some(*s) }).collect::<Vec<_>>();
　　let rmin = c.iter().scan(0, |s, &c| { *s += if c < 0 { c * 9 } else { 0 }; Some(*s) }).collect::<Vec<_>>();
　　let (mut i, mut n, mut d, mut ct) = (0, 1, vec![0; c.len()], vec![0; c.len() + 1]);
　　loop {
　　　d[i] += 1;
　　　if d[i] < 10 {
　　　　let m = pow10(n as u32 + s); ct[i] = c[i] * d[i] + ct[i+1];
　　　　if i == 0 {
　　　　　if ct[0] >= 0 && ct[0] % m < pow10(s) { answer.push(d.iter().take(n).rev().fold(0, |sum, &d| sum * 16 + d)) }
　　　　} else {
　　　　　let (max, min) = (ct[i] + rmax[i-1], ct[i] + rmin[i-1]);
　　　　　if max >= 0 && (max - min > m || pow10(s) > min % m || min % m > max % m) { i -= 1; }
　　　　}
　　　} else { d[i] = -1; i += 1; if i == n { if n == d.len() { break; } n += 1; } }
　　}
　}
　answer.sort(); answer
}

**デフォルトの名無しさん** · 2025/03/21(金) 12:58:11.47

>>697
// 略記
fn pow16(x: u32) -> i128 { 16_i128.pow(x) }
fn pow10(x: u32) -> i128 { 10_i128.pow(x) }

// 結果検証
fn main() {
　let answer = odai_680();
　assert_eq!(167, answer.len());
　for &a in &answer {
　　assert!(a.to_string().contains(&format!("{a:x}")));
　}
　assert_eq!(0, answer[0]);
　assert_eq!(1, answer[1]);
　assert_eq!(357440, answer[10]);
　assert_eq!(2182104649, answer[54]);
　assert_eq!(3927570397557, answer[71]);
　assert_eq!(38135630558262267902210, answer[99]);
　assert_eq!(331052794565713975838768757043267, answer[152]);
　assert_eq!(697786638998562641695629924526065234, answer[answer.len() - 1]);
}

**デフォルトの名無しさん** · 2025/03/21(金) 20:49:29.98

>>697-698
Rustはよく知らないが、mainのforループ内をprintln!("{}", a);に置き換えれば解が表示されるんだよね?
実行結果を>>685で述べたC++プログラムのものと照合したら167個の解すべてが一致した。見事正解!
実行時間はC++プログラムの数倍かかるようだが、ideoneでの実行時間も見たいので載せて下さい。

**デフォルトの名無しさん** · 2025/03/23(日) 23:00:51.13

>>680から1週間経ったので解答例を掲載

>>685を書いたときに作ってあった2つのC++プログラム
https://ideone.com/KID2jR
https://ideone.com/ysdd6b

1番目ではsolve関数の再帰呼び出しの対象とするx[p]の下限と上限を線形探索するが、
2番目では二分探索する。要素数10では二分探索の効果は薄いと思いきや、大分速くなった。

2番目を読み返していたらバグを発見してしまった。i = N - 1のとき63行目のa[i + 1]はa[N]となり
配列の添字範囲外アクセス。0との比較だけだし、if文の評価がどっちでも以降の処理は結局同じだから、
実害も解への影響もないが、厳格さが必要ならif ((i + 1 < N ? a[i + 1] : 0) >= 0) {と書き換えるべきだな。
実行時間への影響は無視できる。

それぞれのPowerShellへの移植版
https://ideone.com/vEGZ3D
https://ideone.com/azzMa4

完全な逐語訳ではなく、PowerShellで書くと遅くなったり煩雑になったりする箇所は適宜改変した。
15桁以下の場合は64ビット整数でも桁溢れしないので、BigIntの代わりにInt64を使えば少し速くなる。

**デフォルトの名無しさん** · 2025/03/24(月) 22:16:36.44

非素数であることが既知の巨大整数を素因数分解するときの
最速のアルゴリズムって何がある？

**デフォルトの名無しさん** · 2025/03/25(火) 15:25:56.57

>>699
> 実行時間はC++プログラムの数倍かかるようだが

rustc -C opt-level=2 でコンパイルしたら
g++ -O2 でコンパイルした ideone_KID2jR.cpp (>>700の一つめ) とほぼ同じ速度出たよ

**デフォルトの名無しさん** · 2025/03/25(火) 15:54:47.24

>>702
データ精度を揃えたアルゴリズム比較のために
>>697-698をi128固定ではなくnum::BigIntにして計測して見ては？

あと出題者>>685は>>700の二つ目で(倍速以上に)短縮出来たと言っているよ

**デフォルトの名無しさん** · 2025/03/25(火) 16:11:02.68

そこまでは興味ないや
「数倍」だったのはもしかして最適化オプション付けてなかったんじゃない?ってだけの話

**デフォルトの名無しさん** · 2025/03/25(火) 17:30:47.40

>>697-698をBigIntに変えるのはどうしたらいいのか分かんなかったので
>>700の方を boost::multiprecision::cpp_int から boost::multiprecision::int128_t に変えてみた

改変版 | オリジナル
https://ideone.com/Ie0HhO 0.12s | https://ideone.com/KID2jR 0.43s
https://ideone.com/np3p5h 0.11s | https://ideone.com/ysdd6b 0.23s

**デフォルトの名無しさん** · 2025/03/25(火) 20:18:24.92

>>705
感心した、出題者回答C++コードはほんの少し変更するだけで簡単にBigInt/i128切り替え出来るのか

>>697-698
Rustはどうなのかな？

**デフォルトの名無しさん** · 2025/03/25(火) 23:43:24.86

>>704
>>699では最適化オプションを付けてrustc -O a.rsでコンパイルした。最適化なしでは
ありの4.6倍くらい掛かった。もしやと思ってコンパイラをアップデートしてみたら、
実行時間は約3分の1に激減し、>>700の1番目と大差ない1.3倍ほどに収まった。

Rustの古いコンパイラ（5年前のもの）がこんなに低性能だったとは…

**デフォルトの名無しさん** · 2025/03/27(木) 11:39:31.21

>>697
crateのnumを使う

**デフォルトの名無しさん** · 2025/03/27(木) 20:29:20.38

c言語で実用的なプログラムを作りたい。
いいテーマはありますか？

**デフォルトの名無しさん** · 2025/03/27(木) 20:35:59.71

お題：＃（シャープ）を入力の段数でウンコ状に並べて出力せよ
出力は全角でも半角でもどちらでもよしとする（5ch は半角スペース表示できない）

in < 3
out >
　　＃
　＃＃＃
＃＃＃＃＃

**デフォルトの名無しさん** · 2025/03/27(木) 21:06:27.50

>>710
PowerShell

function unko($n)
{
　　if ($n -ge 1) {1..$n |% {"　" * ($n - $_) + "＃" * (2 * $_ - 1)}}
}

unko 3

-- 実行結果 --
　　＃
　＃＃＃
＃＃＃＃＃

**デフォルトの名無しさん** · 2025/03/28(金) 21:33:35.13

お題：素因数の総和が2025である2000万以下の自然数をすべて求めて下さい。

例)
32272
　素因数分解すると32272 = 2 × 2 × 2 × 2 × 2017で、
　素因数の総和は2 + 2 + 2 + 2 + 2017 = 2025となります。

※20億以下でもC++で5秒以内に余裕で完了できますが、出力が長すぎるため2000万以下としました。
　その結果、Rでも5秒以内に余裕で完了できる問題になりました。

**デフォルトの名無しさん** · 2025/03/28(金) 21:54:52.53

>>710
山状ではだめだったのか
俺にはわからない

**デフォルトの名無しさん** · 2025/03/28(金) 22:12:15.09

お題
AさんがBさんに惚れてることを
A-B
と表します

両思いのペアを出力してください

入力
D-L,U-X,U-Y,U-R,Z-B,B-E,B-M,B-N,V-H,V-X,W-F,W-R,R-B,R-W,O-W,O-S,F-A,Q-X,P-E,P-L,X-X,Y-M,Y-C,L-U,L-V,I-X,E-B,H-M,A-S

出力
B,E
R,W

**デフォルトの名無しさん** · 2025/03/28(金) 22:28:49.68

>>714
PowerShell

$s = "D-L,U-X,U-Y,U-R,Z-B,B-E,B-M,B-N,V-H,V-X,W-F,W-R,R-B,R-W,O-W,O-S,F-A,Q-X,P-E,P-L,X-X,Y-M,Y-C,L-U,L-V,I-X,E-B,H-M,A-S"
$h = @{}
$s -split "," |% {
　　$a, $b = $_ -split "-"
　　$h[$a] += , $b
}

foreach ($a in $h.keys) {
　　foreach ($b in $h[$a]) {
　　　　if ($a -lt $b -and $h[$b] -contains $a) {"$a,$b"}
　　}
}

-- 実行結果 --
B,E
R,W

**デフォルトの名無しさん** · 2025/03/28(金) 23:19:47.32

>>714
PowerShellでもう少し短く

$s = "D-L,U-X,U-Y,U-R,Z-B,B-E,B-M,B-N,V-H,V-X,W-F,W-R,R-B,R-W,O-W,O-S,F-A,Q-X,P-E,P-L,X-X,Y-M,Y-C,L-U,L-V,I-X,E-B,H-M,A-S"
$h = @{}
$s -split "," |% {
　　$a, $b = $_ -split "-"
　　$i, $t = if ($a -lt $b) {1, "$a,$b"} else {2, "$b,$a"}
　　$h[$t] = $h[$t] -bor $i
}

$h.keys |? {$h[$_] -eq 3} | sort

-- 実行結果 --
B,E
R,W

**デフォルトの名無しさん** · 2025/03/29(土) 11:51:50.06

>>714
Rust

use itertools::Itertools;

fn f(input: &str) -> impl Iterator<Item = &str> {
　input.split(',')
　　.map(|pair| (pair, pair.splitn(2, '-').collect_tuple().unwrap()))
　　.filter(|(_, (a, b))| a < b)
　　.flat_map(|(pair, (a, b))| {
　　　input.split(',')
　　　　.map(|pair| pair.splitn(2, '-').collect_tuple().unwrap())
　　　　.filter_map(move |(x, y)| (a == y && b == x).then_some(pair))
　　})
}

fn main() {
　let input = "D-L,U-X,U-Y,U-R,Z-B,B-E,B-M,B-N,V-H,V-X,W-F,W-R,R-B,R-W,O-W,O-S,F-A,Q-X,P-E,P-L,X-X,Y-M,Y-C,L-U,L-V,I-X,E-B,H-M,A-S";
　itertools::assert_equal(["B-E", "R-W"], f(input).sorted());
}