code stringlengths 1 1.72M | language stringclasses 1 value |
|---|---|
__author__="zoltan kochan"
__date__ ="$12 лют 2011 14:43:42$"
#from core.models.ling_units import *
from core.models.ling_units import ConjuctionStructure, Token
from core.constants import sentence_end
from core.constants import conj_type
from core.constants import concept
from core.constants import position
from core.constants import tags
from core.constants import case, number ##
import core.constants
from core.constants import INHERIT_NAME, INHERIT_VALUE, STATE_START
from core.constants import type as ltype
import sys
import os
from string import digits
from core.lang.process import parse
from copy import deepcopy
import core.compilers.cws as cws
import core.compilers.atnl as atnl
import os, glob
curr_dict = sys.modules[core.constants.__name__].__dict__
def markov(s, tr):
'''Markov's algorithm.'''
for old, new in tr:
if s.find(old) != -1:
s = s.replace(old, new)
return s
class Language():
'''Language is an object that stores all the info about a language.
Like dictionary, grammar, contradictions, etc.'''
# uncomplited = ["..."] #""
# exclamation = ["!"]
# question = ["?"]
# question_exclamation = ["?!"]
space = " "
comma = ","
semicolon = ";"
colon = ":"
# new_par = "~"
question = "?"
exclamation = "!"
point = "."
sent_end = {".": sentence_end["point"],
"...": sentence_end["uncomplited"]}
# "?": SENTENCE_END_QUESTION,
# ""}
def __str__(self):
return self.name
def __init__(self, lang_name):
curr = str(os.path.dirname(sys.argv[0]))
path = os.path.join(os.path.join(curr, "data"), lang_name)
self.name = lang_name
self.path = path
self.separators = [", ", ". "]
self.space = " "
self._init_conjunctions()
self._init_dictionary()
self._init_grammar()
self._init_contr()
#print "ready"
def to_type_code(self, label):
return self.label_types[label.split(":")[0]]
@staticmethod
def _parse_bool(s):
return s == "True"
def _read_file(self, file_path):
global f,s
try:
f = open(file_path, encoding = 'utf-8')
s = [x.split('#')[0].strip() for x in f.readlines()]
i = 0
while i < len(s):
if len(s[i]) == 0:
del s[i]
elif s[i][-1] != '\\':
i += 1
else:
s[i] = s[i][:-1] + ' ' + s[i + 1]
del s[i + 1]
except IOError:
print("can't open file '" + os.path.join(self.path, file_path) + "'")
finally:
f.close()
return s
def divide_into_words(self, text):
"""Lexing : Input is split into tokens"""
res = [text.strip(self.space) + self.space]
if text in self.separators:
return res
for sep in self.separators:
res1 = []
for x in res:
t = x.split(sep)
tt = []
for y in t[:-1]:
tt += [y, sep]
tt += [t[-1]]
res1 += tt
res = res1
start = res
res = []
for x in start:
if x in self.separators:
res += [x]
else:
res += x.split(self.space)
res = [w for w in res if w != ""]
return res
def _init_contr(self):
d = {}
for s in self._read_file(os.path.join(self.path, "contr.txt")):
a, b = s.split("->")
a = a.strip()[1:-1]
b = b.strip()[1:-1]
if a in d:
d[a].append(b)
else:
d[a] = [b]
self.contr = []
for k in d.keys():
self.contr.append((k, d[k]))
def gen_to_ipa(self):
return lambda text: [markov(s, self.tr) for s in text]
def _init_tr(self):
s = self._read_file(os.path.join(self.path, "ipa.txt"))
self.tr = []
if s == [] or s == None or s[0] == "": return
i = 0
while i < len(s):
t1, t2 = [x.strip() for x in s[i].split("->")]
if (not (t1[0] == t1[-1] == t2[0] == t2[-1] == "\"")):
raise Exception("invalid text in _init_tr")
self.tr += [(t1[1:-1], t2[1:-1])]
i += 1
def _init_grammar(self):
print("Initializing %s grammar" % self.name)
res = atnl.parse_file(os.path.join(os.path.join(self.path, "grammar"), "atnl.txt"))
if res is None:
print('error')
else:
print('done')
self.atn, self.label_types = res
def _init_dictionary(self):
self._init_tr()
self.vocabulary, self.meanings = cws.parse_files(os.path.join(self.path, 'dictionary'), self.gen_to_ipa(), True)
self.words = []
for k in self.vocabulary.keys():
self.words += self.vocabulary[k]
def _init_conjunctions(self):
s = self._read_file(os.path.join(self.path, "conj.txt"))
i = 0
self.conjunctions = []
while i < len(s):
c = ConjuctionStructure()
self.conjunctions.append(c)
c.function_number = int(s[i].strip()[1:-1])
i += 2
c.por = [ltype[x.strip()] for x in s[i].split(':')[1].split(",")]# self._conditions(s[i].split(':')[1])
i += 1
while i < len(s) and s[i] != "}":
p = [x.strip().lower() for x in s[i].split(':')]
if len(p) == 1:
c.__dict__[p[0]] = True
elif p[0] in ["order", "max-items"]:
c.__dict__[p[0]] = int(p[1])
elif p[0] == "conj-type":
c.conj_type = conj_type[p[1]]
else:
c.__dict__[p[0].replace("-", "_")] = p[1][1:-1]
i += 1
i += 1
def is_punctuation(self, text):
return text in [self.comma, self.semicolon, self.colon,\
self.exclamation, self.question, self.point]
def is_number(self, t):
for s in t:
if not s in digits:
return False
return True
def init_words(self, text, start = 0, end = 0):
result = []
words = []
tt = text.pop(0)
t = tt.lower()
if self.is_number(t):
w = Token(type["numeral"], [tt], start, end)
w.meaning = t
w.num_type = NUM_TYPE_CARDINAL
w.str_type = STR_TYPE_DIGITS
return [([w], text)]
if t[-3:] in ["1st", "2nd", "3rd"] or t[-2:] == "th" and self.is_number(t[:-2]):
w = Token(type["numeral"], [tt], start, end)
w.meaning = t[:-2]
w.num_type = NUM_TYPE_ORDINAL
w.str_type = STR_TYPE_DIGITS
return [([w], text)]
if self.is_punctuation(t):
w = Token(ltype["punctuation"], [tt], start, end)
words += [w]
for x in self.conjunctions:
if t == x.before:
pos = position["before"]
elif t == x.among:
pos = position["among"]
elif t == x.after:
pos = position["after"]
else:
continue
w = Token(ltype["conjunction"], [tt], start, end)
w.position = pos
#w.type = type["conjunction"]
w.conjuction_structure = deepcopy(x)
words += [w]
if words != []: #EITHER MAKE AN ERROR HERE OR LET IT WORK WHEN THE FIRST WORD IS KNOWN THE SECOND ISN'T AND IT IS AN IDIOM
result += [(words, deepcopy(text))]
for x in self.vocabulary.get(t, []):
p = [t] + deepcopy(text)
for q in x.text:
if q.lower() != p.pop(0).lower():
break
else:
result += [([deepcopy(x)], p)]
if not result or result == []:
raise Exception("Word '%s' not found in the '%s' dictionary." % (t, self.name))
return result
def morphan(self, text):
'''Morphological analyzation'''
for w, rest in self.init_words(text):
if rest == []:
yield [w]
else:
for ww in self.morphan(rest):
yield [deepcopy(w)] + ww
def remove_contr(self, text):
'''Removes all contradictions from the text'''
ss = [text]
for old, news in self.contr:
for i in range(len(ss)):
temp = ss[0]
del ss[0]
if temp.find(old) != -1:
for new in news:
ss.append(temp.replace(old, new))
else:
ss.append(temp)
return ss
def type_labels(self, type):
return [label for label in self.label_types.keys() if self.label_types[label] == type]
def words_to_mem(self, wss):
mem = []
for ws in wss:
mem += [{}]
for w in ws:
for type in self.type_labels(w.type):
if type in mem[-1]:
mem[-1][type] += [(w, len(mem))]
else:
mem[-1][type] = [(w, len(mem))]
return mem
def init_sentence(self, sent, first = "IP"):
ss = self.remove_contr(sent)
res = []
for s in ss:
y = self.divide_into_words(s)
for r in self.morphan(y):
mr = self.words_to_mem(r)
res += [x[2] for x in parse(self, first, STATE_START, mr)]
return res
def conj_str3(self, fn, ct, cs):
return [x for x in self.conjunctions if fn == x.function_number and ct == x.conj_type and cs == x.conj_str]
def conj_str(self, fn, ct):
return [x for x in self.conjunctions if fn == x.function_number and ct == x.conj_type]
def is_one_conjuction(self, before, among, after):
pass
def synset(self, meaning):
return [w for w in self.meanings[meaning] if w.contains(case["@nominative"]) and w.contains(number["@singular"])]
def definition(self, meaning):
raise NotImplementedError
#global_props = [CONCEPT_CASE, CONCEPT_TENSE, CONCEPT_PARTICIPLE, CONCEPT_PERSONE] | Python |
__author__="zoltan kochan"
__date__ ="$30 жовт 2010 15:55:57$"
import sys
from core.constants import concept, noun_type, modificators, conj_str, number
from core.constants import NONE_VALUE
from core.constants import eq
from core.constants import XFROM_NUMBER, XFROM_EVERY, XFROM_FIRST, XFROM_LAST, XFROM_SUM
from core.constants import type as ltype
from types import *
#TODO: All numbers have the same meaning or doesn't have any. And we know which exatly number is it from real_number! It's genious!!! Then I can use numbers for meanings.
#TODO: use codes instead of interlingua-words
dict = sys.modules[__name__].__dict__
class LingUnit:
parent = None
_attrs = None
def get_ghost(self):
pass
def is_proper(self, eqto):
pass
def attr(self, name, value=-898):
'''Gets or sets the attribute of the object.'''
if value == -898:
return self._attrs.get(name, None)
self._attrs[name] = value
return self._agree(name)
def contains(self, p):
return self.attr(p[0]) == p[1]
def fixed_with(self, name):
pass
def numerate(self, num):
pass
def renumerate(self, num):
pass
def add_attach(self, names):
"the parametheres which must be the same here and in the parent"
for n in names:
if type(n) == tuple:
self._attach_up[n[0]] = n[1]
self._attach_down[n[1]] = n[0]
else:
self._attach_up[n] = n
self._attach_down[n] = n
#self._attach += names
#return all([])
for n in names:
if type(n) == tuple and not self._agree(n[0]) or \
type(n) != tuple and not self._agree(n):
#if type(n) != tuple and not self._agree(n):#####################
return False
return True
def add_fixed(self, fixed):
self.fixed = fixed
return self.add_attach(fixed)
def refresh(self):
for a in self._attach_up:
if not self._agree(a):
return False
return True
rx = {
1: {
concept["number"]: XFROM_NUMBER,
concept["case"]: XFROM_EVERY,
concept["tense"]: XFROM_EVERY,
concept["aspect"]: XFROM_EVERY,
concept["mood"]: XFROM_EVERY,
concept["gender"]: XFROM_SUM,
concept["persone"]: XFROM_SUM,
concept["subject-persone"]: XFROM_EVERY, #############
concept["subject-number"]: XFROM_EVERY, #############
concept["subject-form"]: XFROM_EVERY, #############
concept["object-persone"]: XFROM_EVERY, #############
concept["object-number"]: XFROM_EVERY, #############
concept["object-difinity"]: XFROM_EVERY, #############
concept["object-form"]: XFROM_EVERY, #############
concept["difinity"]: XFROM_FIRST,
concept["participle"]: XFROM_FIRST,##########
},
7: {
concept["number"]: XFROM_NUMBER,
concept["case"]: XFROM_EVERY,
concept["tense"]: XFROM_EVERY,
concept["aspect"]: XFROM_EVERY,
concept["mood"]: XFROM_EVERY,
concept["gender"]: XFROM_SUM,
concept["persone"]: XFROM_SUM,
concept["subject-persone"]: XFROM_EVERY, #############
concept["subject-number"]: XFROM_EVERY, #############
concept["subject-form"]: XFROM_EVERY, #############
concept["object-persone"]: XFROM_EVERY, #############
concept["object-number"]: XFROM_EVERY, #############
concept["object-difinity"]: XFROM_EVERY, #############
concept["object-form"]: XFROM_EVERY, #############
concept["difinity"]: XFROM_FIRST,
concept["participle"]: XFROM_FIRST,##########
},
}
def _eko(self, children, name): #АЛЕ ЦЕ ТРЕБА РОБИТИ ЛИШ В КІНЦІ, БО МІНЯТИ МОЖНА РАЗ
if type(children) != list:
if not (name in children._attach_down):
return True
return self._shift_value(self, name, children.attr(children._attach_down[name]))
if len(children) == 0 or not name in children[0]._attach_down: return True
if len(children) == 1: return self._shift_value(self, name, children[0].attr(children[0]._attach_down[name]))
#it is neendeble in any case. but maybe use all not any???
if any([c.attr(name) == None for c in children]): return True
if self.relation is None:
tx = XFROM_EVERY #?
else:
tx = self.rx[self.relation.function_number][name]
if tx == XFROM_NUMBER:
return self._shift_value(self, name, number["plural"])
elif tx == XFROM_EVERY:
f = children[0].attr(name)
for i in range(len(children) - 1):
if children[i + 1].attr(name) != f:
return False
return self._shift_value(self, name, children[0].attr(name))
elif tx == XFROM_SUM:
return self._shift_value(self, name, children[0].attr(children[0]._attach_down[name]))
elif tx == XFROM_FIRST:
return self._shift_value(self, name, children[0].attr(children[0]._attach_down[name]))
raise NotImplementedError
def _bottom_up_refresh(self, name):
b = []
for l in self.left + [self.blocks] + self.right:
b += [self._eko(l, name)]
if not all(b):
return False
if not self._agree(name): ################################################
return False #########################################################
return True
def _shift_value(self, to_obj, name, value):
temp = to_obj.attr(name)
if temp == None:
return to_obj.attr(name, value)
return eq(temp, value)
def _parent_agree(self, name):
if self.parent and name in self._attach_up:#name in self._attach and self.parent:
if not self.parent._bottom_up_refresh(self._attach_up[name]):
return False
return True
def _agree(self, name):
if not self._parent_agree(name):
return False
return True
def __init__(self, type, start, end):
self._attrs = {}
self.type = type
self.start = start
self.end = end
self._attach_up = {}
self._attach_down = {}
self.left = []
self.blocks = []
self.right = []
def get_focused_ling_unit(self, cursor):
""" Returns the focused object """
if self.start <= cursor <= self.end:
return self
return None
def get_tree(self): raise NotImplementedError
#return new TreeNode(this.ToString());
#return TreeNode(str(self))
def to_rtf(self):
raise NotImplementedError
def get_type(self):
return self.attr(concept["type"])
def set_type(self, type):
return self.attr(concept["type"], type)
type = property(get_type, set_type)
class NodeLingUnit(LingUnit):
blocks = None
def __init__(self, type, start, end):
self.blocks = []
LingUnit.__init__(self, type, start, end)
def get_focused_ling_unit(self, cursor):
for x in self.blocks:
temp = x.get_focused_ling_unit(cursor)
if temp: return temp
return LingUnit.get_focused_ling_unit(self, cursor)
def get_tree(self): raise NotImplementedError
#if len(blocks):
# return blocks[0].gtree()
# if (Blocks.Count == 1)
# return Blocks[0].GetTree();
# TreeNode t = new TreeNode(this.ToString());
# foreach (T n in Blocks)
# {
# t.Nodes.Add(n.GetTree());
# }
# return t;
class RelationLingUnit(NodeLingUnit):
relation = None
def __init__(self, type, start, end):
NodeLingUnit.__init__(self, type, start, end)
class FlowerLingUnit(RelationLingUnit):
left = None
right = None
def __init__(self, type, start, end):
self.left = []
self.right = []
RelationLingUnit.__init__(self, type, start, end)
def get_focused_ling_unit(self, cursor): raise NotImplementedError
def get_tree(self): raise NotImplementedError
def __str__(self):
s = ""
if self.left:
for l in self.left:
if not l.get_ghost():
s += str(l) + " "
if self.relation:
if self.relation.before:
bef = self.relation.before + " "
else:
bef = ""
if self.relation.among:
am = self.relation.among + " "
else:
am = ""
if self.relation.after:
af = self.relation.after + " "
else:
af = ""
if self.relation.with_comma:
comma = ","
else:
comma = ""
else:
bef, am, af, comma = "", "", "", ""
s += bef
for b in self.blocks[:-1]:
if not b.get_ghost():
s += str(b) + comma + " " + am # + " "
s += str(self.blocks[-1])
s += af
if self.right:
for r in self.right:
if not r.get_ghost():
s += " " + str(r) if r.type != ltype["punctuation"] else str(r)
if self.type == ltype["sentence"]:
#s += "."
s = s[0].upper() + s[1:]
return s.strip()
def fixed_with(self, name):
return any([x.fixed_with(name) for x in self.left + self.blocks + self.right])
def get_ghost(self):
return any([x.get_ghost() for x in self.left + self.blocks + self.right])
def _top_down_shift(self, obj, name, value):
return value == NONE_VALUE or value != NONE_VALUE and self._shift_value(obj, name, value)
def _agree(self, name):
value = self._attrs.get(name, None)
if value != None:
#top-down refresh
#if not all([self._shift_value(b, b._attach_down[name], value) for b in self.left if name in b._attach_down]):
# return false #IT IS ANALOGICAL
for b in self.left:
if name in b._attach_down:
if not self._top_down_shift(b, b._attach_down[name], value):
return False
if len(self.blocks) <= 1 or self.relation is None or \
self.rx[self.relation.function_number].get(name, None) == XFROM_EVERY:
for b in self.blocks:
if name in b._attach_down:
if not self._top_down_shift(b, b._attach_down[name], value):
return False
for b in self.right:
if name in b._attach_down:
if not self._top_down_shift(b, b._attach_down[name], value):
return False
return LingUnit._agree(self, name)
def numerate(self, num):
for e in self.left + self.blocks + self.right:
num = e.numerate(num)
return num
def renumerate(self, num=None):
if self.attr(concept["order-number"]) != None:
if num == None:
return self.attr(concept["order-number"]) + 1, 0
res = abs(self.attr(concept["order-number"]) - num)
return num + 1, res
res = 0
for e in self.left + self.blocks + self.right:
num, diff = e.renumerate(num)
res += diff
return num, res
def get_cblocks(self):
if self.relation == None:
return self.blocks
bl = []
if self.relation.before != None:
w = Token(self.relation.before)
w.type = ltype["conjunction"]
w.transcription = self.relation.before_transcription
bl += [w]
am = self.relation.among != None
for b in self.blocks[:-1]:
bl += [b]
if am:
w = Token(self.relation.among)
w.type = ltype["conjunction"]
w.transcription = self.relation.among_transcription
bl += [w]
bl += [self.blocks[-1]]
if self.relation.after != None:
w = Token(self.relation.after)
w.type = ltype["conjunction"]
w.transcription = self.relation.after_transcription
bl += [w]
return bl
cblocks = property(get_cblocks)
def is_proper(self, eqto):
pass
class ConjuctionStructure:
before = None
among = None
after = None
with_comma = None
connect = None
function_number = None
order = None
max_items = None
por = None
conj_type = None
def __init__(self):
self.with_comma = False
self.connect = False
self.por = []
# def __init__(self, before, among, after):
# self.before = before
# self.among = among
# self.after = after
def __eq__(self, other):
# return not self and not other or \
# self and other and \
# self.before == other.before and \
# self.among == other.among and \
# self.after == other.after and \
# self.with_comma == other.with_comma and \
# self.connect == other.connect and \
# self.function_number == other.function_number and \
# self.order == other.order #and \
# # self.por == other.por #if i want to use (actiolly there's no obvious need in it) I must choose another way to compare them!!!
return not self and not other or \
self and other and \
(self.before == other.before and \
self.among == other.among and \
self.after == other.after and \
self.with_comma == other.with_comma and \
self.connect == other.connect and \
self.function_number == other.function_number and \
self.order == other.order or \
#self.conj_type == order.conj_type and \
#self.max_items == order.max_items or \
self.before == other.before == None and \
self.among and other.among and \
self.after == other.after == None and \
self.connect == other.connect and \
self.function_number == other.function_number and \
self.order == other.order) #and \
#self.conj_type == order.conj_type and \
#self.max_items == order.max_items)
def __ne__(self, other):
return not (self == other)
def get_conj_str(self):
if self.before:
if self.among:
if self.after:
return conj_str["before-among-after"]
else:
return conj_str["before-among"]
elif self.after:
return conj_str["before-among"]
else:
return conj_str["before"]
elif self.among:
if self.after:
return conj_str["after"]
else:
return conj_str["among-after"]
elif self.after:
return conj_str["after"]
else:
return conj_str["nothing"]
conj_str = property(get_conj_str)
#class Transcription:
# #the first 3 parameters are boolean
# stressed = None
# before_a_vowel = None
# after_a_vowel = None
# transcription = None
#TODO: Add a Lang property.
class Token(LingUnit):
fixed = None
_is_ghost = None #is empty?
_text = None
#Phonetic transcription in International Phonetic Alphabet
def get_transcription(self):
return self.attr(concept["transcription"])
def set_transcription(self, transcription):
return self.attr(concept["transcription"], transcription)
transcription = property(get_transcription, set_transcription)
def get_ghost(self):
return self._is_ghost
def set_ghost(self, value):
self._is_ghost = value
def get_meaning(self):
return self.attr(concept["lemma"])
def set_meaning(self, meaning):
return self.attr(concept["lemma"], meaning)
meaning = property(get_meaning, set_meaning)
def numerate(self, num):
if self.type in modificators: return num#0
self.attr(concept["order-number"], num)
return num + 1
#TODO: TAKE A LOOK AT renumerate1
# def renumerate1(self, num):
# if self.type in modificators: return num, 0#0, 0
# if self.attr(concept["order_number"]) == None:
# res = 0
# else:
# res = abs(self.attr(concept["order_number"]) - num)
# self.attr(concept["order_number"], num)
# return num + 1, res
def renumerate(self, num):
if self.type in modificators: return num, 0#0, 0
if num == None:
if self.attr(concept["order_number"]) == None:
return None, 0
else:
return self.attr(concept["order_number"]) + 1, 0
if self.attr(concept["order_number"]) == None:
res = 0
else:
res = abs(self.attr(concept["order_number"]) - num)
return num + 1, res
def descr(self):
return "(" + str(self.text) + "[" + str(self.meaning) + "] " + str(self._attrs)
#return "(" + str(str(self.text).encode("iso-8859-1")) + "[" + str(self.meaning) + "] " + str(self._attrs)
# def __eq__(self, obj):
# #print("zxx")
# if obj is None:
# return False
# if not (self.type == obj.type and self.meaning == obj.meaning):
# #print "zxx"
# return False
# for key in self._attrs.keys():
# #if key == concept["TAGS: continue ####
# if self._attrs.get(key, None) != obj._attrs.get(key, None):
# #print "zxx"
# return False
# for key in obj._attrs.keys():
# #if key == concept["TAGS: continue #####
# if self._attrs.get(key, None) != obj._attrs.get(key, None):
# #print "zxx"
# return False
# #print "zxx"
# return True
# #return False
# #raise NotImplementedError
def __ne__(self, obj):
return not self.__eq__(obj)
def fixed_with(self, name):
return name in self.fixed
def set_type(self, value):
if value > LAST_TERMINAL:
raise ArgumentError("in Word.type")
def __init__(self, type = None, text = None, start = None, end = None):
self.por = []
self.text = text
#######
#self._attach = []
self.fixed = []
#######
LingUnit.__init__(self, type, start, end)
def __str__(self):
if self.text == None: return ""
s = ""
for t in self.text:
s += t + " "
if self.attr(concept["noun-type"]) == noun_type["proper"]:
s = s[0].upper() + s[1:]
return s[:-1]#.decode("utf8")
def set_text(self, value):
self._text = value
# _text = lower(value)
# if Lang.is_punctuation(value):
# self.type = SYNTACTIC_CATEGORY_PUNCTUATION
# return
# if Lang.modifiers.contains(_text):
# pass
def get_text(self):
return self._text
def del_text(self):
del self._text
text = property(get_text, set_text, del_text)
def get_ltext(self):
return self.text[-1]
def set_ltext(self, value):
self.text[-1] = value
def del_ltext(self):
del self.text[-1]
ltext = property(get_ltext, set_ltext, del_ltext)
| Python |
#!/usr/bin/env python
# -*- coding: latin-1 -*-
# -*- coding: cp1252 -*-
annadTup = (1, 5, 10, 50, 100, 500, 1000)
ag = {1: 'I', 5: 'V', 10: 'X', 50: 'L', 100: 'C', 500: 'D', 1000: 'M'}
ga = {'I': 1, 'V': 5, 'X': 10, 'L': 50, 'C': 100, 'D': 500, 'M': 1000}
tala = input()
tala = int(tala)
tups = ("", tala)
def Giskun(tup):
for x in range(len(annadTup)-1):
if int(tup[1]) in range(annadTup[x], annadTup[x+1]):
return (str(tup[0])+str(ag[annadTup[x]])), (int(tup[1])-int(annadTup[x]))
print("Villa") # Þetta gerist en þá returnast ekkert, gerist bara fyrir tölur >= 1000
def Snyrting(strengur):
strengur = strengur.replace('CCCC', 'CD')
strengur = strengur.replace('XXXX', 'XL')
strengur = strengur.replace('IIII', 'IV')
return strengur
einhverListi = []
einhverListi.append(tups)
ind = 0
while einhverListi[ind][1] != 0:
einhverListi.append(Giskun(einhverListi[ind]))
ind += 1
Svar = Snyrting(einhverListi[ind][0])
print(Svar)
| Python |
file = open("PROBLEMX.DAT", "r")
tolurnar = [line.split(' ') for line in file.readlines()]
for x in range(0, len(tolurnar), 1):
print(int(tolurnar[x][0]) + int(tolurnar[x][1]))
| Python |
import random
def skodaFylki(fylki):
for x in range(1, len(fylki)):
if fylki[x] < fylki[x-1]:
return fylki[x]
mengi = []
n = input()
for x in range(int(n)):
mengi.append(int(n)+1)
stadur = random.randrange(0,int(n))
tala = random.randrange(1,int(n)+1)
mengi.insert(stadur, tala)
print(skodaFylki(mengi))
| Python |
# Breyta tolum i romverskar tolur
# M = 1000
# D = 500
# C = 100
# L = 50
# X = 10
# V = 5
# I = 1
annadTup = (1, 5, 10, 50, 100, 500, 1000)
ag = {1: 'I', 5: 'V', 10: 'X', 50: 'L', 100: 'C', 500: 'D', 1000: 'M'}
ga = {'I': 1, 'V': 5, 'X': 10, 'L': 50, 'C': 100, 'D': 500, 'M': 1000}
def agiskunaradferd(tup):
for x in range(len(annadTup)-1):
if int(tup[1]) in range(annadTup[x], annadTup[x+1]):
return ((str(tup[0])+str(ag[annadtup[x]])), (int(tup[1])-int(annadTup[x])))
def laga(str):
for x in range(3, len(str)):
if str[x-3] == str[x-2] == str[x-1] == str[x]:
for y in range(len(annadTup)):
if ga[str[x]] == annadTup[y]:
bla = str[x] + ag[annadTup[y+1]]
return str.replace(str[x], bla)
tala = input('Hvada tolu viltu skrifa sem romverska tolu? ')
tups = ("", tala)
z = 0
listiAfTuplum = []
listiAfTuplum.append(tups)
print(listiAfTuplum[0][1])
print(agiskunaradferd(listiAfTuplum[0])[1])
#while 0 != int(listiAfTuplum[z][1]):
# listiAfTuplum.append(agiskunaradferd(listiAfTuplum[z]))
# z += 1
#laga(listiAfTuplum[z][0])
| Python |
x = input("Fyrri Talan: ")
y = input("Seinni Talan: ")
if x > y:
print(x, y)
if y > x:
print(y, x)
if x == y:
print("Tölurnar eru jafnar: " + str(x))
| Python |
#verk4
def fall(a, n):
return a**n
Tala = 6
Veldi = 3
print(fall(Tala, Veldi))
| Python |
#!/usr/bin/env python
# -*- coding: latin-1 -*-
# -*- coding: cp1252 -*-
annadTup = (1, 5, 10, 50, 100, 500, 1000)
ag = {1: 'I', 5: 'V', 10: 'X', 50: 'L', 100: 'C', 500: 'D', 1000: 'M'}
ga = {'I': 1, 'V': 5, 'X': 10, 'L': 50, 'C': 100, 'D': 500, 'M': 1000}
tala = input()
tala = int(tala)
tups = ("", tala)
def Giskun(tup):
for x in range(len(annadTup)-1):
if int(tup[1]) in range(annadTup[x], annadTup[x+1]):
return (str(tup[0])+str(ag[annadTup[x]])), (int(tup[1])-int(annadTup[x]))
print("Villa") # Þetta gerist en þá returnast ekkert, gerist bara fyrir tölur >= 1000
def Snyrting(strengur):
strengur = strengur.replace('CCCC', 'CD')
strengur = strengur.replace('XXXX', 'XL')
strengur = strengur.replace('IIII', 'IV')
return strengur
einhverListi = []
einhverListi.append(tups)
ind = 0
while einhverListi[ind][1] != 0:
einhverListi.append(Giskun(einhverListi[ind]))
ind += 1
Svar = Snyrting(einhverListi[ind][0])
print(Svar)
| Python |
sentimetrar = input()
print(int(sentimetrar)/2.54)
| Python |
def finnaDeili(x, y):
if x < y:
meh = y
y = x
x = meh
if x == y:
return x
afgangur = 7788
while afgangur:
if x > y:
afgangur = x%y
x = afgangur
elif y > x:
afgangur = y%x
y = afgangur
if x == 0:
return y
return x
tala1 = input()
tala2 = input()
print(finnaDeili(int(tala1), int(tala2)))
| Python |
#Verkefni 15
#!/usr/bin/env python
# -*- coding: latin-1 -*-
# -*- coding: cp1252 -*-
f = open("PROBLEMB.DAT", "r")
linur = f.readlines()
def greining(x):
x = float(x)
x = x*1000000
upp = 0
nidur = 0
while x < 1000000:
x = invDown(x)
nidur += 1
if x > 1000000:
x = invUp(down(x))
upp += 1
nidur -= 1
return (upp, nidur)
def down(x):
return int(x*0.8)
def invUp(x):
return int(x/0.9)
def invDown(x):
return int(x/0.8)
for x in range(len(linur)):
print("Upp: %d, Niður: %d" % greining(linur[x].strip()))
print()
| Python |
#verk5
mengi = []
for x in range(10):
mengi.append(int(input()))
mengi = sorted(mengi)
for x in range(10):
print(mengi[x])
| Python |
# Grf að í einu ári séu 31*12 dagar
kennitala = input("Kennitala: ")
tala = int(kennitala[0] + kennitala[1]) + 31*(int(kennitala[2]+kennitala[3])-1) # Hver dagur hefur einhverja tölu sem við getum kannað hvort sé á ákveðnu bili
stjornumerki = {0:'Steingeit', 21:'Vatnsberi', 20+31:'Fiskur', 21+31*2:'Hrútur', 21+31*3:'Naut', 22+31*4:'Tvíburi', 21+31*5:'Krabbi',
24+31*6:'Ljón', 24+31*7:'Meyja', 24+31*8:'Vog', 23+31*9:'Sporðdreki', 22+31*10:'Bogmaður', 22+31*11:'Steingeit'}
rettTala = 0
for x in stjornumerki.keys():
if tala > x and rettTala < x:
rettTala = x
print(stjornumerki[rettTala])
| Python |
#Verkefni13
f = open("texti.txt", "r")
linur = [line.split(' ') for line in f.readlines()]
for x in range(len(linur)):
print(len(linur[x])) | Python |
mengi = [["0" for x in range(0, 15)] for x in range(0, 3)]
for y in range(15):
mengi[0][y] = y+1
mengi[1][y] = 2*y+1
mengi[2][y] = int(mengi[2][y-1]) + mengi[1][y]
for y in range(15):
for x in range(3):
print(str(mengi[x][y]) + " ", end='')
print()
print()
| Python |
tala1 = int(input("Fyrri talan: "))
tala2 = int(input("Seinni talan: "))
if tala1 % tala2 == 0:
print(str(tala2) + " gengur upp í " + str(tala1))
else:
print(str(tala2) + " gengur ekki upp í " + str(tala1))
| Python |
# Verður að vera recursive
def veldi(tala, veldid, heildartala = 0): # Get varla gert þetta nema með 3 arguments eða er ég að missa af einhverju?
if heildartala == 0:
heildartala = tala # Má víst ekki setja heildartala = tala í arguments
if veldid == 1:
return heildartala
return veldi(tala, veldid-1, heildartala*tala)
tala = int(input("Tala sem á að hefja í veldi: "))
veldisvisir = int(input("Veldisvísir: "))
print(veldi(tala, veldisvisir))
| Python |
def metraITommur(metrar, sentimetrar):
summaIcm = metrar * 100 + sentimetrar
return (str(summaIcm//30.5) + " fet og " + str(summaIcm%30.5/2.53) + " tommur")
def tommurIMetrum(fet, tommur):
fjoldiCm = 2.53 * tommur + 30.5*fet
return (str(fjoldiCm//100) + " metrar og " + str(fjoldiCm%100) + " sentímetrar")
print("Veldu á hvorn veg á að breyta: ")
print("Metra í tommur (1)") # Veit ekki af hverju ég gerði ekki metra í fet eða sentímetra í tommu en ég stend við þetta val mitt
print("Tommur í metra (2)")
val = int(input("Val: "))
if val == 1:
print(metraITommur(float(input("Fjöldi metra: ")), float(input("Fjöldi sentímetra: "))))
elif val == 2:
print(tommurIMetrum(float(input("Fjöldi feta: ")), float(input("Fjöldi tomma: "))))
else:
print("Röng tala")
| Python |
timakaup = int(input("Tímakaup: "))
timar = int(input("Fjöldi tíma: "))
bonus = int(input("Bónusupphæð: "))
bonusvidmid = int(input("Bónus viðmiðun: "))
heildarlaun = timar * timakaup
if bonusvidmid < timar:
heildarlaun += bonus
print("Heildarlaun: " + str(heildarlaun))
| Python |
def lota(strengur):
strengur = strengur.lower().replace(" ", "")
mogulegarStaerdirLotu = []
for x in range(2, len(strengur)):
if len(strengur) % x == 0:
mogulegarStaerdirLotu.append(x)
for x in mogulegarStaerdirLotu: # Könnum allar stærðir á lotum
gildir = True
fjoldiLota = int(len(strengur)/x)
for y in range(0, x): # Kíkjum á alla stafi í einhverri lotu
for z in range(1, fjoldiLota):
if strengur[y] != strengur[y+x*z]:
gildir = False
if gildir:
return True
return False
strengur = input("Strengur sem á að athuga hvort sé lotubundinn: ")
print(lota(strengur))
| Python |
strengur = input("orð: ")
listi = []
for x in strengur:
listi.append(x)
tempListi = list(listi)
tempListi.sort()
tala = listi.index(tempListi[0])
annarListi = []
for x in range(tala+1, len(listi)):
annarListi.append(listi[x])
fleiriListar = list(annarListi)
fleiriListar.sort()
seinniPartur = False
if fleiriListar == annarListi:
seinniPartur = True
annarListi = []
for x in range(0, tala, -1):
annarListi.append(listi[x])
fleiriListar = list(annarListi)
fleiriListar.sort()
fyrriPartur = False
if fleiriListar == annarListi:
fyrriPartur = True
if fyrriPartur and seinniPartur:
print("Oddaorð")
else:
print("Ekki oddaorð")
| Python |
hFlis = int(input("Hæð flísar: "))
bFlis = int(input("Breidd flísar: "))
hFlatar = int(input("Hæð flatar: "))
bFlatar = int(input("Breidd flatar: "))
haegt = True
if hFlatar % hFlis != 0 and bFlatar % bFlis != 0:
haegt = False
if hFlatar % (hFlis/2) != 0 or bFlatar % (bFlis/2) != 0:
haegt = False
if haegt:
print(str(int((hFlatar*bFlatar)/(hFlis*bFlis))))
else:
print("ekki hægt")
| Python |
dagur = int(input("Hvaða dagur er í dag: "))
dagar = int(input("Fjöldi daga: "))
dagur -= 1
vikudagar = ["sunnudagur", "mánudagur", "þriðjudagur", "miðvikudagur", "fimmtudagur", "föstudagur", "laugadagur"]
samtals = dagur + dagar
print("Eftir " + str(dagar) + " daga er " + vikudagar[samtals%7])
| Python |
strengur = input("Strengur: ")
stafirIStreng = []
fjoldi = []
for x in strengur:
if x in stafirIStreng:
fjoldi[stafirIStreng.index(x)] += 1
else:
stafirIStreng.append(x)
fjoldi.append(1)
stafrof = list(stafirIStreng)
stafrof.sort()
for x in stafrof:
print(x*fjoldi[stafirIStreng.index(x)])
| Python |
#!/usr/bin/env python
# -*- coding: latin-1 -*-
# -*- coding: cp1252 -*-
alphabet = "AÁBCDÐEÉFGHIÍJKLMNOÓPQRSTUÚVWXYZÞÆÖ"
file = open("texti.txt", "r")
ordin = [line.split(' ') for line in file.readlines()]
stafirnir = []
for x in range(len(alphabet)):
stafirnir.append()
for y in range(len(ordin)):
for z in range(len(ordin[y])):
if ordin[y][z] == alphabet[x]:
stafirnir[x] += 1
strengir = []
for x in stafirnir:
strengir.append("*\n"*x+x)
for x in strengir:
print(x)
#þetta er vitlaust.
| Python |
fjoldi = int(input("Fjöldi einstaklinga: "))
f = open("kjulli.txt", "r")
meinturFjoldi = int(f.readline())
for x in f.readlines():
if "*" in x:
break
listi = x.split(" ")
tala = int(listi[1])*fjoldi/meinturFjoldi
print(listi[0] + " " + str(tala) + " " + listi[2], end="")
| Python |
strengur = ""
hlidalengd = int(input())
for x in range(hlidalengd):
strengur += "Q"
while hlidalengd > 0:
strengur = "\n" + strengur
strengur = "Q" + strengur
if hlidalengd > 1:
for x in range(hlidalengd-2):
strengur = " " + strengur
strengur = "Q" + strengur
hlidalengd -= 1
print(strengur)
#held þetta sé rétt....
| Python |
#!/usr/bin/env python
# -*- coding: latin-1 -*-
# -*- coding: cp1252 -*-
def summa(tala):
summa = 0
for x in range(1, tala):
if x%2 == 1 or x%6==0:
summa += x
return summa
tala= int(input())
print (summa(tala))
| Python |
fjoldiFerda = int(input("Fjöldi ferða: "))
staktVerd = int(input("Verð á stakri ferð: "))
verdA10Ferdum = int(input("Verða á 10 ferðum: "))
arskort = int(input("Verð á árskorti: "))
if(fjoldiFerda//10 * verdA10Ferdum + fjoldiFerda%10 * staktVerd > arskort):
print("Árskort")
else:
print(str(fjoldiFerda//10) + " 10 miða kort og " + str(fjoldiFerda%10) + " stakar ferðir")
| Python |
listi = []
for x in range(0, 10):
listi.append(int(input()))
for x in range(9, -1, -1):
print(listi[x])
| Python |
def loð(breidd):
mengi = []
for i in range(10,200,10):
mengi.append(float((i*breidd)/4046))
print("lengd " + "Stærð í ekrum")
for j in range(0,10):
print((j+1)*10, end=" ")
print(mengi[j])
breidd= int(input())
loð(breidd)
| Python |
#!/usr/bin/env python
# -*- coding: latin-1 -*-
# -*- coding: cp1252 -*-
def summa(tala):
summa = 0
for x in range(1, tala):
if x%2 == 1 or x%6==0:
summa += x
return summa
tala= int(input())
print (summa(tala))
| Python |
#!/usr/bin/env python
# -*- coding: latin-1 -*-
# -*- coding: cp1252 -*-
#def lesa(strengur):
strengur= "6+7-56 + 4"
tala = 0
temp = ""
formerki = 1
for x in strengur:
if x == "+":
tala += formerki*int(temp)
formerki = 1
temp = ""
elif x == "-":
tala += formerki*int(temp)
formerki = -1
temp = ""
elif x != " ":
temp += x
tala += formerki*int(temp)
print(str(tala))
#return (mengi)
#strengur=str(input())
#print (lesa(strengur))
| Python |
#!/usr/bin/env python
# -*- coding: latin-1 -*-
# -*- coding: cp1252 -*-
alphabet = "AÁBCDÐEÉFGHIÍJKLMNOÓPQRSTUÚVWXYZÞÆÖ"
file = open("texti.txt", "r")
ordin = [line.split(' ') for line in file.readlines()]
stafirnir = []
for x in range(len(alphabet)):
stafirnir.append()
for y in range(len(ordin)):
for z in range(len(ordin[y])):
if ordin[y][z] == alphabet[x]:
stafirnir[x] += 1
strengir = []
for x in stafirnir:
strengir.append("*\n"*x+x)
for x in strengir:
print(x)
#þetta er vitlaust.
| Python |
def lagari(fylki):
hjalp = "ABCD"
for x in range(5):
for y in range(5):
if fylki[x][y] == "XX":
fylki[x][y] = hjalp[x] + str(y)
else:
fylki[x][y] = int(fylki[x][y])
return fylki
def geneq(fylki):
jofnur = [["0" for x in range(5)] for x in range(9)]
for rod in range(4):
for dalkur in range(5):
jofnur[rod][dalkur] = fylki[dalkur][rod]
for dalkur in range(4):
for rod in range(5):
jofnur[dalkur+4][rod] = fylki[dalkur][rod]
for x in range(5):
jofnur[8][x] = fylki[x][x]
for x in jofnur:
for y in range(4):
if str(x[y]).isdigit():
x[4] = int(x[4])
x[4] -= x[y]
x.pop(y)
return jofnur
#def reiknirit(jofnur):
inntak = """XX XX 13 XX 67
3 XX XX XX 37
XX XX XX 11 34
XX 15 XX XX 69
52 48 31 76 38"""
strengir = inntak.splitlines()
ordin = [line.split(' ') for line in strengir]
ordin = lagari(ordin)
print(geneq(ordin))
for x in range(5):
for y in range(5):
print(ordin[x][y], end=' ')
print()
| Python |
strengur = input("Skammstöfun: ")
rett = True
if len(strengur) != 7:
rett = False
for x in range(3):
if strengur[x].islower():
rett = False
for x in range(3, 7):
if not strengur[x].isdigit():
rett = False
if rett:
print("Rétt skammstöfun")
else:
print("Röng skammstöfun")
| Python |
import random
def sortCheck(tolur):
variab = False
for x in range(4):
if tolur.count(x+1) == 0:
variab = True
return variab
mengi = []
counter = 0
for y in range(123456):
mengi = []
for x in range(13):
mengi.append(random.randint(1, 4))
if sortCheck(mengi):
counter += 1
print(counter/123456)
#finnst talan full lág en þetta skilar lausn.
| Python |
f = open("frettatilkynning.txt", "r")
linur = f.readlines()
find = "Nkia"
replace = "Nokia"
for lina in linur:
while lina.count(find) != 0:
lina = lina[:lina.index(find)] + replace + lina[lina.index(find)+len(find):]
print(lina)
| Python |
fjoldi = int(input())
tolur = []
maxgildi = 0
for x in range(fjoldi):
tolur[x] = int(input())
if maxgildi < tolur[x]:
maxgildi = tolur[x]
print(maxgildi)
| Python |
stafir = "AÁBCDÐEÉFGHIÍJKLMNOÓPQRSTUÚVWXYZÞÆÖ"
f = open("texti.txt", "r")
strengur = f.readline()
fjoldi = []
for x in stafir:
fjoldi.append(strengur.count(x))
for a in range(15, 0, -1):
tempStrengur = "AÁBCDÐEÉFGHIÍJKLMNOÓPQRSTUÚVWXYZÞÆÖ"
for x in range(0, len(stafir)):
if fjoldi[x] >= a:
tempStrengur = tempStrengur[:x] + "*" + tempStrengur[x+1:]
else:
tempStrengur = tempStrengur[:x] + " " + tempStrengur[x+1:]
print(tempStrengur)
print(stafir)
| Python |
tala = input("Tala: ")
strengur = ""
for x in range(len(tala)-1, -1, -1):
strengur += tala[x]
print(strengur)
| Python |
dagur = int(input("Dagur: "))
manudur = int(input("Mánuður: "))
tala = manudur*100 + dagur
if tala < 121: # Currently steingeit
print("Eftir " + str(121-tala) + " daga byrjar Vatnsberinn")
elif tala < 220: # vatnsberi
if manudur == 1:
print("Eftir " + str(20 + 131 - tala) + " daga byrjar Fiskurinn")
else:
print("Eftir " + str(220 - tala) + " daga byrjar Fiskurinn")
elif tala <= 320: # Fiskur
if manudur == 2:
print("Eftir " + str(21 + 228 - tala) + " daga byrjar Hrútur")
else:
print("Eftir " + str(321 - tala) + " daga byrjar Hrútur")
elif tala <= 420: # Hrútur
if manudur == 3:
print("Eftir " + str(21 + 331 - tala) + " daga byrjar Naut")
else:
print("Eftir " + str(421 - tala) + " daga byrjar Naut")
elif tala <= 521: # Naut
if manudur == 4:
print("Eftir " + str(22 + 430 - tala) + " daga byrjar Tvíburi")
else:
print("Eftir " + str(522 - tala) + " daga byrjar Tvíburi")
elif tala <= 620: # Tvíburi
if manudur == 5:
print("Eftir " + str(21 + 531 - tala) + " daga byrjar Krabbi")
else:
print("Eftir " + str(621 - tala) + " daga byrjar Krabbi")
elif tala <= 723: # Krabbi
if manudur == 6:
print("Eftir " + str(24 + 630 - tala) + " daga byrjar Ljón")
else:
print("Eftir " + str(724 - tala) + " daga byrjar Ljón")
elif tala <=823: # Ljón
if manudur == 7:
print("Eftir " + str(24 + 731 - tala) + " daga byrjar Meyja")
else:
print("Eftir " + str(824 - tala) + " daga byrjar Meyja")
elif tala <= 923: # Meyja
if manudur == 8:
print("Eftir " + str(24 + 831 - tala) + " daga byrjar Vog")
else:
print("Eftir " + str(924 - tala) + " daga byrjar Vog")
elif tala <= 1022: # Vog
if manudur == 9:
print("Eftir " + str(23 + 930 - tala) + " daga byrjar Sporðdreki")
else:
print("Eftir " + str(1023 - tala) + " daga byrjar Sporðdreki")
elif tala <= 1121: # Sporðdreki
if manudur == 10:
print("Eftir " + str(22 + 1030 - tala) + " daga byrjar Bogmaður")
else:
print("Eftir " + str(1122 - tala) + " daga byrjar Bogmaður")
elif tala <= 1221: # Bogmaður
if manudur == 11:
print("Eftir " + str(22 + 1130 - tala) + " daga byrjar Steingeit")
else:
print("Eftir " + str(1222 - tala) + " daga byrjar Steingeit")
else: # Steingeit
print("Eftir " + str(21 + 1231 - tala) + " daga byrjar Vatnsberi")
| Python |
def hrop(x):
if x == 0 or x == 1:
return 1
return x*hrop(x-1)
def pascal(x):
strengur = ""
for y in range(x+1):
strengur += str(int(hrop(x)/(hrop(y)*hrop(x-y)))) + " "
return strengur
print(pascal(13))
| Python |
string = input("Strengur: ")
stafir = []
fjoldi = []
for x in string:
if x not in stafir:
stafir.append(x)
tvisvar = []
trisvar = []
for x in range(0, len(string)-1):
if string[x] == string[x+1]:
if x+2 < len(string) and string[x] != string[x+2]:
if string[x] not in tvisvar:
tvisvar.append(string[x])
else:
if string[x] not in trisvar:
trisvar.append(string[x])
fjarlaegja = []
for x in trisvar:
if x in tvisvar:
tvisvar.remove(x)
for x in tvisvar:
print(x + " kemur fyrir tvisvar")
for x in trisvar:
print(x + " kemur fyrir þrisvar")
| Python |
f = file.open(timi.txt, "r")
strengir = f.splitlines()
upppl = []
for x in strengir:
upppl.append(x.split())
| Python |
inntak = """XX XX 13 XX 67
3 XX XX XX 37
XX XX XX 11 34
XX 15 XX XX 69
52 48 31 76 38"""
def lagari(fylki):
hjalp = "ABCD"
for x in range(5):
fylki[x][4] = int(fylki[x][4])
fylki[4][x] = int(fylki[4][x])
for x in range(5):
for y in range(5):
if fylki[x][y] == "XX":
fylki[x][y] = hjalp[x] + str(y)
elif x < 4 and y < 4:
fylki[x][y] = int(fylki[x][y])
fylki[x][4] -= fylki[x][y]
fylki[4][y] -= fylki[x][y]
if x == y:
fylki[4][4] -= fylki[x][y]
fylki[x][y] = 0
return fylki
def geneq(fylki):
jofnur = []
temp = []
temp1 = []
temp2 = []
temp3 = []
temp4 = []
for x in range(5):
if x < 4:
jofnur.append(fylki[x])
temp.append(fylki[0][x])
temp1.append(fylki[1][x])
temp2.append(fylki[2][x])
temp3.append(fylki[3][x])
temp4.append(fylki[x][x]
jofnur.append(temp)
jofnur.append(temp1)
jofnur.append(temp2)
jofnur.append(temp3)
jofnur.append(temp3)
for x in jofnur:
print(x)
strengir = inntak.splitlines()
ordin = [line.split(' ') for line in strengir]
ordin = lagari(ordin)
geneq(ordin)
for x in range(5):
for y in range(5):
print(ordin[x][y], end=' ')
print()
| Python |
height = int(input())
breidd = int(input())
floturH = int(input())
floturB = int(input())
def leysa(a, b, GefA, GefB):
fjoldi = (GefA//a)*(GefB//b)
if (GefA//a)*(GefB//b) == (GefA*GefB)/(a*b):
return (GefA*GefB)/(a*b)
if GefA%a == 0:
GefB -= GefB/b
if GefB != b/2:
return fjoldi+(GefB/b)
if GefB == b/2:
return fjoldi+(GefB//(2*b))
if GefB%b == 0:
GefA -= GefA/a
if GefA != a/2:
return fjoldi+(GefA//a)
if GefA == a/2:
return fjoldi+(GefA//(2*a))
return 0
x = leysa(height, breidd, floturH, floturB)
y = leysa(breidd, height, floturH, floturB)
if x == 0:
print(y)
if y == 0:
print(x)
elif x < y:
print(x)
else: print(y)
| Python |
f = open("timi.txt", "r")
hlauparar = []
for line in f.readlines():
temp = line.split(" ")
timi = int(temp[1])*60 + int(temp[2])
hlauparar.append([temp[0], timi])
[hradasti, nafn] = [hlauparar[0][1], hlauparar[0][0]]
for hlaupari in hlauparar:
if hlaupari[1] < hradasti:
[hradasti, nafn] = [hlaupari[1], hlaupari[0]]
print(nafn + " var fljótastur")
| Python |
#!/usr/bin/env python
# -*- coding: latin-1 -*-
# -*- coding: cp1252 -*-
#def lesa(strengur):
strengur= "6+7-56 + 4"
tala = 0
temp = ""
formerki = 1
for x in strengur:
if x == "+":
tala += formerki*int(temp)
formerki = 1
temp = ""
elif x == "-":
tala += formerki*int(temp)
formerki = -1
temp = ""
elif x != " ":
temp += x
tala += formerki*int(temp)
print(str(tala))
#return (mengi)
#strengur=str(input())
#print (lesa(strengur))
| Python |
#!/usr/bin/env python
# -*- coding: latin-1 -*-
# -*- coding: cp1252 -*-
def fallid(n, a, b): # Kannski hægt að losna við að senda alltaf a og b?
if n == 1:
return a
if n == 2:
return b
if n%2 == 0:
return fallid(n-1, a, b) + fallid(n-2, a, b)
return 2*fallid(n-1, a, b) - fallid(n-2, a, b)
(a, b, n) = input("a b n: ").split(" ")
a = int(a)
b = int(b)
n = int(n)
print(fallid(n, a, b))
| Python |
#!/usr/bin/env python
# -*- coding: latin-1 -*-
# -*- coding: cp1252 -*-
# Leyfilegar aðgerðir á listann eru bara pop() (tekur síðasta stakið úr listanum og skilar því)
# og push eða append() í python sem þið vitið hvað gerir
class MinBidrod:
def __init__(self):
self.Stafli1 = [] # Þótt ég geri þetta sem lista þá má skv verkefninu ekki nota þetta sem lista
self.Stafli2 = [] # Það má bara eiga við efsta stakið, Stafli1[-1]
self.iTala1 = 0
self.iTala2 = 0 # Hef satt að segja enga hugmynd um hvað þessar 3 tölur eiga að gera
self.iTala3 = 0 # Má örugglega ekki nota len og á staðinn að athuga hvað pop af tómri röð gerir
self.iTala4 = 0 # en þetta er bara fínt
def enque(self, stak): # Bætir við staki á Stafla1 fremst
self.Stafli1.append(stak)
def deque(self): # Á að losa Stafla1 við fremsta stakið
self.Stafli2 = []
while len(self.Stafli1) != 0:
self.Stafli2.append(self.Stafli1.pop())
self.Stafli2.pop() # Losum okkur við efsta stak Stafla2, þ.e. neðsta stak Stafla 1
while len(self.Stafli2) != 0:
self.Stafli1.append(self.Stafli2.pop())
def birtaBidrod(self): # Grf að "eiga við" sé líka að prenta svo ég má bara prenta efsta stakið (mjög óljóst í lýsingu imo)
self.Stafli2 = []
if len(self.Stafli1) == 0:
print("Röðin er tóm")
return
prentStrengur = ""
for x in range(0, len(self.Stafli1)):
self.Stafli2.append(self.Stafli1.pop())
for x in range(0, len(self.Stafli2)):
self.iTala1 = self.Stafli2.pop()
prentStrengur += str(self.iTala1) + "-"
self.Stafli1.append(self.iTala1)
print(prentStrengur.strip("-"))
bid = MinBidrod()
bid.birtaBidrod()
bid.enque(11)
bid.enque(25)
bid.birtaBidrod()
bid.deque()
| Python |
#!/usr/bin/env python
# -*- coding: latin-1 -*-
# -*- coding: cp1252 -*-
# Þessi klasi er þegar til í Python (eins og við mætti búast): http://docs.python.org/2/library/fractions.html
# class AlmenntBrot(Fraction) væri því lausn sem virkaði en má væntanlega ekki
# Ef þið eruð að pæla í hvað __fall__ föllin gera (og hvaða fleiri eru til):
# http://www.rafekettler.com/magicmethods.html
class AlmenntBrot:
def __init__(self, teljari=1, nefnari=1):
self.iNefnari = nefnari
self.iTeljari = teljari
self.stytta()
def skrifaUt(self):
self.stytta() # Just in case, forritið gæti hafa stillt iNefnari/teljari sjálft
print(str(self.iTeljari) + "/" + str(self.iNefnari))
def __add__(self, other):
teljari = self.iNefnari*other.iTeljari + self.iTeljari*other.iNefnari
nefnari = self.iNefnari*other.iNefnari
c = AlmenntBrot(teljari, nefnari)
c.stytta()
return c
def __sub__(self, other):
teljari = self.iTeljari*other.iNefnari - self.iNefnari*other.iTeljari
nefnari = self.iNefnari*other.iNefnari
c = AlmenntBrot(teljari, nefnari)
c.stytta()
return c
def __mul__(self, other):
teljari = self.iTeljari*other.iTeljari
nefnari = self.iNefnari*other.iNefnari
c = AlmenntBrot(teljari, nefnari)
c.stytta()
return c
def __truediv__(self, other): # Hef satt að segja ekki hugmynd af hverju það er truediv en ekki div og nenni ekki að finna ástæðuna (div er samt til)
teljari = self.iTeljari*other.iNefnari
nefnari = self.iNefnari*other.iTeljari
c = AlmenntBrot(teljari, nefnari)
c.stytta()
return c
def stytta(self):
# Hér má finna sameiginlega þætti og stytta en ég nenni ekki að implementa það atm
# Verkefni eftirlátið lesanda
return
a = AlmenntBrot(5, 6)
a.skrifaUt()
b = AlmenntBrot(3, 4)
b.skrifaUt()
a = a/b
a.skrifaUt()
| Python |
#!/usr/bin/env python
# -*- coding: latin-1 -*-
# -*- coding: cp1252 -*-
# Fun fact: Lisp forritunarmálið notar (+ 3 5) til að skrifa 3 + 5 (og er einnig þekkt fyrir að nota þúsund milljón sviga)
def rpn(strengur): # Reverse Polish notation (reyndar supportar þetta ekki tölur yfir 9 ólíkt rpn en hugmynd er sú sama)
buid = False
takn = []
for x in strengur: # Ástæðan fyrir þessu var að t.d. 525*/ verður 510/ en á að vera 5 10 / (þ.e. bil skipta máli)
takn.append(x)
while(len(takn) != 1):
if takn.count("+") != 0:
stadur = takn.index("+")
if takn[stadur-1].isdigit() and takn[stadur-2].isdigit(): # Athuga hvort stökin á undan + séu tölur
tala = str(int(takn[stadur-1]) + int(takn[stadur-2]))
takn[stadur] = tala # Breyti + í rétta tölu
takn.pop(stadur-1) # Eyði svo tölunum
takn.pop(stadur-2)
if takn.count("-") != 0:
stadur = takn.index("-")
if takn[stadur-1].isdigit() and takn[stadur-2].isdigit():
tala = str(int(takn[stadur-2]) - int(takn[stadur-1]))
takn[stadur] = tala
takn.pop(stadur-1)
takn.pop(stadur-2)
if takn.count("*") != 0:
stadur = takn.index("*")
if takn[stadur-1].isdigit() and takn[stadur-2].isdigit():
tala = str(int(takn[stadur-1]) * int(takn[stadur-2]))
takn[stadur] = tala
takn.pop(stadur-1)
takn.pop(stadur-2)
if takn.count("/") != 0:
stadur = takn.index("/")
if takn[stadur-1].isdigit() and takn[stadur-2].isdigit():
tala = str(int(takn[stadur-2]) / int(takn[stadur-1]))
takn[stadur] = tala
takn.pop(stadur-1)
takn.pop(stadur-2)
return takn[0]
print(rpn(input("Inntak: ")))
| Python |
#!/usr/bin/env python
# -*- coding: latin-1 -*-
# -*- coding: cp1252 -*-
def summaThatta(tala):
summa = 0
for x in range(1, tala):
if tala%x == 0:
summa += x
return summa
def kininTala(n):
kininTolur = [6]
fjoldiOddatalna = 2
while(len(kininTolur) < n):
summa = 0
for x in range(1, 2*fjoldiOddatalna, 2): #Fer yfir allar oddatölur upp að fjoldiOddatalna*2-1
summa += x**3
if summa == summaThatta(summa):
kininTolur.append(summa)
fjoldiOddatalna += 1
return kininTolur[n-1]
print(kininTala(int(input("Kínin tala númer: "))))
| Python |
def rodun(listi):
while(not rettRadad(listi)):
for x in range(0, len(listi)-1):
if listi[x] > listi[x+1]:
temp = listi[x]
listi[x] = listi[x+1]
listi[x+1] = temp
return listi
def rettRadad(listi):
for x in range(0, len(listi) - 1):
if listi[x] > listi[x+1]:
return False
return True
print(rodun([0, 80, 2, -14, 7])) | Python |
#!/usr/bin/env python
# -*- coding: latin-1 -*-
# -*- coding: cp1252 -*-
strTala = input("ISBN tala: ").replace('-', '')
s1 = []
summa = 0
for x in strTala:
if x == "X":
x = "10"
summa += int(x)
s1.append(summa)
summa = 0
for x in s1:
summa += x
if summa % 11 == 0:
print("Lögleg")
else:
print("Ekki lögleg")
| Python |
#!/usr/bin/env python
# -*- coding: latin-1 -*-
# -*- coding: cp1252 -*-
# Leyfilegar aðgerðir á listann eru bara pop() (tekur síðasta stakið úr listanum og skilar því)
# og push eða append() í python sem þið vitið hvað gerir
class MinBidrod:
def __init__(self):
self.Stafli1 = [] # Þótt ég geri þetta sem lista þá má skv verkefninu ekki nota þetta sem lista
self.Stafli2 = [] # Það má bara eiga við efsta stakið, Stafli1[-1]
self.iTala1 = 0
self.iTala2 = 0 # Hef satt að segja enga hugmynd um hvað þessar 3 tölur eiga að gera
self.iTala3 = 0 # Má örugglega ekki nota len og á staðinn að athuga hvað pop af tómri röð gerir
self.iTala4 = 0 # en þetta er bara fínt
def enque(self, stak): # Bætir við staki á Stafla1 fremst
self.Stafli1.append(stak)
def deque(self): # Á að losa Stafla1 við fremsta stakið
self.Stafli2 = []
while len(self.Stafli1) != 0:
self.Stafli2.append(self.Stafli1.pop())
self.Stafli2.pop() # Losum okkur við efsta stak Stafla2, þ.e. neðsta stak Stafla 1
while len(self.Stafli2) != 0:
self.Stafli1.append(self.Stafli2.pop())
def birtaBidrod(self): # Grf að "eiga við" sé líka að prenta svo ég má bara prenta efsta stakið (mjög óljóst í lýsingu imo)
self.Stafli2 = []
if len(self.Stafli1) == 0:
print("Röðin er tóm")
return
prentStrengur = ""
for x in range(0, len(self.Stafli1)):
self.Stafli2.append(self.Stafli1.pop())
for x in range(0, len(self.Stafli2)):
self.iTala1 = self.Stafli2.pop()
prentStrengur += str(self.iTala1) + "-"
self.Stafli1.append(self.iTala1)
print(prentStrengur.strip("-"))
bid = MinBidrod()
bid.birtaBidrod()
bid.enque(11)
bid.enque(25)
bid.birtaBidrod()
bid.deque()
| Python |
#!/usr/bin/env python
# -*- coding: latin-1 -*-
# -*- coding: cp1252 -*-
tolur = input("Fjöldi hjarta og fjöldi lappa: ").split(" ")
hjortu = int(tolur[0])
lappir = int(tolur[1])
for x in range(0, hjortu+1): # Látum x vera fjölda nautgripa
if 4*x + (hjortu-x)*2 == lappir:
print("Það fórust " + str(x) + " nautgripir og " + str(hjortu-x) + " kjúklingar.")
| Python |
#!/usr/bin/env python
# -*- coding: latin-1 -*-
# -*- coding: cp1252 -*-
def fallid(n, a, b): # Kannski hægt að losna við að senda alltaf a og b?
if n == 1:
return a
if n == 2:
return b
if n%2 == 0:
return fallid(n-1, a, b) + fallid(n-2, a, b)
return 2*fallid(n-1, a, b) - fallid(n-2, a, b)
(a, b, n) = input("a b n: ").split(" ")
a = int(a)
b = int(b)
n = int(n)
print(fallid(n, a, b))
| Python |
#!/usr/bin/env python
# -*- coding: latin-1 -*-
# -*- coding: cp1252 -*-
# Virðist virka þó það komi random tala af nýjum línum sem ég nenni ekki að finna út af hverju gerist
inputFile = open('forrit.txt', 'r')
outputFile = open('forritAnKommenta.txt', 'w')
skrifaLinu = True
for line in inputFile.readlines():
if line.find("/*") != -1 and line.find("*/") != -1:
outputFile.write(line[:line.find("/*")] + line[line.find("*/")+2:])
buid = True
elif line.find("/*") != -1:
skrifaLinu = False
outputFile.write(line[:line.find("/*")])
buid = True
elif line.find("*/") != -1:
skrifaLinu = True
outputFile.write(line[line.find("*/")+2:])
buid = True
elif line.find("//") != -1 and skrifaLinu:
outputFile.write(line[:line.find("//")] + "\n")
elif skrifaLinu:
outputFile.write(line + "\n")
| Python |
#!/usr/bin/env python
# -*- coding: latin-1 -*-
# -*- coding: cp1252 -*-
strTala = input("ISBN tala: ").replace('-', '')
s1 = []
summa = 0
for x in strTala:
if x == "X":
x = "10"
summa += int(x)
s1.append(summa)
summa = 0
for x in s1:
summa += x
if summa % 11 == 0:
print("Lögleg")
else:
print("Ekki lögleg")
| Python |
#!/usr/bin/env python
# -*- coding: latin-1 -*-
# -*- coding: cp1252 -*-
def summaThatta(tala):
summa = 0
for x in range(1, tala):
if tala%x == 0:
summa += x
return summa
def kininTala(n):
kininTolur = [6]
fjoldiOddatalna = 2
while(len(kininTolur) < n):
summa = 0
for x in range(1, 2*fjoldiOddatalna, 2): #Fer yfir allar oddatölur upp að fjoldiOddatalna*2-1
summa += x**3
if summa == summaThatta(summa):
kininTolur.append(summa)
fjoldiOddatalna += 1
return kininTolur[n-1]
print(kininTala(int(input("Kínin tala númer: "))))
| Python |
#!/usr/bin/env python
# -*- coding: latin-1 -*-
# -*- coding: cp1252 -*-
# Þessi klasi er þegar til í Python (eins og við mætti búast): http://docs.python.org/2/library/fractions.html
# class AlmenntBrot(Fraction) væri því lausn sem virkaði en má væntanlega ekki
# Ef þið eruð að pæla í hvað __fall__ föllin gera (og hvaða fleiri eru til):
# http://www.rafekettler.com/magicmethods.html
class AlmenntBrot:
def __init__(self, teljari=1, nefnari=1):
self.iNefnari = nefnari
self.iTeljari = teljari
self.stytta()
def skrifaUt(self):
self.stytta() # Just in case, forritið gæti hafa stillt iNefnari/teljari sjálft
print(str(self.iTeljari) + "/" + str(self.iNefnari))
def __add__(self, other):
teljari = self.iNefnari*other.iTeljari + self.iTeljari*other.iNefnari
nefnari = self.iNefnari*other.iNefnari
c = AlmenntBrot(teljari, nefnari)
c.stytta()
return c
def __sub__(self, other):
teljari = self.iTeljari*other.iNefnari - self.iNefnari*other.iTeljari
nefnari = self.iNefnari*other.iNefnari
c = AlmenntBrot(teljari, nefnari)
c.stytta()
return c
def __mul__(self, other):
teljari = self.iTeljari*other.iTeljari
nefnari = self.iNefnari*other.iNefnari
c = AlmenntBrot(teljari, nefnari)
c.stytta()
return c
def __truediv__(self, other): # Hef satt að segja ekki hugmynd af hverju það er truediv en ekki div og nenni ekki að finna ástæðuna (div er samt til)
teljari = self.iTeljari*other.iNefnari
nefnari = self.iNefnari*other.iTeljari
c = AlmenntBrot(teljari, nefnari)
c.stytta()
return c
def stytta(self):
# Hér má finna sameiginlega þætti og stytta en ég nenni ekki að implementa það atm
# Verkefni eftirlátið lesanda
return
a = AlmenntBrot(5, 6)
a.skrifaUt()
b = AlmenntBrot(3, 4)
b.skrifaUt()
a = a/b
a.skrifaUt()
| Python |
#!/usr/bin/env python
# -*- coding: latin-1 -*-
# -*- coding: cp1252 -*-
# Fun fact: Lisp forritunarmálið notar (+ 3 5) til að skrifa 3 + 5 (og er einnig þekkt fyrir að nota þúsund milljón sviga)
def rpn(strengur): # Reverse Polish notation (reyndar supportar þetta ekki tölur yfir 9 ólíkt rpn en hugmynd er sú sama)
buid = False
takn = []
for x in strengur: # Ástæðan fyrir þessu var að t.d. 525*/ verður 510/ en á að vera 5 10 / (þ.e. bil skipta máli)
takn.append(x)
while(len(takn) != 1):
if takn.count("+") != 0:
stadur = takn.index("+")
if takn[stadur-1].isdigit() and takn[stadur-2].isdigit(): # Athuga hvort stökin á undan + séu tölur
tala = str(int(takn[stadur-1]) + int(takn[stadur-2]))
takn[stadur] = tala # Breyti + í rétta tölu
takn.pop(stadur-1) # Eyði svo tölunum
takn.pop(stadur-2)
if takn.count("-") != 0:
stadur = takn.index("-")
if takn[stadur-1].isdigit() and takn[stadur-2].isdigit():
tala = str(int(takn[stadur-2]) - int(takn[stadur-1]))
takn[stadur] = tala
takn.pop(stadur-1)
takn.pop(stadur-2)
if takn.count("*") != 0:
stadur = takn.index("*")
if takn[stadur-1].isdigit() and takn[stadur-2].isdigit():
tala = str(int(takn[stadur-1]) * int(takn[stadur-2]))
takn[stadur] = tala
takn.pop(stadur-1)
takn.pop(stadur-2)
if takn.count("/") != 0:
stadur = takn.index("/")
if takn[stadur-1].isdigit() and takn[stadur-2].isdigit():
tala = str(int(takn[stadur-2]) / int(takn[stadur-1]))
takn[stadur] = tala
takn.pop(stadur-1)
takn.pop(stadur-2)
return takn[0]
print(rpn(input("Inntak: ")))
| Python |
#!/usr/bin/env python
# -*- coding: latin-1 -*-
# -*- coding: cp1252 -*-
# Skipanirnar sjálfar eru gallaðar, ekki forritið
# Ef loopunum er sleppt þá prentar þetta "hi mom" eins og á að gerast
def naestiStadur(nuverandiStadur, att): # 1 er áfram, -1 afturábak
if att == 1:
nuverandiStadur += 1
elif att == -1:
nuverandiStadur -= 1
if nuverandiStadur >= 26: # 25 er hæsta því það byrjar á 0 og er 26 stafi, stafrófið
nuverandiStadur -= 26
elif nuverandiStadur < 0:
nuverandiStadur += 26
return nuverandiStadur
def igorTulkur(strengur, utprentun = "", gildi = [], stadsetningKronu = 0):
stafrof = "abcdefghijklmnopqrstuvxyz"
if gildi == []:
for a in range(0, 26):
gildi.append(0)
while strengur != "":
if strengur[0] == ">":
stadsetningKronu = naestiStadur(stadsetningKronu, 1)
strengur = strengur[1:]
elif strengur[0] == "<":
stadsetningKronu = naestiStadur(stadsetningKronu, -1)
strengur = strengur[1:]
elif strengur[0] == "+":
gildi[stadsetningKronu] += 1
strengur = strengur[1:]
elif strengur[0] == "-":
gildi[stadsetningKronu] -= 1
strengur = strengur[1:]
elif strengur[0] == ".":
utprentun += stafrof[stadsetningKronu]
strengur = strengur[1:]
elif strengur[0] == ",":
utprentun += " "
strengur = strengur[1:]
elif strengur[0] == "[":
x = strengur.index("]") #Finnum hvar loopan endar
loopa(strengur[1:x], utprentun, gildi, stadsetningKronu) # Sendum allt án []
strengur = strengur[x+1:] # Nýji strengurinn er án [
else: # Ætti aldrei að gerast
print("Hunsa " + strengur[0])
strengur = strengur[1:]
return utprentun
def loopa(strengur, utprentun, gildi, stadsetningKronu):
igorTulkur(strengur, utprentun, gildi, stadsetningKronu)
while(gildi[stadsetningKronu] != 0):
igorTulkur(strengur, utprentun, gildi, stadsetningKronu)
print(igorTulkur(">++++++[<+++>-]>>++>>>++>.+>.[<++>-]>>>>,.[<++>]>>.<<."))
| Python |
#!/usr/bin/env python
# -*- coding: latin-1 -*-
# -*- coding: cp1252 -*-
tolur = input("Fjöldi hjarta og fjöldi lappa: ").split(" ")
hjortu = int(tolur[0])
lappir = int(tolur[1])
for x in range(0, hjortu+1): # Látum x vera fjölda nautgripa
if 4*x + (hjortu-x)*2 == lappir:
print("Það fórust " + str(x) + " nautgripir og " + str(hjortu-x) + " kjúklingar.")
| Python |
#!/usr/bin/env python
# -*- coding: latin-1 -*-
# -*- coding: cp1252 -*-
# Virðist virka þó það komi random tala af nýjum línum sem ég nenni ekki að finna út af hverju gerist
inputFile = open('forrit.txt', 'r')
outputFile = open('forritAnKommenta.txt', 'w')
skrifaLinu = True
for line in inputFile.readlines():
if line.find("/*") != -1 and line.find("*/") != -1:
outputFile.write(line[:line.find("/*")] + line[line.find("*/")+2:])
buid = True
elif line.find("/*") != -1:
skrifaLinu = False
outputFile.write(line[:line.find("/*")])
buid = True
elif line.find("*/") != -1:
skrifaLinu = True
outputFile.write(line[line.find("*/")+2:])
buid = True
elif line.find("//") != -1 and skrifaLinu:
outputFile.write(line[:line.find("//")] + "\n")
elif skrifaLinu:
outputFile.write(line + "\n")
| Python |
#!/usr/bin/env python
# -*- coding: latin-1 -*-
# -*- coding: cp1252 -*-
# Skipanirnar sjálfar eru gallaðar, ekki forritið
# Ef loopunum er sleppt þá prentar þetta "hi mom" eins og á að gerast
def naestiStadur(nuverandiStadur, att): # 1 er áfram, -1 afturábak
if att == 1:
nuverandiStadur += 1
elif att == -1:
nuverandiStadur -= 1
if nuverandiStadur >= 26: # 25 er hæsta því það byrjar á 0 og er 26 stafi, stafrófið
nuverandiStadur -= 26
elif nuverandiStadur < 0:
nuverandiStadur += 26
return nuverandiStadur
def igorTulkur(strengur, utprentun = "", gildi = [], stadsetningKronu = 0):
stafrof = "abcdefghijklmnopqrstuvxyz"
if gildi == []:
for a in range(0, 26):
gildi.append(0)
while strengur != "":
if strengur[0] == ">":
stadsetningKronu = naestiStadur(stadsetningKronu, 1)
strengur = strengur[1:]
elif strengur[0] == "<":
stadsetningKronu = naestiStadur(stadsetningKronu, -1)
strengur = strengur[1:]
elif strengur[0] == "+":
gildi[stadsetningKronu] += 1
strengur = strengur[1:]
elif strengur[0] == "-":
gildi[stadsetningKronu] -= 1
strengur = strengur[1:]
elif strengur[0] == ".":
utprentun += stafrof[stadsetningKronu]
strengur = strengur[1:]
elif strengur[0] == ",":
utprentun += " "
strengur = strengur[1:]
elif strengur[0] == "[":
x = strengur.index("]") #Finnum hvar loopan endar
loopa(strengur[1:x], utprentun, gildi, stadsetningKronu) # Sendum allt án []
strengur = strengur[x+1:] # Nýji strengurinn er án [
else: # Ætti aldrei að gerast
print("Hunsa " + strengur[0])
strengur = strengur[1:]
return utprentun
def loopa(strengur, utprentun, gildi, stadsetningKronu):
igorTulkur(strengur, utprentun, gildi, stadsetningKronu)
while(gildi[stadsetningKronu] != 0):
igorTulkur(strengur, utprentun, gildi, stadsetningKronu)
print(igorTulkur(">++++++[<+++>-]>>++>>>++>.+>.[<++>-]>>>>,.[<++>]>>.<<."))
| Python |
def triangle(rows):
for rownum in range (rows):
newValue=1
PrintingList = [newValue]
for iteration in range (rownum):
newValue = newValue * ( rownum-iteration ) * 1 / ( iteration + 1 )
print(convert(int(newValue)), end='')
print()
def convert(x):
skil = ""
if int(x)%2 == 0:
skil += "."
if int(x)%2 == 1:
skil += "#"
return skil
fjoldi = int(input())
print("#")
triangle(fjoldi)
| Python |
def fall(strengur):
svar = ""
for x in range(10):
svar += str(strengur.count(str(x))) + " "
return svar
oft = int(input())
for y in range(oft):
fjoldi = int(input())
strengur = ""
for x in range(fjoldi):
strengur += str(x+1)
print(fall(strengur))
| Python |
def trihyrningsTolur(inntak):
n = 1
while n*(n+1)/2 <= inntak:
n += 1
if n*(n+1)/2 > inntak:
k = inntak - (int(n*(n-1)/2))
return str(n-1) + " " + str(k)
oft = int(input())
for x in range(oft):
tala = int(input())
print(trihyrningsTolur(tala))
| Python |
def lausnar(inntak):
tomurListi = []
if hreyfing(inntak, (0, 0), tomurListi):
return "Terminates"
return "Infinite loop"
def gaHvortHringur(skiptirEkki, geyma, iThessu):
if geyma in iThessu:
return False
iThessu.append(geyma)
return hreyfing(skiptirEkki, geyma, iThessu)
def hreyfing(bord, stada, listi):
takn = {"^", "v", "<", ">", "@"}
if bord[stada[0]][stada[1]] == "^":
k = 1
while bord[stada[0]+k][stada[1]] not in takn:
k += 1
if bord[stada[0]+k][stada[1]] != "@":
return gaHvortHringur(bord, (stada[0]+k, stada[1]), listi)
return True
if bord[stada[0]][stada[1]] == "v":
k = -1
while bord[stada[0]+k][stada[1]] not in takn:
k -= 1
if bord[stada[0]+k+1][stada[1]] != "@":
return gaHvortHringur(bord, (stada[0]+k, stada[1]), listi)
return True
if bord[stada[0]][stada[1]] == "<":
k = -1
while bord[stada[0]][stada[1] + k] not in takn:
k -= 1
if bord[stada[0]][stada[1]+k] != "@":
return gaHvortHringur(bord, (stada[0], stada[1]+k), listi)
return True
if bord[stada[0]][stada[1]] == ">":
k = 1
while bord[stada[0]][stada[1] + k] not in takn:
k += 1
if bord[stada[0]][stada[1]+k] != "@":
return gaHvortHringur(bord, (stada[0], stada[1]+k), listi)
return True
if bord[stada[0]][stada[1]] == "@":
return True
oft = int(input())
for x in range(oft):
k = 0
mengi = []
mengi.append(input())
while mengi[k] != "#":
mengi.append(input())
k += 1
if mengi[-1] == "#":
mengi.pop(-1)
print(lausnar(mengi))
| Python |
def fyrstaLausn(stodum, uppl):
maxi = 0
for x in stodum:
if maxi < min(int(x), int(uppl[0])-int(x)):
maxi = min(int(x), int(uppl[0])-int(x))
return maxi
def onnurLausn(stodum, uppl):
maxi = 0
for x in stodum:
if maxi < max(int(x), int(uppl[0])-int(x)):
maxi = max(int(x), int(uppl[0])-int(x))
return maxi
oft = int(input())
for x in range(oft):
ln = input()
lni = ln.split(" ")
stadir = input()
stadiri = stadir.split(" ")
print(fyrstaLausn(stadiri, lni), end = ' ')
print(onnurLausn(stadiri, lni))
| Python |
def lausnar(inntak):
tomurListi = []
if hreyfing(inntak, (0, 0), tomurListi):
return "Terminates"
return "Infinite loop"
def gaHvortHringur(skiptirEkki, geyma, iThessu):
if geyma in iThessu:
return False
iThessu.append(geyma)
return hreyfing(skiptirEkki, geyma, iThessu)
def hreyfing(bord, stada, listi):
takn = {"^", "v", "<", ">", "@"}
if bord[stada[0]][stada[1]] == "^":
k = -1
while bord[stada[0]+k][stada[1]] not in takn:
k -= 1
if bord[stada[0]+k][stada[1]] != "@":
return gaHvortHringur(bord, (stada[0]+k, stada[1]), listi)
return True
if bord[stada[0]][stada[1]] == "v":
k = 1
while bord[stada[0]+k][stada[1]] not in takn:
k += 1
if bord[stada[0]+k][stada[1]] != "@":
return gaHvortHringur(bord, (stada[0]+k, stada[1]), listi)
return True
if bord[stada[0]][stada[1]] == "<":
k = -1
while bord[stada[0]][stada[1] + k] not in takn:
k -= 1
if bord[stada[0]][stada[1]+k] != "@":
return gaHvortHringur(bord, (stada[0], stada[1]+k), listi)
return True
if bord[stada[0]][stada[1]] == ">":
k = 1
while bord[stada[0]][stada[1] + k] not in takn:
k += 1
if bord[stada[0]][stada[1]+k] != "@":
return gaHvortHringur(bord, (stada[0], stada[1]+k), listi)
return True
if bord[stada[0]][stada[1]] == "@":
return True
oft = int(input())
for x in range(oft):
k = 0
mengi = []
mengi.append(input())
while mengi[k] != "#":
mengi.append(input())
k += 1
if mengi[-1] == "#":
mengi.pop(-1)
print(lausnar(mengi))
| Python |
def fall(strengur):
svar = ""
for x in range(10):
if x < 9:
svar += str(strengur.count(str(x))) + " "
else:
svar += str(strengur.count(str(x)))
return svar
oft = int(input())
for y in range(oft):
fjoldi = int(input())
strengur = ""
for x in range(fjoldi):
strengur += str(x+1)
print(fall(strengur))
| Python |
def fyrstaLausn(stodum, uppl):
maxi = 0
for x in stodum:
if maxi < min(int(x), int(uppl[0])-int(x)):
maxi = min(int(x), int(uppl[0])-int(x))
return maxi
def onnurLausn(stodum, uppl):
maxi = 0
for x in stodum:
if maxi < max(int(x), int(uppl[0])-int(x)):
maxi = max(int(x), int(uppl[0])-int(x))
return maxi
oft = int(input())
for x in range(oft):
ln = input()
lni = ln.split(" ")
stadir = input()
stadiri = stadir.split(" ")
print(fyrstaLausn(stadiri, lni), end = ' ')
print(onnurLausn(stadiri, lni))
| Python |
oft = int(input())
for x in range(oft):
ni = input()
n = ni.split(" ")
n[0] = int(n[0])
n[1] = int(n[1])
a = 5*n[0]
b = 5
for y in range(n[1]):
if a >= b:
a -= b
b += 10
else:
a *= 100
b = (b-b%10)*10 + b%10
print(b)
| Python |
def trihyrningsTolur(inntak):
n = 1
while n*(n+1)/2 <= inntak:
n += 1
if n*(n+1)/2 > inntak:
k = inntak - (int(n*(n-1)/2))
return str(n-1) + " " + str(k)
oft = int(input())
for x in range(oft):
tala = int(input())
print(trihyrningsTolur(tala))
| Python |
oft = int(input())
for x in range(oft):
ni = input()
n = ni.split(" ")
n[0] = int(n[0])
n[1] = int(n[1])
a = 5*n[0]
b = 5
for y in range(n[1]):
if a >= b:
a -= b
b += 10
else:
a *= 100
b = (b-b%10)*10 + b%10
print(b)
| Python |
def fall(inntak):
if inntak == 1:
return 0
if inntak == 2:
return 1
if inntak == 3:
return 2
else:
return (fall(inntak-1)+(inntak-1)//2)*(inntak-1)
profanir = int(input())
tilvik = []
for x in range(profanir):
tala = int(input())
tilvik.append(tala)
print(fall(tala))
| Python |
def fall(inntak):
strengir = []
strengir2 = []
strengir3 = []
strengir4 = []
strengir5 = []
strengir6 = []
strengir7 = []
strengir8 = []
strengir9 = []
if inntak == 1:
return 0
for x in range(inntak):
for y in range(inntak):
strengir.append(str(x) + str(y))
for x in range(len(strengir)):
if strengir[x][0] != strengir[x][1]:
strengir2.append(strengir[x])
if len(strengir2) != 0:
lausn = len(strengir2)
if len(strengir2) != 0:
for x in range(len(strengir2)):
if strengir2[x][0] != strengir2[0][0] and strengir2[x][1] != strengir2[0][1]:
strengir3.append(strengir2[x])
if len(strengir3) != 0:
lausn *= len(strengir3)
if len(strengir3) != 0:
for x in range(len(strengir3)):
if strengir3[x][0] != strengir3[0][0] and strengir3[x][1] != strengir3[0][1]:
strengir4.append(strengir3[x])
if len(strengir4) != 0:
lausn *= len(strengir4)
if len(strengir4) != 0:
for x in range(len(strengir4)):
if strengir4[x][0] != strengir4[0][0] and strengir4[x][1] != strengir4[0][1]:
strengir5.append(strengir4[x])
if len(strengir5) != 0:
lausn *= len(strengir5)
if len(strengir5) != 0:
for x in range(len(strengir5)):
if strengir5[x][0] != strengir5[0][0] and strengir5[x][1] != strengir5[0][1]:
strengir6.append(strengir5[x])
if len(strengir6) != 0:
lausn *= len(strengir6)
if len(strengir6) != 0:
for x in range(len(strengir6)):
if strengir6[x][0] != strengir6[0][0] and strengir6[x][1] != strengir6[0][1]:
strengir7.append(strengir6[x])
if len(strengir7) != 0:
lausn *= len(strengir7)
if len(strengir7) != 0:
for x in range(len(strengir7)):
if strengir7[x][0] != strengir7[0][0] and strengir7[x][1] != strengir7[0][1]:
strengir8.append(strengir7[x])
if len(strengir8) != 0:
lausn *= len(strengir8)
if len(strengir8) != 0:
for x in range(len(strengir8)):
if strengir8[x][0] != strengir8[0][0] and strengir8[x][1] != strengir8[0][1]:
strengir9.append(strengir8[x])
if len(strengir9) != 0:
lausn *= len(strengir9)
return lausn
profanir = int(input())
tilvik = []
for x in range(profanir):
tala = int(input())
tilvik.append(tala)
print(fall(tala))
| Python |
def hrop(x):
if x == 0 or x == 1:
return 1
return x*hrop(x-1)
def pascal(x):
mengi = []
for y in range(x+1):
mengi.append(int(hrop(x)/(hrop(y)*hrop(x-y))))
return mengi
def convert(xy):
skil = ""
for x in xy:
if int(x)%2 == 0:
skil += "."
if int(x)%2 == 1:
skil += "#"
return skil
fjoldi = int(input())
print("#")
for x in range(1, fjoldi):
print(convert(pascal(x)))
| Python |
def snuaVid(x):
stok = []
skil = ""
teljari = 0
for y in range(len(x)):
if x[y] == "[":
stok.append(x[y+1])
if len(stok) > 1:
teljari += 1
if x[y] == "[" and x[y+2] != "]":
stok[teljari] += x[y+2]
if y+3 < len(x) and x[y+3] != "]":
stok[teljari] += x[y+3]
if y+4 < len(x) and x[y+4] != "]":
stok[teljari] += x[y+4]
for x in range(len(stok)-1, -1, -1):
if x < len(stok)-1:
skil += "[" + stok[x] + "]->"
else:
skil += "[" + stok[x] + "]->"
skil += "NULL"
return skil
oft = int(input())
listar = []
for x in range(oft):
t = input()
listar.append(snuaVid(t))
for x in listar:
print(x)
| Python |
def skemmtun(streng):
skilyrdi = True
for x in range(len(streng)):
if streng[x] == " ":
if streng[x-1] != streng[x+1]:
skilyrdi = False
return skilyrdi
oft = int(input())
strengir = []
for x in range(oft):
blahh = input()
strengir.append(blahh)
if skemmtun(blahh):
print("Fun")
else:
print("Boring")
| Python |
def hrop(x):
if x == 0 or x == 1:
return 1
return x*hrop(x-1)
def fjoldi(folk):
moguleikar = folk**2 - folk
moguleikar2 = 1
i=1
while moguleikar-2*folk-3*i > 0:
moguleikar2 *= moguleikar -2*folk -3*i
i += 1
return moguleikar2
profanir = int(input())
tilvik = []
for x in range(profanir):
tala = int(input())
tilvik.append(tala)
print(fjoldi(tala))
| Python |
def fall(inntak):
hjalp = "ABCDEFGHI"
strengir = []
strengir2 = []
for x in range(inntak):
for y in range(inntak):
strengir.append(hjalp[x] + str(y))
for x in range(len(strengir)):
if strengir[x][0] != hjalp[int(strengir[x][1])]:
strengir2.append(x)
lausn = len(strengir)
while len(strengir) != 0:
for x in range(1, len(strengir)):
if strengir[x][0] == strengir[0][0] or strengir[x][1] == strengir[0][1]:
strengir.pop(x)
strengir.pop(0)
if len(strengir) != 0:
lausn *= len(strengir)
return lausn
profanir = int(input())
tilvik = []
for x in range(profanir):
tala = int(input())
tilvik.append(tala)
print(fall(tala))
| Python |
def hrop(x):
if x == 0 or x == 1:
return 1
return x*hrop(x-1)
def pascal(x):
mengi = []
for y in range(x+1):
mengi.append(int(hrop(x)/(hrop(y)*hrop(x-y))))
return mengi
def convert(xy):
skil = ""
for x in xy:
if int(x)%2 == 0:
skil += "."
if int(x)%2 == 1:
skil += "#"
return skil
fjoldi = int(input())
print("#")
for x in range(1, fjoldi):
print(convert(pascal(x)))
| Python |
def skemmtun(streng):
skilyrdi = True
streng = streng.lower()
for x in range(len(streng)):
if streng[x] == " ":
if streng[x-1] != streng[x+1]:
skilyrdi = False
return skilyrdi
oft = int(input())
strengir = []
for x in range(oft):
blahh = input()
strengir.append(blahh)
if skemmtun(blahh):
print("Fun")
else:
print("Boring")
| Python |
from math import sqrt
prime = []
prime.append(2)
prime.append(3)
prime.append(5)
prime.append(7)
x = 11
EkkiPrime = False
while len(prime) < 1001:
Breyta = int(sqrt(x))
for y in range(2, Breyta+1, 1):
if x%y == 0:
EkkiPrime = True
if EkkiPrime == False:
prime.append(x)
x += 1
EkkiPrime = False
fjoldi = int(input())
for x in range(fjoldi):
prufa = int(input())
print(prime(prufa))
# Virkar
| Python |
def snuaVid(x):
stok = []
skil = ""
teljari = 0
for y in range(len(x)):
if x[y] == "[":
stok.append(x[y+1])
if len(stok) > 1:
teljari += 1
if x[y] == "[" and x[y+2] != "]":
stok[teljari] += x[y+2]
if y+3 < len(x) and x[y+3] != "]":
stok[teljari] += x[y+3]
if y+4 < len(x) and x[y+4] != "]":
stok[teljari] += x[y+4]
for x in range(len(stok)-1, -1, -1):
if x < len(stok)-1:
skil += "[" + stok[x] + "]->"
else:
skil += "[" + stok[x] + "]->"
skil += "NULL"
return skil
oft = int(input())
listar = []
for x in range(oft):
t = input()
listar.append(snuaVid(t))
for x in listar:
print(x)
| Python |
def fall(inntak):
if inntak == 1:
return 0
if inntak == 2:
return 1
if inntak == 3:
return 2
else:
return (fall(inntak-1)+(inntak-1)//2)*(inntak-1)
profanir = int(input())
tilvik = []
for x in range(profanir):
tala = int(input())
tilvik.append(tala)
print(fall(tala))
| Python |
from math import sqrt
prime = []
prime1 = []
for x in range(1001):
prime1.append(x)
for x in prime1:
for y in range(1, len(prime1)):
if x != y and x != 0 and prime1[y]%x == 0:
prime1[y] = 0
for x in prime1:
if x != 0:
prime.append(x)
fjoldi = int(input())
for x in range(fjoldi):
prufa = int(input())
print(prime[prufa])
# Virkar
| Python |
#!/usr/bin/env python
# -*- coding: latin-1 -*-
# -*- coding: cp1252 -*-
hofudstoll = int(input())
arlSparn = int(input())
vextir = int(input())
fjoldiAra = int(input())
def timabil(b, a, v, ar, f):
b = b*(1+(v/100))
if ar > 0:
b += a
if ar < f:
return timabil(b, a, v, ar+1, f)
return b
print(timabil(hofudstoll, arlSparn, vextir, 0, fjoldiAra))
#Rounding error? amk þetta ætti að virka...
| Python |
#!/usr/bin/env python
# -*- coding: latin-1 -*-
# -*- coding: cp1252 -*-
hofudstoll = int(input())
arlSparn = int(input())
vextir = int(input())
fjoldiAra = int(input())
def timabil(b, a, v, ar, f):
b = b*(1+(v/100))
if ar > 0:
b += a
if ar < f:
return timabil(b, a, v, ar+1, f)
return b
print(timabil(hofudstoll, arlSparn, vextir, 0, fjoldiAra))
#Rounding error? amk þetta ætti að virka...
| Python |
klst = int(input())
minut = int(input())
sek = int(input())
minut += sek//60
klst += minut//60
minut = minut%60
sek = sek%60
print("klukkan er: " + str(klst) + ":" + str(minut) + ":" + str(sek) + ".")
| Python |
import random
def athugaHus(a):
a.sort()
if(a[0] == a[1] == a[2] and a[3] == a[4]):
return 1
if(a[0] == a[1] and a[2] == a[3] == a[4]):
return 1
return 0
def kasta():
mengi = []
for x in range(5):
mengi.append(random.randint(1, 6))
return mengi
teljari = 0
for x in range(1000000):
teljari += athugaHus(kasta())
print(teljari/1000000)
| Python |
tala = input("Hver er talan? ")
utprentun = ""
prefix = {'1':'eitt', '2':'tvö', '3':'þrjú', '4':'fjögur', '5':'fimm', '6':'sex', '7':'sjö', '8':'átta', '9':'níu'}
annarTugur = {'10':'tíu', '11':'ellefu', '12':'tólf', '13':'þrettán', '14':'fjórtán', '15':'fimmtán', '16':'sextán', '17':'sautján', '18':'átján', '19':'nítján'}
tugir = {'2':'tuttugu', '3':'þrjátíu', '4':'fjörutíu', '5':'fimmtíu', '6':'sextíu', '7':'sjötíu', '8':'áttatíu', '9':'níutíu'}
tolur = {'0':'', '1':'einn', '2':'tveir', '3':'þrír', '4':'fjórir', '5':'fimm', '6':'sex', '7':'sjö', '8':'átta', '9':'níu'}
if len(tala) == 3:
if tala[0] == '1':
utprentun += "eitt hundrað "
else:
utprentun += prefix[tala[0]] + " hundruð "
tala = tala[1:]
if len(tala) == 2:
if utprentun != "" and int(tala) == 0:
utprentun += "og "
if tala[0] == '1':
utprentun += annarTugur[tala]
elif tala[0] != '0':
utprentun += tugir[tala[0]] + " "
if tala[1] != '0':
utprentun += "og "
tala = tala[1:]
if len(tala) == 1:
utprentun += tolur[tala[0]]
tala = tala[1:]
print(utprentun)
| Python |
import random
def sortCheck(tolur):
variab = False
for x in range(4):
if tolur.count(x+1) == 0:
variab = True
return variab
mengi = []
counter = 0
for y in range(123456):
mengi[:] = []
for x in range(13):
mengi.append(random.randint(1, 4))
if sortCheck(mengi):
counter += 1
print(counter/123456)
#finnst talan full lág en þetta skilar lausn.
| Python |
# best arnor geri þetta, her er kodinn sem hann notadi i svipudu verkefni
# Grf að í einu ári séu 31*12 dagar
kennitala = input("Kennitala: ")
tala = int(kennitala[0] + kennitala[1]) + 31*(int(kennitala[2]+kennitala[3])-1) # Hver dagur hefur einhverja tölu sem við getum kannað hvort sé á ákveðnu bili
stjornumerki = {0:'Steingeit', 21:'Vatnsberi', 20+31:'Fiskur', 21+31*2:'Hrútur', 21+31*3:'Naut', 22+31*4:'Tvíburi', 21+31*5:'Krabbi',
24+31*6:'Ljón', 24+31*7:'Meyja', 24+31*8:'Vog', 23+31*9:'Sporðdreki', 22+31*10:'Bogmaður', 22+31*11:'Steingeit'}
rettTala = 0
for x in stjornumerki.keys():
if tala > x and rettTala < x:
rettTala = x
print(stjornumerki[rettTala])
#her er svo brute force kodi fra mer
kennitala = input()
if int(kennitala[2] + kennitala[3]) == 1:
if int(kennitala[0] + kennitala[1]) > 20:
print ("Vatnsberi")
else: print("Steingeit")
if int(kennitala[2] + kennitala[3]) == 2:
if int(kennitala[0] + kennitala[1]) > 19:
print("Fiskur")
else: print("Vatnsberi")
if int(kennitala[2] + kennitala[3]) == 3:
if int(kennitala[0] + kennitala[1]) > 20:
print("Hrútur")
else: print("Fiskur")
if int(kennitala[2] + kennitala[3]) == 4:
if int(kennitala[0] + kennitala[1]) > 20:
print("Naut")
else: print("Hrútur")
if int(kennitala[2] + kennitala[3]) == 5:
if int(kennitala[0] + kennitala[1]) > 21:
print("Tvíburi")
else: print("Naut")
if int(kennitala[2] + kennitala[3]) == 6:
if int(kennitala[0] + kennitala[1]) > 20:
print("Krabbi")
else: print("Tvíburi")
if int(kennitala[2] + kennitala[3]) == 7:
if int(kennitala[0] + kennitala[1]) > 23:
print("Ljón")
else: print("Krabbi")
if int(kennitala[2] + kennitala[3]) == 8:
if int(kennitala[0] + kennitala[1]) > 23:
print("Meyja")
else: print("Ljón")
if int(kennitala[2] + kennitala[3]) == 9:
if int(kennitala[0] + kennitala[1]) > 23:
print("Vog")
else: print("Meyja")
if int(kennitala[2] + kennitala[3]) == 10:
if int(kennitala[0] + kennitala[1]) > 22:
print("Sporðdreki")
else: print("Vog")
if int(kennitala[2] + kennitala[3]) == 11:
if int(kennitala[0] + kennitala[1]) > 21:
print("Bogmaður")
else: print("Sporðdreki")
if int(kennitala[2] + kennitala[3]) == 12:
if int(kennitala[0] + kennitala[1]) > 21:
print("Steingeit")
else: print("Bogmaður")
| Python |
Subsets and Splits
SQL Console for ajibawa-2023/Python-Code-Large
Provides a useful breakdown of language distribution in the training data, showing which languages have the most samples and helping identify potential imbalances across different language groups.