## user behavior – Which is faster to fill-out: Paper or digital forms?

It depends on your customers. I personally definitely prefer paper, but I see why others wouldn’t.

The pros of paper are that it is well known and well understood, and there can not go much wrong with it. People know how to fill out forms. The culprits are also well known and well understood. You need to enter the data manually, and you can have problems reading it etc.

When using electronic devices, you need to make sure they actually work. Tech trouble happens more often then you think. You need to have tech support available when the connection to the server has trouble, or when the app crashes, or whatever. Especially when the amount of devices is small and you need every of them (if you have 50+ devices and one doesn’t respond anymore, you simply take it out of circulation until it can be fixed, if you only have 5 or so then not having one will be a significant setback).

Then you will need to have people that can assist the customers with the electronic form. Especially elderly people (or in general, not tech-savvy users) might be very uncomfortable with it.

So in the end it boils down to what costs less, the overhead of having to enter the data from paper forms into your system or the overhead of having tech support available and having people available that can assists with entering the data. That is hard to see from the outside.

You can always do the hybrid approach. Have some tablets available and encourage users to use the tablets, but also keep some paper forms on hand. You can use paper forms for people who don’t want the tablet (e.g. elderly people) and also have them available in case the electronic system breaks down. This also lets you get your own experiences with the system and how well it works with your customers and allows you to gradually phase-out paper if that turns out to be beneficial.

Whatever the user inputs is already entered into the system. Highly legible.

No. You should never design a system in that way. The filled out forms should be submitted into a separate system, where they can be audited (e.g. for inappropriate, offensive or otherwise malicious inputs) and then electronically be transferred into your database. This also allows for corrections or for only partial data transfers, depending on how its implemented. I would never have users fill out forms that directly change my data set (never trust user input)!

Another thing you can consider is letting users use their own devices. Prepare it as a web form. You can have a validation token in form of a QR-code. Hand the customer a small paper card with the QR code. They scan it, open the web site, fill out the form, and the token gets invalidated and can not be used again. This way, you do not have the bottleneck of bringing lots of your own devices. You should still have some devices that you can lend people who don’t have a smartphone, but you can avoid the bottleneck of only having a few devices.

## Making a rock paper scissor game using list in Python

Hello am a new to python and my programming concept is catching up to me, i just created my first ever project which i did not look else where for an answer and took me one day total hours 6 to write bit slow but can some tell me how to improve this code except from using function is their a way to use for loop to check the if player1 is rock and player two is scissor then make player 1 wins since rock beats scissor thank you.

``````choice = ('r', 'p', 's')
player = ('1', '2')
user_Ply = ()
ply_round = 0
draw = 0

print("--------------------------------------------------------------------")
print(r"""THIS IS A GAME OF ROCK, PAPER AND SICSSORS TO PLAY EITHER ENTER
R FOR "ROCK" P FOR "PAPER" AND "S" FOR SCISSORS """)

while True:
ply_round += 1
win = ''
active_player = player(0)
isPlayer1_TheActive_Player = True
if isPlayer1_TheActive_Player:
for i, players in enumerate(player):
if active_player == player(i):
print('------------------------------------------')
ply_1 = input('Enter "Rock","Paper","Scissors :" ')
user_Ply.append(ply_1)
for j, v in enumerate(choice):
if choice(j) in ply_1:
print(f'you choose {choice(j)}')
else:
print('------------------------------------------')
ply_2 = input('Enter "Rock","Paper","Scissors :" ')
user_Ply.append(ply_2)
for j, v in enumerate(choice):
if choice(j) in ply_2:
print(f'you choose {choice(j)}')
isPlayer1_TheActive_Player = False

if ((user_Ply(0) == choice(-1) and user_Ply(1) == choice(-1)) or (user_Ply(0) == choice(1) and user_Ply(1) == choice(1)) or (user_Ply(0) == choice(0) and user_Ply(1) == choice(0))):
print(fr'The result of round {ply_round} is a draw')
draw += 1
user_Ply.clear()
elif (user_Ply(0) == choice(0) and user_Ply(1) == choice(-1)):
print(fr'The result of round {ply_round} is a win for P1')
user_Ply.clear()
elif (user_Ply(1) == choice(0) and user_Ply(0) == choice(-1)):
print(fr'The result of round {ply_round} is a win for P2')
user_Ply.clear()
elif (user_Ply(0) == choice(-1) and user_Ply(0) == choice(1)):
print(fr'The result of round {ply_round} is a win for P1')
user_Ply.clear()
elif (user_Ply(1) == choice(1) and user_Ply(0) == choice(-1)):
print(fr'The result of round {ply_round} is a win for P2')
user_Ply.clear()
elif (user_Ply(0) == choice(1) and user_Ply(0) == choice(0)):
print(fr'The result of round {ply_round} is a win for P1')
user_Ply.clear()
elif (user_Ply(1) == choice(0) and user_Ply(0) == choice(1)):
print(fr'The result of round {ply_round} is a win for P2')
user_Ply.clear()
else:
user_Ply.clear()
if ply_round == 5:
break
print('------------------------------')
print('Game over')
print()
``````

## security – Electrum paper wallet exploit

I want to generate a paper wallet with Electrum using my personal computer that I’ve been using for a few years now, meaning that I’m online with it daily.

I know that the optimal solution is to use a computer that has never been connected to the internet, but I’m curious if there are any reports of malware compromising this kind of setup.
(I’m considering this setup because where I’m from it is not so easy/fast to get a hardware wallet)

1. Go offline
2. Generate seed words
3. Copy them to paper
4. Delete wallet from computer

## beginner – A pretty simple Rock, Paper, Scissor game on C++

I’ve decided to learn more about C++ with the time that I have right now through Udemy courses. To test out the stuff that I’ve learned up until now, I decided to try and code with some of the knowledge I’ve gained. I wanted try out object oriented features since I’ve been doing stuff through procedural programming instead. This is just a simple program utilising a few bits of OOP. I’m not sure if my use of it is appropriate (seeing as it is very minimal in use throughout the program). I would love some feedback and some tips to improve. Please keep feedback simple since I’m new to programming in general, and I don’t know all of the technical jargon. Thanks.

``````// SIMPLE ROCK PAPER SCISSOR GAME w/ some OOP features
#include <cstdlib>
#include <vector>
#include <ctime>
#include <string>
#include <iostream>
using namespace std;

class Player {      //stores player/enemy points
private:
int score;
public:
int getScore() {
return score;
}

void incrementScore() {
score++;
}
//constructor
Player(int points);
};

//constructor
Player::Player(int points)
: score {points} {
}

int convertToInt(string pChoice) {      //converts player input into integers
if (pChoice == "Rock" || pChoice == "rock") {
return 0;
}
else if (pChoice == "Paper" || pChoice == "paper") {
return 1;
}
else if (pChoice == "Scissor" || pChoice == "scissor") {
return 2;
}

return 0;
}

bool inputValidation(const vector <string> choices, string pChoice) {      //validates player input
bool boolean {};
for (const string choice : choices) {     //checks vector that contains a list of all possible options
if (choice == pChoice) {
boolean = true;
break;
}
else {
boolean = false;
}
}
return boolean;
}

void printEnemyChoice(unsigned int &enemyRand, string &enemyChoice) {   //prints enemy choice
//remember that 0, 1 and 2 correspond to rock, paper and scissor respectively
switch (enemyRand) {
case 0: {
enemyChoice = "Rock";
cout << "Enemy picked: " << enemyChoice << endl;
break;
}
case 1: {
enemyChoice = "Paper";
cout << "Enemy picked: " << enemyChoice << endl;
break;
}
case 2: {
enemyChoice = "Scissors";
cout << "Enemy picked: " << enemyChoice << endl;
break;
}
}
}

void checkResult(Player &playerScore, Player &enemyScore, unsigned int &playerIChoice, unsigned int &enemyRand) {   //determines the winner
/* a 2D array is used to compared playerIChoice (the player's choice) and the enemy's choice (randomly generated)
* 0 represents draw
* 1 represents player's win
* 2 represents enemy's win
* remember that 0, 1, 2 is also Rock, Paper and Scissor respectively.. bit confusing. Hope theres a better way to name this properly.
* for eg. if playerIChoice = 2 (Scissors) and enemyRand = 1 (Paper), this points to "1" on the 2D array (3rd row, column 2)
* since it points to a "1", therefore the player wins (Scissors beats Paper).
* 1 is assigned to result, which is used in a switch statement to print out the winner on case 1 and increments the playerScore.score attribute.
*/

int resultArray(3)(3) {
{0, 2, 1},
{1, 0, 2},
{2, 1, 0}
};

int result = resultArray(playerIChoice)(enemyRand);
switch (result) {
case 0: {
cout << "Result is: Draw" << endl;
break;
}
case 1: {
cout << "Result is: You win!" << endl;
playerScore.incrementScore();
break;
}
case 2: {
cout << "Result is: You lose!" << endl;
enemyScore.incrementScore();
break;
}
}
}

int main() {
Player playerScore {0};
Player enemyScore {0};
bool gameLoop {true};
const vector <string> choices {"Rock", "rock", "Paper", "paper", "Scissor", "scissor", "Q", "q"};
string playerChoice {};
string enemyChoice {};
unsigned int playerIChoice {};
unsigned int enemyRand {};

cout << "======================================" << endl;
cout << "Rock, Paper, Scissor! - CLI w/ Objects" << endl;
cout << "======================================" << endl;

while (gameLoop) {
cout << "nChoose rock, paper, or scissor: " << endl;
cout << "Press Q to quit the game." << endl;
cin >> playerChoice;

if (playerChoice == "Q" || playerChoice == "q") {
cout << "Thanks for playing." << endl;
gameLoop = false;
break;
}

if (inputValidation(choices, playerChoice) == false) {      //passes vector with valid input and player's input to compare
cout << "Invalid input, try again!" << endl;
continue;
}

cout << "You picked: " << playerChoice << endl;
playerIChoice = convertToInt(playerChoice);         //converts valid input into integers to compare with enemy's choice

srand (time(NULL));
enemyRand = rand() % 3;     //generates random number from 0-2

printEnemyChoice(enemyRand, enemyChoice);
checkResult(playerScore, enemyScore, playerIChoice, enemyRand);

cout << "nYour score is: " << playerScore.getScore() << endl;
cout << "Enemy score is: " << enemyScore.getScore() << endl;
}

return 0;
}
``````

## Rock, Paper, Scissors in C#

First of all, I am very new to programming and also this site.

This is a very simple “Rock, Paper, Scissors” game I made in C#. At first, it asks if I want to play the game. If my answer is yes, then I enter my name and the game starts. The program asks me to choose rock, paper or scissors, then the computer randomly picks one ,the program compares them and gives the outcome. If I win 5 rounds I win the game but if the computer wins 5 round it wins the game, and then the program asks if I want to play again.

My code is working but I think it could have been better, cleaner and shorter.

``````using System;
using System.ComponentModel.Design;

namespace rockpaperscissors
{
class Player
{
public string playername;
private int playerscore;

public int Score
{
get { return playerscore; }
set { playerscore = value; }
}
}
class RockPaperScissors
{
public static string p_rps;
private static int c_rps;
private static int computerscore;

public static void Initialize(Player player)
{
player.Score = 0;
computerscore = 0;
}

public static void Board(Player player)
{
Console.WriteLine("ntt{0}: {1}nnttComputer: {2}n", player.playername, player.Score, computerscore);
}

public static int ComputerRPS()
{
Random c = new Random();
c_rps = c.Next(1, 4);

return c_rps;
}

public static void Check(int c, Player player)
{
c = ComputerRPS();

switch(c)
{
case 1:

if (p_rps == "R")
{
Console.WriteLine("Tie");
}
else if (p_rps == "P")
{
Console.WriteLine("Computer chose rock.nPaper beats rock. {0} wins this round.", player.playername);
player.Score++;
}
else if (p_rps == "S")
{
Console.WriteLine("Computer chose rock.nRock beats scissors. Computer wins this round.");
computerscore++;
}

break;

case 2:

if (p_rps == "R")
{
Console.WriteLine("Computer chose paper.nPaper beats rock. Computer wins this round.");
computerscore++;
}
else if (p_rps == "P")
{
Console.WriteLine("Tie");
}
else if (p_rps == "S")
{
Console.WriteLine("Computer chose paper.nScissors beats rock. {0} wins this round.", player.playername);
player.Score++;
}

break;

case 3:

if (p_rps == "R")
{
Console.WriteLine("Computer chose scissors.nRock beats scissors. {0} wins this round.", player.playername);
player.Score++;
}
else if (p_rps == "P")
{
Console.WriteLine("Computer chose scissors.nScissors beats paper. Computer wins this round.");
computerscore++;
}
else if (p_rps == "S")
{
Console.WriteLine("Tie");
}

break;
}
}

public static bool WhoWins(Player player)
{
if (player.Score == 5)
{
Console.WriteLine("n{0} wins the game.n",player.playername);
return true;
}
if (computerscore == 5)
{
Console.WriteLine("nComputer wins the game.n");
return true;
}

return false;
}
}
class Program
{
public static bool play;
public static string startgame;

static void StartGameOrNot()
{
do
{
startgame.ToUpper();

if (startgame == "Y")
{
play = true;
}
else if (startgame == "N")
{
Console.WriteLine("nOkay then, goodbye");
Environment.Exit(0);
}
else
{
Console.Write("nInvalid. Do you want to start the game? (Y/N) --> ");
}
} while (startgame != "Y" && startgame != "N");
}
static void Main(string() args)
{
Console.Write("Do you want to start the game? (Y/N) --> ");
StartGameOrNot();

Player player1 = new Player();

Console.Clear();
Console.Write("nntWhat is your name? --> ");

Console.Clear();
RockPaperScissors.Initialize(player1);

while (play)
{
RockPaperScissors.Board(player1);

do
{
Console.Write("Rock, paper, scissors? (R/P/S) --> ");
} while (RockPaperScissors.p_rps == "R" && RockPaperScissors.p_rps == "P" && RockPaperScissors.p_rps == "S");

int c = RockPaperScissors.ComputerRPS();

Console.Clear();

RockPaperScissors.Check(c, player1);

if(RockPaperScissors.WhoWins(player1))
{
Console.Write("Replay? --> ");
StartGameOrNot();
RockPaperScissors.Initialize(player1);
Console.Clear();
}
}
}
}
}
$$```$$
``````

## Triple monitor wall paper, but as 3 separate images

I have a triple monitor set up. Two monitors are on 1 pc with Widows 10 and the Thrid monitor on another PC.
Is there anywhere I can get wallpaper that will stretch across the 3 monitors but are available as 3 separate images so they can be loaded on the relevant PC’s. Or is there software that I can easily edit my own panoramic picture?

Thanks

## Can I send bitcoin from paper wallet directly to hardware wallet?

Can I send bitcoin from my paper wallet to my hardware Ledger wallet without using blockchain wallet?

## London public transport: Is it possible to buy a paper ticket for a single journey?

I will only be in London for two days and plan to take the Tube no more than 2 or 3 times, so it doesn’t make much sense to buy an Oyster card.

You can buy single journey paper tickets for the tube, but they strongly discourage it through pricing. I just looked up a zone 1 Tube fare and it was £2.40 on Oyster but £4.90 on a paper ticket.

At those prices even if you don’t get your card deposit back (or you get the visitor card with its non-refundable charge) it doesn’t take very many journeys for Oyster to beat paper tickets.

Another option is to use a contactless credit/debit card but if you have a non-UK card beware of foreign transaction fees.

Also note that while you can use paper single tickets on the Tube you can’t use them on buses in London. Your only options there are Oyster, contactless and travelcards.

(I read there is an activation cost and you won’t get a full refund if you use it for such a short time).

There are two types of Oyster card. Regular cards and Visitor cards. Regular cards have a £5 refundable deposit, Visitor cards have a £3 non-refundable “activation fee”. The Visitor card can only be obtained outside London. Regular cards can be obtained at any Tube station. The Visitor card comes with a few special offers for London attractions that the regular card doesn’t but otherwise the cards are much the same.

AIUI with cash at a machine you can top up any amount down to the smallest coins the machine will take while if you pay by card at a machine or pay at a ticket office the minimum top-up is £5.

Getting the deposit and remaining credit refunded used to require dealing with a manned ticket office but it seems it’s now possible to do it at a ticket machine.

## Compact embedding of the room of signed radon measurements in the Sobolev room \$ W ^ {- 1, q} \$ from Evans paper; Does it work in a room dimension?

Background: I am working on a PDE problem where I have an approximate sequence of measurement functions and have to embed them compactly in a negative Sobolev space $$W ^ {- m, q}$$ on the limited interval in $$mathbb {R}$$. I am mainly interested in the rooms in which $$q = 2$$. I only found such an embedding in the one sentence from the paper:

Evans – Weak Convergence Methods for Nonlinear Partial Differential Equations, 1990.

Sentence 6 (Compactness for measures, page 7): Take the order $${ mu_k } _ {k = 1} ^ { infty}$$ is limited in $$mathcal {M} (U)$$, $$U subset mathbb {R} ^ n$$. Then $${ mu_k } _ {k = 1} ^ { infty}$$ is in precompact $$W ^ {- 1, q} (U)$$ for each $$1 leq q <1 ^ *$$.

Here $$mathcal {M} (U)$$ represents the space of the signed radon measurements $$U$$ with finite mass, $$U subset mathbb {R} ^ n$$ is an open, limited, smooth subset of $$mathbb {R} ^ n, n geq 2$$ and $$1 ^ * = frac {n} {n-1}$$ represents a Sobolev conjugate.

The identical sentence (Lemma 2.55, page 38) is given in the book: Malek, Necas, Rokyta, Ruzicka – Weak and measurable solutions for evolutionary PDEs, 1996, with one difference that instead of $$1 leq q <1 ^ *$$, There it says $$1 leq q < frac {n} {n-1}$$ (This is not explicitly written here $$n geq 2$$).

My question: does sentence 6 work in one dimension ($$n = 1$$)? That means we have a compact embedding of the room $$mathcal {M} (U)$$ in the room $$W ^ {- 1, q} (U)$$, Where $$U subset mathbb {R}$$?

• I assume that we have a compact embedding in $$W ^ {- 1, q} (U)$$, then we have it in the $$W ^ {- m, q} (U), m geq 1$$?
• Are there other measurement spaces (e.g. space of finite positive dimensions)? $$mathcal {M} _ +$$The space of probability measures with a finite first moment $$Pr_1$$etc.), which are compactly embedded in some negative Sobolev spaces $$W ^ {- m, q} (U)$$?

I think if we use the definition of the Sobolev conjugate: $$frac {1} {p ^ *} = frac {1} {p} – frac {1} {n}$$, we get for $$p = 1, n = 1$$ the $$frac {1} {1 ^ *} = frac {1} {1} – frac {1} {1} Rightarrow 1 ^ * = infty$$. So we would have sentence 6 (maybe) working for everyone $$1 leq q < infty$$ (and then for $$q = 2$$ Likewise)? If we use $$p ^ * = frac {np} {n-p}$$ we would have for $$n = 1,$$ $$p ^ * = frac {p} {1-p}$$ and we couldn't take here $$p = 1$$ and get $$p ^ *$$.

I don't usually deal with the measured and negative Sobolev spaces, so I don't know much about them. Help would be great and I definitely need it. And any additional reference besides the two above would be nice. Thanks in advance.

## Printing – Which PPI do I have to set for photos to avoid pixelated, jagged edges on paper?

I want to take some photos with my smartphone. I will receive JPEG files. PPI will be 72. In the next step, I will move these photos to a desktop computer. In the next step I will convert photos from JPEG to TIFF. I don't know what software I'm going to use for this. Maybe GIMP, ImageMagick or something else.

I don't want to use JPEG while editing because JPEG has lossy compression. This affects editing and artifacts. When I edit photos, I save them a few times. If I edit photos in JPEG and save them a few times, I get artifacts in them. I don't want artifacts in photos. For this reason, I convert photos from JPEG to TIFF after moving photos from my smartphone to my desktop computer.

In the next step I will edit these TIFFs: I will cut, scale, rotate some of them. In some photos I will adjust brightness and contrast. I don't know what software I'm going to use for this. Maybe GIMP, ImageMagick or something else.

In the next step I import edited TIFFs into a software in which I arrange photos on pages and add a few lines of text to each – explanation of what is in the photo. I will arrange a few photos and texts for each of them on each page. I will have about 9 or 10 pages. Maybe I'm using LibreOffice Writer, Scribus or something else. In the next step I will create a PDF file.

The next step is to send a PDF file to a friend. Friend will read it on smartphone or desktop computer. He'll be using Adobe Acrobat Reader or something similar. Maybe a friend would like to print this PDF on a printer. In this case, photos on paper should not have pixelated, jagged edges.

Which PPI do I have to set for photos to avoid pixelated, jagged edges on paper?