标签: mutable

好的,所以我正在尝试编写一个可以接受输入的回溯算法:

0 2 3 1 (top-right location, length, horizontal or vertical)
1 0 4 0
2 2 4 0
1 3 3 1
top (the actual words)
that
toga
cat

并吐出一个填字游戏,如:

**c***
that**
**toga
***p**

我到目前为止的代码是:

//prints the puzzle
let printPuzzle (puzzle : char[,]) =
    printfn "%s" ""
    printfn "%A" puzzle
    printfn "%s" ""

//checks if the words fits
let rec doesItFit place (puzzle : char[,]) (word : seq<char>) =
    let (row, col, length, isVertical) = place
    if length <> …

在尝试克隆可变集合时,我最初的方法是在mutable.Cloneable特征上使用clone()方法.但是,这遵循java.Object.clone实现,该实现创建引用的副本,而不是深层副本.从测试中,我可以确认可变.{Queue,Seq,Set}所有浅拷贝.

我已经采用原始的新xxx(copy:_*)方法来创建一个深层副本,但我的问题是mutable.Cloneable特性的目的是什么,如果它没有实现？

可能是另一个愚蠢的F#初学者的问题...但是它一直困扰着我

我似乎无法在网上找到任何答案...可能是'因为我搜索错误的条款,但是呃

无论如何我的代码如下:

let counter() = 
    let mutable x = 0

    let increment(y :int) =
        x <- x + y // this line is giving me trouble
        printfn "%A" x // and this one too

    increment // return the function

Visual Studio告诉我,x以无效的方式使用,闭包不能捕获可变变量

这是为什么？我能做些什么来让我改变它？

以下生成不可变向量的向量:

var darr = Vector.tabulate(2, 3){ (a,b) => a*2+b }
darr: scala.collection.immutable.Vector[scala.collection.immutable.Vector[Int]] = Vector(Vector(0, 1, 2), Vector(2, 3, 4))

但是我们的用例需要的是一个可变向量的向量.怎么办？

我正在尝试使用Rust(以一种惯用的方式)进行Matasano crytpo挑战.

第二个任务是xor两个向量.我现在的代码是:

extern crate rustc_serialize;

use rustc_serialize::hex::{FromHex,ToHex};

pub fn fixed_xor(l: &str, r: &str) -> String {
    let mut l = l.from_hex().unwrap();
    let r = r.from_hex().unwrap();
    for i in 0..l.len() {
        l[i] ^= r[i];
    }
    return l.to_hex();
}

这是有效的,但由于for循环中的范围,它不会感觉到惯用的代码.

是否可以压缩l并r获得对该元素的可变引用以及对该元素l的非可变引用r？

(注意,我没有检查向量的长度.我知道这会在现实生活中爆炸,但我想现在关注for循环)

我正在制作一个组合优化项目来学习Rust,我遇到了一个问题,我无法解决自己...

我有两个功能:

pub fn get_pareto_front_offline<'a>(scheduling_jobs: &'a Vec<Vec<u32>>, costs_vector: &'a Vec<(u32, u32)>) -> Vec<(&'a Vec<u32>, &'a (u32, u32))> {
    // ...
}

和

pub fn pareto_approach_offline<'a>(list_of_jobs: &'a mut Vec<Vec<u32>>, neighborhood: &'a mut Vec<Vec<u32>>, costs: &'a Vec<(u32, u32)>) -> Vec<(&'a Vec<u32>, &'a (u32, u32))> {
    let pareto_front = get_pareto_front_offline(neighborhood, costs);

    loop {
        if pareto_front == vec![] {
            break;
        }

        neighborhood.clear();

        for front in pareto_front.iter() {
            neighborhood.push((front.0).clone());
        }
    }

    pareto_front
}

我有一个问题,因为编译器告诉我:

cannot borrow '*neighborhood' as mutable because it is also borrowed as …

我一直试图及时完成对黑客的这项练习.但由于超时,我的以下Haskell解决方案因测试案例13到15而失败.

我的Haskell解决方案

import           Data.Vector(Vector(..),fromList,(!),(//),toList)
import           Data.Vector.Mutable
import qualified Data.Vector as V 
import           Data.ByteString.Lazy.Char8 (ByteString(..))
import qualified Data.ByteString.Lazy.Char8 as L
import Data.ByteString.Lazy.Builder
import Data.Maybe
import Control.Applicative
import Data.Monoid
import Prelude hiding (length)

readInt' = fst . fromJust . L.readInt 
toB []     = mempty
toB (x:xs) = string8 (show x) <> string8 " " <> toB xs

main = do 
  [firstLine, secondLine] <- L.lines <$> L.getContents
  let [n,k] = map readInt' $ L.words firstLine
  let xs = largestPermutation n k …

我有一个var x类型ListBuffer[ListBuffer[Int]],其中我使用函数克隆clone并设置为另一个var y,然后我使用update此新函数var y来更新内容,但是当我检查它的原始内容var x是否相同var y？为什么是这样？我究竟做错了什么？他们的解决方法是什么？我试图获得ListBuffer的副本,我可以修改,而无需更改初始ListBuffer的原始内容.

由于元组是Python中不可变的数据类型,而元组理解不是一个问题,那么为什么使用圆括号而不是方括号的List理解能够正常工作并产生常规元组？

我认为使用圆括号来定义元组而不是列表(我知道我没有错).

根据我的理解,我将值附加到已经定义的元组,并且我能够更新元组,并且不应该发生(在Python中),因为元组是不可变的.

我没有收到任何错误,有人请告诉我这是一个合理的解释.

这是我的代码:

ignore = (r"^\@define\s")
x = tuple()
(x.append(True if re.search(regex, line) else False) for regex in ignore)
if True in x:
  print("How is this possible?")

以下C#代码编译正常:

static readonly List<int> list = new List<int>();
static void Main(string[] args)
{
    list.Add(1);
    list.Add(2);
    list.Add(3);
}

如果我在Rust中编写类似的代码,它将无法编译,因为它不能将immutable借用v为mutable:

let v = Vec::new();
v.push(1);
v.push(2);
v.push(3);

push函数如何知道v是不可变的？