int main()

#include <iostream>
#include <fstream>
#include <string>
#include <cstring>

using namespace std;

//This program makes a new text file that contains all combinations of two letters.
// aa, ab, ..., zy, zz

int main(){
	string filename = "two_letters.txt";

	ofstream outFile;
	outFile.open(filename.c_str());

	if(!outFile.is_open()){
		cout << "Something's wrong. Closing..." << endl;
		return 0;
	}

	for(char first = 'a'; first <= 'z'; first++){
		for(char second = 'a'; second <= 'z'; second++){
			outFile << first << second << " ";
		}
		outFile << endl;
	}

	return 0;
}

#include <iostream>
#include <cstring>
int main(int argc, char** argv){
	//With decimal
	if(strstr(argv[1], ".") != nullptr){
		int i = 0;
		//Skip i to first non 0 digit
		while(argv[1][i] < '1' || argv[1][i] > '9') ++i;
		//If digit comes before decimal
		if((argv[1] + i) < strstr(argv[1], ".")){	//Good example of pointer arithmetic
			std::cout << strlen(argv[1] + i) - 1 << std::endl;	//Another good example
		}else{
			//If digit is after decimal
			std::cout << strlen(argv[1] + i) << std::endl;
		}
	}else{
	//Without decimal
		int m = 0;
		int i = 0;
		while(argv[1][i] < '1' || argv[1][i] > '9') ++i;	//In case of some number like 0045
		for(; argv[1][i] != '\0'; ++i){
			if(argv[1][i] >= '1' && argv[1][i] <= '9') m = i + 1;
		}
		std::cout << m << std::endl;
	}
	return 0;
}

#include <iostream>
using namespace std;

int main() {


    int arr[5];
    
    for(int i = 0; i < 5; i++) {
        arr[i] = i;
    }

    for(int i = 0; i < 5; i++) {
        cout << "Outputting array info at position " << i + 1 << ": " << arr[i] << endl;
    }

    for(int i=0;i<5;i++)
	{		
		for(int j=i+1;j<5;j++)
		{
			if(arr[i]>arr[j])
			{
				int temp=arr[i];
				arr[i]=arr[j];
				arr[j]=temp;
			}
		}
	}

    cout << endl;

    for(int i = 0; i < 5; i++) {
        cout << "Outputting sorted array info at position " << i + 1 << ": " << arr[i] << endl;
    }

    return 0;
}

//Leif Messinger
//Finds all sets of 5 5 letter words that don't have duplicate letters in either themselves or each other.
//First it reads the words in and puts them in groups of their bitmasks
//After that, we recurse on each group. Before doing that, we remove the group from the set of other groups to check it against.
#include <cstdio> //getchar, printf
#include <cassert> //assert
#include <vector>
#include <set>
#include <algorithm> //std::copy_if
#include <iterator> //std::back_inserter

#define CHECK_FOR_CRLF true
#define MIN_WORDS 5
#define MAX_WORDS 5
#define WORD_TOO_LONG(len) (len != 5)

const unsigned int charToBitmask(const char bruh){
	assert(bruh >= 'a' && bruh <= 'z');
	return (1 << (bruh - 'a'));
}

void printBitmask(unsigned int bitmask){
	char start = 'a';
	while(bitmask != 0){
		if(bitmask & 1){
			putchar(start);
		}

		bitmask >>= 1;
		++start;
	}
}

//Pointer needs to be deleted
const std::set<unsigned int>* getBitmasks(){
	std::set<unsigned int>* bitmasksPointer = new std::set<unsigned int>;
	std::set<unsigned int>& bitmasks = (*bitmasksPointer);

	unsigned int bitmask = 0;
	unsigned int wordLength = 0;
	bool duplicateLetters = false;
	for(char c = getchar(); c >= 0; c = getchar()){
		if(CHECK_FOR_CRLF && c == '\r'){
			continue;
		}
		if(c == '\n'){
			if(!(WORD_TOO_LONG(wordLength) || duplicateLetters)) bitmasks.insert(bitmask);
			bitmask = 0;
			wordLength = 0;
			duplicateLetters = false;
			continue;
		}
		if((bitmask & charToBitmask(c)) != 0) duplicateLetters = true;
		bitmask |= charToBitmask(c);
		++wordLength;
	}

	return bitmasksPointer;
}

void printBitmasks(const std::vector<unsigned int>& bitmasks){
	for(unsigned int bruh : bitmasks){
		printBitmask(bruh);
		putchar(','); putchar(' ');
	}
	puts("");
}

//Just to be clear, when I mean "word", I mean a group of words with the same letters.
void recurse(std::vector<unsigned int>& oldBitmasks, std::vector<unsigned int> history, const unsigned int currentBitmask){
	//If there's not enough words left
	if(oldBitmasks.size() + (-(history.size())) + (-MIN_WORDS) <= 0){
		//If there's enough words
		if(history.size() >= MIN_WORDS){
			//Print the list
			printBitmasks(history);
		}
		return;
	//To make it faster, we can stop it after 5 words too
	}else if(history.size() >= MAX_WORDS){
		//Print the list
		printBitmasks(history);
		return;
	}

	//Thin out the array with only stuff that matches the currentBitmask.
	std::vector<unsigned int> newBitmasks;
	std::copy_if(oldBitmasks.begin(), oldBitmasks.end(), std::back_inserter(newBitmasks), [&currentBitmask](unsigned int bruh){
		return (bruh & currentBitmask) == 0;
	});

	while(newBitmasks.size() > 0){
		//I know this modifies 'oldBitmasks' too. It's intentional.
		//This makes it so that the word is never involved in any of the child serches or any of the later searches in this while loop.
		const unsigned int word = newBitmasks.back(); newBitmasks.pop_back();

		std::vector<unsigned int> newHistory = history;
		newHistory.push_back(word);

		recurse(newBitmasks, newHistory, currentBitmask | word);
	}
}

int main(){
	const std::set<unsigned int>* bitmasksSet = getBitmasks();
	std::vector<unsigned int> bitmasks(bitmasksSet->begin(), bitmasksSet->end());
	delete bitmasksSet;

	recurse(bitmasks, std::vector<unsigned int>(), 0);

	return 0;
}

#include <iostream>
#include <string>	//Should already be in iostream
#include <cstdlib>

//A word score adds up the character values. a-z gets mapped to 1-26 for the values of the characters.

//wordScore [wordValue]
//Pipe in the input into stdin, or type the words yourself.

//Lowercase words only
int characterValue(const char b){
	return ((b >= 'a') && (b <= 'z'))? ((b - 'a') + 1) : 0;
}

int main(int argc, char** argv){
    //The first argument specifies if you are trying to look for a certain word score
	int wordValue = (argc > 1)? std::atoi(argv[1]) : 0;

	std::string line;
	while(std::getline(std::cin, line)){
		int sum = 0;
		for(const char c : line){
			sum += characterValue(c);
		}
		if(wordValue){	//If wordValue is 0 or the sum is the correct value
			if(wordValue == sum){
				std::cout << line << std::endl;
			}
		} else {
			std::cout << sum << "\t" << line << std::endl;
		}
	}
	return 0;
}