Instruction stringlengths 45 106 | input_code stringlengths 1 13.7k | output_code stringlengths 1 13.7k |
|---|---|---|
Write a version of this Lua function in C# with identical behavior. | Matrix = {}
function Matrix.new( dim_y, dim_x )
assert( dim_y and dim_x )
local matrix = {}
local metatab = {}
setmetatable( matrix, metatab )
metatab.__add = Matrix.Add
metatab.__mul = Matrix.Mul
metatab.__pow = Matrix.Pow
matrix.dim_y = dim_y
matrix.dim_x = dim_x
m... | using System;
using System.Collections;
using System.Collections.Generic;
using static System.Linq.Enumerable;
public static class MatrixExponentation
{
public static double[,] Identity(int size) {
double[,] matrix = new double[size, size];
for (int i = 0; i < size; i++) matrix[i, i] = 1;
r... |
Convert this Lua block to C++, preserving its control flow and logic. | Matrix = {}
function Matrix.new( dim_y, dim_x )
assert( dim_y and dim_x )
local matrix = {}
local metatab = {}
setmetatable( matrix, metatab )
metatab.__add = Matrix.Add
metatab.__mul = Matrix.Mul
metatab.__pow = Matrix.Pow
matrix.dim_y = dim_y
matrix.dim_x = dim_x
m... | #include <complex>
#include <cmath>
#include <iostream>
using namespace std;
template<int MSize = 3, class T = complex<double> >
class SqMx {
typedef T Ax[MSize][MSize];
typedef SqMx<MSize, T> Mx;
private:
Ax a;
SqMx() { }
public:
SqMx(const Ax &_a) {
for (int r = 0; r < MSize; r++)
for (int c =... |
Translate the given Lua code snippet into Python without altering its behavior. | Matrix = {}
function Matrix.new( dim_y, dim_x )
assert( dim_y and dim_x )
local matrix = {}
local metatab = {}
setmetatable( matrix, metatab )
metatab.__add = Matrix.Add
metatab.__mul = Matrix.Mul
metatab.__pow = Matrix.Pow
matrix.dim_y = dim_y
matrix.dim_x = dim_x
m... | >>> from operator import mul
>>> def matrixMul(m1, m2):
return map(
lambda row:
map(
lambda *column:
sum(map(mul, row, column)),
*m2),
m1)
>>> def identity(size):
size = range(size)
return [[(i==j)*1 for i in size] for j in size]
>>> def matrixExp(m, pow):
assert pow>=0 an... |
Translate this program into VB but keep the logic exactly as in Lua. | Matrix = {}
function Matrix.new( dim_y, dim_x )
assert( dim_y and dim_x )
local matrix = {}
local metatab = {}
setmetatable( matrix, metatab )
metatab.__add = Matrix.Add
metatab.__mul = Matrix.Mul
metatab.__pow = Matrix.Pow
matrix.dim_y = dim_y
matrix.dim_x = dim_x
m... | Option Base 1
Private Function Identity(n As Integer) As Variant
Dim I() As Variant
ReDim I(n, n)
For j = 1 To n
For k = 1 To n
I(j, k) = 0
Next k
Next j
For j = 1 To n
I(j, j) = 1
Next j
Identity = I
End Function
Function MatrixExponentiation(ByVal x As ... |
Rewrite the snippet below in Go so it works the same as the original Lua code. | Matrix = {}
function Matrix.new( dim_y, dim_x )
assert( dim_y and dim_x )
local matrix = {}
local metatab = {}
setmetatable( matrix, metatab )
metatab.__add = Matrix.Add
metatab.__mul = Matrix.Mul
metatab.__pow = Matrix.Pow
matrix.dim_y = dim_y
matrix.dim_x = dim_x
m... | package main
import "fmt"
type vector = []float64
type matrix []vector
func (m1 matrix) mul(m2 matrix) matrix {
rows1, cols1 := len(m1), len(m1[0])
rows2, cols2 := len(m2), len(m2[0])
if cols1 != rows2 {
panic("Matrices cannot be multiplied.")
}
result := make(matrix, rows1)
for i := ... |
Change the following Mathematica code into C without altering its purpose. | a = {{3, 2}, {4, 1}};
MatrixPower[a, 0]
MatrixPower[a, 1]
MatrixPower[a, -1]
MatrixPower[a, 4]
MatrixPower[a, 1/2]
MatrixPower[a, Pi]
| #include <math.h>
#include <stdio.h>
#include <stdlib.h>
typedef struct squareMtxStruct {
int dim;
double *cells;
double **m;
} *SquareMtx;
typedef void (*FillFunc)( double *cells, int r, int dim, void *ff_data);
SquareMtx NewSquareMtx( int dim, FillFunc fillFunc, void *ff_data )
{
SquareMtx sm =... |
Change the programming language of this snippet from Mathematica to C# without modifying what it does. | a = {{3, 2}, {4, 1}};
MatrixPower[a, 0]
MatrixPower[a, 1]
MatrixPower[a, -1]
MatrixPower[a, 4]
MatrixPower[a, 1/2]
MatrixPower[a, Pi]
| using System;
using System.Collections;
using System.Collections.Generic;
using static System.Linq.Enumerable;
public static class MatrixExponentation
{
public static double[,] Identity(int size) {
double[,] matrix = new double[size, size];
for (int i = 0; i < size; i++) matrix[i, i] = 1;
r... |
Change the following Mathematica code into C++ without altering its purpose. | a = {{3, 2}, {4, 1}};
MatrixPower[a, 0]
MatrixPower[a, 1]
MatrixPower[a, -1]
MatrixPower[a, 4]
MatrixPower[a, 1/2]
MatrixPower[a, Pi]
| #include <complex>
#include <cmath>
#include <iostream>
using namespace std;
template<int MSize = 3, class T = complex<double> >
class SqMx {
typedef T Ax[MSize][MSize];
typedef SqMx<MSize, T> Mx;
private:
Ax a;
SqMx() { }
public:
SqMx(const Ax &_a) {
for (int r = 0; r < MSize; r++)
for (int c =... |
Keep all operations the same but rewrite the snippet in Python. | a = {{3, 2}, {4, 1}};
MatrixPower[a, 0]
MatrixPower[a, 1]
MatrixPower[a, -1]
MatrixPower[a, 4]
MatrixPower[a, 1/2]
MatrixPower[a, Pi]
| >>> from operator import mul
>>> def matrixMul(m1, m2):
return map(
lambda row:
map(
lambda *column:
sum(map(mul, row, column)),
*m2),
m1)
>>> def identity(size):
size = range(size)
return [[(i==j)*1 for i in size] for j in size]
>>> def matrixExp(m, pow):
assert pow>=0 an... |
Produce a functionally identical VB code for the snippet given in Mathematica. | a = {{3, 2}, {4, 1}};
MatrixPower[a, 0]
MatrixPower[a, 1]
MatrixPower[a, -1]
MatrixPower[a, 4]
MatrixPower[a, 1/2]
MatrixPower[a, Pi]
| Option Base 1
Private Function Identity(n As Integer) As Variant
Dim I() As Variant
ReDim I(n, n)
For j = 1 To n
For k = 1 To n
I(j, k) = 0
Next k
Next j
For j = 1 To n
I(j, j) = 1
Next j
Identity = I
End Function
Function MatrixExponentiation(ByVal x As ... |
Generate a Go translation of this Mathematica snippet without changing its computational steps. | a = {{3, 2}, {4, 1}};
MatrixPower[a, 0]
MatrixPower[a, 1]
MatrixPower[a, -1]
MatrixPower[a, 4]
MatrixPower[a, 1/2]
MatrixPower[a, Pi]
| package main
import "fmt"
type vector = []float64
type matrix []vector
func (m1 matrix) mul(m2 matrix) matrix {
rows1, cols1 := len(m1), len(m1[0])
rows2, cols2 := len(m2), len(m2[0])
if cols1 != rows2 {
panic("Matrices cannot be multiplied.")
}
result := make(matrix, rows1)
for i := ... |
Rewrite the snippet below in C so it works the same as the original MATLAB code. | function [output] = matrixexponentiation(matrixA, exponent)
output = matrixA^(exponent);
| #include <math.h>
#include <stdio.h>
#include <stdlib.h>
typedef struct squareMtxStruct {
int dim;
double *cells;
double **m;
} *SquareMtx;
typedef void (*FillFunc)( double *cells, int r, int dim, void *ff_data);
SquareMtx NewSquareMtx( int dim, FillFunc fillFunc, void *ff_data )
{
SquareMtx sm =... |
Write the same algorithm in C# as shown in this MATLAB implementation. | function [output] = matrixexponentiation(matrixA, exponent)
output = matrixA^(exponent);
| using System;
using System.Collections;
using System.Collections.Generic;
using static System.Linq.Enumerable;
public static class MatrixExponentation
{
public static double[,] Identity(int size) {
double[,] matrix = new double[size, size];
for (int i = 0; i < size; i++) matrix[i, i] = 1;
r... |
Port the provided MATLAB code into C++ while preserving the original functionality. | function [output] = matrixexponentiation(matrixA, exponent)
output = matrixA^(exponent);
| #include <complex>
#include <cmath>
#include <iostream>
using namespace std;
template<int MSize = 3, class T = complex<double> >
class SqMx {
typedef T Ax[MSize][MSize];
typedef SqMx<MSize, T> Mx;
private:
Ax a;
SqMx() { }
public:
SqMx(const Ax &_a) {
for (int r = 0; r < MSize; r++)
for (int c =... |
Write the same code in Python as shown below in MATLAB. | function [output] = matrixexponentiation(matrixA, exponent)
output = matrixA^(exponent);
| >>> from operator import mul
>>> def matrixMul(m1, m2):
return map(
lambda row:
map(
lambda *column:
sum(map(mul, row, column)),
*m2),
m1)
>>> def identity(size):
size = range(size)
return [[(i==j)*1 for i in size] for j in size]
>>> def matrixExp(m, pow):
assert pow>=0 an... |
Translate the given MATLAB code snippet into VB without altering its behavior. | function [output] = matrixexponentiation(matrixA, exponent)
output = matrixA^(exponent);
| Option Base 1
Private Function Identity(n As Integer) As Variant
Dim I() As Variant
ReDim I(n, n)
For j = 1 To n
For k = 1 To n
I(j, k) = 0
Next k
Next j
For j = 1 To n
I(j, j) = 1
Next j
Identity = I
End Function
Function MatrixExponentiation(ByVal x As ... |
Port the following code from MATLAB to Go with equivalent syntax and logic. | function [output] = matrixexponentiation(matrixA, exponent)
output = matrixA^(exponent);
| package main
import "fmt"
type vector = []float64
type matrix []vector
func (m1 matrix) mul(m2 matrix) matrix {
rows1, cols1 := len(m1), len(m1[0])
rows2, cols2 := len(m2), len(m2[0])
if cols1 != rows2 {
panic("Matrices cannot be multiplied.")
}
result := make(matrix, rows1)
for i := ... |
Translate the given Nim code snippet into C without altering its behavior. | import sequtils, strutils
type Matrix[N: static int; T] = array[1..N, array[1..N, T]]
func `*`[N, T](a, b: Matrix[N, T]): Matrix[N, T] =
for i in 1..N:
for j in 1..N:
for k in 1..N:
result[i][j] += a[i][k] * b[k][j]
func identityMatrix[N; T](): Matrix[N, T] =
for i in 1..N:
result[i][i] = ... | #include <math.h>
#include <stdio.h>
#include <stdlib.h>
typedef struct squareMtxStruct {
int dim;
double *cells;
double **m;
} *SquareMtx;
typedef void (*FillFunc)( double *cells, int r, int dim, void *ff_data);
SquareMtx NewSquareMtx( int dim, FillFunc fillFunc, void *ff_data )
{
SquareMtx sm =... |
Transform the following Nim implementation into C#, maintaining the same output and logic. | import sequtils, strutils
type Matrix[N: static int; T] = array[1..N, array[1..N, T]]
func `*`[N, T](a, b: Matrix[N, T]): Matrix[N, T] =
for i in 1..N:
for j in 1..N:
for k in 1..N:
result[i][j] += a[i][k] * b[k][j]
func identityMatrix[N; T](): Matrix[N, T] =
for i in 1..N:
result[i][i] = ... | using System;
using System.Collections;
using System.Collections.Generic;
using static System.Linq.Enumerable;
public static class MatrixExponentation
{
public static double[,] Identity(int size) {
double[,] matrix = new double[size, size];
for (int i = 0; i < size; i++) matrix[i, i] = 1;
r... |
Convert the following code from Nim to C++, ensuring the logic remains intact. | import sequtils, strutils
type Matrix[N: static int; T] = array[1..N, array[1..N, T]]
func `*`[N, T](a, b: Matrix[N, T]): Matrix[N, T] =
for i in 1..N:
for j in 1..N:
for k in 1..N:
result[i][j] += a[i][k] * b[k][j]
func identityMatrix[N; T](): Matrix[N, T] =
for i in 1..N:
result[i][i] = ... | #include <complex>
#include <cmath>
#include <iostream>
using namespace std;
template<int MSize = 3, class T = complex<double> >
class SqMx {
typedef T Ax[MSize][MSize];
typedef SqMx<MSize, T> Mx;
private:
Ax a;
SqMx() { }
public:
SqMx(const Ax &_a) {
for (int r = 0; r < MSize; r++)
for (int c =... |
Generate a Python translation of this Nim snippet without changing its computational steps. | import sequtils, strutils
type Matrix[N: static int; T] = array[1..N, array[1..N, T]]
func `*`[N, T](a, b: Matrix[N, T]): Matrix[N, T] =
for i in 1..N:
for j in 1..N:
for k in 1..N:
result[i][j] += a[i][k] * b[k][j]
func identityMatrix[N; T](): Matrix[N, T] =
for i in 1..N:
result[i][i] = ... | >>> from operator import mul
>>> def matrixMul(m1, m2):
return map(
lambda row:
map(
lambda *column:
sum(map(mul, row, column)),
*m2),
m1)
>>> def identity(size):
size = range(size)
return [[(i==j)*1 for i in size] for j in size]
>>> def matrixExp(m, pow):
assert pow>=0 an... |
Write the same algorithm in VB as shown in this Nim implementation. | import sequtils, strutils
type Matrix[N: static int; T] = array[1..N, array[1..N, T]]
func `*`[N, T](a, b: Matrix[N, T]): Matrix[N, T] =
for i in 1..N:
for j in 1..N:
for k in 1..N:
result[i][j] += a[i][k] * b[k][j]
func identityMatrix[N; T](): Matrix[N, T] =
for i in 1..N:
result[i][i] = ... | Option Base 1
Private Function Identity(n As Integer) As Variant
Dim I() As Variant
ReDim I(n, n)
For j = 1 To n
For k = 1 To n
I(j, k) = 0
Next k
Next j
For j = 1 To n
I(j, j) = 1
Next j
Identity = I
End Function
Function MatrixExponentiation(ByVal x As ... |
Produce a functionally identical Go code for the snippet given in Nim. | import sequtils, strutils
type Matrix[N: static int; T] = array[1..N, array[1..N, T]]
func `*`[N, T](a, b: Matrix[N, T]): Matrix[N, T] =
for i in 1..N:
for j in 1..N:
for k in 1..N:
result[i][j] += a[i][k] * b[k][j]
func identityMatrix[N; T](): Matrix[N, T] =
for i in 1..N:
result[i][i] = ... | package main
import "fmt"
type vector = []float64
type matrix []vector
func (m1 matrix) mul(m2 matrix) matrix {
rows1, cols1 := len(m1), len(m1[0])
rows2, cols2 := len(m2), len(m2[0])
if cols1 != rows2 {
panic("Matrices cannot be multiplied.")
}
result := make(matrix, rows1)
for i := ... |
Preserve the algorithm and functionality while converting the code from OCaml to C. |
let eye n =
let a = Array.make_matrix n n 0.0 in
for i=0 to n-1 do
a.(i).(i) <- 1.0
done;
(a)
;;
let dim a = Array.length a, Array.length a.(0);;
let matrix p q v =
if (List.length v) <> (p * q)
then failwith "bad dimensions"
else
let a = Array.make_matrix p q (List.hd v) in
let rec g i j... | #include <math.h>
#include <stdio.h>
#include <stdlib.h>
typedef struct squareMtxStruct {
int dim;
double *cells;
double **m;
} *SquareMtx;
typedef void (*FillFunc)( double *cells, int r, int dim, void *ff_data);
SquareMtx NewSquareMtx( int dim, FillFunc fillFunc, void *ff_data )
{
SquareMtx sm =... |
Port the provided OCaml code into C# while preserving the original functionality. |
let eye n =
let a = Array.make_matrix n n 0.0 in
for i=0 to n-1 do
a.(i).(i) <- 1.0
done;
(a)
;;
let dim a = Array.length a, Array.length a.(0);;
let matrix p q v =
if (List.length v) <> (p * q)
then failwith "bad dimensions"
else
let a = Array.make_matrix p q (List.hd v) in
let rec g i j... | using System;
using System.Collections;
using System.Collections.Generic;
using static System.Linq.Enumerable;
public static class MatrixExponentation
{
public static double[,] Identity(int size) {
double[,] matrix = new double[size, size];
for (int i = 0; i < size; i++) matrix[i, i] = 1;
r... |
Transform the following OCaml implementation into C++, maintaining the same output and logic. |
let eye n =
let a = Array.make_matrix n n 0.0 in
for i=0 to n-1 do
a.(i).(i) <- 1.0
done;
(a)
;;
let dim a = Array.length a, Array.length a.(0);;
let matrix p q v =
if (List.length v) <> (p * q)
then failwith "bad dimensions"
else
let a = Array.make_matrix p q (List.hd v) in
let rec g i j... | #include <complex>
#include <cmath>
#include <iostream>
using namespace std;
template<int MSize = 3, class T = complex<double> >
class SqMx {
typedef T Ax[MSize][MSize];
typedef SqMx<MSize, T> Mx;
private:
Ax a;
SqMx() { }
public:
SqMx(const Ax &_a) {
for (int r = 0; r < MSize; r++)
for (int c =... |
Translate the given OCaml code snippet into Python without altering its behavior. |
let eye n =
let a = Array.make_matrix n n 0.0 in
for i=0 to n-1 do
a.(i).(i) <- 1.0
done;
(a)
;;
let dim a = Array.length a, Array.length a.(0);;
let matrix p q v =
if (List.length v) <> (p * q)
then failwith "bad dimensions"
else
let a = Array.make_matrix p q (List.hd v) in
let rec g i j... | >>> from operator import mul
>>> def matrixMul(m1, m2):
return map(
lambda row:
map(
lambda *column:
sum(map(mul, row, column)),
*m2),
m1)
>>> def identity(size):
size = range(size)
return [[(i==j)*1 for i in size] for j in size]
>>> def matrixExp(m, pow):
assert pow>=0 an... |
Keep all operations the same but rewrite the snippet in VB. |
let eye n =
let a = Array.make_matrix n n 0.0 in
for i=0 to n-1 do
a.(i).(i) <- 1.0
done;
(a)
;;
let dim a = Array.length a, Array.length a.(0);;
let matrix p q v =
if (List.length v) <> (p * q)
then failwith "bad dimensions"
else
let a = Array.make_matrix p q (List.hd v) in
let rec g i j... | Option Base 1
Private Function Identity(n As Integer) As Variant
Dim I() As Variant
ReDim I(n, n)
For j = 1 To n
For k = 1 To n
I(j, k) = 0
Next k
Next j
For j = 1 To n
I(j, j) = 1
Next j
Identity = I
End Function
Function MatrixExponentiation(ByVal x As ... |
Ensure the translated Go code behaves exactly like the original OCaml snippet. |
let eye n =
let a = Array.make_matrix n n 0.0 in
for i=0 to n-1 do
a.(i).(i) <- 1.0
done;
(a)
;;
let dim a = Array.length a, Array.length a.(0);;
let matrix p q v =
if (List.length v) <> (p * q)
then failwith "bad dimensions"
else
let a = Array.make_matrix p q (List.hd v) in
let rec g i j... | package main
import "fmt"
type vector = []float64
type matrix []vector
func (m1 matrix) mul(m2 matrix) matrix {
rows1, cols1 := len(m1), len(m1[0])
rows2, cols2 := len(m2), len(m2[0])
if cols1 != rows2 {
panic("Matrices cannot be multiplied.")
}
result := make(matrix, rows1)
for i := ... |
Change the following Perl code into C without altering its purpose. | use strict;
package SquareMatrix;
use Carp;
use overload (
'""' => \&_string,
'*' => \&_mult,
'*=' => \&_mult,
'**' => \&_expo,
'=' => \&_copy,
);
sub make {
my $cls = shift;
my $n = @_;
for ... | #include <math.h>
#include <stdio.h>
#include <stdlib.h>
typedef struct squareMtxStruct {
int dim;
double *cells;
double **m;
} *SquareMtx;
typedef void (*FillFunc)( double *cells, int r, int dim, void *ff_data);
SquareMtx NewSquareMtx( int dim, FillFunc fillFunc, void *ff_data )
{
SquareMtx sm =... |
Port the following code from Perl to C# with equivalent syntax and logic. | use strict;
package SquareMatrix;
use Carp;
use overload (
'""' => \&_string,
'*' => \&_mult,
'*=' => \&_mult,
'**' => \&_expo,
'=' => \&_copy,
);
sub make {
my $cls = shift;
my $n = @_;
for ... | using System;
using System.Collections;
using System.Collections.Generic;
using static System.Linq.Enumerable;
public static class MatrixExponentation
{
public static double[,] Identity(int size) {
double[,] matrix = new double[size, size];
for (int i = 0; i < size; i++) matrix[i, i] = 1;
r... |
Maintain the same structure and functionality when rewriting this code in C++. | use strict;
package SquareMatrix;
use Carp;
use overload (
'""' => \&_string,
'*' => \&_mult,
'*=' => \&_mult,
'**' => \&_expo,
'=' => \&_copy,
);
sub make {
my $cls = shift;
my $n = @_;
for ... | #include <complex>
#include <cmath>
#include <iostream>
using namespace std;
template<int MSize = 3, class T = complex<double> >
class SqMx {
typedef T Ax[MSize][MSize];
typedef SqMx<MSize, T> Mx;
private:
Ax a;
SqMx() { }
public:
SqMx(const Ax &_a) {
for (int r = 0; r < MSize; r++)
for (int c =... |
Ensure the translated Python code behaves exactly like the original Perl snippet. | use strict;
package SquareMatrix;
use Carp;
use overload (
'""' => \&_string,
'*' => \&_mult,
'*=' => \&_mult,
'**' => \&_expo,
'=' => \&_copy,
);
sub make {
my $cls = shift;
my $n = @_;
for ... | >>> from operator import mul
>>> def matrixMul(m1, m2):
return map(
lambda row:
map(
lambda *column:
sum(map(mul, row, column)),
*m2),
m1)
>>> def identity(size):
size = range(size)
return [[(i==j)*1 for i in size] for j in size]
>>> def matrixExp(m, pow):
assert pow>=0 an... |
Convert this Perl block to VB, preserving its control flow and logic. | use strict;
package SquareMatrix;
use Carp;
use overload (
'""' => \&_string,
'*' => \&_mult,
'*=' => \&_mult,
'**' => \&_expo,
'=' => \&_copy,
);
sub make {
my $cls = shift;
my $n = @_;
for ... | Option Base 1
Private Function Identity(n As Integer) As Variant
Dim I() As Variant
ReDim I(n, n)
For j = 1 To n
For k = 1 To n
I(j, k) = 0
Next k
Next j
For j = 1 To n
I(j, j) = 1
Next j
Identity = I
End Function
Function MatrixExponentiation(ByVal x As ... |
Keep all operations the same but rewrite the snippet in Go. | use strict;
package SquareMatrix;
use Carp;
use overload (
'""' => \&_string,
'*' => \&_mult,
'*=' => \&_mult,
'**' => \&_expo,
'=' => \&_copy,
);
sub make {
my $cls = shift;
my $n = @_;
for ... | package main
import "fmt"
type vector = []float64
type matrix []vector
func (m1 matrix) mul(m2 matrix) matrix {
rows1, cols1 := len(m1), len(m1[0])
rows2, cols2 := len(m2), len(m2[0])
if cols1 != rows2 {
panic("Matrices cannot be multiplied.")
}
result := make(matrix, rows1)
for i := ... |
Convert this Racket snippet to C and keep its semantics consistent. | #lang racket
(require math)
(define a (matrix ((3 2) (2 1))))
(for ([i 11])
(printf "a^~a = ~s\n" i (matrix-expt a i)))
(define (mpower M p)
(cond [(= p 1) M]
[(even? p) (mpower (matrix* M M) (/ p 2))]
[else (matrix* M (mpower M (sub1 p)))]))
(for ([i (in-range 1 11)])
(printf "a... | #include <math.h>
#include <stdio.h>
#include <stdlib.h>
typedef struct squareMtxStruct {
int dim;
double *cells;
double **m;
} *SquareMtx;
typedef void (*FillFunc)( double *cells, int r, int dim, void *ff_data);
SquareMtx NewSquareMtx( int dim, FillFunc fillFunc, void *ff_data )
{
SquareMtx sm =... |
Convert this Racket block to C#, preserving its control flow and logic. | #lang racket
(require math)
(define a (matrix ((3 2) (2 1))))
(for ([i 11])
(printf "a^~a = ~s\n" i (matrix-expt a i)))
(define (mpower M p)
(cond [(= p 1) M]
[(even? p) (mpower (matrix* M M) (/ p 2))]
[else (matrix* M (mpower M (sub1 p)))]))
(for ([i (in-range 1 11)])
(printf "a... | using System;
using System.Collections;
using System.Collections.Generic;
using static System.Linq.Enumerable;
public static class MatrixExponentation
{
public static double[,] Identity(int size) {
double[,] matrix = new double[size, size];
for (int i = 0; i < size; i++) matrix[i, i] = 1;
r... |
Convert the following code from Racket to C++, ensuring the logic remains intact. | #lang racket
(require math)
(define a (matrix ((3 2) (2 1))))
(for ([i 11])
(printf "a^~a = ~s\n" i (matrix-expt a i)))
(define (mpower M p)
(cond [(= p 1) M]
[(even? p) (mpower (matrix* M M) (/ p 2))]
[else (matrix* M (mpower M (sub1 p)))]))
(for ([i (in-range 1 11)])
(printf "a... | #include <complex>
#include <cmath>
#include <iostream>
using namespace std;
template<int MSize = 3, class T = complex<double> >
class SqMx {
typedef T Ax[MSize][MSize];
typedef SqMx<MSize, T> Mx;
private:
Ax a;
SqMx() { }
public:
SqMx(const Ax &_a) {
for (int r = 0; r < MSize; r++)
for (int c =... |
Keep all operations the same but rewrite the snippet in Python. | #lang racket
(require math)
(define a (matrix ((3 2) (2 1))))
(for ([i 11])
(printf "a^~a = ~s\n" i (matrix-expt a i)))
(define (mpower M p)
(cond [(= p 1) M]
[(even? p) (mpower (matrix* M M) (/ p 2))]
[else (matrix* M (mpower M (sub1 p)))]))
(for ([i (in-range 1 11)])
(printf "a... | >>> from operator import mul
>>> def matrixMul(m1, m2):
return map(
lambda row:
map(
lambda *column:
sum(map(mul, row, column)),
*m2),
m1)
>>> def identity(size):
size = range(size)
return [[(i==j)*1 for i in size] for j in size]
>>> def matrixExp(m, pow):
assert pow>=0 an... |
Translate the given Racket code snippet into VB without altering its behavior. | #lang racket
(require math)
(define a (matrix ((3 2) (2 1))))
(for ([i 11])
(printf "a^~a = ~s\n" i (matrix-expt a i)))
(define (mpower M p)
(cond [(= p 1) M]
[(even? p) (mpower (matrix* M M) (/ p 2))]
[else (matrix* M (mpower M (sub1 p)))]))
(for ([i (in-range 1 11)])
(printf "a... | Option Base 1
Private Function Identity(n As Integer) As Variant
Dim I() As Variant
ReDim I(n, n)
For j = 1 To n
For k = 1 To n
I(j, k) = 0
Next k
Next j
For j = 1 To n
I(j, j) = 1
Next j
Identity = I
End Function
Function MatrixExponentiation(ByVal x As ... |
Ensure the translated Go code behaves exactly like the original Racket snippet. | #lang racket
(require math)
(define a (matrix ((3 2) (2 1))))
(for ([i 11])
(printf "a^~a = ~s\n" i (matrix-expt a i)))
(define (mpower M p)
(cond [(= p 1) M]
[(even? p) (mpower (matrix* M M) (/ p 2))]
[else (matrix* M (mpower M (sub1 p)))]))
(for ([i (in-range 1 11)])
(printf "a... | package main
import "fmt"
type vector = []float64
type matrix []vector
func (m1 matrix) mul(m2 matrix) matrix {
rows1, cols1 := len(m1), len(m1[0])
rows2, cols2 := len(m2), len(m2[0])
if cols1 != rows2 {
panic("Matrices cannot be multiplied.")
}
result := make(matrix, rows1)
for i := ... |
Maintain the same structure and functionality when rewriting this code in C. | class Array {
method ** (Number n { .>= 0 }) {
var tmp = self
var out = self.len.of {|i| self.len.of {|j| i == j ? 1 : 0 }}
loop {
out = (out `mmul` tmp) if n.is_odd
n >>= 1 || break
tmp = (tmp `mmul` tmp)
}
return out
}
}
var m = [[1,... | #include <math.h>
#include <stdio.h>
#include <stdlib.h>
typedef struct squareMtxStruct {
int dim;
double *cells;
double **m;
} *SquareMtx;
typedef void (*FillFunc)( double *cells, int r, int dim, void *ff_data);
SquareMtx NewSquareMtx( int dim, FillFunc fillFunc, void *ff_data )
{
SquareMtx sm =... |
Produce a language-to-language conversion: from Ruby to C#, same semantics. | class Array {
method ** (Number n { .>= 0 }) {
var tmp = self
var out = self.len.of {|i| self.len.of {|j| i == j ? 1 : 0 }}
loop {
out = (out `mmul` tmp) if n.is_odd
n >>= 1 || break
tmp = (tmp `mmul` tmp)
}
return out
}
}
var m = [[1,... | using System;
using System.Collections;
using System.Collections.Generic;
using static System.Linq.Enumerable;
public static class MatrixExponentation
{
public static double[,] Identity(int size) {
double[,] matrix = new double[size, size];
for (int i = 0; i < size; i++) matrix[i, i] = 1;
r... |
Please provide an equivalent version of this Ruby code in C++. | class Array {
method ** (Number n { .>= 0 }) {
var tmp = self
var out = self.len.of {|i| self.len.of {|j| i == j ? 1 : 0 }}
loop {
out = (out `mmul` tmp) if n.is_odd
n >>= 1 || break
tmp = (tmp `mmul` tmp)
}
return out
}
}
var m = [[1,... | #include <complex>
#include <cmath>
#include <iostream>
using namespace std;
template<int MSize = 3, class T = complex<double> >
class SqMx {
typedef T Ax[MSize][MSize];
typedef SqMx<MSize, T> Mx;
private:
Ax a;
SqMx() { }
public:
SqMx(const Ax &_a) {
for (int r = 0; r < MSize; r++)
for (int c =... |
Produce a functionally identical Python code for the snippet given in Ruby. | class Array {
method ** (Number n { .>= 0 }) {
var tmp = self
var out = self.len.of {|i| self.len.of {|j| i == j ? 1 : 0 }}
loop {
out = (out `mmul` tmp) if n.is_odd
n >>= 1 || break
tmp = (tmp `mmul` tmp)
}
return out
}
}
var m = [[1,... | >>> from operator import mul
>>> def matrixMul(m1, m2):
return map(
lambda row:
map(
lambda *column:
sum(map(mul, row, column)),
*m2),
m1)
>>> def identity(size):
size = range(size)
return [[(i==j)*1 for i in size] for j in size]
>>> def matrixExp(m, pow):
assert pow>=0 an... |
Preserve the algorithm and functionality while converting the code from Ruby to VB. | class Array {
method ** (Number n { .>= 0 }) {
var tmp = self
var out = self.len.of {|i| self.len.of {|j| i == j ? 1 : 0 }}
loop {
out = (out `mmul` tmp) if n.is_odd
n >>= 1 || break
tmp = (tmp `mmul` tmp)
}
return out
}
}
var m = [[1,... | Option Base 1
Private Function Identity(n As Integer) As Variant
Dim I() As Variant
ReDim I(n, n)
For j = 1 To n
For k = 1 To n
I(j, k) = 0
Next k
Next j
For j = 1 To n
I(j, j) = 1
Next j
Identity = I
End Function
Function MatrixExponentiation(ByVal x As ... |
Generate a Go translation of this Ruby snippet without changing its computational steps. | class Array {
method ** (Number n { .>= 0 }) {
var tmp = self
var out = self.len.of {|i| self.len.of {|j| i == j ? 1 : 0 }}
loop {
out = (out `mmul` tmp) if n.is_odd
n >>= 1 || break
tmp = (tmp `mmul` tmp)
}
return out
}
}
var m = [[1,... | package main
import "fmt"
type vector = []float64
type matrix []vector
func (m1 matrix) mul(m2 matrix) matrix {
rows1, cols1 := len(m1), len(m1[0])
rows2, cols2 := len(m2), len(m2[0])
if cols1 != rows2 {
panic("Matrices cannot be multiplied.")
}
result := make(matrix, rows1)
for i := ... |
Change the programming language of this snippet from Scala to C without modifying what it does. |
typealias Vector = DoubleArray
typealias Matrix = Array<Vector>
operator fun Matrix.times(other: Matrix): Matrix {
val rows1 = this.size
val cols1 = this[0].size
val rows2 = other.size
val cols2 = other[0].size
require(cols1 == rows2)
val result = Matrix(rows1) { Vector(cols2) }
for (i in... | #include <math.h>
#include <stdio.h>
#include <stdlib.h>
typedef struct squareMtxStruct {
int dim;
double *cells;
double **m;
} *SquareMtx;
typedef void (*FillFunc)( double *cells, int r, int dim, void *ff_data);
SquareMtx NewSquareMtx( int dim, FillFunc fillFunc, void *ff_data )
{
SquareMtx sm =... |
Write the same algorithm in C# as shown in this Scala implementation. |
typealias Vector = DoubleArray
typealias Matrix = Array<Vector>
operator fun Matrix.times(other: Matrix): Matrix {
val rows1 = this.size
val cols1 = this[0].size
val rows2 = other.size
val cols2 = other[0].size
require(cols1 == rows2)
val result = Matrix(rows1) { Vector(cols2) }
for (i in... | using System;
using System.Collections;
using System.Collections.Generic;
using static System.Linq.Enumerable;
public static class MatrixExponentation
{
public static double[,] Identity(int size) {
double[,] matrix = new double[size, size];
for (int i = 0; i < size; i++) matrix[i, i] = 1;
r... |
Transform the following Scala implementation into C++, maintaining the same output and logic. |
typealias Vector = DoubleArray
typealias Matrix = Array<Vector>
operator fun Matrix.times(other: Matrix): Matrix {
val rows1 = this.size
val cols1 = this[0].size
val rows2 = other.size
val cols2 = other[0].size
require(cols1 == rows2)
val result = Matrix(rows1) { Vector(cols2) }
for (i in... | #include <complex>
#include <cmath>
#include <iostream>
using namespace std;
template<int MSize = 3, class T = complex<double> >
class SqMx {
typedef T Ax[MSize][MSize];
typedef SqMx<MSize, T> Mx;
private:
Ax a;
SqMx() { }
public:
SqMx(const Ax &_a) {
for (int r = 0; r < MSize; r++)
for (int c =... |
Keep all operations the same but rewrite the snippet in Python. |
typealias Vector = DoubleArray
typealias Matrix = Array<Vector>
operator fun Matrix.times(other: Matrix): Matrix {
val rows1 = this.size
val cols1 = this[0].size
val rows2 = other.size
val cols2 = other[0].size
require(cols1 == rows2)
val result = Matrix(rows1) { Vector(cols2) }
for (i in... | >>> from operator import mul
>>> def matrixMul(m1, m2):
return map(
lambda row:
map(
lambda *column:
sum(map(mul, row, column)),
*m2),
m1)
>>> def identity(size):
size = range(size)
return [[(i==j)*1 for i in size] for j in size]
>>> def matrixExp(m, pow):
assert pow>=0 an... |
Convert this Scala block to VB, preserving its control flow and logic. |
typealias Vector = DoubleArray
typealias Matrix = Array<Vector>
operator fun Matrix.times(other: Matrix): Matrix {
val rows1 = this.size
val cols1 = this[0].size
val rows2 = other.size
val cols2 = other[0].size
require(cols1 == rows2)
val result = Matrix(rows1) { Vector(cols2) }
for (i in... | Option Base 1
Private Function Identity(n As Integer) As Variant
Dim I() As Variant
ReDim I(n, n)
For j = 1 To n
For k = 1 To n
I(j, k) = 0
Next k
Next j
For j = 1 To n
I(j, j) = 1
Next j
Identity = I
End Function
Function MatrixExponentiation(ByVal x As ... |
Please provide an equivalent version of this Scala code in Go. |
typealias Vector = DoubleArray
typealias Matrix = Array<Vector>
operator fun Matrix.times(other: Matrix): Matrix {
val rows1 = this.size
val cols1 = this[0].size
val rows2 = other.size
val cols2 = other[0].size
require(cols1 == rows2)
val result = Matrix(rows1) { Vector(cols2) }
for (i in... | package main
import "fmt"
type vector = []float64
type matrix []vector
func (m1 matrix) mul(m2 matrix) matrix {
rows1, cols1 := len(m1), len(m1[0])
rows2, cols2 := len(m2), len(m2[0])
if cols1 != rows2 {
panic("Matrices cannot be multiplied.")
}
result := make(matrix, rows1)
for i := ... |
Change the following Tcl code into C without altering its purpose. | package require Tcl 8.5
namespace path {::tcl::mathop ::tcl::mathfunc}
proc matrix_exp {m pow} {
if { ! [string is int -strict $pow]} {
error "non-integer exponents not implemented"
}
if {$pow < 0} {
error "negative exponents not implemented"
}
lassign [size $m] rows cols
s... | #include <math.h>
#include <stdio.h>
#include <stdlib.h>
typedef struct squareMtxStruct {
int dim;
double *cells;
double **m;
} *SquareMtx;
typedef void (*FillFunc)( double *cells, int r, int dim, void *ff_data);
SquareMtx NewSquareMtx( int dim, FillFunc fillFunc, void *ff_data )
{
SquareMtx sm =... |
Translate the given Tcl code snippet into C# without altering its behavior. | package require Tcl 8.5
namespace path {::tcl::mathop ::tcl::mathfunc}
proc matrix_exp {m pow} {
if { ! [string is int -strict $pow]} {
error "non-integer exponents not implemented"
}
if {$pow < 0} {
error "negative exponents not implemented"
}
lassign [size $m] rows cols
s... | using System;
using System.Collections;
using System.Collections.Generic;
using static System.Linq.Enumerable;
public static class MatrixExponentation
{
public static double[,] Identity(int size) {
double[,] matrix = new double[size, size];
for (int i = 0; i < size; i++) matrix[i, i] = 1;
r... |
Convert the following code from Tcl to C++, ensuring the logic remains intact. | package require Tcl 8.5
namespace path {::tcl::mathop ::tcl::mathfunc}
proc matrix_exp {m pow} {
if { ! [string is int -strict $pow]} {
error "non-integer exponents not implemented"
}
if {$pow < 0} {
error "negative exponents not implemented"
}
lassign [size $m] rows cols
s... | #include <complex>
#include <cmath>
#include <iostream>
using namespace std;
template<int MSize = 3, class T = complex<double> >
class SqMx {
typedef T Ax[MSize][MSize];
typedef SqMx<MSize, T> Mx;
private:
Ax a;
SqMx() { }
public:
SqMx(const Ax &_a) {
for (int r = 0; r < MSize; r++)
for (int c =... |
Please provide an equivalent version of this Tcl code in Python. | package require Tcl 8.5
namespace path {::tcl::mathop ::tcl::mathfunc}
proc matrix_exp {m pow} {
if { ! [string is int -strict $pow]} {
error "non-integer exponents not implemented"
}
if {$pow < 0} {
error "negative exponents not implemented"
}
lassign [size $m] rows cols
s... | >>> from operator import mul
>>> def matrixMul(m1, m2):
return map(
lambda row:
map(
lambda *column:
sum(map(mul, row, column)),
*m2),
m1)
>>> def identity(size):
size = range(size)
return [[(i==j)*1 for i in size] for j in size]
>>> def matrixExp(m, pow):
assert pow>=0 an... |
Produce a language-to-language conversion: from Tcl to VB, same semantics. | package require Tcl 8.5
namespace path {::tcl::mathop ::tcl::mathfunc}
proc matrix_exp {m pow} {
if { ! [string is int -strict $pow]} {
error "non-integer exponents not implemented"
}
if {$pow < 0} {
error "negative exponents not implemented"
}
lassign [size $m] rows cols
s... | Option Base 1
Private Function Identity(n As Integer) As Variant
Dim I() As Variant
ReDim I(n, n)
For j = 1 To n
For k = 1 To n
I(j, k) = 0
Next k
Next j
For j = 1 To n
I(j, j) = 1
Next j
Identity = I
End Function
Function MatrixExponentiation(ByVal x As ... |
Write the same algorithm in Go as shown in this Tcl implementation. | package require Tcl 8.5
namespace path {::tcl::mathop ::tcl::mathfunc}
proc matrix_exp {m pow} {
if { ! [string is int -strict $pow]} {
error "non-integer exponents not implemented"
}
if {$pow < 0} {
error "negative exponents not implemented"
}
lassign [size $m] rows cols
s... | package main
import "fmt"
type vector = []float64
type matrix []vector
func (m1 matrix) mul(m2 matrix) matrix {
rows1, cols1 := len(m1), len(m1[0])
rows2, cols2 := len(m2), len(m2[0])
if cols1 != rows2 {
panic("Matrices cannot be multiplied.")
}
result := make(matrix, rows1)
for i := ... |
Please provide an equivalent version of this C++ code in Rust. | #include <complex>
#include <cmath>
#include <iostream>
using namespace std;
template<int MSize = 3, class T = complex<double> >
class SqMx {
typedef T Ax[MSize][MSize];
typedef SqMx<MSize, T> Mx;
private:
Ax a;
SqMx() { }
public:
SqMx(const Ax &_a) {
for (int r = 0; r < MSize; r++)
for (int c =... | use std::fmt;
use std::ops;
const WIDTH: usize = 6;
#[derive(Clone)]
struct SqMat {
data: Vec<Vec<i64>>,
}
impl fmt::Debug for SqMat {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
let mut row = "".to_string();
for i in &self.data {
for j in i {
row += ... |
Keep all operations the same but rewrite the snippet in Python. | use std::fmt;
use std::ops;
const WIDTH: usize = 6;
#[derive(Clone)]
struct SqMat {
data: Vec<Vec<i64>>,
}
impl fmt::Debug for SqMat {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
let mut row = "".to_string();
for i in &self.data {
for j in i {
row += ... | >>> from operator import mul
>>> def matrixMul(m1, m2):
return map(
lambda row:
map(
lambda *column:
sum(map(mul, row, column)),
*m2),
m1)
>>> def identity(size):
size = range(size)
return [[(i==j)*1 for i in size] for j in size]
>>> def matrixExp(m, pow):
assert pow>=0 an... |
Translate this program into VB but keep the logic exactly as in Rust. | use std::fmt;
use std::ops;
const WIDTH: usize = 6;
#[derive(Clone)]
struct SqMat {
data: Vec<Vec<i64>>,
}
impl fmt::Debug for SqMat {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
let mut row = "".to_string();
for i in &self.data {
for j in i {
row += ... | Option Base 1
Private Function Identity(n As Integer) As Variant
Dim I() As Variant
ReDim I(n, n)
For j = 1 To n
For k = 1 To n
I(j, k) = 0
Next k
Next j
For j = 1 To n
I(j, j) = 1
Next j
Identity = I
End Function
Function MatrixExponentiation(ByVal x As ... |
Rewrite this program in Rust while keeping its functionality equivalent to the C version. | #include <math.h>
#include <stdio.h>
#include <stdlib.h>
typedef struct squareMtxStruct {
int dim;
double *cells;
double **m;
} *SquareMtx;
typedef void (*FillFunc)( double *cells, int r, int dim, void *ff_data);
SquareMtx NewSquareMtx( int dim, FillFunc fillFunc, void *ff_data )
{
SquareMtx sm =... | use std::fmt;
use std::ops;
const WIDTH: usize = 6;
#[derive(Clone)]
struct SqMat {
data: Vec<Vec<i64>>,
}
impl fmt::Debug for SqMat {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
let mut row = "".to_string();
for i in &self.data {
for j in i {
row += ... |
Port the provided C# code into Rust while preserving the original functionality. | using System;
using System.Collections;
using System.Collections.Generic;
using static System.Linq.Enumerable;
public static class MatrixExponentation
{
public static double[,] Identity(int size) {
double[,] matrix = new double[size, size];
for (int i = 0; i < size; i++) matrix[i, i] = 1;
r... | use std::fmt;
use std::ops;
const WIDTH: usize = 6;
#[derive(Clone)]
struct SqMat {
data: Vec<Vec<i64>>,
}
impl fmt::Debug for SqMat {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
let mut row = "".to_string();
for i in &self.data {
for j in i {
row += ... |
Rewrite this program in Rust while keeping its functionality equivalent to the Go version. | package main
import "fmt"
type vector = []float64
type matrix []vector
func (m1 matrix) mul(m2 matrix) matrix {
rows1, cols1 := len(m1), len(m1[0])
rows2, cols2 := len(m2), len(m2[0])
if cols1 != rows2 {
panic("Matrices cannot be multiplied.")
}
result := make(matrix, rows1)
for i := ... | use std::fmt;
use std::ops;
const WIDTH: usize = 6;
#[derive(Clone)]
struct SqMat {
data: Vec<Vec<i64>>,
}
impl fmt::Debug for SqMat {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
let mut row = "".to_string();
for i in &self.data {
for j in i {
row += ... |
Translate this program into C# but keep the logic exactly as in Ada. | with Ada.Text_Io; use Ada.Text_Io;
with Ada.Unchecked_Deallocation;
with Ada.Containers.Doubly_Linked_Lists;
procedure Tree_Traversal is
type Node;
type Node_Access is access Node;
type Node is record
Left : Node_Access := null;
Right : Node_Access := null;
Data : Integer;
end record;
... | using System;
using System.Collections.Generic;
using System.Linq;
class Node
{
int Value;
Node Left;
Node Right;
Node(int value = default(int), Node left = default(Node), Node right = default(Node))
{
Value = value;
Left = left;
Right = right;
}
IEnumerable<int> P... |
Translate the given Ada code snippet into C without altering its behavior. | with Ada.Text_Io; use Ada.Text_Io;
with Ada.Unchecked_Deallocation;
with Ada.Containers.Doubly_Linked_Lists;
procedure Tree_Traversal is
type Node;
type Node_Access is access Node;
type Node is record
Left : Node_Access := null;
Right : Node_Access := null;
Data : Integer;
end record;
... | #include <stdlib.h>
#include <stdio.h>
typedef struct node_s
{
int value;
struct node_s* left;
struct node_s* right;
} *node;
node tree(int v, node l, node r)
{
node n = malloc(sizeof(struct node_s));
n->value = v;
n->left = l;
n->right = r;
return n;
}
void destroy_tree(node n)
{
if (n->left)
... |
Produce a language-to-language conversion: from Ada to C++, same semantics. | with Ada.Text_Io; use Ada.Text_Io;
with Ada.Unchecked_Deallocation;
with Ada.Containers.Doubly_Linked_Lists;
procedure Tree_Traversal is
type Node;
type Node_Access is access Node;
type Node is record
Left : Node_Access := null;
Right : Node_Access := null;
Data : Integer;
end record;
... | #include <boost/scoped_ptr.hpp>
#include <iostream>
#include <queue>
template<typename T>
class TreeNode {
public:
TreeNode(const T& n, TreeNode* left = NULL, TreeNode* right = NULL)
: mValue(n),
mLeft(left),
mRight(right) {}
T getValue() const {
return mValue;
}
TreeNode* left() const {
... |
Generate an equivalent Go version of this Ada code. | with Ada.Text_Io; use Ada.Text_Io;
with Ada.Unchecked_Deallocation;
with Ada.Containers.Doubly_Linked_Lists;
procedure Tree_Traversal is
type Node;
type Node_Access is access Node;
type Node is record
Left : Node_Access := null;
Right : Node_Access := null;
Data : Integer;
end record;
... | package main
import "fmt"
type node struct {
value int
left, right *node
}
func (n *node) iterPreorder(visit func(int)) {
if n == nil {
return
}
visit(n.value)
n.left.iterPreorder(visit)
n.right.iterPreorder(visit)
}
func (n *node) iterInorder(visit func(int)) {
if ... |
Keep all operations the same but rewrite the snippet in Java. | with Ada.Text_Io; use Ada.Text_Io;
with Ada.Unchecked_Deallocation;
with Ada.Containers.Doubly_Linked_Lists;
procedure Tree_Traversal is
type Node;
type Node_Access is access Node;
type Node is record
Left : Node_Access := null;
Right : Node_Access := null;
Data : Integer;
end record;
... | import java.util.*;
public class TreeTraversal {
static class Node<T> {
T value;
Node<T> left;
Node<T> right;
Node(T value) {
this.value = value;
}
void visit() {
System.out.print(this.value + " ");
}
}
static enum ORDER {
PREORDER, INORDER, POSTORDER, LEVEL
}
stat... |
Translate the given Ada code snippet into Python without altering its behavior. | with Ada.Text_Io; use Ada.Text_Io;
with Ada.Unchecked_Deallocation;
with Ada.Containers.Doubly_Linked_Lists;
procedure Tree_Traversal is
type Node;
type Node_Access is access Node;
type Node is record
Left : Node_Access := null;
Right : Node_Access := null;
Data : Integer;
end record;
... | from collections import namedtuple
Node = namedtuple('Node', 'data, left, right')
tree = Node(1,
Node(2,
Node(4,
Node(7, None, None),
None),
Node(5, None, None)),
Node(3,
Node(6,
... |
Generate an equivalent VB version of this Ada code. | with Ada.Text_Io; use Ada.Text_Io;
with Ada.Unchecked_Deallocation;
with Ada.Containers.Doubly_Linked_Lists;
procedure Tree_Traversal is
type Node;
type Node_Access is access Node;
type Node is record
Left : Node_Access := null;
Right : Node_Access := null;
Data : Integer;
end record;
... | Public Value As Integer
Public LeftChild As TreeItem
Public RightChild As TreeItem
|
Please provide an equivalent version of this Arturo code in C. | tree: [1 [2 [4 [7 [] []] []] [5 [] []]] [3 [6 [8 [] []] [9 [] []]] []]]
tree: [1 [2 [4 [7 ] ] [5 ]] [3 [6 [8 ] [9 ]] ]]
visit: func [tree [block!]][prin rejoin [first tree " "]]
left: :second
right: :third
preorder: func [tree [block!]][
if not empty? tree [visit tree]
attempt [preorder left tree]
attempt [pr... | #include <stdlib.h>
#include <stdio.h>
typedef struct node_s
{
int value;
struct node_s* left;
struct node_s* right;
} *node;
node tree(int v, node l, node r)
{
node n = malloc(sizeof(struct node_s));
n->value = v;
n->left = l;
n->right = r;
return n;
}
void destroy_tree(node n)
{
if (n->left)
... |
Write a version of this Arturo function in C# with identical behavior. | tree: [1 [2 [4 [7 [] []] []] [5 [] []]] [3 [6 [8 [] []] [9 [] []]] []]]
tree: [1 [2 [4 [7 ] ] [5 ]] [3 [6 [8 ] [9 ]] ]]
visit: func [tree [block!]][prin rejoin [first tree " "]]
left: :second
right: :third
preorder: func [tree [block!]][
if not empty? tree [visit tree]
attempt [preorder left tree]
attempt [pr... | using System;
using System.Collections.Generic;
using System.Linq;
class Node
{
int Value;
Node Left;
Node Right;
Node(int value = default(int), Node left = default(Node), Node right = default(Node))
{
Value = value;
Left = left;
Right = right;
}
IEnumerable<int> P... |
Produce a functionally identical C++ code for the snippet given in Arturo. | tree: [1 [2 [4 [7 [] []] []] [5 [] []]] [3 [6 [8 [] []] [9 [] []]] []]]
tree: [1 [2 [4 [7 ] ] [5 ]] [3 [6 [8 ] [9 ]] ]]
visit: func [tree [block!]][prin rejoin [first tree " "]]
left: :second
right: :third
preorder: func [tree [block!]][
if not empty? tree [visit tree]
attempt [preorder left tree]
attempt [pr... | #include <boost/scoped_ptr.hpp>
#include <iostream>
#include <queue>
template<typename T>
class TreeNode {
public:
TreeNode(const T& n, TreeNode* left = NULL, TreeNode* right = NULL)
: mValue(n),
mLeft(left),
mRight(right) {}
T getValue() const {
return mValue;
}
TreeNode* left() const {
... |
Write the same algorithm in Java as shown in this Arturo implementation. | tree: [1 [2 [4 [7 [] []] []] [5 [] []]] [3 [6 [8 [] []] [9 [] []]] []]]
tree: [1 [2 [4 [7 ] ] [5 ]] [3 [6 [8 ] [9 ]] ]]
visit: func [tree [block!]][prin rejoin [first tree " "]]
left: :second
right: :third
preorder: func [tree [block!]][
if not empty? tree [visit tree]
attempt [preorder left tree]
attempt [pr... | import java.util.*;
public class TreeTraversal {
static class Node<T> {
T value;
Node<T> left;
Node<T> right;
Node(T value) {
this.value = value;
}
void visit() {
System.out.print(this.value + " ");
}
}
static enum ORDER {
PREORDER, INORDER, POSTORDER, LEVEL
}
stat... |
Maintain the same structure and functionality when rewriting this code in Python. | tree: [1 [2 [4 [7 [] []] []] [5 [] []]] [3 [6 [8 [] []] [9 [] []]] []]]
tree: [1 [2 [4 [7 ] ] [5 ]] [3 [6 [8 ] [9 ]] ]]
visit: func [tree [block!]][prin rejoin [first tree " "]]
left: :second
right: :third
preorder: func [tree [block!]][
if not empty? tree [visit tree]
attempt [preorder left tree]
attempt [pr... | from collections import namedtuple
Node = namedtuple('Node', 'data, left, right')
tree = Node(1,
Node(2,
Node(4,
Node(7, None, None),
None),
Node(5, None, None)),
Node(3,
Node(6,
... |
Write the same code in VB as shown below in Arturo. | tree: [1 [2 [4 [7 [] []] []] [5 [] []]] [3 [6 [8 [] []] [9 [] []]] []]]
tree: [1 [2 [4 [7 ] ] [5 ]] [3 [6 [8 ] [9 ]] ]]
visit: func [tree [block!]][prin rejoin [first tree " "]]
left: :second
right: :third
preorder: func [tree [block!]][
if not empty? tree [visit tree]
attempt [preorder left tree]
attempt [pr... | Public Value As Integer
Public LeftChild As TreeItem
Public RightChild As TreeItem
|
Translate the given Arturo code snippet into Go without altering its behavior. | tree: [1 [2 [4 [7 [] []] []] [5 [] []]] [3 [6 [8 [] []] [9 [] []]] []]]
tree: [1 [2 [4 [7 ] ] [5 ]] [3 [6 [8 ] [9 ]] ]]
visit: func [tree [block!]][prin rejoin [first tree " "]]
left: :second
right: :third
preorder: func [tree [block!]][
if not empty? tree [visit tree]
attempt [preorder left tree]
attempt [pr... | package main
import "fmt"
type node struct {
value int
left, right *node
}
func (n *node) iterPreorder(visit func(int)) {
if n == nil {
return
}
visit(n.value)
n.left.iterPreorder(visit)
n.right.iterPreorder(visit)
}
func (n *node) iterInorder(visit func(int)) {
if ... |
Produce a language-to-language conversion: from AutoHotKey to C, same semantics. | AddNode(Tree,1,2,3,1)
AddNode(Tree,2,4,5,2)
AddNode(Tree,3,6,0,3)
AddNode(Tree,4,7,0,4)
AddNode(Tree,5,0,0,5)
AddNode(Tree,6,8,9,6)
AddNode(Tree,7,0,0,7)
AddNode(Tree,8,0,0,8)
AddNode(Tree,9,0,0,9)
MsgBox % "Preorder: " PreOrder(Tree,1)
MsgBox % "Inorder: " InOrder(Tree,1)
MsgBox % "postorder: " PostOrder(... | #include <stdlib.h>
#include <stdio.h>
typedef struct node_s
{
int value;
struct node_s* left;
struct node_s* right;
} *node;
node tree(int v, node l, node r)
{
node n = malloc(sizeof(struct node_s));
n->value = v;
n->left = l;
n->right = r;
return n;
}
void destroy_tree(node n)
{
if (n->left)
... |
Please provide an equivalent version of this AutoHotKey code in C#. | AddNode(Tree,1,2,3,1)
AddNode(Tree,2,4,5,2)
AddNode(Tree,3,6,0,3)
AddNode(Tree,4,7,0,4)
AddNode(Tree,5,0,0,5)
AddNode(Tree,6,8,9,6)
AddNode(Tree,7,0,0,7)
AddNode(Tree,8,0,0,8)
AddNode(Tree,9,0,0,9)
MsgBox % "Preorder: " PreOrder(Tree,1)
MsgBox % "Inorder: " InOrder(Tree,1)
MsgBox % "postorder: " PostOrder(... | using System;
using System.Collections.Generic;
using System.Linq;
class Node
{
int Value;
Node Left;
Node Right;
Node(int value = default(int), Node left = default(Node), Node right = default(Node))
{
Value = value;
Left = left;
Right = right;
}
IEnumerable<int> P... |
Port the provided AutoHotKey code into C++ while preserving the original functionality. | AddNode(Tree,1,2,3,1)
AddNode(Tree,2,4,5,2)
AddNode(Tree,3,6,0,3)
AddNode(Tree,4,7,0,4)
AddNode(Tree,5,0,0,5)
AddNode(Tree,6,8,9,6)
AddNode(Tree,7,0,0,7)
AddNode(Tree,8,0,0,8)
AddNode(Tree,9,0,0,9)
MsgBox % "Preorder: " PreOrder(Tree,1)
MsgBox % "Inorder: " InOrder(Tree,1)
MsgBox % "postorder: " PostOrder(... | #include <boost/scoped_ptr.hpp>
#include <iostream>
#include <queue>
template<typename T>
class TreeNode {
public:
TreeNode(const T& n, TreeNode* left = NULL, TreeNode* right = NULL)
: mValue(n),
mLeft(left),
mRight(right) {}
T getValue() const {
return mValue;
}
TreeNode* left() const {
... |
Convert this AutoHotKey block to Java, preserving its control flow and logic. | AddNode(Tree,1,2,3,1)
AddNode(Tree,2,4,5,2)
AddNode(Tree,3,6,0,3)
AddNode(Tree,4,7,0,4)
AddNode(Tree,5,0,0,5)
AddNode(Tree,6,8,9,6)
AddNode(Tree,7,0,0,7)
AddNode(Tree,8,0,0,8)
AddNode(Tree,9,0,0,9)
MsgBox % "Preorder: " PreOrder(Tree,1)
MsgBox % "Inorder: " InOrder(Tree,1)
MsgBox % "postorder: " PostOrder(... | import java.util.*;
public class TreeTraversal {
static class Node<T> {
T value;
Node<T> left;
Node<T> right;
Node(T value) {
this.value = value;
}
void visit() {
System.out.print(this.value + " ");
}
}
static enum ORDER {
PREORDER, INORDER, POSTORDER, LEVEL
}
stat... |
Convert the following code from AutoHotKey to Python, ensuring the logic remains intact. | AddNode(Tree,1,2,3,1)
AddNode(Tree,2,4,5,2)
AddNode(Tree,3,6,0,3)
AddNode(Tree,4,7,0,4)
AddNode(Tree,5,0,0,5)
AddNode(Tree,6,8,9,6)
AddNode(Tree,7,0,0,7)
AddNode(Tree,8,0,0,8)
AddNode(Tree,9,0,0,9)
MsgBox % "Preorder: " PreOrder(Tree,1)
MsgBox % "Inorder: " InOrder(Tree,1)
MsgBox % "postorder: " PostOrder(... | from collections import namedtuple
Node = namedtuple('Node', 'data, left, right')
tree = Node(1,
Node(2,
Node(4,
Node(7, None, None),
None),
Node(5, None, None)),
Node(3,
Node(6,
... |
Maintain the same structure and functionality when rewriting this code in VB. | AddNode(Tree,1,2,3,1)
AddNode(Tree,2,4,5,2)
AddNode(Tree,3,6,0,3)
AddNode(Tree,4,7,0,4)
AddNode(Tree,5,0,0,5)
AddNode(Tree,6,8,9,6)
AddNode(Tree,7,0,0,7)
AddNode(Tree,8,0,0,8)
AddNode(Tree,9,0,0,9)
MsgBox % "Preorder: " PreOrder(Tree,1)
MsgBox % "Inorder: " InOrder(Tree,1)
MsgBox % "postorder: " PostOrder(... | Public Value As Integer
Public LeftChild As TreeItem
Public RightChild As TreeItem
|
Translate the given AutoHotKey code snippet into Go without altering its behavior. | AddNode(Tree,1,2,3,1)
AddNode(Tree,2,4,5,2)
AddNode(Tree,3,6,0,3)
AddNode(Tree,4,7,0,4)
AddNode(Tree,5,0,0,5)
AddNode(Tree,6,8,9,6)
AddNode(Tree,7,0,0,7)
AddNode(Tree,8,0,0,8)
AddNode(Tree,9,0,0,9)
MsgBox % "Preorder: " PreOrder(Tree,1)
MsgBox % "Inorder: " InOrder(Tree,1)
MsgBox % "postorder: " PostOrder(... | package main
import "fmt"
type node struct {
value int
left, right *node
}
func (n *node) iterPreorder(visit func(int)) {
if n == nil {
return
}
visit(n.value)
n.left.iterPreorder(visit)
n.right.iterPreorder(visit)
}
func (n *node) iterInorder(visit func(int)) {
if ... |
Keep all operations the same but rewrite the snippet in C. | function preorder(tree, node, res, child) {
if (node == "")
return
res[res["count"]++] = node
split(tree[node], child, ",")
preorder(tree,child[1],res)
preorder(tree,child[2],res)
}
function inorder(tree, node, res, child) {
if (node == "")
return
split(tree[no... | #include <stdlib.h>
#include <stdio.h>
typedef struct node_s
{
int value;
struct node_s* left;
struct node_s* right;
} *node;
node tree(int v, node l, node r)
{
node n = malloc(sizeof(struct node_s));
n->value = v;
n->left = l;
n->right = r;
return n;
}
void destroy_tree(node n)
{
if (n->left)
... |
Produce a functionally identical C# code for the snippet given in AWK. | function preorder(tree, node, res, child) {
if (node == "")
return
res[res["count"]++] = node
split(tree[node], child, ",")
preorder(tree,child[1],res)
preorder(tree,child[2],res)
}
function inorder(tree, node, res, child) {
if (node == "")
return
split(tree[no... | using System;
using System.Collections.Generic;
using System.Linq;
class Node
{
int Value;
Node Left;
Node Right;
Node(int value = default(int), Node left = default(Node), Node right = default(Node))
{
Value = value;
Left = left;
Right = right;
}
IEnumerable<int> P... |
Convert this AWK block to C++, preserving its control flow and logic. | function preorder(tree, node, res, child) {
if (node == "")
return
res[res["count"]++] = node
split(tree[node], child, ",")
preorder(tree,child[1],res)
preorder(tree,child[2],res)
}
function inorder(tree, node, res, child) {
if (node == "")
return
split(tree[no... | #include <boost/scoped_ptr.hpp>
#include <iostream>
#include <queue>
template<typename T>
class TreeNode {
public:
TreeNode(const T& n, TreeNode* left = NULL, TreeNode* right = NULL)
: mValue(n),
mLeft(left),
mRight(right) {}
T getValue() const {
return mValue;
}
TreeNode* left() const {
... |
Convert this AWK block to Java, preserving its control flow and logic. | function preorder(tree, node, res, child) {
if (node == "")
return
res[res["count"]++] = node
split(tree[node], child, ",")
preorder(tree,child[1],res)
preorder(tree,child[2],res)
}
function inorder(tree, node, res, child) {
if (node == "")
return
split(tree[no... | import java.util.*;
public class TreeTraversal {
static class Node<T> {
T value;
Node<T> left;
Node<T> right;
Node(T value) {
this.value = value;
}
void visit() {
System.out.print(this.value + " ");
}
}
static enum ORDER {
PREORDER, INORDER, POSTORDER, LEVEL
}
stat... |
Write a version of this AWK function in Python with identical behavior. | function preorder(tree, node, res, child) {
if (node == "")
return
res[res["count"]++] = node
split(tree[node], child, ",")
preorder(tree,child[1],res)
preorder(tree,child[2],res)
}
function inorder(tree, node, res, child) {
if (node == "")
return
split(tree[no... | from collections import namedtuple
Node = namedtuple('Node', 'data, left, right')
tree = Node(1,
Node(2,
Node(4,
Node(7, None, None),
None),
Node(5, None, None)),
Node(3,
Node(6,
... |
Change the programming language of this snippet from AWK to VB without modifying what it does. | function preorder(tree, node, res, child) {
if (node == "")
return
res[res["count"]++] = node
split(tree[node], child, ",")
preorder(tree,child[1],res)
preorder(tree,child[2],res)
}
function inorder(tree, node, res, child) {
if (node == "")
return
split(tree[no... | Public Value As Integer
Public LeftChild As TreeItem
Public RightChild As TreeItem
|
Preserve the algorithm and functionality while converting the code from AWK to Go. | function preorder(tree, node, res, child) {
if (node == "")
return
res[res["count"]++] = node
split(tree[node], child, ",")
preorder(tree,child[1],res)
preorder(tree,child[2],res)
}
function inorder(tree, node, res, child) {
if (node == "")
return
split(tree[no... | package main
import "fmt"
type node struct {
value int
left, right *node
}
func (n *node) iterPreorder(visit func(int)) {
if n == nil {
return
}
visit(n.value)
n.left.iterPreorder(visit)
n.right.iterPreorder(visit)
}
func (n *node) iterInorder(visit func(int)) {
if ... |
Change the following Clojure code into C without altering its purpose. | (defn walk [node f order]
(when node
(doseq [o order]
(if (= o :visit)
(f (:val node))
(walk (node o) f order)))))
(defn preorder [node f]
(walk node f [:visit :left :right]))
(defn inorder [node f]
(walk node f [:left :visit :right]))
(defn postorder [node f]
(walk node f [:left :right... | #include <stdlib.h>
#include <stdio.h>
typedef struct node_s
{
int value;
struct node_s* left;
struct node_s* right;
} *node;
node tree(int v, node l, node r)
{
node n = malloc(sizeof(struct node_s));
n->value = v;
n->left = l;
n->right = r;
return n;
}
void destroy_tree(node n)
{
if (n->left)
... |
Rewrite this program in C# while keeping its functionality equivalent to the Clojure version. | (defn walk [node f order]
(when node
(doseq [o order]
(if (= o :visit)
(f (:val node))
(walk (node o) f order)))))
(defn preorder [node f]
(walk node f [:visit :left :right]))
(defn inorder [node f]
(walk node f [:left :visit :right]))
(defn postorder [node f]
(walk node f [:left :right... | using System;
using System.Collections.Generic;
using System.Linq;
class Node
{
int Value;
Node Left;
Node Right;
Node(int value = default(int), Node left = default(Node), Node right = default(Node))
{
Value = value;
Left = left;
Right = right;
}
IEnumerable<int> P... |
Write a version of this Clojure function in C++ with identical behavior. | (defn walk [node f order]
(when node
(doseq [o order]
(if (= o :visit)
(f (:val node))
(walk (node o) f order)))))
(defn preorder [node f]
(walk node f [:visit :left :right]))
(defn inorder [node f]
(walk node f [:left :visit :right]))
(defn postorder [node f]
(walk node f [:left :right... | #include <boost/scoped_ptr.hpp>
#include <iostream>
#include <queue>
template<typename T>
class TreeNode {
public:
TreeNode(const T& n, TreeNode* left = NULL, TreeNode* right = NULL)
: mValue(n),
mLeft(left),
mRight(right) {}
T getValue() const {
return mValue;
}
TreeNode* left() const {
... |
Rewrite the snippet below in Java so it works the same as the original Clojure code. | (defn walk [node f order]
(when node
(doseq [o order]
(if (= o :visit)
(f (:val node))
(walk (node o) f order)))))
(defn preorder [node f]
(walk node f [:visit :left :right]))
(defn inorder [node f]
(walk node f [:left :visit :right]))
(defn postorder [node f]
(walk node f [:left :right... | import java.util.*;
public class TreeTraversal {
static class Node<T> {
T value;
Node<T> left;
Node<T> right;
Node(T value) {
this.value = value;
}
void visit() {
System.out.print(this.value + " ");
}
}
static enum ORDER {
PREORDER, INORDER, POSTORDER, LEVEL
}
stat... |
Ensure the translated Python code behaves exactly like the original Clojure snippet. | (defn walk [node f order]
(when node
(doseq [o order]
(if (= o :visit)
(f (:val node))
(walk (node o) f order)))))
(defn preorder [node f]
(walk node f [:visit :left :right]))
(defn inorder [node f]
(walk node f [:left :visit :right]))
(defn postorder [node f]
(walk node f [:left :right... | from collections import namedtuple
Node = namedtuple('Node', 'data, left, right')
tree = Node(1,
Node(2,
Node(4,
Node(7, None, None),
None),
Node(5, None, None)),
Node(3,
Node(6,
... |
Convert the following code from Clojure to VB, ensuring the logic remains intact. | (defn walk [node f order]
(when node
(doseq [o order]
(if (= o :visit)
(f (:val node))
(walk (node o) f order)))))
(defn preorder [node f]
(walk node f [:visit :left :right]))
(defn inorder [node f]
(walk node f [:left :visit :right]))
(defn postorder [node f]
(walk node f [:left :right... | Public Value As Integer
Public LeftChild As TreeItem
Public RightChild As TreeItem
|
Generate an equivalent Go version of this Clojure code. | (defn walk [node f order]
(when node
(doseq [o order]
(if (= o :visit)
(f (:val node))
(walk (node o) f order)))))
(defn preorder [node f]
(walk node f [:visit :left :right]))
(defn inorder [node f]
(walk node f [:left :visit :right]))
(defn postorder [node f]
(walk node f [:left :right... | package main
import "fmt"
type node struct {
value int
left, right *node
}
func (n *node) iterPreorder(visit func(int)) {
if n == nil {
return
}
visit(n.value)
n.left.iterPreorder(visit)
n.right.iterPreorder(visit)
}
func (n *node) iterInorder(visit func(int)) {
if ... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.