Instruction stringlengths 45 106 | input_code stringlengths 1 13.7k | output_code stringlengths 1 13.7k |
|---|---|---|
Ensure the translated Java code behaves exactly like the original Pascal snippet. |
uses
strUtils;
var
line: string;
c: char;
begin
readLn(line);
for c in ['A', 'E', 'I', 'O', 'U', 'a', 'e', 'i', 'o', 'u'] do
begin
line := delChars(line, c)
end;
writeLn(line)
end.
| public static String removeVowelse(String str){
String re = "";
char c;
for(int x = 0; x<str.length(); x++){
c = str.charAt(x);
if(!(c=='a'||c=='e'||c=='i'||c=='o'||c=='u'))
re+=c;
}
return re;
}
|
Rewrite the snippet below in Java so it works the same as the original Pascal code. |
uses
strUtils;
var
line: string;
c: char;
begin
readLn(line);
for c in ['A', 'E', 'I', 'O', 'U', 'a', 'e', 'i', 'o', 'u'] do
begin
line := delChars(line, c)
end;
writeLn(line)
end.
| public static String removeVowelse(String str){
String re = "";
char c;
for(int x = 0; x<str.length(); x++){
c = str.charAt(x);
if(!(c=='a'||c=='e'||c=='i'||c=='o'||c=='u'))
re+=c;
}
return re;
}
|
Rewrite the snippet below in Python so it works the same as the original Pascal code. |
uses
strUtils;
var
line: string;
c: char;
begin
readLn(line);
for c in ['A', 'E', 'I', 'O', 'U', 'a', 'e', 'i', 'o', 'u'] do
begin
line := delChars(line, c)
end;
writeLn(line)
end.
|
def exceptGlyphs(exclusions):
def go(s):
return ''.join(
c for c in s if c not in exclusions
)
return go
def main():
txt =
print(
exceptGlyphs('eau')(txt)
)
if __name__ == '__main__':
main()
|
Produce a language-to-language conversion: from Pascal to Python, same semantics. |
uses
strUtils;
var
line: string;
c: char;
begin
readLn(line);
for c in ['A', 'E', 'I', 'O', 'U', 'a', 'e', 'i', 'o', 'u'] do
begin
line := delChars(line, c)
end;
writeLn(line)
end.
|
def exceptGlyphs(exclusions):
def go(s):
return ''.join(
c for c in s if c not in exclusions
)
return go
def main():
txt =
print(
exceptGlyphs('eau')(txt)
)
if __name__ == '__main__':
main()
|
Translate this program into VB but keep the logic exactly as in Pascal. |
uses
strUtils;
var
line: string;
c: char;
begin
readLn(line);
for c in ['A', 'E', 'I', 'O', 'U', 'a', 'e', 'i', 'o', 'u'] do
begin
line := delChars(line, c)
end;
writeLn(line)
end.
| Imports System.Text
Module Module1
Function RemoveVowels(s As String) As String
Dim sb As New StringBuilder
For Each c In s
Select Case c
Case "A", "a"
Case "E", "e"
Case "I", "i"
Case "O", "o"
Case "U", "u... |
Convert this Pascal snippet to VB and keep its semantics consistent. |
uses
strUtils;
var
line: string;
c: char;
begin
readLn(line);
for c in ['A', 'E', 'I', 'O', 'U', 'a', 'e', 'i', 'o', 'u'] do
begin
line := delChars(line, c)
end;
writeLn(line)
end.
| Imports System.Text
Module Module1
Function RemoveVowels(s As String) As String
Dim sb As New StringBuilder
For Each c In s
Select Case c
Case "A", "a"
Case "E", "e"
Case "I", "i"
Case "O", "o"
Case "U", "u... |
Can you help me rewrite this code in Go instead of Pascal, keeping it the same logically? |
uses
strUtils;
var
line: string;
c: char;
begin
readLn(line);
for c in ['A', 'E', 'I', 'O', 'U', 'a', 'e', 'i', 'o', 'u'] do
begin
line := delChars(line, c)
end;
writeLn(line)
end.
| package main
import (
"fmt"
"strings"
)
func removeVowels(s string) string {
var sb strings.Builder
vowels := "aeiouAEIOU"
for _, c := range s {
if !strings.ContainsAny(string(c), vowels) {
sb.WriteRune(c)
}
}
return sb.String()
}
func main() {
s := "Go Pro... |
Convert this Pascal snippet to Go and keep its semantics consistent. |
uses
strUtils;
var
line: string;
c: char;
begin
readLn(line);
for c in ['A', 'E', 'I', 'O', 'U', 'a', 'e', 'i', 'o', 'u'] do
begin
line := delChars(line, c)
end;
writeLn(line)
end.
| package main
import (
"fmt"
"strings"
)
func removeVowels(s string) string {
var sb strings.Builder
vowels := "aeiouAEIOU"
for _, c := range s {
if !strings.ContainsAny(string(c), vowels) {
sb.WriteRune(c)
}
}
return sb.String()
}
func main() {
s := "Go Pro... |
Rewrite this program in C while keeping its functionality equivalent to the Perl version. | use strict;
use warnings;
use utf8;
binmode STDOUT, ":utf8";
use Unicode::Normalize;
my $text = <<~'END';
Norwegian, Icelandic, German, Turkish, French, Spanish, English:
Undervisningen skal være gratis, i det minste på de elementære og grunnleggende trinn.
Skal hún veitt ókeypis, að minnsta kosti barnafræ... | #include <stdio.h>
void print_no_vowels(const char *s) {
for (; *s != 0; s++) {
switch (*s) {
case 'A':
case 'E':
case 'I':
case 'O':
case 'U':
case 'a':
case 'e':
case 'i':
case 'o':
case 'u':
break;
defaul... |
Preserve the algorithm and functionality while converting the code from Perl to C. | use strict;
use warnings;
use utf8;
binmode STDOUT, ":utf8";
use Unicode::Normalize;
my $text = <<~'END';
Norwegian, Icelandic, German, Turkish, French, Spanish, English:
Undervisningen skal være gratis, i det minste på de elementære og grunnleggende trinn.
Skal hún veitt ókeypis, að minnsta kosti barnafræ... | #include <stdio.h>
void print_no_vowels(const char *s) {
for (; *s != 0; s++) {
switch (*s) {
case 'A':
case 'E':
case 'I':
case 'O':
case 'U':
case 'a':
case 'e':
case 'i':
case 'o':
case 'u':
break;
defaul... |
Rewrite this program in C# while keeping its functionality equivalent to the Perl version. | use strict;
use warnings;
use utf8;
binmode STDOUT, ":utf8";
use Unicode::Normalize;
my $text = <<~'END';
Norwegian, Icelandic, German, Turkish, French, Spanish, English:
Undervisningen skal være gratis, i det minste på de elementære og grunnleggende trinn.
Skal hún veitt ókeypis, að minnsta kosti barnafræ... | static string remove_vowels(string value)
{
var stripped = from c in value.ToCharArray()
where !"aeiouAEIOU".Contains(c)
select c;
return new string(stripped.ToArray());
}
static void test(string value)
{
Console.WriteLine("Input: " + value);
Console.WriteLine("O... |
Please provide an equivalent version of this Perl code in C#. | use strict;
use warnings;
use utf8;
binmode STDOUT, ":utf8";
use Unicode::Normalize;
my $text = <<~'END';
Norwegian, Icelandic, German, Turkish, French, Spanish, English:
Undervisningen skal være gratis, i det minste på de elementære og grunnleggende trinn.
Skal hún veitt ókeypis, að minnsta kosti barnafræ... | static string remove_vowels(string value)
{
var stripped = from c in value.ToCharArray()
where !"aeiouAEIOU".Contains(c)
select c;
return new string(stripped.ToArray());
}
static void test(string value)
{
Console.WriteLine("Input: " + value);
Console.WriteLine("O... |
Convert the following code from Perl to C++, ensuring the logic remains intact. | use strict;
use warnings;
use utf8;
binmode STDOUT, ":utf8";
use Unicode::Normalize;
my $text = <<~'END';
Norwegian, Icelandic, German, Turkish, French, Spanish, English:
Undervisningen skal være gratis, i det minste på de elementære og grunnleggende trinn.
Skal hún veitt ókeypis, að minnsta kosti barnafræ... | #include <algorithm>
#include <iostream>
class print_no_vowels {
private:
const std::string &str;
public:
print_no_vowels(const std::string &s) : str(s) {}
friend std::ostream &operator<<(std::ostream &, print_no_vowels);
};
std::ostream &operator<<(std::ostream &os, print_no_vowels pnv) {
auto it = p... |
Translate this program into C++ but keep the logic exactly as in Perl. | use strict;
use warnings;
use utf8;
binmode STDOUT, ":utf8";
use Unicode::Normalize;
my $text = <<~'END';
Norwegian, Icelandic, German, Turkish, French, Spanish, English:
Undervisningen skal være gratis, i det minste på de elementære og grunnleggende trinn.
Skal hún veitt ókeypis, að minnsta kosti barnafræ... | #include <algorithm>
#include <iostream>
class print_no_vowels {
private:
const std::string &str;
public:
print_no_vowels(const std::string &s) : str(s) {}
friend std::ostream &operator<<(std::ostream &, print_no_vowels);
};
std::ostream &operator<<(std::ostream &os, print_no_vowels pnv) {
auto it = p... |
Translate the given Perl code snippet into Java without altering its behavior. | use strict;
use warnings;
use utf8;
binmode STDOUT, ":utf8";
use Unicode::Normalize;
my $text = <<~'END';
Norwegian, Icelandic, German, Turkish, French, Spanish, English:
Undervisningen skal være gratis, i det minste på de elementære og grunnleggende trinn.
Skal hún veitt ókeypis, að minnsta kosti barnafræ... | public static String removeVowelse(String str){
String re = "";
char c;
for(int x = 0; x<str.length(); x++){
c = str.charAt(x);
if(!(c=='a'||c=='e'||c=='i'||c=='o'||c=='u'))
re+=c;
}
return re;
}
|
Rewrite the snippet below in Java so it works the same as the original Perl code. | use strict;
use warnings;
use utf8;
binmode STDOUT, ":utf8";
use Unicode::Normalize;
my $text = <<~'END';
Norwegian, Icelandic, German, Turkish, French, Spanish, English:
Undervisningen skal være gratis, i det minste på de elementære og grunnleggende trinn.
Skal hún veitt ókeypis, að minnsta kosti barnafræ... | public static String removeVowelse(String str){
String re = "";
char c;
for(int x = 0; x<str.length(); x++){
c = str.charAt(x);
if(!(c=='a'||c=='e'||c=='i'||c=='o'||c=='u'))
re+=c;
}
return re;
}
|
Transform the following Perl implementation into Python, maintaining the same output and logic. | use strict;
use warnings;
use utf8;
binmode STDOUT, ":utf8";
use Unicode::Normalize;
my $text = <<~'END';
Norwegian, Icelandic, German, Turkish, French, Spanish, English:
Undervisningen skal være gratis, i det minste på de elementære og grunnleggende trinn.
Skal hún veitt ókeypis, að minnsta kosti barnafræ... |
def exceptGlyphs(exclusions):
def go(s):
return ''.join(
c for c in s if c not in exclusions
)
return go
def main():
txt =
print(
exceptGlyphs('eau')(txt)
)
if __name__ == '__main__':
main()
|
Can you help me rewrite this code in Python instead of Perl, keeping it the same logically? | use strict;
use warnings;
use utf8;
binmode STDOUT, ":utf8";
use Unicode::Normalize;
my $text = <<~'END';
Norwegian, Icelandic, German, Turkish, French, Spanish, English:
Undervisningen skal være gratis, i det minste på de elementære og grunnleggende trinn.
Skal hún veitt ókeypis, að minnsta kosti barnafræ... |
def exceptGlyphs(exclusions):
def go(s):
return ''.join(
c for c in s if c not in exclusions
)
return go
def main():
txt =
print(
exceptGlyphs('eau')(txt)
)
if __name__ == '__main__':
main()
|
Produce a language-to-language conversion: from Perl to VB, same semantics. | use strict;
use warnings;
use utf8;
binmode STDOUT, ":utf8";
use Unicode::Normalize;
my $text = <<~'END';
Norwegian, Icelandic, German, Turkish, French, Spanish, English:
Undervisningen skal være gratis, i det minste på de elementære og grunnleggende trinn.
Skal hún veitt ókeypis, að minnsta kosti barnafræ... | Imports System.Text
Module Module1
Function RemoveVowels(s As String) As String
Dim sb As New StringBuilder
For Each c In s
Select Case c
Case "A", "a"
Case "E", "e"
Case "I", "i"
Case "O", "o"
Case "U", "u... |
Keep all operations the same but rewrite the snippet in VB. | use strict;
use warnings;
use utf8;
binmode STDOUT, ":utf8";
use Unicode::Normalize;
my $text = <<~'END';
Norwegian, Icelandic, German, Turkish, French, Spanish, English:
Undervisningen skal være gratis, i det minste på de elementære og grunnleggende trinn.
Skal hún veitt ókeypis, að minnsta kosti barnafræ... | Imports System.Text
Module Module1
Function RemoveVowels(s As String) As String
Dim sb As New StringBuilder
For Each c In s
Select Case c
Case "A", "a"
Case "E", "e"
Case "I", "i"
Case "O", "o"
Case "U", "u... |
Translate this program into Go but keep the logic exactly as in Perl. | use strict;
use warnings;
use utf8;
binmode STDOUT, ":utf8";
use Unicode::Normalize;
my $text = <<~'END';
Norwegian, Icelandic, German, Turkish, French, Spanish, English:
Undervisningen skal være gratis, i det minste på de elementære og grunnleggende trinn.
Skal hún veitt ókeypis, að minnsta kosti barnafræ... | package main
import (
"fmt"
"strings"
)
func removeVowels(s string) string {
var sb strings.Builder
vowels := "aeiouAEIOU"
for _, c := range s {
if !strings.ContainsAny(string(c), vowels) {
sb.WriteRune(c)
}
}
return sb.String()
}
func main() {
s := "Go Pro... |
Convert this Perl snippet to Go and keep its semantics consistent. | use strict;
use warnings;
use utf8;
binmode STDOUT, ":utf8";
use Unicode::Normalize;
my $text = <<~'END';
Norwegian, Icelandic, German, Turkish, French, Spanish, English:
Undervisningen skal være gratis, i det minste på de elementære og grunnleggende trinn.
Skal hún veitt ókeypis, að minnsta kosti barnafræ... | package main
import (
"fmt"
"strings"
)
func removeVowels(s string) string {
var sb strings.Builder
vowels := "aeiouAEIOU"
for _, c := range s {
if !strings.ContainsAny(string(c), vowels) {
sb.WriteRune(c)
}
}
return sb.String()
}
func main() {
s := "Go Pro... |
Convert the following code from REXX to C, ensuring the logic remains intact. |
parse arg x
if x='' | x="," then x= 'REXX Programming Language'
say ' input string: ' x
vowels= 'AEIOUaeiou' || "üéâäàåçêëèïîìÄÅÉæÆôöòûùÿÖÜáíóúªºαΩ"
$= translate( xrange(), ., ' ')
q= substr($, verify($, x), 1)
y= translate(x, q, " ") ... | #include <stdio.h>
void print_no_vowels(const char *s) {
for (; *s != 0; s++) {
switch (*s) {
case 'A':
case 'E':
case 'I':
case 'O':
case 'U':
case 'a':
case 'e':
case 'i':
case 'o':
case 'u':
break;
defaul... |
Maintain the same structure and functionality when rewriting this code in C. |
parse arg x
if x='' | x="," then x= 'REXX Programming Language'
say ' input string: ' x
vowels= 'AEIOUaeiou' || "üéâäàåçêëèïîìÄÅÉæÆôöòûùÿÖÜáíóúªºαΩ"
$= translate( xrange(), ., ' ')
q= substr($, verify($, x), 1)
y= translate(x, q, " ") ... | #include <stdio.h>
void print_no_vowels(const char *s) {
for (; *s != 0; s++) {
switch (*s) {
case 'A':
case 'E':
case 'I':
case 'O':
case 'U':
case 'a':
case 'e':
case 'i':
case 'o':
case 'u':
break;
defaul... |
Write the same code in C# as shown below in REXX. |
parse arg x
if x='' | x="," then x= 'REXX Programming Language'
say ' input string: ' x
vowels= 'AEIOUaeiou' || "üéâäàåçêëèïîìÄÅÉæÆôöòûùÿÖÜáíóúªºαΩ"
$= translate( xrange(), ., ' ')
q= substr($, verify($, x), 1)
y= translate(x, q, " ") ... | static string remove_vowels(string value)
{
var stripped = from c in value.ToCharArray()
where !"aeiouAEIOU".Contains(c)
select c;
return new string(stripped.ToArray());
}
static void test(string value)
{
Console.WriteLine("Input: " + value);
Console.WriteLine("O... |
Preserve the algorithm and functionality while converting the code from REXX to C#. |
parse arg x
if x='' | x="," then x= 'REXX Programming Language'
say ' input string: ' x
vowels= 'AEIOUaeiou' || "üéâäàåçêëèïîìÄÅÉæÆôöòûùÿÖÜáíóúªºαΩ"
$= translate( xrange(), ., ' ')
q= substr($, verify($, x), 1)
y= translate(x, q, " ") ... | static string remove_vowels(string value)
{
var stripped = from c in value.ToCharArray()
where !"aeiouAEIOU".Contains(c)
select c;
return new string(stripped.ToArray());
}
static void test(string value)
{
Console.WriteLine("Input: " + value);
Console.WriteLine("O... |
Write the same code in C++ as shown below in REXX. |
parse arg x
if x='' | x="," then x= 'REXX Programming Language'
say ' input string: ' x
vowels= 'AEIOUaeiou' || "üéâäàåçêëèïîìÄÅÉæÆôöòûùÿÖÜáíóúªºαΩ"
$= translate( xrange(), ., ' ')
q= substr($, verify($, x), 1)
y= translate(x, q, " ") ... | #include <algorithm>
#include <iostream>
class print_no_vowels {
private:
const std::string &str;
public:
print_no_vowels(const std::string &s) : str(s) {}
friend std::ostream &operator<<(std::ostream &, print_no_vowels);
};
std::ostream &operator<<(std::ostream &os, print_no_vowels pnv) {
auto it = p... |
Port the following code from REXX to C++ with equivalent syntax and logic. |
parse arg x
if x='' | x="," then x= 'REXX Programming Language'
say ' input string: ' x
vowels= 'AEIOUaeiou' || "üéâäàåçêëèïîìÄÅÉæÆôöòûùÿÖÜáíóúªºαΩ"
$= translate( xrange(), ., ' ')
q= substr($, verify($, x), 1)
y= translate(x, q, " ") ... | #include <algorithm>
#include <iostream>
class print_no_vowels {
private:
const std::string &str;
public:
print_no_vowels(const std::string &s) : str(s) {}
friend std::ostream &operator<<(std::ostream &, print_no_vowels);
};
std::ostream &operator<<(std::ostream &os, print_no_vowels pnv) {
auto it = p... |
Change the following REXX code into Java without altering its purpose. |
parse arg x
if x='' | x="," then x= 'REXX Programming Language'
say ' input string: ' x
vowels= 'AEIOUaeiou' || "üéâäàåçêëèïîìÄÅÉæÆôöòûùÿÖÜáíóúªºαΩ"
$= translate( xrange(), ., ' ')
q= substr($, verify($, x), 1)
y= translate(x, q, " ") ... | public static String removeVowelse(String str){
String re = "";
char c;
for(int x = 0; x<str.length(); x++){
c = str.charAt(x);
if(!(c=='a'||c=='e'||c=='i'||c=='o'||c=='u'))
re+=c;
}
return re;
}
|
Port the provided REXX code into Java while preserving the original functionality. |
parse arg x
if x='' | x="," then x= 'REXX Programming Language'
say ' input string: ' x
vowels= 'AEIOUaeiou' || "üéâäàåçêëèïîìÄÅÉæÆôöòûùÿÖÜáíóúªºαΩ"
$= translate( xrange(), ., ' ')
q= substr($, verify($, x), 1)
y= translate(x, q, " ") ... | public static String removeVowelse(String str){
String re = "";
char c;
for(int x = 0; x<str.length(); x++){
c = str.charAt(x);
if(!(c=='a'||c=='e'||c=='i'||c=='o'||c=='u'))
re+=c;
}
return re;
}
|
Transform the following REXX implementation into Python, maintaining the same output and logic. |
parse arg x
if x='' | x="," then x= 'REXX Programming Language'
say ' input string: ' x
vowels= 'AEIOUaeiou' || "üéâäàåçêëèïîìÄÅÉæÆôöòûùÿÖÜáíóúªºαΩ"
$= translate( xrange(), ., ' ')
q= substr($, verify($, x), 1)
y= translate(x, q, " ") ... |
def exceptGlyphs(exclusions):
def go(s):
return ''.join(
c for c in s if c not in exclusions
)
return go
def main():
txt =
print(
exceptGlyphs('eau')(txt)
)
if __name__ == '__main__':
main()
|
Preserve the algorithm and functionality while converting the code from REXX to Python. |
parse arg x
if x='' | x="," then x= 'REXX Programming Language'
say ' input string: ' x
vowels= 'AEIOUaeiou' || "üéâäàåçêëèïîìÄÅÉæÆôöòûùÿÖÜáíóúªºαΩ"
$= translate( xrange(), ., ' ')
q= substr($, verify($, x), 1)
y= translate(x, q, " ") ... |
def exceptGlyphs(exclusions):
def go(s):
return ''.join(
c for c in s if c not in exclusions
)
return go
def main():
txt =
print(
exceptGlyphs('eau')(txt)
)
if __name__ == '__main__':
main()
|
Convert the following code from REXX to VB, ensuring the logic remains intact. |
parse arg x
if x='' | x="," then x= 'REXX Programming Language'
say ' input string: ' x
vowels= 'AEIOUaeiou' || "üéâäàåçêëèïîìÄÅÉæÆôöòûùÿÖÜáíóúªºαΩ"
$= translate( xrange(), ., ' ')
q= substr($, verify($, x), 1)
y= translate(x, q, " ") ... | Imports System.Text
Module Module1
Function RemoveVowels(s As String) As String
Dim sb As New StringBuilder
For Each c In s
Select Case c
Case "A", "a"
Case "E", "e"
Case "I", "i"
Case "O", "o"
Case "U", "u... |
Can you help me rewrite this code in VB instead of REXX, keeping it the same logically? |
parse arg x
if x='' | x="," then x= 'REXX Programming Language'
say ' input string: ' x
vowels= 'AEIOUaeiou' || "üéâäàåçêëèïîìÄÅÉæÆôöòûùÿÖÜáíóúªºαΩ"
$= translate( xrange(), ., ' ')
q= substr($, verify($, x), 1)
y= translate(x, q, " ") ... | Imports System.Text
Module Module1
Function RemoveVowels(s As String) As String
Dim sb As New StringBuilder
For Each c In s
Select Case c
Case "A", "a"
Case "E", "e"
Case "I", "i"
Case "O", "o"
Case "U", "u... |
Please provide an equivalent version of this REXX code in Go. |
parse arg x
if x='' | x="," then x= 'REXX Programming Language'
say ' input string: ' x
vowels= 'AEIOUaeiou' || "üéâäàåçêëèïîìÄÅÉæÆôöòûùÿÖÜáíóúªºαΩ"
$= translate( xrange(), ., ' ')
q= substr($, verify($, x), 1)
y= translate(x, q, " ") ... | package main
import (
"fmt"
"strings"
)
func removeVowels(s string) string {
var sb strings.Builder
vowels := "aeiouAEIOU"
for _, c := range s {
if !strings.ContainsAny(string(c), vowels) {
sb.WriteRune(c)
}
}
return sb.String()
}
func main() {
s := "Go Pro... |
Generate an equivalent Go version of this REXX code. |
parse arg x
if x='' | x="," then x= 'REXX Programming Language'
say ' input string: ' x
vowels= 'AEIOUaeiou' || "üéâäàåçêëèïîìÄÅÉæÆôöòûùÿÖÜáíóúªºαΩ"
$= translate( xrange(), ., ' ')
q= substr($, verify($, x), 1)
y= translate(x, q, " ") ... | package main
import (
"fmt"
"strings"
)
func removeVowels(s string) string {
var sb strings.Builder
vowels := "aeiouAEIOU"
for _, c := range s {
if !strings.ContainsAny(string(c), vowels) {
sb.WriteRune(c)
}
}
return sb.String()
}
func main() {
s := "Go Pro... |
Change the following Ruby code into C without altering its purpose. | p "Remove vowels from a string".delete("aeiouAEIOU")
| #include <stdio.h>
void print_no_vowels(const char *s) {
for (; *s != 0; s++) {
switch (*s) {
case 'A':
case 'E':
case 'I':
case 'O':
case 'U':
case 'a':
case 'e':
case 'i':
case 'o':
case 'u':
break;
defaul... |
Write the same code in C as shown below in Ruby. | p "Remove vowels from a string".delete("aeiouAEIOU")
| #include <stdio.h>
void print_no_vowels(const char *s) {
for (; *s != 0; s++) {
switch (*s) {
case 'A':
case 'E':
case 'I':
case 'O':
case 'U':
case 'a':
case 'e':
case 'i':
case 'o':
case 'u':
break;
defaul... |
Rewrite the snippet below in C# so it works the same as the original Ruby code. | p "Remove vowels from a string".delete("aeiouAEIOU")
| static string remove_vowels(string value)
{
var stripped = from c in value.ToCharArray()
where !"aeiouAEIOU".Contains(c)
select c;
return new string(stripped.ToArray());
}
static void test(string value)
{
Console.WriteLine("Input: " + value);
Console.WriteLine("O... |
Rewrite the snippet below in C# so it works the same as the original Ruby code. | p "Remove vowels from a string".delete("aeiouAEIOU")
| static string remove_vowels(string value)
{
var stripped = from c in value.ToCharArray()
where !"aeiouAEIOU".Contains(c)
select c;
return new string(stripped.ToArray());
}
static void test(string value)
{
Console.WriteLine("Input: " + value);
Console.WriteLine("O... |
Change the following Ruby code into C++ without altering its purpose. | p "Remove vowels from a string".delete("aeiouAEIOU")
| #include <algorithm>
#include <iostream>
class print_no_vowels {
private:
const std::string &str;
public:
print_no_vowels(const std::string &s) : str(s) {}
friend std::ostream &operator<<(std::ostream &, print_no_vowels);
};
std::ostream &operator<<(std::ostream &os, print_no_vowels pnv) {
auto it = p... |
Port the provided Ruby code into Java while preserving the original functionality. | p "Remove vowels from a string".delete("aeiouAEIOU")
| public static String removeVowelse(String str){
String re = "";
char c;
for(int x = 0; x<str.length(); x++){
c = str.charAt(x);
if(!(c=='a'||c=='e'||c=='i'||c=='o'||c=='u'))
re+=c;
}
return re;
}
|
Rewrite this program in Java while keeping its functionality equivalent to the Ruby version. | p "Remove vowels from a string".delete("aeiouAEIOU")
| public static String removeVowelse(String str){
String re = "";
char c;
for(int x = 0; x<str.length(); x++){
c = str.charAt(x);
if(!(c=='a'||c=='e'||c=='i'||c=='o'||c=='u'))
re+=c;
}
return re;
}
|
Write the same algorithm in Python as shown in this Ruby implementation. | p "Remove vowels from a string".delete("aeiouAEIOU")
|
def exceptGlyphs(exclusions):
def go(s):
return ''.join(
c for c in s if c not in exclusions
)
return go
def main():
txt =
print(
exceptGlyphs('eau')(txt)
)
if __name__ == '__main__':
main()
|
Convert the following code from Ruby to Python, ensuring the logic remains intact. | p "Remove vowels from a string".delete("aeiouAEIOU")
|
def exceptGlyphs(exclusions):
def go(s):
return ''.join(
c for c in s if c not in exclusions
)
return go
def main():
txt =
print(
exceptGlyphs('eau')(txt)
)
if __name__ == '__main__':
main()
|
Convert the following code from Ruby to VB, ensuring the logic remains intact. | p "Remove vowels from a string".delete("aeiouAEIOU")
| Imports System.Text
Module Module1
Function RemoveVowels(s As String) As String
Dim sb As New StringBuilder
For Each c In s
Select Case c
Case "A", "a"
Case "E", "e"
Case "I", "i"
Case "O", "o"
Case "U", "u... |
Port the provided Ruby code into VB while preserving the original functionality. | p "Remove vowels from a string".delete("aeiouAEIOU")
| Imports System.Text
Module Module1
Function RemoveVowels(s As String) As String
Dim sb As New StringBuilder
For Each c In s
Select Case c
Case "A", "a"
Case "E", "e"
Case "I", "i"
Case "O", "o"
Case "U", "u... |
Change the programming language of this snippet from Ruby to Go without modifying what it does. | p "Remove vowels from a string".delete("aeiouAEIOU")
| package main
import (
"fmt"
"strings"
)
func removeVowels(s string) string {
var sb strings.Builder
vowels := "aeiouAEIOU"
for _, c := range s {
if !strings.ContainsAny(string(c), vowels) {
sb.WriteRune(c)
}
}
return sb.String()
}
func main() {
s := "Go Pro... |
Produce a functionally identical Go code for the snippet given in Ruby. | p "Remove vowels from a string".delete("aeiouAEIOU")
| package main
import (
"fmt"
"strings"
)
func removeVowels(s string) string {
var sb strings.Builder
vowels := "aeiouAEIOU"
for _, c := range s {
if !strings.ContainsAny(string(c), vowels) {
sb.WriteRune(c)
}
}
return sb.String()
}
func main() {
s := "Go Pro... |
Ensure the translated C code behaves exactly like the original Scala snippet. | fun removeVowels(s: String): String {
val re = StringBuilder()
for (c in s) {
if (c != 'A' && c != 'a'
&& c != 'E' && c != 'e'
&& c != 'I' && c != 'i'
&& c != 'O' && c != 'o'
&& c != 'U' && c != 'u') {
re.append(c)
}
}
return re... | #include <stdio.h>
void print_no_vowels(const char *s) {
for (; *s != 0; s++) {
switch (*s) {
case 'A':
case 'E':
case 'I':
case 'O':
case 'U':
case 'a':
case 'e':
case 'i':
case 'o':
case 'u':
break;
defaul... |
Convert this Scala block to C, preserving its control flow and logic. | fun removeVowels(s: String): String {
val re = StringBuilder()
for (c in s) {
if (c != 'A' && c != 'a'
&& c != 'E' && c != 'e'
&& c != 'I' && c != 'i'
&& c != 'O' && c != 'o'
&& c != 'U' && c != 'u') {
re.append(c)
}
}
return re... | #include <stdio.h>
void print_no_vowels(const char *s) {
for (; *s != 0; s++) {
switch (*s) {
case 'A':
case 'E':
case 'I':
case 'O':
case 'U':
case 'a':
case 'e':
case 'i':
case 'o':
case 'u':
break;
defaul... |
Transform the following Scala implementation into C#, maintaining the same output and logic. | fun removeVowels(s: String): String {
val re = StringBuilder()
for (c in s) {
if (c != 'A' && c != 'a'
&& c != 'E' && c != 'e'
&& c != 'I' && c != 'i'
&& c != 'O' && c != 'o'
&& c != 'U' && c != 'u') {
re.append(c)
}
}
return re... | static string remove_vowels(string value)
{
var stripped = from c in value.ToCharArray()
where !"aeiouAEIOU".Contains(c)
select c;
return new string(stripped.ToArray());
}
static void test(string value)
{
Console.WriteLine("Input: " + value);
Console.WriteLine("O... |
Write the same algorithm in C# as shown in this Scala implementation. | fun removeVowels(s: String): String {
val re = StringBuilder()
for (c in s) {
if (c != 'A' && c != 'a'
&& c != 'E' && c != 'e'
&& c != 'I' && c != 'i'
&& c != 'O' && c != 'o'
&& c != 'U' && c != 'u') {
re.append(c)
}
}
return re... | static string remove_vowels(string value)
{
var stripped = from c in value.ToCharArray()
where !"aeiouAEIOU".Contains(c)
select c;
return new string(stripped.ToArray());
}
static void test(string value)
{
Console.WriteLine("Input: " + value);
Console.WriteLine("O... |
Write a version of this Scala function in C++ with identical behavior. | fun removeVowels(s: String): String {
val re = StringBuilder()
for (c in s) {
if (c != 'A' && c != 'a'
&& c != 'E' && c != 'e'
&& c != 'I' && c != 'i'
&& c != 'O' && c != 'o'
&& c != 'U' && c != 'u') {
re.append(c)
}
}
return re... | #include <algorithm>
#include <iostream>
class print_no_vowels {
private:
const std::string &str;
public:
print_no_vowels(const std::string &s) : str(s) {}
friend std::ostream &operator<<(std::ostream &, print_no_vowels);
};
std::ostream &operator<<(std::ostream &os, print_no_vowels pnv) {
auto it = p... |
Rewrite this program in C++ while keeping its functionality equivalent to the Scala version. | fun removeVowels(s: String): String {
val re = StringBuilder()
for (c in s) {
if (c != 'A' && c != 'a'
&& c != 'E' && c != 'e'
&& c != 'I' && c != 'i'
&& c != 'O' && c != 'o'
&& c != 'U' && c != 'u') {
re.append(c)
}
}
return re... | #include <algorithm>
#include <iostream>
class print_no_vowels {
private:
const std::string &str;
public:
print_no_vowels(const std::string &s) : str(s) {}
friend std::ostream &operator<<(std::ostream &, print_no_vowels);
};
std::ostream &operator<<(std::ostream &os, print_no_vowels pnv) {
auto it = p... |
Rewrite the snippet below in Java so it works the same as the original Scala code. | fun removeVowels(s: String): String {
val re = StringBuilder()
for (c in s) {
if (c != 'A' && c != 'a'
&& c != 'E' && c != 'e'
&& c != 'I' && c != 'i'
&& c != 'O' && c != 'o'
&& c != 'U' && c != 'u') {
re.append(c)
}
}
return re... | public static String removeVowelse(String str){
String re = "";
char c;
for(int x = 0; x<str.length(); x++){
c = str.charAt(x);
if(!(c=='a'||c=='e'||c=='i'||c=='o'||c=='u'))
re+=c;
}
return re;
}
|
Convert this Scala snippet to Java and keep its semantics consistent. | fun removeVowels(s: String): String {
val re = StringBuilder()
for (c in s) {
if (c != 'A' && c != 'a'
&& c != 'E' && c != 'e'
&& c != 'I' && c != 'i'
&& c != 'O' && c != 'o'
&& c != 'U' && c != 'u') {
re.append(c)
}
}
return re... | public static String removeVowelse(String str){
String re = "";
char c;
for(int x = 0; x<str.length(); x++){
c = str.charAt(x);
if(!(c=='a'||c=='e'||c=='i'||c=='o'||c=='u'))
re+=c;
}
return re;
}
|
Translate this program into Python but keep the logic exactly as in Scala. | fun removeVowels(s: String): String {
val re = StringBuilder()
for (c in s) {
if (c != 'A' && c != 'a'
&& c != 'E' && c != 'e'
&& c != 'I' && c != 'i'
&& c != 'O' && c != 'o'
&& c != 'U' && c != 'u') {
re.append(c)
}
}
return re... |
def exceptGlyphs(exclusions):
def go(s):
return ''.join(
c for c in s if c not in exclusions
)
return go
def main():
txt =
print(
exceptGlyphs('eau')(txt)
)
if __name__ == '__main__':
main()
|
Produce a language-to-language conversion: from Scala to Python, same semantics. | fun removeVowels(s: String): String {
val re = StringBuilder()
for (c in s) {
if (c != 'A' && c != 'a'
&& c != 'E' && c != 'e'
&& c != 'I' && c != 'i'
&& c != 'O' && c != 'o'
&& c != 'U' && c != 'u') {
re.append(c)
}
}
return re... |
def exceptGlyphs(exclusions):
def go(s):
return ''.join(
c for c in s if c not in exclusions
)
return go
def main():
txt =
print(
exceptGlyphs('eau')(txt)
)
if __name__ == '__main__':
main()
|
Preserve the algorithm and functionality while converting the code from Scala to VB. | fun removeVowels(s: String): String {
val re = StringBuilder()
for (c in s) {
if (c != 'A' && c != 'a'
&& c != 'E' && c != 'e'
&& c != 'I' && c != 'i'
&& c != 'O' && c != 'o'
&& c != 'U' && c != 'u') {
re.append(c)
}
}
return re... | Imports System.Text
Module Module1
Function RemoveVowels(s As String) As String
Dim sb As New StringBuilder
For Each c In s
Select Case c
Case "A", "a"
Case "E", "e"
Case "I", "i"
Case "O", "o"
Case "U", "u... |
Port the following code from Scala to VB with equivalent syntax and logic. | fun removeVowels(s: String): String {
val re = StringBuilder()
for (c in s) {
if (c != 'A' && c != 'a'
&& c != 'E' && c != 'e'
&& c != 'I' && c != 'i'
&& c != 'O' && c != 'o'
&& c != 'U' && c != 'u') {
re.append(c)
}
}
return re... | Imports System.Text
Module Module1
Function RemoveVowels(s As String) As String
Dim sb As New StringBuilder
For Each c In s
Select Case c
Case "A", "a"
Case "E", "e"
Case "I", "i"
Case "O", "o"
Case "U", "u... |
Convert this Scala block to Go, preserving its control flow and logic. | fun removeVowels(s: String): String {
val re = StringBuilder()
for (c in s) {
if (c != 'A' && c != 'a'
&& c != 'E' && c != 'e'
&& c != 'I' && c != 'i'
&& c != 'O' && c != 'o'
&& c != 'U' && c != 'u') {
re.append(c)
}
}
return re... | package main
import (
"fmt"
"strings"
)
func removeVowels(s string) string {
var sb strings.Builder
vowels := "aeiouAEIOU"
for _, c := range s {
if !strings.ContainsAny(string(c), vowels) {
sb.WriteRune(c)
}
}
return sb.String()
}
func main() {
s := "Go Pro... |
Produce a language-to-language conversion: from Scala to Go, same semantics. | fun removeVowels(s: String): String {
val re = StringBuilder()
for (c in s) {
if (c != 'A' && c != 'a'
&& c != 'E' && c != 'e'
&& c != 'I' && c != 'i'
&& c != 'O' && c != 'o'
&& c != 'U' && c != 'u') {
re.append(c)
}
}
return re... | package main
import (
"fmt"
"strings"
)
func removeVowels(s string) string {
var sb strings.Builder
vowels := "aeiouAEIOU"
for _, c := range s {
if !strings.ContainsAny(string(c), vowels) {
sb.WriteRune(c)
}
}
return sb.String()
}
func main() {
s := "Go Pro... |
Can you help me rewrite this code in C instead of Swift, keeping it the same logically? | func isVowel(_ char: Character) -> Bool {
switch (char) {
case "a", "A", "e", "E", "i", "I", "o", "O", "u", "U":
return true
default:
return false
}
}
func removeVowels(string: String) -> String {
return string.filter{!isVowel($0)}
}
let str = "The Swift Programming Language"
print... | #include <stdio.h>
void print_no_vowels(const char *s) {
for (; *s != 0; s++) {
switch (*s) {
case 'A':
case 'E':
case 'I':
case 'O':
case 'U':
case 'a':
case 'e':
case 'i':
case 'o':
case 'u':
break;
defaul... |
Convert this Swift snippet to C and keep its semantics consistent. | func isVowel(_ char: Character) -> Bool {
switch (char) {
case "a", "A", "e", "E", "i", "I", "o", "O", "u", "U":
return true
default:
return false
}
}
func removeVowels(string: String) -> String {
return string.filter{!isVowel($0)}
}
let str = "The Swift Programming Language"
print... | #include <stdio.h>
void print_no_vowels(const char *s) {
for (; *s != 0; s++) {
switch (*s) {
case 'A':
case 'E':
case 'I':
case 'O':
case 'U':
case 'a':
case 'e':
case 'i':
case 'o':
case 'u':
break;
defaul... |
Generate a C# translation of this Swift snippet without changing its computational steps. | func isVowel(_ char: Character) -> Bool {
switch (char) {
case "a", "A", "e", "E", "i", "I", "o", "O", "u", "U":
return true
default:
return false
}
}
func removeVowels(string: String) -> String {
return string.filter{!isVowel($0)}
}
let str = "The Swift Programming Language"
print... | static string remove_vowels(string value)
{
var stripped = from c in value.ToCharArray()
where !"aeiouAEIOU".Contains(c)
select c;
return new string(stripped.ToArray());
}
static void test(string value)
{
Console.WriteLine("Input: " + value);
Console.WriteLine("O... |
Write the same algorithm in C# as shown in this Swift implementation. | func isVowel(_ char: Character) -> Bool {
switch (char) {
case "a", "A", "e", "E", "i", "I", "o", "O", "u", "U":
return true
default:
return false
}
}
func removeVowels(string: String) -> String {
return string.filter{!isVowel($0)}
}
let str = "The Swift Programming Language"
print... | static string remove_vowels(string value)
{
var stripped = from c in value.ToCharArray()
where !"aeiouAEIOU".Contains(c)
select c;
return new string(stripped.ToArray());
}
static void test(string value)
{
Console.WriteLine("Input: " + value);
Console.WriteLine("O... |
Write the same algorithm in C++ as shown in this Swift implementation. | func isVowel(_ char: Character) -> Bool {
switch (char) {
case "a", "A", "e", "E", "i", "I", "o", "O", "u", "U":
return true
default:
return false
}
}
func removeVowels(string: String) -> String {
return string.filter{!isVowel($0)}
}
let str = "The Swift Programming Language"
print... | #include <algorithm>
#include <iostream>
class print_no_vowels {
private:
const std::string &str;
public:
print_no_vowels(const std::string &s) : str(s) {}
friend std::ostream &operator<<(std::ostream &, print_no_vowels);
};
std::ostream &operator<<(std::ostream &os, print_no_vowels pnv) {
auto it = p... |
Produce a functionally identical C++ code for the snippet given in Swift. | func isVowel(_ char: Character) -> Bool {
switch (char) {
case "a", "A", "e", "E", "i", "I", "o", "O", "u", "U":
return true
default:
return false
}
}
func removeVowels(string: String) -> String {
return string.filter{!isVowel($0)}
}
let str = "The Swift Programming Language"
print... | #include <algorithm>
#include <iostream>
class print_no_vowels {
private:
const std::string &str;
public:
print_no_vowels(const std::string &s) : str(s) {}
friend std::ostream &operator<<(std::ostream &, print_no_vowels);
};
std::ostream &operator<<(std::ostream &os, print_no_vowels pnv) {
auto it = p... |
Can you help me rewrite this code in Java instead of Swift, keeping it the same logically? | func isVowel(_ char: Character) -> Bool {
switch (char) {
case "a", "A", "e", "E", "i", "I", "o", "O", "u", "U":
return true
default:
return false
}
}
func removeVowels(string: String) -> String {
return string.filter{!isVowel($0)}
}
let str = "The Swift Programming Language"
print... | public static String removeVowelse(String str){
String re = "";
char c;
for(int x = 0; x<str.length(); x++){
c = str.charAt(x);
if(!(c=='a'||c=='e'||c=='i'||c=='o'||c=='u'))
re+=c;
}
return re;
}
|
Transform the following Swift implementation into Java, maintaining the same output and logic. | func isVowel(_ char: Character) -> Bool {
switch (char) {
case "a", "A", "e", "E", "i", "I", "o", "O", "u", "U":
return true
default:
return false
}
}
func removeVowels(string: String) -> String {
return string.filter{!isVowel($0)}
}
let str = "The Swift Programming Language"
print... | public static String removeVowelse(String str){
String re = "";
char c;
for(int x = 0; x<str.length(); x++){
c = str.charAt(x);
if(!(c=='a'||c=='e'||c=='i'||c=='o'||c=='u'))
re+=c;
}
return re;
}
|
Can you help me rewrite this code in Python instead of Swift, keeping it the same logically? | func isVowel(_ char: Character) -> Bool {
switch (char) {
case "a", "A", "e", "E", "i", "I", "o", "O", "u", "U":
return true
default:
return false
}
}
func removeVowels(string: String) -> String {
return string.filter{!isVowel($0)}
}
let str = "The Swift Programming Language"
print... |
def exceptGlyphs(exclusions):
def go(s):
return ''.join(
c for c in s if c not in exclusions
)
return go
def main():
txt =
print(
exceptGlyphs('eau')(txt)
)
if __name__ == '__main__':
main()
|
Can you help me rewrite this code in Python instead of Swift, keeping it the same logically? | func isVowel(_ char: Character) -> Bool {
switch (char) {
case "a", "A", "e", "E", "i", "I", "o", "O", "u", "U":
return true
default:
return false
}
}
func removeVowels(string: String) -> String {
return string.filter{!isVowel($0)}
}
let str = "The Swift Programming Language"
print... |
def exceptGlyphs(exclusions):
def go(s):
return ''.join(
c for c in s if c not in exclusions
)
return go
def main():
txt =
print(
exceptGlyphs('eau')(txt)
)
if __name__ == '__main__':
main()
|
Rewrite the snippet below in VB so it works the same as the original Swift code. | func isVowel(_ char: Character) -> Bool {
switch (char) {
case "a", "A", "e", "E", "i", "I", "o", "O", "u", "U":
return true
default:
return false
}
}
func removeVowels(string: String) -> String {
return string.filter{!isVowel($0)}
}
let str = "The Swift Programming Language"
print... | Imports System.Text
Module Module1
Function RemoveVowels(s As String) As String
Dim sb As New StringBuilder
For Each c In s
Select Case c
Case "A", "a"
Case "E", "e"
Case "I", "i"
Case "O", "o"
Case "U", "u... |
Rewrite the snippet below in VB so it works the same as the original Swift code. | func isVowel(_ char: Character) -> Bool {
switch (char) {
case "a", "A", "e", "E", "i", "I", "o", "O", "u", "U":
return true
default:
return false
}
}
func removeVowels(string: String) -> String {
return string.filter{!isVowel($0)}
}
let str = "The Swift Programming Language"
print... | Imports System.Text
Module Module1
Function RemoveVowels(s As String) As String
Dim sb As New StringBuilder
For Each c In s
Select Case c
Case "A", "a"
Case "E", "e"
Case "I", "i"
Case "O", "o"
Case "U", "u... |
Write the same code in Go as shown below in Swift. | func isVowel(_ char: Character) -> Bool {
switch (char) {
case "a", "A", "e", "E", "i", "I", "o", "O", "u", "U":
return true
default:
return false
}
}
func removeVowels(string: String) -> String {
return string.filter{!isVowel($0)}
}
let str = "The Swift Programming Language"
print... | package main
import (
"fmt"
"strings"
)
func removeVowels(s string) string {
var sb strings.Builder
vowels := "aeiouAEIOU"
for _, c := range s {
if !strings.ContainsAny(string(c), vowels) {
sb.WriteRune(c)
}
}
return sb.String()
}
func main() {
s := "Go Pro... |
Please provide an equivalent version of this Swift code in Go. | func isVowel(_ char: Character) -> Bool {
switch (char) {
case "a", "A", "e", "E", "i", "I", "o", "O", "u", "U":
return true
default:
return false
}
}
func removeVowels(string: String) -> String {
return string.filter{!isVowel($0)}
}
let str = "The Swift Programming Language"
print... | package main
import (
"fmt"
"strings"
)
func removeVowels(s string) string {
var sb strings.Builder
vowels := "aeiouAEIOU"
for _, c := range s {
if !strings.ContainsAny(string(c), vowels) {
sb.WriteRune(c)
}
}
return sb.String()
}
func main() {
s := "Go Pro... |
Rewrite the snippet below in Rust so it works the same as the original C code. | #include <stdio.h>
void print_no_vowels(const char *s) {
for (; *s != 0; s++) {
switch (*s) {
case 'A':
case 'E':
case 'I':
case 'O':
case 'U':
case 'a':
case 'e':
case 'i':
case 'o':
case 'u':
break;
defaul... | fn remove_vowels(str: String) -> String {
let vowels = "aeiouAEIOU";
let mut devowelled_string = String::from("");
for i in str.chars() {
if vowels.contains(i) {
continue;
} else {
devowelled_string.push(i);
}
}
return devowelled_string;
}
fn main() ... |
Produce a functionally identical Rust code for the snippet given in C++. | #include <algorithm>
#include <iostream>
class print_no_vowels {
private:
const std::string &str;
public:
print_no_vowels(const std::string &s) : str(s) {}
friend std::ostream &operator<<(std::ostream &, print_no_vowels);
};
std::ostream &operator<<(std::ostream &os, print_no_vowels pnv) {
auto it = p... | fn remove_vowels(str: String) -> String {
let vowels = "aeiouAEIOU";
let mut devowelled_string = String::from("");
for i in str.chars() {
if vowels.contains(i) {
continue;
} else {
devowelled_string.push(i);
}
}
return devowelled_string;
}
fn main() ... |
Change the following C++ code into Rust without altering its purpose. | #include <algorithm>
#include <iostream>
class print_no_vowels {
private:
const std::string &str;
public:
print_no_vowels(const std::string &s) : str(s) {}
friend std::ostream &operator<<(std::ostream &, print_no_vowels);
};
std::ostream &operator<<(std::ostream &os, print_no_vowels pnv) {
auto it = p... | fn remove_vowels(str: String) -> String {
let vowels = "aeiouAEIOU";
let mut devowelled_string = String::from("");
for i in str.chars() {
if vowels.contains(i) {
continue;
} else {
devowelled_string.push(i);
}
}
return devowelled_string;
}
fn main() ... |
Change the programming language of this snippet from C# to Rust without modifying what it does. | static string remove_vowels(string value)
{
var stripped = from c in value.ToCharArray()
where !"aeiouAEIOU".Contains(c)
select c;
return new string(stripped.ToArray());
}
static void test(string value)
{
Console.WriteLine("Input: " + value);
Console.WriteLine("O... | fn remove_vowels(str: String) -> String {
let vowels = "aeiouAEIOU";
let mut devowelled_string = String::from("");
for i in str.chars() {
if vowels.contains(i) {
continue;
} else {
devowelled_string.push(i);
}
}
return devowelled_string;
}
fn main() ... |
Port the following code from Java to Rust with equivalent syntax and logic. | public static String removeVowelse(String str){
String re = "";
char c;
for(int x = 0; x<str.length(); x++){
c = str.charAt(x);
if(!(c=='a'||c=='e'||c=='i'||c=='o'||c=='u'))
re+=c;
}
return re;
}
| fn remove_vowels(str: String) -> String {
let vowels = "aeiouAEIOU";
let mut devowelled_string = String::from("");
for i in str.chars() {
if vowels.contains(i) {
continue;
} else {
devowelled_string.push(i);
}
}
return devowelled_string;
}
fn main() ... |
Keep all operations the same but rewrite the snippet in Rust. | package main
import (
"fmt"
"strings"
)
func removeVowels(s string) string {
var sb strings.Builder
vowels := "aeiouAEIOU"
for _, c := range s {
if !strings.ContainsAny(string(c), vowels) {
sb.WriteRune(c)
}
}
return sb.String()
}
func main() {
s := "Go Pro... | fn remove_vowels(str: String) -> String {
let vowels = "aeiouAEIOU";
let mut devowelled_string = String::from("");
for i in str.chars() {
if vowels.contains(i) {
continue;
} else {
devowelled_string.push(i);
}
}
return devowelled_string;
}
fn main() ... |
Write the same code in Rust as shown below in Go. | package main
import (
"fmt"
"strings"
)
func removeVowels(s string) string {
var sb strings.Builder
vowels := "aeiouAEIOU"
for _, c := range s {
if !strings.ContainsAny(string(c), vowels) {
sb.WriteRune(c)
}
}
return sb.String()
}
func main() {
s := "Go Pro... | fn remove_vowels(str: String) -> String {
let vowels = "aeiouAEIOU";
let mut devowelled_string = String::from("");
for i in str.chars() {
if vowels.contains(i) {
continue;
} else {
devowelled_string.push(i);
}
}
return devowelled_string;
}
fn main() ... |
Port the following code from Rust to Python with equivalent syntax and logic. | fn remove_vowels(str: String) -> String {
let vowels = "aeiouAEIOU";
let mut devowelled_string = String::from("");
for i in str.chars() {
if vowels.contains(i) {
continue;
} else {
devowelled_string.push(i);
}
}
return devowelled_string;
}
fn main() ... |
def exceptGlyphs(exclusions):
def go(s):
return ''.join(
c for c in s if c not in exclusions
)
return go
def main():
txt =
print(
exceptGlyphs('eau')(txt)
)
if __name__ == '__main__':
main()
|
Port the provided Rust code into VB while preserving the original functionality. | fn remove_vowels(str: String) -> String {
let vowels = "aeiouAEIOU";
let mut devowelled_string = String::from("");
for i in str.chars() {
if vowels.contains(i) {
continue;
} else {
devowelled_string.push(i);
}
}
return devowelled_string;
}
fn main() ... | Imports System.Text
Module Module1
Function RemoveVowels(s As String) As String
Dim sb As New StringBuilder
For Each c In s
Select Case c
Case "A", "a"
Case "E", "e"
Case "I", "i"
Case "O", "o"
Case "U", "u... |
Convert this C# snippet to Rust and keep its semantics consistent. | static string remove_vowels(string value)
{
var stripped = from c in value.ToCharArray()
where !"aeiouAEIOU".Contains(c)
select c;
return new string(stripped.ToArray());
}
static void test(string value)
{
Console.WriteLine("Input: " + value);
Console.WriteLine("O... | fn remove_vowels(str: String) -> String {
let vowels = "aeiouAEIOU";
let mut devowelled_string = String::from("");
for i in str.chars() {
if vowels.contains(i) {
continue;
} else {
devowelled_string.push(i);
}
}
return devowelled_string;
}
fn main() ... |
Can you help me rewrite this code in Rust instead of Java, keeping it the same logically? | public static String removeVowelse(String str){
String re = "";
char c;
for(int x = 0; x<str.length(); x++){
c = str.charAt(x);
if(!(c=='a'||c=='e'||c=='i'||c=='o'||c=='u'))
re+=c;
}
return re;
}
| fn remove_vowels(str: String) -> String {
let vowels = "aeiouAEIOU";
let mut devowelled_string = String::from("");
for i in str.chars() {
if vowels.contains(i) {
continue;
} else {
devowelled_string.push(i);
}
}
return devowelled_string;
}
fn main() ... |
Produce a functionally identical Python code for the snippet given in Rust. | fn remove_vowels(str: String) -> String {
let vowels = "aeiouAEIOU";
let mut devowelled_string = String::from("");
for i in str.chars() {
if vowels.contains(i) {
continue;
} else {
devowelled_string.push(i);
}
}
return devowelled_string;
}
fn main() ... |
def exceptGlyphs(exclusions):
def go(s):
return ''.join(
c for c in s if c not in exclusions
)
return go
def main():
txt =
print(
exceptGlyphs('eau')(txt)
)
if __name__ == '__main__':
main()
|
Change the programming language of this snippet from Rust to VB without modifying what it does. | fn remove_vowels(str: String) -> String {
let vowels = "aeiouAEIOU";
let mut devowelled_string = String::from("");
for i in str.chars() {
if vowels.contains(i) {
continue;
} else {
devowelled_string.push(i);
}
}
return devowelled_string;
}
fn main() ... | Imports System.Text
Module Module1
Function RemoveVowels(s As String) As String
Dim sb As New StringBuilder
For Each c In s
Select Case c
Case "A", "a"
Case "E", "e"
Case "I", "i"
Case "O", "o"
Case "U", "u... |
Ensure the translated Rust code behaves exactly like the original C snippet. | #include <stdio.h>
void print_no_vowels(const char *s) {
for (; *s != 0; s++) {
switch (*s) {
case 'A':
case 'E':
case 'I':
case 'O':
case 'U':
case 'a':
case 'e':
case 'i':
case 'o':
case 'u':
break;
defaul... | fn remove_vowels(str: String) -> String {
let vowels = "aeiouAEIOU";
let mut devowelled_string = String::from("");
for i in str.chars() {
if vowels.contains(i) {
continue;
} else {
devowelled_string.push(i);
}
}
return devowelled_string;
}
fn main() ... |
Produce a language-to-language conversion: from Ada to C#, same semantics. | with Ada.Text_Io;
with Ada.Float_Text_Io; use Ada.Float_Text_Io;
with Ada.containers.Vectors;
procedure Forward_Difference is
package Flt_Vect is new Ada.Containers.Vectors(Positive, Float);
use Flt_Vect;
procedure Print(Item : Vector) is
begin
if not Item.Is_Empty then
Ada.Text_IO.Put('[');... | using System;
using System.Collections.Generic;
using System.Linq;
class Program
{
static IEnumerable<int> ForwardDifference(IEnumerable<int> sequence, uint order = 1u)
{
switch (order)
{
case 0u:
return sequence;
case 1u:
return sequence.... |
Convert this Ada snippet to C and keep its semantics consistent. | with Ada.Text_Io;
with Ada.Float_Text_Io; use Ada.Float_Text_Io;
with Ada.containers.Vectors;
procedure Forward_Difference is
package Flt_Vect is new Ada.Containers.Vectors(Positive, Float);
use Flt_Vect;
procedure Print(Item : Vector) is
begin
if not Item.Is_Empty then
Ada.Text_IO.Put('[');... | #include <stdlib.h>
#include <string.h>
#include <stdio.h>
double* fwd_diff(double* x, unsigned int len, unsigned int order)
{
unsigned int i, j;
double* y;
if (order >= len) return 0;
y = malloc(sizeof(double) * len);
if (!order) {
memcpy(y, x, sizeof(double) * len);
return y;
}
for (j = 0; j < orde... |
Convert this Ada snippet to C++ and keep its semantics consistent. | with Ada.Text_Io;
with Ada.Float_Text_Io; use Ada.Float_Text_Io;
with Ada.containers.Vectors;
procedure Forward_Difference is
package Flt_Vect is new Ada.Containers.Vectors(Positive, Float);
use Flt_Vect;
procedure Print(Item : Vector) is
begin
if not Item.Is_Empty then
Ada.Text_IO.Put('[');... | #include <vector>
#include <iterator>
#include <algorithm>
template<typename InputIterator, typename OutputIterator>
OutputIterator forward_difference(InputIterator first, InputIterator last,
OutputIterator dest)
{
if (first == last)
return dest;
typedef typename... |
Convert the following code from Ada to Go, ensuring the logic remains intact. | with Ada.Text_Io;
with Ada.Float_Text_Io; use Ada.Float_Text_Io;
with Ada.containers.Vectors;
procedure Forward_Difference is
package Flt_Vect is new Ada.Containers.Vectors(Positive, Float);
use Flt_Vect;
procedure Print(Item : Vector) is
begin
if not Item.Is_Empty then
Ada.Text_IO.Put('[');... | package main
import "fmt"
func main() {
a := []int{90, 47, 58, 29, 22, 32, 55, 5, 55, 73}
fmt.Println(a)
fmt.Println(fd(a, 9))
}
func fd(a []int, ord int) []int {
for i := 0; i < ord; i++ {
for j := 0; j < len(a)-i-1; j++ {
a[j] = a[j+1] - a[j]
}
}
return a[:len(a)... |
Generate a Java translation of this Ada snippet without changing its computational steps. | with Ada.Text_Io;
with Ada.Float_Text_Io; use Ada.Float_Text_Io;
with Ada.containers.Vectors;
procedure Forward_Difference is
package Flt_Vect is new Ada.Containers.Vectors(Positive, Float);
use Flt_Vect;
procedure Print(Item : Vector) is
begin
if not Item.Is_Empty then
Ada.Text_IO.Put('[');... | import java.util.Arrays;
public class FD {
public static void main(String args[]) {
double[] a = {90, 47, 58, 29, 22, 32, 55, 5, 55, 73};
System.out.println(Arrays.toString(dif(a, 1)));
System.out.println(Arrays.toString(dif(a, 2)));
System.out.println(Arrays.toString(dif(a, 9)));
... |
Convert the following code from Ada to Python, ensuring the logic remains intact. | with Ada.Text_Io;
with Ada.Float_Text_Io; use Ada.Float_Text_Io;
with Ada.containers.Vectors;
procedure Forward_Difference is
package Flt_Vect is new Ada.Containers.Vectors(Positive, Float);
use Flt_Vect;
procedure Print(Item : Vector) is
begin
if not Item.Is_Empty then
Ada.Text_IO.Put('[');... | >>> dif = lambda s: [x-s[i] for i,x in enumerate(s[1:])]
>>>
>>> difn = lambda s, n: difn(dif(s), n-1) if n else s
>>> s = [90, 47, 58, 29, 22, 32, 55, 5, 55, 73]
>>> difn(s, 0)
[90, 47, 58, 29, 22, 32, 55, 5, 55, 73]
>>> difn(s, 1)
[-43, 11, -29, -7, 10, 23, -50, 50, 18]
>>> difn(s, 2)
[54, -40, 22, 17, 13, -73, 100... |
Change the programming language of this snippet from Ada to VB without modifying what it does. | with Ada.Text_Io;
with Ada.Float_Text_Io; use Ada.Float_Text_Io;
with Ada.containers.Vectors;
procedure Forward_Difference is
package Flt_Vect is new Ada.Containers.Vectors(Positive, Float);
use Flt_Vect;
procedure Print(Item : Vector) is
begin
if not Item.Is_Empty then
Ada.Text_IO.Put('[');... | Module ForwardDifference
Sub Main()
Dim lNum As New List(Of Integer)(New Integer() {90, 47, 58, 29, 22, 32, 55, 5, 55, 73})
For i As UInteger = 0 To 9
Console.WriteLine(String.Join(" ", (From n In Difference(i, lNum) Select String.Format("{0,5}", n)).ToArray()))
Next
Con... |
Port the provided Arturo code into C while preserving the original functionality. |
vsub: function [u v][
map couple u v 'pair -> pair\0 - pair\1
]
differences: function [block][
order: attr "order"
if order = null -> order: 1
loop 1..order 'n -> block: vsub block drop block 1
return block
]
print differences .order: 4 [90.5 47 58 29 22 32 55 5 55 73.5]
print differences [1 2 3... | #include <stdlib.h>
#include <string.h>
#include <stdio.h>
double* fwd_diff(double* x, unsigned int len, unsigned int order)
{
unsigned int i, j;
double* y;
if (order >= len) return 0;
y = malloc(sizeof(double) * len);
if (!order) {
memcpy(y, x, sizeof(double) * len);
return y;
}
for (j = 0; j < orde... |
Generate an equivalent C# version of this Arturo code. |
vsub: function [u v][
map couple u v 'pair -> pair\0 - pair\1
]
differences: function [block][
order: attr "order"
if order = null -> order: 1
loop 1..order 'n -> block: vsub block drop block 1
return block
]
print differences .order: 4 [90.5 47 58 29 22 32 55 5 55 73.5]
print differences [1 2 3... | using System;
using System.Collections.Generic;
using System.Linq;
class Program
{
static IEnumerable<int> ForwardDifference(IEnumerable<int> sequence, uint order = 1u)
{
switch (order)
{
case 0u:
return sequence;
case 1u:
return sequence.... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.