Peter Schőn slapec

## js_arg_extract_w_pyv8.js
import PyV8


class Globals(PyV8.JSClass):
    def __init__(self):
        super(Globals, self).__init__()
        self.coords = []

    def PutMarkers(self, selector, coords):
        coords = PyV8.convert(coords)

## tech_circle.html
<html>
<head>
</head>

<canvas id="c" width="800", height="600" style="display: none"></canvas>
<img id="kep">
<button id="f5">F5</button>
<script>
  function newCircle(ctx){
    ctx.beginPath();

## google_search_by_image.py
# coding: utf-8
import requests
from lxml.html import fromstring
from requests_toolbelt.multipart.encoder import MultipartEncoder


def extract(soup):
    for elem in soup.cssselect('.rc h3 a'):
        href = elem.get('href')
        if 'parom.hu' not in href:

## dump.py
# coding: utf-8

import json
import argparse
import os
import re
from pathlib import Path

os.environ.setdefault("DJANGO_SETTINGS_MODULE", "wimm.settings")

## order.py
import re
items = ('burger', 'fries', 'chicken', 'pizza', 'sandwich', 'onionrings', 'milkshake', 'coke')

def get_order(s):
    words = re.findall('|'.join(items), s, flags=re.IGNORECASE)
    words.sort(key=items.index)

    return ' '.join(map(str.capitalize, words))

## longest_palindrome.py
def longest_palindrome(text):
    text_length = len(text)
    def find(longest_possible):
        for window in range(text_length - longest_possible + 1):
            subtext = text[window:window + longest_possible]
            if subtext == subtext[::-1]:
                return longest_possible
        else:
            return find(longest_possible - 1)

## josephus_survivor.py
import collections

def josephus_survivor(n, k):
    population = collections.deque(range(1, n + 1))
    retval = None
    while population:
        population.rotate(1 - k)
        retval = population.popleft()

    return retval

## scramble.py
import collections

def scramble(word, chars):
    word_char_count = collections.Counter(word)
    chars_char_count = collections.Counter(chars)
    chars_char_count.subtract(word_char_count)

    return all(chars_char_count[word_char] >= 0 for word_char in word_char_count.keys())

print(scramble('door', 'abcdeooor'))

## increment_if_ends_with_int.py
import re

def patch(match):
    incremented = str(int(match.group(0)) + 1)
    padded = incremented.zfill(len(match.group(0)))
    return padded

def increment_if_ends_with_int(text):
    patched = re.sub('(\d+)$', patch, text)
    if not patched[-1].isdigit():

## smallest_unique_number.py
import collections
def smallest_unique_number(numbers: list) -> int:
    try:
        least_common, population = collections.Counter(numbers).most_common()[-1]
        assert population == 1
        return least_common

    except (AssertionError, IndexError):
        return -1
	import PyV8


	class Globals(PyV8.JSClass):
	def __init__(self):
	super(Globals, self).__init__()
	self.coords = []

	def PutMarkers(self, selector, coords):
	coords = PyV8.convert(coords)
	<html>
	<head>
	</head>

	<canvas id="c" width="800", height="600" style="display: none"></canvas>
	<img id="kep">
	<button id="f5">F5</button>
	<script>
	function newCircle(ctx){
	ctx.beginPath();
	# coding: utf-8
	import requests
	from lxml.html import fromstring
	from requests_toolbelt.multipart.encoder import MultipartEncoder


	def extract(soup):
	for elem in soup.cssselect('.rc h3 a'):
	href = elem.get('href')
	if 'parom.hu' not in href:
	# coding: utf-8

	import json
	import argparse
	import os
	import re
	from pathlib import Path

	os.environ.setdefault("DJANGO_SETTINGS_MODULE", "wimm.settings")
	import re
	items = ('burger', 'fries', 'chicken', 'pizza', 'sandwich', 'onionrings', 'milkshake', 'coke')

	def get_order(s):
	words = re.findall('\|'.join(items), s, flags=re.IGNORECASE)
	words.sort(key=items.index)

	return ' '.join(map(str.capitalize, words))
	def longest_palindrome(text):
	text_length = len(text)
	def find(longest_possible):
	for window in range(text_length - longest_possible + 1):
	subtext = text[window:window + longest_possible]
	if subtext == subtext[::-1]:
	return longest_possible
	else:
	return find(longest_possible - 1)
	import collections

	def josephus_survivor(n, k):
	population = collections.deque(range(1, n + 1))
	retval = None
	while population:
	population.rotate(1 - k)
	retval = population.popleft()

	return retval
	import collections

	def scramble(word, chars):
	word_char_count = collections.Counter(word)
	chars_char_count = collections.Counter(chars)
	chars_char_count.subtract(word_char_count)

	return all(chars_char_count[word_char] >= 0 for word_char in word_char_count.keys())

	print(scramble('door', 'abcdeooor'))
	import re

	def patch(match):
	incremented = str(int(match.group(0)) + 1)
	padded = incremented.zfill(len(match.group(0)))
	return padded

	def increment_if_ends_with_int(text):
	patched = re.sub('(\d+)$', patch, text)
	if not patched[-1].isdigit():
	import collections
	def smallest_unique_number(numbers: list) -> int:
	try:
	least_common, population = collections.Counter(numbers).most_common()[-1]
	assert population == 1
	return least_common

	except (AssertionError, IndexError):
	return -1