Golang To Solidity Converter

import (
“fmt”
“math/rand”
“time”
)

func main() {
rand.Seed(time.Now().UnixNano())
numberToGuess := rand.Intn(100) + 1
var userGuess int

fmt.Println(“Welcome to the Number Guessing Game!”)
fmt.Println(“I have generated a random number between 1 and 100.”)
fmt.Println(“Try to guess it!”)

for {
fmt.Print(“Enter your guess: “)
fmt.Scanln(&userGuess)

if userGuess < 1 || userGuess > 100 {
fmt.Println(“Please guess a number between 1 and 100.”)
continue
}

if userGuess < numberToGuess { fmt.Println("Too low! Try again.") } else if userGuess > numberToGuess {
fmt.Println(“Too high! Try again.”)
} else {
fmt.Println(“Congratulations! You’ve guessed the number!”)
break
}
}
}

contract NumberGuessingGame {
uint256 private numberToGuess;
uint256 private userGuess;
bool private gameEnded;

constructor() {
// Simulate a random number generation using current block timestamp
numberToGuess = (uint256(keccak256(abi.encodePacked(block.timestamp))) % 100) + 1;
gameEnded = false;
}

function guess(uint256 _guess) public {
require(!gameEnded, “Game has ended.”);
require(_guess >= 1 && _guess <= 100, "Please guess a number between 1 and 100."); userGuess = _guess; if (userGuess < numberToGuess) { revert("Too low! Try again."); } else if (userGuess > numberToGuess) {
revert(“Too high! Try again.”);
} else {
gameEnded = true;
emit GameWon(“Congratulations! You’ve guessed the number!”);
}
}

event GameWon(string message);
}

import (
“bufio”
“fmt”
“os”
“strings”
)

type KeyValueStore struct {
store map[string]string
}

func NewKeyValueStore() *KeyValueStore {
return &KeyValueStore{store: make(map[string]string)}
}

func (kvs *KeyValueStore) Set(key, value string) {
kvs.store[key] = value
}

func (kvs *KeyValueStore) Get(key string) (string, bool) {
value, exists := kvs.store[key]
return value, exists
}

func (kvs *KeyValueStore) Delete(key string) {
delete(kvs.store, key)
}

func (kvs *KeyValueStore) DisplayAll() {
for key, value := range kvs.store {
fmt.Printf(“%s: %sn”, key, value)
}
}

func main() {
kvs := NewKeyValueStore()
scanner := bufio.NewScanner(os.Stdin)

for {
fmt.Print(“Enter command (set/get/delete/display/exit): “)
scanner.Scan()
command := scanner.Text()

switch strings.ToLower(command) {
case “set”:
fmt.Print(“Enter key: “)
scanner.Scan()
key := scanner.Text()
fmt.Print(“Enter value: “)
scanner.Scan()
value := scanner.Text()
kvs.Set(key, value)
fmt.Println(“Key-value pair set.”)

case “get”:
fmt.Print(“Enter key: “)
scanner.Scan()
key := scanner.Text()
value, exists := kvs.Get(key)
if exists {
fmt.Printf(“Value: %sn”, value)
} else {
fmt.Println(“Key does not exist.”)
}

case “delete”:
fmt.Print(“Enter key: “)
scanner.Scan()
key := scanner.Text()
kvs.Delete(key)
fmt.Println(“Key-value pair deleted (if it existed).”)

case “display”:
kvs.DisplayAll()

case “exit”:
fmt.Println(“Exiting…”)
return

default:
fmt.Println(“Unknown command. Please try again.”)
}
}
}

contract KeyValueStore {
mapping(string => string) private store;

function set(string memory key, string memory value) public {
store[key] = value;
}

function get(string memory key) public view returns (string memory value, bool exists) {
if (keccak256(abi.encodePacked(store[key])) != keccak256(abi.encodePacked(“”))) {
return (store[key], true);
} else {
return (“”, false);
}
}

function deleteKey(string memory key) public {
delete store[key];
}

function displayAll() public view returns (string memory) {
string memory result = “”;
for (uint i = 0; i < getKeysCount(); i++) { string memory key = getKeyAtIndex(i); result = string(abi.encodePacked(result, key, ": ", store[key], "n")); } return result; } // Below functions are needed for displayAll string[] private keys; function getKeysCount() private view returns (uint) { return keys.length; } function getKeyAtIndex(uint index) private view returns (string memory) { return keys[index]; } function addKey(string memory key) public { keys.push(key); } }