def solution(n, k):
    L = [i for i in range(1, n + 1)]
    count = 0
    for j in per(L):
        count += 1
        if count == k:
            return list(j)
Пример #2
0
def solution(n, weak, dist):
    W = len(weak)
    for i in range(len(weak) - 1):
        weak.append(weak[i] + n)
    dist = sorted(dist, reverse=True)
    print(dist)

    def func(friends, weaks):
        cover, fidx = friends[0] + weaks[0], 0
        for i, weakpoint in enumerate(weaks):
            if cover >= weakpoint:
                pass
            else:
                fidx += 1
                if fidx == len(friends):
                    return False
                cover = weakpoint + friends[fidx]
        return True

    for i in range(len(dist)):
        for friends in per(dist, i + 1):
            print(friends)
            for k in range(W):
                w = weak[k:k + W]
                if func(friends, w):
                    return len(friends)

    return -1
Пример #3
0
def call(numset):
	def calc(ar):
		operations=[
			"%f %%s %f %%s %f %%s %f" %(ar[0],ar[1],ar[2],ar[3]),
			"(%f %%s %f) %%s %f %%s %f" %(ar[0],ar[1],ar[2],ar[3]),
			"%f %%s (%f %%s %f) %%s %f" %(ar[0],ar[1],ar[2],ar[3]),
			# "%f %%s %f %%s (%f %%s %f)" %(ar[0],ar[1],ar[2],ar[3]),
			"(%f %%s %f %%s %f) %%s %f" %(ar[0],ar[1],ar[2],ar[3]),
			# "%f %%s (%f %%s %f %%s %f)" %(ar[0],ar[1],ar[2],ar[3]),
			"((%f %%s %f) %%s %f) %%s %f" %(ar[0],ar[1],ar[2],ar[3]),
			"(%f %%s (%f %%s %f)) %%s %f" %(ar[0],ar[1],ar[2],ar[3]),
			# "%f %%s ((%f %%s %f) %%s %f)" %(ar[0],ar[1],ar[2],ar[3]),
			# "%f %%s (%f %%s (%f %%s %f))" %(ar[0],ar[1],ar[2],ar[3]),
			"(%f %%s %f) %%s (%f %%s %f)" %(ar[0],ar[1],ar[2],ar[3])
		]
		results=set([])
		for op in operations:
			for sign in operatorset:
				eq=op %(sign[0],sign[1],sign[2])
				try:
					if eval(eq)==24:
						results.add(re.sub(".0+","",eq))
				except:pass
		for result in results:print result
		return
	
	generator=per(numset)
	while True:
		try:calc(generator.next())
		except:break
def solution(n, k):
    L = []
    M = []
    for i in range(1, n + 1):
        L.append(i)
    for j in per(L):
        M.append(list(j))
    return M[k - 1]
Пример #5
0
def sum3(n):
    unique = set()
    temp = int(n**(1 / 3)) + 1
    for a, b, c, d in per(range(1, temp), 4):
        s = a**3 + b**3
        if s == c**3 + d**3 and s < n and s not in unique:
            unique.add(s)
            yield s
Пример #6
0
def cycle(n):
    s = str(n)
    nums = [int(''.join(i)) for i in per(s) if int(''.join(i)) > n and isprime_2(int(''.join(i)))]
    for num in nums:
        sub = num - n
        for _num in nums:
            _sub = _num - num
            if _sub == sub:
                return int(str(n) + str(num) + str(_num)), sub
    return False, False
def solution(n, k):
    L = []
    for i in range(1, n + 1):  #[1,2,3,...,n-1,n]리스트를 만들어서 퍼뮤테이션에 사용하려고
        L.append(i)

    count = 0
    for j in per(L):
        count += 1
        if count == k:
            return list(j)
Пример #8
0
def plotAll(map_points, points):
    order = pick_random(points)
    orders = list(per(order))
    for i in range(len(orders)):
        orders[i] = goBack(orders[i])
    orders = orders[:int(len(orders) / 2)]
    #orders = orders[:int(len(orders)/2)]
    for i in range(len(orders)):
        distance = str(total_distance(map_points, orders[i]))
        plt.figure(i)
        plt.title(distance)
        plot_points(map_points, points, orders[i])
Пример #9
0
def solution(numbers):

    answer = []
    for k in range(1, len(numbers) + 1):  # 1부터 숫자의 길이만큼 반복
        perlist = list(map(''.join, per(list(numbers), k)))  #k자리 경우의 수 추출
        for i in list(set(perlist)):  # set과 list화로 1차 중복제거
            if check(int(i)):  # 소수 맞으면
                answer.append(int(i))  # answer에 어펜드

    answer = len(set(answer))  # 2차 중복제거 및 숫자 확인

    return answer
Пример #10
0
 def fuse(w):
     for w in wincomb:
         for p in list(per(w)):
             t = frozenset(p)
             if t in grank:
                 #print "found!!!!!!!!!!!"
                 grank[t] = mix(grank[t], wincomb[t])
                 times[t] += 1
                 break
         else:
             #print "adding", w
             grank[w] = wincomb[w]
             times[w] = 0
Пример #11
0
def pandigital(order):
    nums = [str(i) for i in xrange(1, order+1)]
    product = []
    for num in per(nums):
        num = ''.join(num)
        if isprime(int(num)) and check(num, order):
            product.append(int(num))
        else:
            continue
    if product:
        return max(product)
    else:
        return None
Пример #12
0
def solution(numbers):
    nl = []
    for i in range(1, len(numbers) + 1):
        x = per(numbers, i)
        for j in x:
            nl.append(int(''.join(j)))
    nl = set(nl)

    cnt = 0
    for i in nl:
        if i != 0 and i != 1:
            if prime(i) == True:
                cnt += 1
    return cnt
Пример #13
0
def main():
    temp = list(map(int, input().split()))
    c, a, b = temp.pop(temp.index(max(temp))), temp[0], temp[1]
    condicoes = [
        abs(b - c) < a < b + c,
        abs(a - c) < b < a + c,
        abs(a - b) < c < a + b
    ]
    if all(condicoes):
        if a == b == c:
            print('Valido-Equilatero')
        elif a != b != c:
            print('Valido-Escaleno')
        elif any(map(lambda x: x[0] == x[1] != x[2], per([a, b, c], 3))):
            print('Valido-Isoceles')
        print('Retangulo: {}'.format('S' if a**2 + b**2 == c**2 else 'N'))
    else:
        print('Invalido')
Пример #14
0
def bruteForce(points, map_points):
    #find all the possible total distances that would take to travel to all the
    #points, and display the graph with the shortest distance_map
    distances = []
    orders = []
    order = pick_random(map_points)
    orders = (list(per(order)))
    for i in range(len(orders)):
        orders[i] = goBack(orders[i])
    print(orders)
    orders = orders[:int(len(orders) / 2)]
    for i in range(len(orders)):
        distance = total_distance(map_points, orders[i])
        distances.append(distance)
    minDistIndex, minDist = minIndex(distances)
    minOrder = orders[minDistIndex]
    print(max(distances))
    return minDist, minOrder
Пример #15
0
    def win(self, turn, app, mode):
        self.app = app
        self.mode = mode
        self.crossed_boxs += 1
        self.uncrossed_boxs -= 1
        winning_cases = [[0, 1, 2], [3, 4, 5], [6, 7, 8], [0, 3, 6],
                         [1, 4, 7], [2, 4, 8], [0, 4, 8], [2, 4, 6]]
        if turn == 1:
            lista = self.player_moves1
        else:
            lista = self.player_moves2

        for case in winning_cases:
            for combination in list(per(lista, len(lista))):
                for case2 in list(per(case, len(case))):
                    if list(combination) == list(case2):
                        return True
                    else:
                        pass
Пример #16
0
def solution(string):
	cal = ['-', '+', '*']
	priority = list(map(list, per(cal)))
	input_list = []
	answer = []

	tmp = ''
	for cur in string:
		if cur in cal:
			input_list.append(int(tmp))
			input_list.append(cur)
			tmp = ''
		else:
			tmp += cur
	input_list.append(int(tmp))

	for cur in priority:
		tmp_list = deepcopy(input_list)
		for cal in cur:
			idx = 0
			while idx < len(tmp_list):
				if tmp_list[idx] == cal:
					if tmp_list[idx] == '-':
						tmp = tmp_list[idx - 1] - tmp_list[idx + 1]
					elif tmp_list[idx] == '+':
						tmp = tmp_list[idx - 1] + tmp_list[idx + 1]
					elif tmp_list[idx] == '*':
						tmp = tmp_list[idx - 1] * tmp_list[idx + 1]
					tmp_list[idx - 1] = tmp
					tmp_list.pop(idx)
					tmp_list.pop(idx)
					idx -= 1

				idx += 1
		answer.append(abs(tmp_list[0]))
	return max(answer)
Пример #17
0
from itertools import permutations as per

shouldhave = '123456789'

sudos = [''.join(l for l in _gen) for _gen in per(shouldhave)]
kudos = {
        0:[], 1:[], 2:[], 3:[], 4:[], 5:[], 6:[], 7:[], 8:[], 9:[], 10:[], 11:[], 12:[], 13:[], 14:[],
        15:[], 16:[], 17:[], 18:[], 19:[], 20:[], 21:[], 22:[], 23:[], 24:[], 25:[], 26:[], 27:[], 28:[],
        29:[], 30:[], 31:[], 32:[], 33:[], 34:[], 35:[], 36:[], 37:[], 38:[], 39:[], 40:[], 41:[], 42:[],
        43:[], 44:[], 45:[], 46:[], 47:[], 48:[], 49:[], 50:[]
}

su_sum = 0

f = open('_sudoku.txt', 'r')
count = 50
while count > 0:
    _line = f.readline()
    if 'Grid' in _line:
        _firstrow = f.readline().strip()
        boxes = {0:[], 1:[], 2:[], 3:[], 4:[], 5:[], 6:[], 7:[], 8:[] }
        _shdntcnt =  {0:[], 1:[], 2:[], 3:[], 4:[], 5:[], 6:[], 7:[], 8:[] }
        '''for _inbox in _firstrow:
            if _inbox != '0': 
                boxes[_firstrow.index(_inbox)//3].append(_inbox)
        '''
        for _next8rows in range(2,10):
            _thisline = f.readline().strip()
            for _cur in range(8):
                if _thisline[_cur] != '0':
                    box_count = (_next8rows//3) + _cur // 3
from itertools import permutations as per
s=sorted(list(map("".join,set(per(input()))))
print(len(s),*s,sep='\n')
Пример #19
0
function_exercises.is_two(n)

from function_exercises import is_vowel

from function_exercises import is_consonant as is_c

# 1.How many different ways can you combine the letters from "abc" with the numbers 1, 2, and 3?

from itertools import product as p
combinations = list(p('abc', '123'))
combinations

# 2. How many different ways can you combine two of the letters from "abcd"?

from itertools import permutations as per
combs2 = list(per('abcd', 2))
combs2


from json import load
lis = load(open("profiles.json"))
lis

len(lis)

len([d for d in lis if d['isActive'] == True])

len([d for d in lis if d['isActive'] == False])

def handle_balance(s):
    return float(s[1:].replace(',', ''))
Пример #20
0
from itertools import permutations as per
import re

operators=per(['+','+','+','-','-','-','*','*','*','/','/','/'],3)
operatorset=set([])
while True:
	try:operatorset.add(operators.next())
	except:break

def call(numset):
	def calc(ar):
		operations=[
			"%f %%s %f %%s %f %%s %f" %(ar[0],ar[1],ar[2],ar[3]),
			"(%f %%s %f) %%s %f %%s %f" %(ar[0],ar[1],ar[2],ar[3]),
			"%f %%s (%f %%s %f) %%s %f" %(ar[0],ar[1],ar[2],ar[3]),
			# "%f %%s %f %%s (%f %%s %f)" %(ar[0],ar[1],ar[2],ar[3]),
			"(%f %%s %f %%s %f) %%s %f" %(ar[0],ar[1],ar[2],ar[3]),
			# "%f %%s (%f %%s %f %%s %f)" %(ar[0],ar[1],ar[2],ar[3]),
			"((%f %%s %f) %%s %f) %%s %f" %(ar[0],ar[1],ar[2],ar[3]),
			"(%f %%s (%f %%s %f)) %%s %f" %(ar[0],ar[1],ar[2],ar[3]),
			# "%f %%s ((%f %%s %f) %%s %f)" %(ar[0],ar[1],ar[2],ar[3]),
			# "%f %%s (%f %%s (%f %%s %f))" %(ar[0],ar[1],ar[2],ar[3]),
			"(%f %%s %f) %%s (%f %%s %f)" %(ar[0],ar[1],ar[2],ar[3])
		]
		results=set([])
		for op in operations:
			for sign in operatorset:
				eq=op %(sign[0],sign[1],sign[2])
				try:
					if eval(eq)==24:
						results.add(re.sub(".0+","",eq))
Пример #21
0
                value += b
            else:
                value += m
        mem[adress] = int(value, 2)
print(sum(list(mem.values())))


mem = {}
for line in open("i").read().strip().splitlines():
    op, val = line.split(" = ")
    if op == "mask":
        mask = [i for i in val]
    else:
        adress = [i for i in f"{int(op[4:-1]):b}".zfill(36)]
        new = ""
        for m, a in zip(mask, adress):
            if m == "0":
                new += a
            else:
                new += m
        perms = set()
        for com in comwr((0, 1), new.count("X")):
            for perm in per(com):
                perms.add(perm)
        for perm in perms:
            tmp = new
            for i in perm:
                tmp = tmp.replace("X", str(i), 1)
            mem[int(tmp, 2)] = int(val)
print(sum(list(mem.values())))
Пример #22
0
    node : int
        The vertex to which we need minimum cost.
    """
    cost_path = 0
    for node in range(len(set_Vertices)-1):
        cost_path += dist(graph, set_Vertices[node], set_Vertices[node+1])
    return cost_path


if __name__ == '__main__':
    graphs = []
    initial_non = value_nonl(gen())
    # dict conatining sbox
    non_sbox = {initial_non: gen()}
    all_perms = list(per(range(8)))
    array = gen()
    if is_bijective(array):
        for var in range(10):
            array_mod = []
            for num in range(32):
                array_mod, graph = substitution(
                    all_perms, array, array_mod, num)
                graphs.append(graph)
            # calculate non-linearity of modified Sbox
            nn_array_mod = value_nonl(array_mod)
            if nn_array_mod > limit1:
                non_sbox[nn_array_mod] = [array_mod, graphs]
            print(var, value_nonl(array), nn_array_mod)
    else:
        print('Is not bijective!')
Пример #23
0
from itertools import permutations as per

#takes in the input
x = list(map(int, input().split()))
h2, h1 = x.pop(-1), x.pop(-1)

#not necessarily the quickest way, but still fast
#loops each permuation and calculates sum to compare to heights
for y in per(x):
    s1, s2 = sum(y[0:3]), sum(y[3:])
    if (s1 == h1 and s2 == h2):
        t1 = ' '.join(list(map(str, sorted(y[0:3], reverse=True))))  
        t2 = ' '.join(list(map(str, sorted(y[3:], reverse=True))))  
        print ("{} {}".format(t1, t2))
        break
Пример #24
0
from itertools import permutations as per
string, num = map(str, input().split())
num = int(num)
answer = list(per(string, num))
permu = []
for sub in answer:
    temp = ''
    for key in sub:
        key = str(key)
        temp += key
    permu.append(temp)

permu.sort()
for item in permu:
    print(item)
Пример #25
0
from itertools import permutations as per
p, k = input().split()
l = list(per(sorted(p), int(k)))
for var in l:
    print((var[0] + var[1]).upper())
Пример #26
0
f = open("randomdata", "w")

chars = [chr(c) for c in range(ord('A'), ord('Z')+1)]
# chars += [chr(c) for c in range(ord('a'), ord('z')+1)]

init = 0
while init < lines:
	temp = ""
	for i in xrange(randint(4, 20)):
		temp += choice(chars)
	f.write(temp+"\n")
	init += 1

print "%d lines random data done" % lines

f.close()

f = open("ordereddata", "w")
chars = [chr(c) for c in range(ord('A'), ord('K')+1)]
gene = per( chars )
init = 0
while init < lines:
	f.write("".join(gene.next())+"\n")
	init += 1

print "%d lines ordered data done" % lines

f.close()

raw_input()
Пример #27
0
'''
Created on 3 Oct 2020

@author: peter
'''

from itertools import permutations as per

all_perms = [''.join(letter) for letter in per(list('peterlavin'))]

print(len(all_perms))

# print(all_perms)
for i, perm in enumerate(all_perms):
    if i < 1000:
        print(perm)
    else:
        break
#
# valid_words = ('cat', 'act', 'tac')
#
# final_list = []
#
# for word in all_perms:
#     if word in valid_words:
#         final_list.append(word)
#
#
#
# print(final_list)
Пример #28
0
from itertools import product
a, b = map(int, input().split()), map(int, input().split())
print(*(product(a, b)))

from itertools import permutations as per
inp = input().split()
astring = list(inp[0])
astring.sort()
r = int(inp[1])
l = list(map(''.join, per(astring, r)))
print(*l, sep='\n')

#palindrome
(n, num) = (int(input()), list(input().split()))
print(all(int(i) > 0 for i in num) and any(i[:] == i[::-1] for i in num))
Пример #29
0
from itertools import permutations as per
import sys
n = int(input())
nums = list(map(int, (sys.stdin.readline().split())))
real_ans = 0
for p in per(nums, n):
    ans = 0
    for i in range(n - 1):
        ans += abs(p[i] - p[i + 1])
    if real_ans < ans:
        real_ans = ans
    else:
        continue
print(real_ans)
Пример #30
0
print(question)

num_check = is_two(3)
print(num_check)

check = iscon("t")
print(check)

# 1. How many different ways can you combine the letters from "abc" with the numbers 1, 2, and 3?
from itertools import product
prod = list(product("abc", "123"))
num = len(prod)
print(prod)
print(f"There are {num} possible combinations.")

# 2. How many different ways can you combine two of the letters from "abcd"?

from itertools import combinations_with_replacement as cwr
combo = list(cwr("abcd", 2))
length = len(combo)
print(combo)
print(f"There are {length} possible combinations.")

# 2. Number 2 using permutations instead of combinations_with_replacement

from itertools import permutations as per
combo = list(per("abcd", 2))
length = len(combo)
print(combo)
print(f"There are {length} possible combinations.")
Пример #31
0
from itertools import permutations as per

N, M, H = map(int, input().split())
B = [list(map(int, input().split())) for _ in range(N)]
house = [(i, j) for i in range(N) for j in range(N) if B[i][j] == 1]
milk = [(i, j) for i in range(N) for j in range(N) if B[i][j] == 2]


def sol(p):
    h = M
    cnt = 0
    ans = 0
    x, y = p[0]
    for i in range(len(p) - 1):
        x0, y0 = p[i]
        x1, y1 = p[i + 1]
        dist = abs(x0 - x1) + abs(y0 - y1)
        if h >= dist:
            h -= dist
            h += H
            cnt += 1
        else:
            break
        if h >= abs(x - x1) + abs(y - y1):
            ans = cnt
    return ans

print(max(sol(house + list(p)) for p in per(milk)))
Пример #32
0
def permutations(string):
    return list(set(map(''.join, per(string))))
Пример #33
0
from itertools import permutations as per

print list(per(range(10)))[999999]
Пример #34
0
            name_list.sort()
            if num == 1:
                print(name_list[0])
            else:
            
                num = int(input().strip())
                for i in range(num):
                    name1,name2 = input().strip().split()
                    name_dict[name1].add(name2)
                    name_dict[name2].add(name1)

                index = 1
                length = len(name_list)
                ans = []
                #print(name_dict)
                for k in per(name_list):
                    has = True
                    #print(k)
                    for i in range(1,length):
                        if k[i-1] in name_dict[k[i]]:
                            has = False
                            break
                    if has:
                        ans = k
                        break
                    
                if has:
                    print(' '.join(ans))
                else:
                    print('You all need therapy.')
        except:
Пример #35
0
## 문제 18.
## 어떤 대상을 순서에 따라 배열한 것을 순열이라고 합니다.
## 예를 들어 3124는 숫자 1, 2, 3, 4로 만들 수 있는 순열 중 하나입니다.

## 이렇게 만들 수 있는 모든 순열을 숫자나 문자 순으로 늘어놓은 것을
## 사전식(lexicographic) 순서라고 합니다.

## 0, 1, 2로 만들 수 있는 사전식 순열은 다음과 같습니다.
## 012   021   102   120   201   210

## 0, 1, 2, 3, 4, 5, 6, 7, 8, 9로 만들 수 있는 사전식 순열에서
## 1,000,000번째는 무엇입니까?      # 2783915604
from itertools import permutations as per

# my_list = [0, 1, 2]
my_list = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
tmp_list = list(per(my_list))
lex_list = list()

for i in tmp_list:
    my_str = ''
    for v in i:
        my_str += str(v)

    lex_list.append(my_str)

# print((lex_list))
print(lex_list[1000000])