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

**デフォルトの名無しさん** · 2023/08/03(木) 13:52:13.20

プログラミングのお題スレです。

【出題と回答例】
1 名前：デフォルトの名無しさん
　お題：お題本文

2 名前：デフォルトの名無しさん
　>>1 使用言語
　回答本文
　結果がある場合はそれも

【ソースコードが長くなったら】 (オンラインでコードを実行できる)
https://ideone.com/
http://codepad.org/
http://compileonline.com/
http://rextester.com/runcode
https://runnable.com/
https://code.hackerearth.com/
http://melpon.org/wandbox
https://paiza.io/

宿題は宿題スレがあるのでそちらへ。

※前スレ
プログラミングのお題スレ Part21
https://mevius.5ch.net/test/read.cgi/tech/1668333636/

**デフォルトの名無しさん** · 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での実行時間も見たいので載せて下さい。