我想在Haskell中创建一个基于可变数组的堆(在其他地方找到的基本类).但是,有些事情我不喜欢我最初的方法:
f示例函数中使用我的堆时,我必须n绕过s.将我的堆抽象为一个漂亮的数据类型的最佳方法是什么？我觉得这可以解决我的大部分问题.
buildHeap max_n =
do
arr <- newArray (1, max_n) 0 :: ST s (STArray s Int Int)
return (0, arr)
-- My heap needs to know the array where the elements are stored
-- and how many elements it has
f n = --example use
do
(n1, arr) <- buildHeap n
(n2, _) <- addHeap (n1, arr) 1
(n3, _) <- addHeap (n2, arr) 2
getElems arr
main …我在Ubuntu下使用OpenJDK Java编译器.我想将一个字符数组转换为一个字符串,当它似乎最终给出了模糊的结果时,我试着写一个toString我自己的方法.在这个过程中,我写了一个测试程序,其中(出于乐趣)我尝试编译以下代码.
class toString{
public static void main(String[] args){
string = "abc";
string = string + "bcd";
System.out.println(string);
}
}
现在,我知道StringJava中的对象是不可变的,代码实际上应该生成错误但令我惊讶的是,它打印abcbcd到控制台.这是否意味着StringJava中的对象是可变的,或者在这种情况下OpenJDK编译器的实现是否有问题？
有人可以向我解释为什么ArrayBuffer的padTo方法不能像我期望的那样工作吗？在这个例子中,我希望toArray创建的数组的长度为10.
scala> val b = new scala.collection.mutable.ArrayBuffer[Byte]
b: scala.collection.mutable.ArrayBuffer[Byte] = ArrayBuffer()
scala> b.append(2)
scala> b
res1: scala.collection.mutable.ArrayBuffer[Byte] = ArrayBuffer(2)
scala> b.append(2)
scala> b
res3: scala.collection.mutable.ArrayBuffer[Byte] = ArrayBuffer(2, 2)
scala> b.padTo(10,0)
res4: scala.collection.mutable.ArrayBuffer[AnyVal] = ArrayBuffer(2, 2, 0, 0, 0, 0, 0, 0, 0, 0)
scala> b.toArray
res5: Array[Byte] = Array(2, 2)
我是新手,并且遇到了我需要一个可变数值变量的实例
下面是一个通过一串位(101011 ....)工作的函数,如果它遇到1改变一个名为"value"的数值变量,如果它遇到0则必须改变相同的变量"value".因此,当我们到达字符串的末尾时,我们应该得到总数为"值".
(define (implode bstr value)
(for ([c (string-length bstr)])
(display (string-ref bstr c))
(if (eqv? (string-ref bstr c) #\1) (displayln (+ (/ value 3) 17))
(displayln (/ value 3)))))
如果没有mtauble变量,我可以通过prgram运行这个变量吗？
我正在使用多个文件,我有一个可变字段的问题.在file1.ml中,我声明:
type mytype = {
mutable numbers : int list;
}
所以,在file2.ml中,我有mytype类型的元素.但是,当我想做的时候:
myElement.numbers
返回以下错误:错误:未绑定的记录字段标签号.
谢谢,欢迎任何帮助.
我们说classes在Python中是可变的,这意味着你可以使用引用我们可以改变将反映在对象中的值.例如,
>>> A = [1, 2, 3]
>>> B = A
>>> B[2] = 5
>>> A
[1, 2, 5]
在这里,我可以更改A对象的值,B因为它list是一个可变类型.我的问题是为什么我不能使用相同的概念更改下面的类的属性:
class C:
apple = 2
def __init__(self):
self.dangerous = 2
D = C # D is pointing to same class C
D().dangerous = 5 # changing the value of class attribute D
D().apple = 3 # changing the value of apple here
print D().apple
print D().dangerous
OUTPUT:
2
2
任何人都可以解释为什么输出2 …
我正在学习"Java SE 7程序员I和II学习指南",我不明白下面的解释.
class Fortress{
private String name;
private ArrayList<Integer> list;
Fortress?? {list=new ArrayList<Integer>;
String getName{return name;}
void addToList(int x){list.add(x);}
ArrayList getList(){return list;} // line 1
}
哪行代码打破了封装？答案:第9行."当封装像ArrayList这样的可变对象时,你的getter必须返回对对象副本的引用,而不仅仅是对原始对象的引用".
我没有理解解释或如何修改原始代码.
所以在getList()而不是
return list;
我们应该这样做吗？
ArrayList<Integer> list2=list;
return list2;
我有一个列表,并希望单独返回每个元素.基本上就像从堆栈中弹出一样.例如:
let rnd = new System.Random()
let rnds = List.init 10 (fun _ -> rnd.Next(100))
List.iter (fun x -> printfn "%A"x ) rnds
但是,我实际上想要一个接一个地返回每个整数,直到列表为空,而不是迭代.所以基本上是这样的:
List.head(rnds)
List.head(List.tail(rnds))
List.head(List.tail(List.tail(rnds)))
List.head(List.tail(List.tail(List.tail(List.tail(rnds)))))
不幸的是,我尝试使用折叠或扫描的递归解决方案甚至更好的尝试都没有成功.例如,这只返回列表(与map相同).
let pop3 (rnds:int list) =
let rec pop3' rnds acc =
match rnds with
| head :: tail -> List.tail(tail)
| [] -> acc
pop3' [] rnds
我读过Rust在使用Hindley-Milner时具有很好的类型推断。Rust还具有可变变量，并且当HM算法具有可变性时，AFAIK必须存在一些约束，因为它可能过于笼统。如下代码：
let mut a;
a = 3;
a = 2.5;
不进行编译，因为在第二行推断出整数，并且不能将浮点值分配给整数变量。因此，我猜测对于简单变量，一旦推断出非泛型类型，该变量就会成为单类型并且无法再进行泛化。
但是，像Vec这样的模板呢？例如此代码：
let mut v;
v = Vec::new();
v.push(3);
v.push(2.3);
这再次失败，但对于最后一行再次失败。这意味着第二行部分推断了类型（Vec），而第三行推断了容器类型。
怎么了 有我不知道的诸如价值限制之类的东西吗？还是我使事情复杂化了，Rust有更严格的规则（就像根本没有泛化一样）？
将元素复制回列表:
>> a = [[1,2],[3,4]]
>> b = []
>> b = a[1]
>> a.insert(1,b)
>> a
[[1,2],[3,4],[3,4]]
>> a[2][0] = 0
>> a
???
你期望列出'a'是什么？它出现为[[1,2],[0,4],[0,4]]这对我来说非常令人惊讶,而我预期[[1,2],[1,4],[0, 4]]
我有点知道答案但是,这个想法还不是很清楚.请详细说明为什么会发生这种情况以及如何摆脱它？