我有一个使用 Rust 创建冒泡排序的编程作业。我在 Rust 方面确实没有太多经验，所以这对我来说有点困难：
fn main() {
println!("Sort numbers ascending");
let num:[i32; 10] = [4, 65, 2, -31, 0, 99, 2, 83, 782, 1];
println!("Before: {:?}", num);
bubble_sort( num);
println!("After: {:?}\n", num);
}
fn swap( a: &mut i32, b: &mut i32){
let tmp: i32 = *b;
*b=*a;
*a=tmp;
}
fn bubble_sort(mut arr: [i32; 10]) {
for i in 0..arr.len() {
for j in 0..arr.len() - 1 - i {
if arr[j] > arr[j + 1] {
swap( &mut arr[j], …这符合阅读的预期：
fn u64_from_low_eight(buf: &[u8; 9]) -> u64 {
let bytes: &[u8; size_of::<u64>()] = buf[..size_of::<u64>()].try_into().unwrap();
u64::from_le_bytes(*bytes)
}
（它很好地优化为 AArch64 和 x86_64 上的单个汇编指令。）
我原本期望类似的方法可以将 u64 未对齐写入缓冲区。
/// Encodes a u64 into 1-9 bytes and returns the number of bytes updated.
pub fn encode(value: u64, buf: &mut [u8; 9]) -> usize {
let low64: &mut [u8; size_of::<u64>()] = &mut buf[..(size_of::<u64>())].try_into().unwrap();
match value {
// FIXME: Change to exclusive ranges once the feature's stabilised.
OFFSET0..=OFFSET1_LESS_ONE => {
let num = inner_encode::<1>(value, low64);
#[cfg(test)] eprintln!("low64: …如果已经有人问过,请随时给我指出其他答案!
我本月刚刚发布新版本的F#.我有OO和函数语言的一些背景知识(Haskell和Scheme,但不是OCaml/ML).到目前为止,已经出现了几个问题,而不是阅读F#CTP附带的小教程.
1)可变变量优于monad吗？如果是这样,那么在F#中完全避开monad吗？
2)我对使用的大小写感到困惑.在本教程代码文件中,有时函数以小写字母开头,有时以大写字母开头.我知道MS倾向于喜欢带有函数和方法的初始大写,但在这里似乎有两种方法可以做到这一点.这对我来说并不是什么大不了的事,因为我只是在自己的时间玩耍,但我很好奇标准是什么.
3)我对OO和功能样式的整体组合感到非常困惑.print_string "string"有道理,但接下来就是List.map fn list(除非List只是命名空间,如果是这样,请原谅我).然后是str.Length.任何人都在关心何时使用什么,哪个更受欢迎？
谢谢!
我正在编写这段代码作为面向对象编程的练习.
在这里,我试图将房屋定义为房间列表,并将每个房间定义为设备列表(例如灯具).
首先,我创建了所有对象,并将两个房间附加到房屋,并为每个房间添加了不同的设备.很基本的.
问题是,似乎设备被附加到两个房间.这是为什么？
代码:
#! /usr/bin/python
class House:
def __init__(self, rooms = list()):
self.rooms = rooms
print('house created')
class Room:
def __init__(self, name = 'a room', devs = list()):
self.name = name
self.devs = devs
print('room ' + self.name + ' created')
class Device:
def __init__(self, name = 'a device'):
self.name = name
print('device ' + self.name + ' created')
def main():
#1
h = House()
r1 = Room(name = 'R1')
r2 = Room(name = 'R2')
d1 = Device(name …我在scala中编写了一些代码来解析相对(文件)路径,请参阅下面的代码.我将路径存储为字符串列表,当我计算相对路径时,我使用一个可变列表变量,其中我存储了我工作的列表的修改副本.
我有一种直觉,认为这可能不是最好的方式,或者是这样吗？我应该使用可变列表并操纵它吗？或者我应该只使用不可变列表,根本没有变量和功能版本？该方法应如何写成"亲戚"？
class PathInfo(e: List[String]) {
val elements=e;
def relative(s : String) :PathInfo= relative(PathInfo.fromString(s));
def relative(that : PathInfo) : PathInfo = {
var list : List[String]=List();
for (item <- elements) {
list = list :+ item;
}
for (item <- that.elements) {
item match {
case "." => ;
case ".." => list = list dropRight(1);
case other => list = list :+ other;
}
}
new PathInfo(list);
}
override def toString : String = {
elements.mkString("/");
}
}
object …在我的一些项目中,我发现自己宣布了一个相当无聊的课程:
Class Holder(Of T)
Public It As T
Sub New(ByVal It As T)
Me.It = It
End Sub
End Class
例如,允许对象以这样的方式向另一个对象提供信息,使得信息可以随后在任何地方发生变化.例如,在一个词典(串,持有人(中SomeImmutableType)),所以可以更新SomeImmutableType的事情,而不必改变词典本身(因为字典对一个给定的关键条目总是包含相同的Holder对象,即持有人对象可以用作锁).
是否有更适合此目的的内置类？我更喜欢.net 2.0兼容性,但即使在4.0中,Tuple类型也是不可变的.如果没有这样建于一件事,就是它需要一个持有人类型来定义它本身作为一个嵌套的类型,或者要求有一个项目中持有人一个定义每种类型的更好吗？
我所知道的唯一内置的东西是Array.使用一个元素的数组是可行的,但它感觉真的很吵,因为通常当代码有一个数组时,期望它可以使用某个大小而不是一个.
PS -用例:
我看到一篇关于不可变对象的文章.
它表示何时:
variable = immutable
将不可变赋值给变量.
例如
a = b # b is a immutable
它在这种情况下a指的是a copy of b,而不是reference to b.如果是mutable,那么a就是a reference to b
所以:
a = 10
b = a
a =20
print (b) #b still is 10
但在这种情况下:
a = 10
b = 10
a is b # return True
print id(10)
print id(a)
print id(b) # id(a) == id(b) == id(10)
if a是副本10, …
我正在重新编写游戏,我问了一个问题," 我如何迭代四重链接的二维数据网格,好像它是一个二维数组？ ",适用于Haskell.
为了首先创建数据网格,我使用了一种非常命令式的算法,如下所示.它依赖的关键特性是我可以将索引转换为数组并从中创建引用.例如,"&array [x] [y]".
我需要能够将索引转换为可变数组,并在Haskell中从中生成状态引用.因此类型签名可能是
convertToSTRef :: i -> STArray s i a -> ST s (STRef s a)
我查看了文档,尝试过hoogle和hayoo,但没有找到完成此任务的方法.
PS或者,如果某人有我可以使用的不同算法,那就太棒了.
PSS简单的命令式算法.
const size_t rows = 20;
const size_t columns = 59;
block tiles[columns][rows];
block * const start = &tiles[columns/2][rows/2];
for (size_t x = 0; x < columns; ++x)
for (size_t y = 0; y < rows; ++y)
{
tiles[x][y].floor = '^';
tiles[x][y].inhabitant = WALL;
tiles[x][y].side_block[EAST] = (x + 1 < columns) ? &tiles[x + 1][y] : NULL; …这是完整的代码.我会尝试展示一些作品.我正在写一个通过telnet工作的tic tac toe服务器.这是游戏板的代表
let empty_board = [|
[|EMPTY; EMPTY; EMPTY|];
[|EMPTY; EMPTY; EMPTY|];
[|EMPTY; EMPTY; EMPTY|]|]
它仅用于Array.copy在游戏循环中传递玩家描述符和新棋盘:
let prepare_game_process pair_of_players=
pair_of_players >>= fun (player1, player2) ->
send_to_client player1 "You play for X";
send_to_client player2 "You play for O";
let new_board = Array.copy empty_board in
game_loop player1 player2 new_board
但是每次新游戏开始时,game_loop中的所有更改都会反映到原始的empty_board:
let make_move x y board token=
board.(y).(x) <- token;
board
我看了十亿次代码,但我根本看不出原因.
function bubbleSort(toSort) {
let sort = toSort;
let swapped = true;
while(swapped) {
swapped = false;
for(let i = 0; i < sort.length; i++) {
if(sort[i-1] > sort[i]) {
let temp = sort[i-1];
sort[i-1] = sort[i];
sort[i] = temp;
swapped = true;
}
}
}
return sort;
}
let asdf = [1,4,3,2];
let asd = bubbleSort(asdf);
console.log(asdf, asd);
此代码的输出为:[1,2,3,4] [1,2,3,4].
我期待的是:[1,4,3,2] [1,2,3,4].
我想知道的是,为什么这会改变asdf变量？bubbleSort函数接受给定的数组(asdf),复制它(排序),然后处理该变量并返回它,asd设置为等于.我觉得自己像个白痴,但我不知道为什么会这样:(