Сначала опубликуйте приложение в магазине Play, затем выполните следующие действия:
Я добавил пример, который вы можете проверить ниже SS.
РЕДАКТИРОВАТЬ 1: -
Шаги для Выпуск Hashkey :
keytool -exportcert -alias **myaliasname** -keystore **"C:\Users\hiren.patel\Desktop\mykeystore.jks"** | "C:\openssl-0.9.8e_X64\bin\openssl.exe" sha1 -binary | "C:\openssl-0.9.8e_X64\bin\openssl.exe" base64
Просьба изменить Псевдоним Имя и Keystore с указанием пути в качестве вашего требования.
Терминал будет запрашивать у пароль хранилища ключей. Вы должны предоставить пароль для того же хранилища ключей .
Итак, наконец, вы получите Release Hashkey .
Готово
РЕДАКТИРОВАТЬ 2:
Используйте эту команду в Linux:
echo 33:4E:48:84:19:50:3A:1F:63:A6:0F:F6:A1:C2:31:E5:01:38:55:2E | xxd -r -p | openssl base64
, если вы не Если у вас не установлена ОС Linux, вы можете сделать это онлайн: по этой ссылке:
https://rextester.com/l/bash_online_compiler
Примечание: USE КЛЮЧ ПОДПИСАНИЯ API ОТ КОНСОЛИ РАЗРАБОТЧИКА.
Редактировать 3:
Попробуйте сгенерировать хеш без псевдонима для Google APK Sign Enabled
т.е.
keytool -exportcert -keystore MyProductionKeys.keystore | xxd -p | tr -d "[:space:]" | echo -n com.example.myapp `cat` | sha256sum | tr -d "[:space:]-" | xxd -r -p | base64 | cut -c1-11
ПРИМЕЧАНИЕ. Отпечаток сертификата SHA-256, взять его с консоли разработчика
С таким количеством предложенных решений, Я удивлен, что никто не предложил то, что я ' d рассмотрим очевидный (для нехешируемых, но сопоставимых элементов) - [ itertools.groupby
] [1]. itertools
предлагает быструю, многоразовую функциональность и позволяет делегировать некоторую сложную логику хорошо протестированным компонентам стандартной библиотеки. Рассмотрим, например:
import itertools
import operator
def most_common(L):
# get an iterable of (item, iterable) pairs
SL = sorted((x, i) for i, x in enumerate(L))
# print 'SL:', SL
groups = itertools.groupby(SL, key=operator.itemgetter(0))
# auxiliary function to get "quality" for an item
def _auxfun(g):
item, iterable = g
count = 0
min_index = len(L)
for _, where in iterable:
count += 1
min_index = min(min_index, where)
# print 'item %r, count %r, minind %r' % (item, count, min_index)
return count, -min_index
# pick the highest-count/earliest item
return max(groups, key=_auxfun)[0]
Конечно, это можно было бы написать более кратко, но я стремлюсь к максимальной ясности. Два оператора print
можно раскомментировать, чтобы лучше увидеть механизм в действии; например, с печатает без комментариев:
print most_common(['goose', 'duck', 'duck', 'goose'])
испускает:
SL: [('duck', 1), ('duck', 2), ('goose', 0), ('goose', 3)]
item 'duck', count 2, minind 1
item 'goose', count 2, minind 0
goose
Как видите, SL
- это список пар, каждая пара - элемент, за которым следует индекс элемента в исходном list (для реализации ключевого условия, согласно которому, если "наиболее распространенные" элементы с одинаковым наибольшим количеством> 1, результат должен быть самым ранним из возникших).
groupby
группирует только по элементу (через operator.itemgetter
). Вспомогательная функция, вызываемая один раз для каждой группировки во время вычисления max
, получает и внутренне распаковывает группу - кортеж с двумя элементами (item, iterable)
, где элементы итерируемого также являются двух- кортежи элементов, (элемент, исходный индекс)
[[элементы из SL
]].
Затем вспомогательная функция использует цикл для определения количества записей в группе итерируемый, и минимальный исходный индекс; он возвращает их как комбинированный «ключ качества» с измененным знаком минимального индекса, поэтому операция max
будет считать «лучше» те элементы, которые встречались раньше в исходном списке.
Этот код мог бы быть намного проще, если бы он беспокоился немного меньше о проблемах большого О во времени и пространстве, например ...:
def most_common(L):
groups = itertools.groupby(sorted(L))
def _auxfun((item, iterable)):
return len(list(iterable)), -L.index(item)
return max(groups, key=_auxfun)[0]
та же основная идея, только выраженная более просто и компактно. .. но, увы, лишнее O (N) вспомогательное пространство (для воплощения итераций групп в списки) и O (N в квадрате) времени (чтобы получить L.index
каждого элемента). В то время как преждевременная оптимизация является корнем всего зла в программировании, намеренный выбор подхода O (N в квадрате), когда доступен O (N log N), просто идет слишком вразрез с масштабируемостью! -)
Наконец, для тем, кто предпочитает «однострочные» ясности и производительности, бонусная однострочная версия с соответствующим образом искаженными именами: -).
from itertools import groupby as g
def most_common_oneliner(L):
return max(g(sorted(L)), key=lambda(x, v):(len(list(v)),-L.index(x)))[0]
def mostCommonElement(list):
count = {} // dict holder
max = 0 // keep track of the count by key
result = None // holder when count is greater than max
for i in list:
if i not in count:
count[i] = 1
else:
count[i] += 1
if count[i] > max:
max = count[i]
result = i
return result
mostCommonElement (["a", "b", "a", "c"])-> "a"
>>> li = ['goose', 'duck', 'duck']
>>> def foo(li):
st = set(li)
mx = -1
for each in st:
temp = li.count(each):
if mx < temp:
mx = temp
h = each
return h
>>> foo(li)
'duck'
Это очевидное медленное решение (O (n ^ 2)), если ни сортировка, ни хеширование невозможны, но доступно сравнение равенства ( ==
):
def most_common(items):
if not items:
raise ValueError
fitems = []
best_idx = 0
for item in items:
item_missing = True
i = 0
for fitem in fitems:
if fitem[0] == item:
fitem[1] += 1
d = fitem[1] - fitems[best_idx][1]
if d > 0 or (d == 0 and fitems[best_idx][2] > fitem[2]):
best_idx = i
item_missing = False
break
i += 1
if item_missing:
fitems.append([item, 1, i])
return items[best_idx]
Но если сделать ваши элементы хэшируемыми или сортируемыми (как рекомендовано другими ответами), почти всегда будет быстрее находить наиболее распространенный элемент, если длина вашего списка (n) велика. O (n) в среднем с хешированием и O (n * log (n)) в худшем случае для сортировки.
Здесь:
def most_common(l):
max = 0
maxitem = None
for x in set(l):
count = l.count(x)
if count > max:
max = count
maxitem = x
return maxitem
У меня есть смутное ощущение, что где-то в стандартной библиотеке есть метод, который даст вам количество каждого элемента, но я не могу его найти.
# use Decorate, Sort, Undecorate to solve the problem
def most_common(iterable):
# Make a list with tuples: (item, index)
# The index will be used later to break ties for most common item.
lst = [(x, i) for i, x in enumerate(iterable)]
lst.sort()
# lst_final will also be a list of tuples: (count, index, item)
# Sorting on this list will find us the most common item, and the index
# will break ties so the one listed first wins. Count is negative so
# largest count will have lowest value and sort first.
lst_final = []
# Get an iterator for our new list...
itr = iter(lst)
# ...and pop the first tuple off. Setup current state vars for loop.
count = 1
tup = next(itr)
x_cur, i_cur = tup
# Loop over sorted list of tuples, counting occurrences of item.
for tup in itr:
# Same item again?
if x_cur == tup[0]:
# Yes, same item; increment count
count += 1
else:
# No, new item, so write previous current item to lst_final...
t = (-count, i_cur, x_cur)
lst_final.append(t)
# ...and reset current state vars for loop.
x_cur, i_cur = tup
count = 1
# Write final item after loop ends
t = (-count, i_cur, x_cur)
lst_final.append(t)
lst_final.sort()
answer = lst_final[0][2]
return answer
print most_common(['x', 'e', 'a', 'e', 'a', 'e', 'e']) # prints 'e'
print most_common(['goose', 'duck', 'duck', 'goose']) # prints 'goose'
Однострочное сообщение:
def most_common (lst):
return max(((item, lst.count(item)) for item in set(lst)), key=lambda a: a[1])[0]
Если они не хэшируемые, вы можете отсортировать их и выполнить один цикл для результата, подсчитывая элементы (идентичные элементы будут рядом друг с другом). Но может быть быстрее сделать их хешируемыми и использовать dict.
def most_common(lst):
cur_length = 0
max_length = 0
cur_i = 0
max_i = 0
cur_item = None
max_item = None
for i, item in sorted(enumerate(lst), key=lambda x: x[1]):
if cur_item is None or cur_item != item:
if cur_length > max_length or (cur_length == max_length and cur_i < max_i):
max_length = cur_length
max_i = cur_i
max_item = cur_item
cur_length = 1
cur_i = i
cur_item = item
else:
cur_length += 1
if cur_length > max_length or (cur_length == max_length and cur_i < max_i):
return cur_item
return max_item
Отсортируйте копию списка и найдите самый длинный прогон. Вы можете украсить список перед сортировкой по индексу каждого элемента, а затем выбрать прогон, который начинается с самого низкого индекса в случае ничьей.
Это решение O (n).
mydict = {}
cnt, itm = 0, ''
for item in reversed(lst):
mydict[item] = mydict.get(item, 0) + 1
if mydict[item] >= cnt :
cnt, itm = mydict[item], item
print itm
(обратное используется, чтобы убедиться, что он возвращает элемент с наименьшим индексом)
Более простой однострочник:
def most_common(lst):
return max(set(lst), key=lst.count)
Возможно, вам это больше не нужно, но я сделал это для аналогичной проблемы. (Из-за комментариев это выглядит длиннее, чем есть.)
itemList = ['hi', 'hi', 'hello', 'bye']
counter = {}
maxItemCount = 0
for item in itemList:
try:
# Referencing this will cause a KeyError exception
# if it doesn't already exist
counter[item]
# ... meaning if we get this far it didn't happen so
# we'll increment
counter[item] += 1
except KeyError:
# If we got a KeyError we need to create the
# dictionary key
counter[item] = 1
# Keep overwriting maxItemCount with the latest number,
# if it's higher than the existing itemCount
if counter[item] > maxItemCount:
maxItemCount = counter[item]
mostPopularItem = item
print mostPopularItem