kazuyamaa/multi-language-messages-01 huggingface dataset:
Task: Unbias a random generator
Go: package main

import (
    "fmt"
    "math/rand"
)

const samples = 1e6

func main() {
    fmt.Println("Generator  1 count  0 count  % 1 count")
    for n := 3; n <= 6; n++ {
        
        randN := func() int {
            if rand.Intn(n) == 0 {
                return 1
            }
            return 0
        }
        var b [2]int
        for x := 0; x < samples; x++ {
            b[randN()]++
        }
        fmt.Printf("randN(%d)   %7d  %7d    %5.2f%%\n",
            n, b[1], b[0], float64(b[1])*100/samples)

        
        unbiased := func() (b int) {
            for b = randN(); b == randN(); b = randN() {
            }
            return
        }
        var u [2]int
        for x := 0; x < samples; x++ {
            u[unbiased()]++
        }
        fmt.Printf("unbiased   %7d  %7d    %5.2f%%\n",
            u[1], u[0], float64(u[1])*100/samples)
    }
}

VB: Module Module1
    Dim random As New Random()

    Function RandN(n As Integer) As Boolean
        Return random.Next(0, n) = 0
    End Function

    Function Unbiased(n As Integer) As Boolean
        Dim flip1 As Boolean
        Dim flip2 As Boolean

        Do
            flip1 = RandN(n)
            flip2 = RandN(n)
        Loop While flip1 = flip2

        Return flip1
    End Function

    Sub Main()
        For n = 3 To 6
            Dim biasedZero = 0
            Dim biasedOne = 0
            Dim unbiasedZero = 0
            Dim unbiasedOne = 0
            For i = 1 To 100000
                If RandN(n) Then
                    biasedOne += 1
                Else
                    biasedZero += 1
                End If
                If Unbiased(n) Then
                    unbiasedOne += 1
                Else
                    unbiasedZero += 1
                End If
            Next

            Console.WriteLine("(N = {0}):".PadRight(17) + "# of 0" + vbTab + "# of 1" + vbTab + "% of 0" + vbTab + "% of 1", n)
            Console.WriteLine("(Biased: {0}):".PadRight(15) + "{0}" + vbTab + "{1}" + vbTab + "{2}" + vbTab + "{3}", biasedZero, biasedOne, biasedZero / 1000, biasedOne / 1000)
            Console.WriteLine("(UnBiased: {0}):".PadRight(15) + "{0}" + vbTab + "{1}" + vbTab + "{2}" + vbTab + "{3}", unbiasedZero, unbiasedOne, unbiasedZero / 1000, unbiasedOne / 1000)
        Next
    End Sub

End Module
Task: Unbias a random generator
C++: #include <iostream>
#include <random>

std::default_random_engine generator;
bool biased(int n) {
    std::uniform_int_distribution<int> distribution(1, n);
    return distribution(generator) == 1;
}

bool unbiased(int n) {
    bool flip1, flip2;

    

    do {
        flip1 = biased(n);
        flip2 = biased(n);
    } while (flip1 == flip2);

    return flip1;
}

int main() {
    for (size_t n = 3; n <= 6; n++) {
        int biasedZero = 0;
        int biasedOne = 0;
        int unbiasedZero = 0;
        int unbiasedOne = 0;

        for (size_t i = 0; i < 100000; i++) {
            if (biased(n)) {
                biasedOne++;
            } else {
                biasedZero++;
            }
            if (unbiased(n)) {
                unbiasedOne++;
            } else {
                unbiasedZero++;
            }
        }

        std::cout << "(N = " << n << ")\n";
        std::cout << "Biased:\n";
        std::cout << "   0 = " << biasedZero << "; " << biasedZero / 1000.0 << "%\n";
        std::cout << "   1 = " << biasedOne << "; " << biasedOne / 1000.0 << "%\n";
        std::cout << "Unbiased:\n";
        std::cout << "   0 = " << unbiasedZero << "; " << unbiasedZero / 1000.0 << "%\n";
        std::cout << "   1 = " << unbiasedOne << "; " << unbiasedOne / 1000.0 << "%\n";
        std::cout << '\n';
    }
    return 0;
}

VB: Module Module1
    Dim random As New Random()

    Function RandN(n As Integer) As Boolean
        Return random.Next(0, n) = 0
    End Function

    Function Unbiased(n As Integer) As Boolean
        Dim flip1 As Boolean
        Dim flip2 As Boolean

        Do
            flip1 = RandN(n)
            flip2 = RandN(n)
        Loop While flip1 = flip2

        Return flip1
    End Function

    Sub Main()
        For n = 3 To 6
            Dim biasedZero = 0
            Dim biasedOne = 0
            Dim unbiasedZero = 0
            Dim unbiasedOne = 0
            For i = 1 To 100000
                If RandN(n) Then
                    biasedOne += 1
                Else
                    biasedZero += 1
                End If
                If Unbiased(n) Then
                    unbiasedOne += 1
                Else
                    unbiasedZero += 1
                End If
            Next

            Console.WriteLine("(N = {0}):".PadRight(17) + "# of 0" + vbTab + "# of 1" + vbTab + "% of 0" + vbTab + "% of 1", n)
            Console.WriteLine("(Biased: {0}):".PadRight(15) + "{0}" + vbTab + "{1}" + vbTab + "{2}" + vbTab + "{3}", biasedZero, biasedOne, biasedZero / 1000, biasedOne / 1000)
            Console.WriteLine("(UnBiased: {0}):".PadRight(15) + "{0}" + vbTab + "{1}" + vbTab + "{2}" + vbTab + "{3}", unbiasedZero, unbiasedOne, unbiasedZero / 1000, unbiasedOne / 1000)
        Next
    End Sub

End Module
Task: Unbias a random generator
Java: public class Bias {
    public static boolean biased(int n) {
        return Math.random() < 1.0 / n;
    }

    public static boolean unbiased(int n) {
        boolean a, b;
        do {
            a = biased(n);
            b = biased(n);
        } while (a == b);
        return a;
    }

    public static void main(String[] args) {
        final int M = 50000;
        for (int n = 3; n < 7; n++) {
            int c1 = 0, c2 = 0;
            for (int i = 0; i < M; i++) {
                c1 += biased(n) ? 1 : 0;
                c2 += unbiased(n) ? 1 : 0;
            }
            System.out.format("%d: %2.2f%%  %2.2f%%\n",
                              n, 100.0*c1/M, 100.0*c2/M);
        }
    }
}

Python: from __future__ import print_function
import random

def randN(N):
    " 1,0 random generator factory with 1 appearing 1/N'th of the time"
    return lambda: random.randrange(N) == 0

def unbiased(biased):
    'uses a biased() generator of 1 or 0, to create an unbiased one'
    this, that = biased(), biased()
    while this == that: 
        this, that = biased(), biased()
    return this         

if __name__ == '__main__':
    from collections import namedtuple

    Stats = namedtuple('Stats', 'count1 count0 percent')

    for N in range(3, 7):
        biased = randN(N)
        v = [biased() for x in range(1000000)]
        v1, v0 = v.count(1), v.count(0)
        print ( "Biased(%i)  = %r" % (N, Stats(v1, v0, 100. * v1/(v1 + v0))) )

        v = [unbiased(biased) for x in range(1000000)]
        v1, v0 = v.count(1), v.count(0)
        print ( "  Unbiased = %r" % (Stats(v1, v0, 100. * v1/(v1 + v0)), ) )
Task: Unbias a random generator
Python: from __future__ import print_function
import random

def randN(N):
    " 1,0 random generator factory with 1 appearing 1/N'th of the time"
    return lambda: random.randrange(N) == 0

def unbiased(biased):
    'uses a biased() generator of 1 or 0, to create an unbiased one'
    this, that = biased(), biased()
    while this == that: 
        this, that = biased(), biased()
    return this         

if __name__ == '__main__':
    from collections import namedtuple

    Stats = namedtuple('Stats', 'count1 count0 percent')

    for N in range(3, 7):
        biased = randN(N)
        v = [biased() for x in range(1000000)]
        v1, v0 = v.count(1), v.count(0)
        print ( "Biased(%i)  = %r" % (N, Stats(v1, v0, 100. * v1/(v1 + v0))) )

        v = [unbiased(biased) for x in range(1000000)]
        v1, v0 = v.count(1), v.count(0)
        print ( "  Unbiased = %r" % (Stats(v1, v0, 100. * v1/(v1 + v0)), ) )

VB: Module Module1
    Dim random As New Random()

    Function RandN(n As Integer) As Boolean
        Return random.Next(0, n) = 0
    End Function

    Function Unbiased(n As Integer) As Boolean
        Dim flip1 As Boolean
        Dim flip2 As Boolean

        Do
            flip1 = RandN(n)
            flip2 = RandN(n)
        Loop While flip1 = flip2

        Return flip1
    End Function

    Sub Main()
        For n = 3 To 6
            Dim biasedZero = 0
            Dim biasedOne = 0
            Dim unbiasedZero = 0
            Dim unbiasedOne = 0
            For i = 1 To 100000
                If RandN(n) Then
                    biasedOne += 1
                Else
                    biasedZero += 1
                End If
                If Unbiased(n) Then
                    unbiasedOne += 1
                Else
                    unbiasedZero += 1
                End If
            Next

            Console.WriteLine("(N = {0}):".PadRight(17) + "# of 0" + vbTab + "# of 1" + vbTab + "% of 0" + vbTab + "% of 1", n)
            Console.WriteLine("(Biased: {0}):".PadRight(15) + "{0}" + vbTab + "{1}" + vbTab + "{2}" + vbTab + "{3}", biasedZero, biasedOne, biasedZero / 1000, biasedOne / 1000)
            Console.WriteLine("(UnBiased: {0}):".PadRight(15) + "{0}" + vbTab + "{1}" + vbTab + "{2}" + vbTab + "{3}", unbiasedZero, unbiasedOne, unbiasedZero / 1000, unbiasedOne / 1000)
        Next
    End Sub

End Module
Task: Morse code
C: 

#include <ctype.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define BIND(A,L,H) ((L)<(A)?(A)<(H)?(A):(H):(L))


char
  
  
  dih[50],dah[50],medium[30],word[30],
  *dd[2] = {dih,dah};
const char
  *ascii = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789.,?'!/()&:;=+-_\"$@",
  *itu[] = {
     "13","3111","3131","311","1","1131","331","1111","11","1333","313","1311","33","31","333","1331","3313","131","111","3","113","1113","133","3113","3133","3311","33333","13333","11333","11133","11113","11111","31111","33111","33311","33331","131313","331133","113311","133331","313133","31131","31331","313313","13111","333111","313131","31113","13131","311113","113313","131131","1113113","133131"
  };

void append(char*s,const char*morse) {
  for (; *morse; ++morse)
    strcat(s,dd['3'==*morse]);
  strcat(s,medium);
}

char*translate(const char*i,char*o) {
  const char*pc;
  sprintf(o,"beep");
  for (; *i; ++i)
    if (NULL == (pc = strchr(ascii,toupper(*i))))
      strcat(o,word);
    else
      append(o,itu[pc-ascii]);
  strcat(o,word);
  return o;
}

int main(int ac,char*av[]) {
  char
    sin[73],sout[100000];
  int
    dit = 100;
  if (1 < ac) {
    if (strlen(av[1]) != strspn(av[1],"0123456789"))
      return 0*fprintf(stderr,"use: %s [duration]   dit in ms, default %d\n",*av,dit);
    dit = BIND(atoi(av[1]),1,1000);
  }
  sprintf(dah," -n -f 440 -l %d -D %d",3*dit,dit);
  sprintf(dih," -n -f 440 -l %d -D %d",dit,dit);
  sprintf(medium," -n -D %d",(3-1)*dit);
  sprintf(word," -n -D %d",(7-(3-1)-1)*dit);
  while (NULL != fgets(sin,72,stdin))
    puts(translate(sin,sout));
  return 0;
}

C#: using System;
using System.Collections.Generic;

namespace Morse
{
    class Morse
    {
        static void Main(string[] args)
        {
            string word = "sos";
            Dictionary<string, string> Codes = new Dictionary<string, string>
            {
                {"a", ".-   "}, {"b", "-... "}, {"c", "-.-. "}, {"d", "-..  "}, 
                {"e", ".    "}, {"f", "..-. "}, {"g", "--.  "}, {"h", ".... "},
                {"i", "..   "}, {"j", ".--- "}, {"k", "-.-  "}, {"l", ".-.. "},
                {"m", "--   "}, {"n", "-.   "}, {"o", "---  "}, {"p", ".--. "}, 
                {"q", "--.- "}, {"r", ".-.  "}, {"s", "...  "}, {"t", "-    "}, 
                {"u", "..-  "}, {"v", "...- "}, {"w", ".--  "}, {"x", "-..- "}, 
                {"y", "-.-- "}, {"z", "--.. "}, {"0", "-----"}, {"1", ".----"}, 
                {"2", "..---"}, {"3", "...--"}, {"4", "....-"}, {"5", "....."}, 
                {"6", "-...."}, {"7", "--..."}, {"8", "---.."}, {"9", "----."}    
            };

            foreach (char c in word.ToCharArray())
            {
                string rslt = Codes[c.ToString()].Trim();
                foreach (char c2 in rslt.ToCharArray())
                {
                    if (c2 == '.')
                        Console.Beep(1000, 250);
                    else
                        Console.Beep(1000, 750);
                }
                System.Threading.Thread.Sleep(50);
            }
        }
    }
}
Task: Input_Output for lines of text
C: #include<stdlib.h>
#include<stdio.h>

#define LEN 100  

int main()
{
	char **list;
	int num, i;
	
	scanf("%d",&num);
	
	list = (char**)malloc(num*sizeof(char*));
	
	for(i=0;i<num;i++)
	{
	   list[i] = (char*)malloc(LEN*sizeof(char));  
	   fflush(stdin);
	   fgets(list[i],LEN,stdin);
	} 
	
	printf("\n");
	
	for(i=0;i<num;i++)
	{
		printf("%s",list[i]);
	}
	
	return 0;
}

C#: #include <iostream>
#include <vector>

int main()
{
    
    int numberOfLines;
    std::cin >> numberOfLines;
    std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n'); 
    
    
    std::vector<std::string> lines(numberOfLines);    
    for(int i = 0; i < numberOfLines; ++i)
    {
        std::getline(std::cin, lines[i]);
    }

    
    for(const auto& value : lines)
    {
        std::cout << value << "\n";
    }
}
Task: Input_Output for lines of text
C: #include<stdlib.h>
#include<stdio.h>

#define LEN 100  

int main()
{
	char **list;
	int num, i;
	
	scanf("%d",&num);
	
	list = (char**)malloc(num*sizeof(char*));
	
	for(i=0;i<num;i++)
	{
	   list[i] = (char*)malloc(LEN*sizeof(char));  
	   fflush(stdin);
	   fgets(list[i],LEN,stdin);
	} 
	
	printf("\n");
	
	for(i=0;i<num;i++)
	{
		printf("%s",list[i]);
	}
	
	return 0;
}

Java: import java.util.Scanner;

public class Main {
	public static void doStuff(String word){
	   System.out.println(word);
	}

	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
		int n = Integer.parseInt(in.nextLine());  
		for(int i=0; i<n; i++){		
			String word = in.nextLine();
			doStuff(word);
		}
	}
}
Task: Input_Output for lines of text
C: #include<stdlib.h>
#include<stdio.h>

#define LEN 100  

int main()
{
	char **list;
	int num, i;
	
	scanf("%d",&num);
	
	list = (char**)malloc(num*sizeof(char*));
	
	for(i=0;i<num;i++)
	{
	   list[i] = (char*)malloc(LEN*sizeof(char));  
	   fflush(stdin);
	   fgets(list[i],LEN,stdin);
	} 
	
	printf("\n");
	
	for(i=0;i<num;i++)
	{
		printf("%s",list[i]);
	}
	
	return 0;
}

Python: try: input = raw_input
except: pass

def do_stuff(words):
	print(words)

linecount = int(input())
for x in range(linecount):
	line = input()
	do_stuff(line)
Task: Input_Output for lines of text
C++: #include <iostream>
#include <vector>

int main()
{
    
    int numberOfLines;
    std::cin >> numberOfLines;
    std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n'); 
    
    
    std::vector<std::string> lines(numberOfLines);    
    for(int i = 0; i < numberOfLines; ++i)
    {
        std::getline(std::cin, lines[i]);
    }

    
    for(const auto& value : lines)
    {
        std::cout << value << "\n";
    }
}

Go: package main

import (
	"bufio"
	"fmt"
	"io"
	"log"
	"os"
)

func main() {
	
	
	
	var lines int
	n, err := fmt.Scanln(&lines)
	if n != 1 || err != nil {
		log.Fatal(err)
	}

	
	
	
	
	
	
	
	
	
	
	
	
	
	

	scanner := bufio.NewScanner(os.Stdin)
	scanner.Split(bufio.ScanLines) 
	for ; scanner.Scan() && lines > 0; lines-- {
		doStuff(scanner.Text())
	}
	if err := scanner.Err(); err != nil {
		log.Fatal(err)
	}
	
	if lines > 0 {
		log.Fatalln("early", io.EOF)
	}
}

func doStuff(line string) {
	fmt.Println(line)
}
Task: Input_Output for lines of text
C++: #include <iostream>
#include <vector>

int main()
{
    
    int numberOfLines;
    std::cin >> numberOfLines;
    std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n'); 
    
    
    std::vector<std::string> lines(numberOfLines);    
    for(int i = 0; i < numberOfLines; ++i)
    {
        std::getline(std::cin, lines[i]);
    }

    
    for(const auto& value : lines)
    {
        std::cout << value << "\n";
    }
}

Java: import java.util.Scanner;

public class Main {
	public static void doStuff(String word){
	   System.out.println(word);
	}

	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
		int n = Integer.parseInt(in.nextLine());  
		for(int i=0; i<n; i++){		
			String word = in.nextLine();
			doStuff(word);
		}
	}
}
Task: Input_Output for lines of text
C++: #include <iostream>
#include <vector>

int main()
{
    
    int numberOfLines;
    std::cin >> numberOfLines;
    std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n'); 
    
    
    std::vector<std::string> lines(numberOfLines);    
    for(int i = 0; i < numberOfLines; ++i)
    {
        std::getline(std::cin, lines[i]);
    }

    
    for(const auto& value : lines)
    {
        std::cout << value << "\n";
    }
}

Python: try: input = raw_input
except: pass

def do_stuff(words):
	print(words)

linecount = int(input())
for x in range(linecount):
	line = input()
	do_stuff(line)
Task: Input_Output for lines of text
Go: package main

import (
	"bufio"
	"fmt"
	"io"
	"log"
	"os"
)

func main() {
	
	
	
	var lines int
	n, err := fmt.Scanln(&lines)
	if n != 1 || err != nil {
		log.Fatal(err)
	}

	
	
	
	
	
	
	
	
	
	
	
	
	
	

	scanner := bufio.NewScanner(os.Stdin)
	scanner.Split(bufio.ScanLines) 
	for ; scanner.Scan() && lines > 0; lines-- {
		doStuff(scanner.Text())
	}
	if err := scanner.Err(); err != nil {
		log.Fatal(err)
	}
	
	if lines > 0 {
		log.Fatalln("early", io.EOF)
	}
}

func doStuff(line string) {
	fmt.Println(line)
}

Java: import java.util.Scanner;

public class Main {
	public static void doStuff(String word){
	   System.out.println(word);
	}

	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
		int n = Integer.parseInt(in.nextLine());  
		for(int i=0; i<n; i++){		
			String word = in.nextLine();
			doStuff(word);
		}
	}
}
Task: Input_Output for lines of text
Java: import java.util.Scanner;

public class Main {
	public static void doStuff(String word){
	   System.out.println(word);
	}

	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
		int n = Integer.parseInt(in.nextLine());  
		for(int i=0; i<n; i++){		
			String word = in.nextLine();
			doStuff(word);
		}
	}
}

Python: try: input = raw_input
except: pass

def do_stuff(words):
	print(words)

linecount = int(input())
for x in range(linecount):
	line = input()
	do_stuff(line)
Task: Input_Output for lines of text
Go: package main

import (
	"bufio"
	"fmt"
	"io"
	"log"
	"os"
)

func main() {
	
	
	
	var lines int
	n, err := fmt.Scanln(&lines)
	if n != 1 || err != nil {
		log.Fatal(err)
	}

	
	
	
	
	
	
	
	
	
	
	
	
	
	

	scanner := bufio.NewScanner(os.Stdin)
	scanner.Split(bufio.ScanLines) 
	for ; scanner.Scan() && lines > 0; lines-- {
		doStuff(scanner.Text())
	}
	if err := scanner.Err(); err != nil {
		log.Fatal(err)
	}
	
	if lines > 0 {
		log.Fatalln("early", io.EOF)
	}
}

func doStuff(line string) {
	fmt.Println(line)
}

Python: try: input = raw_input
except: pass

def do_stuff(words):
	print(words)

linecount = int(input())
for x in range(linecount):
	line = input()
	do_stuff(line)
Task: Input_Output for lines of text
C: #include<stdlib.h>
#include<stdio.h>

#define LEN 100  

int main()
{
	char **list;
	int num, i;
	
	scanf("%d",&num);
	
	list = (char**)malloc(num*sizeof(char*));
	
	for(i=0;i<num;i++)
	{
	   list[i] = (char*)malloc(LEN*sizeof(char));  
	   fflush(stdin);
	   fgets(list[i],LEN,stdin);
	} 
	
	printf("\n");
	
	for(i=0;i<num;i++)
	{
		printf("%s",list[i]);
	}
	
	return 0;
}

C++: #include <iostream>
#include <vector>

int main()
{
    
    int numberOfLines;
    std::cin >> numberOfLines;
    std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n'); 
    
    
    std::vector<std::string> lines(numberOfLines);    
    for(int i = 0; i < numberOfLines; ++i)
    {
        std::getline(std::cin, lines[i]);
    }

    
    for(const auto& value : lines)
    {
        std::cout << value << "\n";
    }
}
Task: Input_Output for lines of text
C: #include<stdlib.h>
#include<stdio.h>

#define LEN 100  

int main()
{
	char **list;
	int num, i;
	
	scanf("%d",&num);
	
	list = (char**)malloc(num*sizeof(char*));
	
	for(i=0;i<num;i++)
	{
	   list[i] = (char*)malloc(LEN*sizeof(char));  
	   fflush(stdin);
	   fgets(list[i],LEN,stdin);
	} 
	
	printf("\n");
	
	for(i=0;i<num;i++)
	{
		printf("%s",list[i]);
	}
	
	return 0;
}

Go: package main

import (
	"bufio"
	"fmt"
	"io"
	"log"
	"os"
)

func main() {
	
	
	
	var lines int
	n, err := fmt.Scanln(&lines)
	if n != 1 || err != nil {
		log.Fatal(err)
	}

	
	
	
	
	
	
	
	
	
	
	
	
	
	

	scanner := bufio.NewScanner(os.Stdin)
	scanner.Split(bufio.ScanLines) 
	for ; scanner.Scan() && lines > 0; lines-- {
		doStuff(scanner.Text())
	}
	if err := scanner.Err(); err != nil {
		log.Fatal(err)
	}
	
	if lines > 0 {
		log.Fatalln("early", io.EOF)
	}
}

func doStuff(line string) {
	fmt.Println(line)
}
Task: Hello world_Newline omission
C: #include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[]) {
  (void) printf("Goodbye, World!");    
  return EXIT_SUCCESS;
}

C#: using System;

class Program
{
    static void Main(string[] args)
    {
        
        Console.WriteLine("Goodbye, World!");

        
        Console.Write("Goodbye, World!");
    }
}
Task: Hello world_Newline omission
C: #include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[]) {
  (void) printf("Goodbye, World!");    
  return EXIT_SUCCESS;
}

C++: #include <iostream>

int main() {
  std::cout << "Goodbye, World!";
  return 0;
}
Task: Hello world_Newline omission
C: #include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[]) {
  (void) printf("Goodbye, World!");    
  return EXIT_SUCCESS;
}

Python: import sys
sys.stdout.write("Goodbye, World!")
Task: Hello world_Newline omission
C: #include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[]) {
  (void) printf("Goodbye, World!");    
  return EXIT_SUCCESS;
}

VB: Module Module1

    Sub Main()
        Console.Write("Goodbye, World!")
    End Sub

End Module
Task: Hello world_Newline omission
C++: #include <iostream>

int main() {
  std::cout << "Goodbye, World!";
  return 0;
}

Go: package main

import "fmt"

func main() { fmt.Print("Goodbye, World!") }
Task: Hello world_Newline omission
C++: #include <iostream>

int main() {
  std::cout << "Goodbye, World!";
  return 0;
}

Python: import sys
sys.stdout.write("Goodbye, World!")
Task: Hello world_Newline omission
Go: package main

import "fmt"

func main() { fmt.Print("Goodbye, World!") }

VB: Module Module1

    Sub Main()
        Console.Write("Goodbye, World!")
    End Sub

End Module
Task: Hello world_Newline omission
Python: import sys
sys.stdout.write("Goodbye, World!")

VB: Module Module1

    Sub Main()
        Console.Write("Goodbye, World!")
    End Sub

End Module
Task: Hello world_Newline omission
C: #include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[]) {
  (void) printf("Goodbye, World!");    
  return EXIT_SUCCESS;
}

Go: package main

import "fmt"

func main() { fmt.Print("Goodbye, World!") }
Task: Hello world_Newline omission
C#: using System;

class Program
{
    static void Main(string[] args)
    {
        
        Console.WriteLine("Goodbye, World!");

        
        Console.Write("Goodbye, World!");
    }
}

C++: #include <iostream>

int main() {
  std::cout << "Goodbye, World!";
  return 0;
}
Task: Hello world_Newline omission
C#: using System;

class Program
{
    static void Main(string[] args)
    {
        
        Console.WriteLine("Goodbye, World!");

        
        Console.Write("Goodbye, World!");
    }
}

Go: package main

import "fmt"

func main() { fmt.Print("Goodbye, World!") }
Task: Hello world_Newline omission
C#: using System;

class Program
{
    static void Main(string[] args)
    {
        
        Console.WriteLine("Goodbye, World!");

        
        Console.Write("Goodbye, World!");
    }
}

Python: import sys
sys.stdout.write("Goodbye, World!")
Task: Hello world_Newline omission
Go: package main

import "fmt"

func main() { fmt.Print("Goodbye, World!") }

Python: import sys
sys.stdout.write("Goodbye, World!")