Недавно опубликовал своё приложение в Play Markete. Понял, что допустил ошибку. Теперь его оттуда нужно удалить. Как?
Перейти на https://play.google.com/apps/publish Раздел «приложение». Далее, «файлы apk». Переключится в расширенный режим. Деактивировать.
Здравствуйте! Мне необходимо вычислить: 2147483647^2147483647%2147483648; 2147483647=2^(31)-1; Пожалуйста, подскажите, как реализовать подобное на с?
Все очень просто. Понятно, что если умножать числа и потом взять по модулю, то для этого нужна будет длинная арифметика. А число выйдет приличное (более 66,571 миллиардов знаков). Поэтому применим трюк - будет после каждого умножения брать по модулю. То есть, код где то такой (схематически)
a = 2147483647;
m = 2147483648;
for (i = 0; i < 2147483647; i++) {
r *=a;
r %= m;
}
Но здесь своя незадача. Работать это дело будет не быстро.
Здесь в бой вступает быстрое возведение в степень. Оно работает очень быстро.
Но есть ещё один подводный камень. Дело в том, что число то большое и вполне будет переполнение. Здесь можно поступить двояко. либо взять 64битное и все сделать, либо, учитывая, что все равно нужно брать по модулю 2 в 32, использовать следствия переполнения (оно будет работать нам на руку).
Вариант с 64битными переменными
#include
#define int64 long long int
int64 st(int64 a, int64 b, int64 m) {
int64 r = 1;
while (b) {
if (b & 1) {
r *= a;
r %= m;
}
a *= a;
a %= m;
b >>=1;
}
return r;
}
int main()
{
int64 a = 2147483647;
int64 m = 2147483648;
int64 r = st(a,a,m);
printf("%lld
", r);
return 0;
}
Вариант с 32битными
#include
unsigned int st(unsigned int a, unsigned int b) {
unsigned int r = 1;
while (b) {
if (b & 1) {
r *= a;
}
a *= a;
b >>=1;
}
return r;
}
int main()
{
unsigned int a = 2147483647;
unsigned int r = st(a,a);
printf("%d
", r);
return 0;
}
p.s все компилировал в gcc строкой gcc test.c -Wall -pedantic -std=c99 на 64 битной системе. Оба варианта выдали 2147483647. На первый взгляд странно. Но потом, взяв обычный листик бумаги, я убедился, что 2147483647 * 2147483647 % 2147483648 равно 1. Отсюда напрашивается вывод, что для (2147483647 ^ a) % 2147483648 равно 1 для всех четных a. и 2147483647 для всех нечетных.
Всем доброго времени суток! В одном из учебных материалов есть задание: напишите программу, о которой мы говорили в самом начале этой главы, которая просит нас ввести сколько угодно слов (по одному слову в строке до тех пор, пока мы не нажмём Enter на пустой строке) и которая затем повторяет нам эти слова в алфавитном порядке. Далее есть дополнительное задание: попробуйте написать указанную программу без использования метода sort. Большая часть программирования - это преодоление сложностей, так что практикуйтесь чаще, насколько это возможно! И здесь я застрял :( Более-менее толковое решение, подходящее на текущий этап обучения/уровень владения языком, было найдено - сортировка пузырьком: words = ["Шарик","Бобик","Барсик","Зорька","Кеша","Арчи","Мурка"] swap = true size = words.length - 1 while swap swap = false for i in 0...size swap |= words[i] > words[i + 1] words[i], words[i + 1] = words[i + 1], words[i] if words[i] > words [i + 1] end size -= 1 end puts words.join(', ') Данный код работает и работает правильно. Но вот проблема - не все строки мне понятны. Кто-нибудь может детально, строчку за строчкой, как для малого дитя, рассказать, что, как и почему там выполняется? Заранее огромное спасибо!
Зря вы сами не писали и не разбирали алгоритм, а решили взять готовый код с недостатком знаний.
Для начала возьмем и разберемся с сортировкой и возьмем массив для примера:
words = ["Шарик","Бобик","Барсик","Зорька","Кеша","Арчи","Мурка"]
Чтобы пройтись по нему, можно использовать цикл for:
for i in 0...words.length
puts words[i]
end
Можно сравнивать строки с помощью обычных логических операций: words[0] > words[1]
Теперь пройдем циклом и попытаемся частично отсортировать наши данные с промежуточным выводом. Поскольку мы будем пользоваться конструкцией i+1, то чтобы не выйти за пределы массива, поменяем words.length на words.length - 1
Для наглядности чуть изменим наш массив.
words = ["Яшка","Шарик","Бобик","Барсик","Зорька","Кеша","Арчи","Мурка"]
for i in 0...words.length - 1
if words[i] > words[i+1] then
temp = words[i]
words[i] = words[i+1]
words[i+1] = temp
end
puts words.join(","),"
"
end
Вывод будет таким:
"Шарик","Яшка","Бобик","Барсик","Зорька","Кеша","Арчи","Мурка"
"Шарик","Бобик","Яшка","Барсик","Зорька","Кеша","Арчи","Мурка"
"Шарик","Бобик","Барсик","Яшка","Зорька","Кеша","Арчи","Мурка"
"Шарик","Бобик","Барсик","Зорька","Яшка","Кеша","Арчи","Мурка"
"Шарик","Бобик","Барсик","Зорька","Кеша","Яшка","Арчи","Мурка"
"Шарик","Бобик","Барсик","Зорька","Кеша","Арчи","Яшка","Мурка"
"Шарик","Бобик","Барсик","Зорька","Кеша","Арчи","Мурка","Яшка"
Как мы видим, самый маленький элемент (буква "я") пропутешествовал в конец, а другие сдвинулись к началу. Если сделать над массивом несколько таких операций, то все элементы выстроятся в отсортированный ряд.
for j in 0...words.length
for i in 0...words.length - 1
if words[i] > words[i+1] then
temp = words[i]
words[i] = words[i+1]
words[i+1] = temp
end
puts words.join(","),"
"
end
end
В конце концов, мы получаем готовую программу сортировки пузырьком.
words = ["Яшка","Шарик","Бобик","Барсик","Зорька","Кеша","Арчи","Мурка"]
for j in 0...words.length - 1
for i in 0...words.length - 1
if words[i] > words[i+1] then
temp = words[i]
words[i] = words[i+1]
words[i+1] = temp
end
end
end
puts words.join(","),"
"
Но на самом деле этот алгоритм не идеален. Для перемены местами элементов мы используем такую конструкцию:
temp = words[i]
words[i] = words[i+1]
words[i+1] = temp
Ruby позволяет делать это проще:
words[i], words[i + 1] = words[i + 1], words[i]
К тому же у IF есть несколько вариантов синтаксиса:
if condition [then]
code
end
и
code if condition
Во втором варианте сначала пишется один оператор и потом проверка, поэтому мы меняем наш код на аналогичный:
for j in 0...words.length - 1
for i in 0...words.length - 1
words[i], words[i + 1] = words[i + 1], words[i] if words[i] > words[i+1]
end
end
Это все один и тот же алгоритм, но записанный разными способами. Теперь разберемся с бесконечным циклом, который Вас смутил.
swap = false
while swap
swap = true
end
Как видите, из простого примера, у нас на самом деле есть условие, это значение логической переменной swap! А теперь как оно меняется.
Есть сокращенные записи операций:
a = a + 1 аналогично a += 1
a = a * 1 аналогично a *= 1
a |= true аналогично a = a | true
В данном случае | является логической операцией ИЛИ которая возвращает TRUE, если хоть один из операторов содержит значение TRUE.
Данный код будет выдавать TRUE всегда, если слова не отсортированы.
for i in 0...words.length - 1
swap |= words[i] > words[i + 1]
end
А значит и заново запустится WHILE, если слова находятся не по порядку. А вот если они по порядку, то цикл прервется и больше не будет выполнятся. Например, для уже отсортированных слов мы пройдемся только один раз, вместо words.length раз, чем экономим себе время.
while swap
swap = false
for i in 0...words.length - 1
swap |= words[i] > words[i + 1]
words[i], words[i + 1] = words[i + 1], words[i] if words[i] > words [i + 1]
end
end
Во время просмотра сортировки видно, что последнее сортируемое слово уже на последнем месте, поэтому не обязательно проходится по всей длине массива. Отсюда получается size, который постоянно уменьшаем на один size -= 1. Вот так алгоритм получаем свой окончательный вид.
words = ["Шарик","Бобик","Барсик","Зорька","Кеша","Арчи","Мурка"]
swap = true
size = words.length - 1
while swap
swap = false
for i in 0...size
swap |= words[i] > words[i + 1]
words[i], words[i + 1] = words[i + 1], words[i] if words[i] > words [i + 1]
end
size -= 1
end
puts words.join(', ')
Чтобы искать по файлу в vim'e, я обычно делаю так:
Нажимаю /
Ввожу требуемый паттерн поиска - например, слово function
Нажимаю enter, и дальше уже двигаюсь по результатам поиска.
Как бы исключить из этого списка пункт2 :)
Допустим, у меня курсор стоит на первой букве слова function, требуется комбинация (биндинг в .vimrc), которую можно нажать - и слово автоматом добавится в буфер поиска.
Алгоритм следующий:
Наводите курсор на слово
Нажимаете *
vim переходит к его следующему вхождению.
Как справедливо отметил KoVadim, вместо * можно использовать #, тогда поиск будет идти в обратном направлении.
Также тут описан способ по поиску и замене слова под курсором.
Есть простая форма, в которой много полей и данных. Сделано с AngularJS. Пользователь может зайти и изменить данные: добавить новые поля или удалить старые.
Требование: сделать без кнопки "сохранить", то есть производить автоматическое сохранение при изменении поля. Существует вероятность, что над формой будут работать несколько пользователей параллельно.
Как сделать это правильно?
Сейчас, как только происходит изменение формы, то посылается post request, и данные сохраняются. Но как тянуть данные при их изменении автоматически? Я не могу каждые X секунд проверять, изменились ли поля. Получится слишком много запросов на сервер. Что думаете?
Если вам нужно поддерживать старые браузеры, то придётся делать регулярные запросы к серверу, здесь особо без вариантов.
Современные браузеры поддерживают веб-сокеты: постоянное полнодуплексное соединение браузера с веб-сервером. Пока соединение открыто, клиент и сервер могут посылать друг другу сообщения.
Сервер может подписаться на обновление данных в базе и рассылать уведомления всем подключенным клиентам по мере необходимости. С точки зрения GUI понадобится дополнительная работа: как уведомлять пользователя, как поступать в случае конфликтов (молча перезаписывать, перезаписывать с подтверждением, предлагать "мержить" и т. п.).
Уровень поддержки в принципе нормальный: http://caniuse.com/#feat=websockets (особенно если вы можете повлиять на то, что стоит у клиента).
Есть признаки документа и введенные вручную примечания к документу. Признак документа содержит текстовое описание, которое может пересекаться с примечанием. Хочется (и требуется по ТЗ) печатать что-то одно. В идеале - то, что длиннее, но для начала - хотя бы чтобы остался только один.
Пример: в комментарии введено "поставить печать", в признаке - "Поставить печать!!!"
Описан следующий компарер:
internal class StringIncludeComparer:IEqualityComparer
public int GetHashCode(string obj)
{
return obj.GetHashCode();
}
}
Собрав в итоге комментарии из документов и комментарии из признаков документов в один List<{ID, Comment}> делаю следующее:
from trp in tmpPostReport
group trp.Comment by trp.Id
into CommPers
select new { Id= CommPers.Key, Comment = string.Join("; ",
CommPers.Distinct(new StringIncludeComparer()).ToArray()) };
Но в итоге получаю строку "поставить печать; Поставить печать!!!"
Вопрос:
Что не так с компарером?
Как сделать так, чтобы при сравнении строк "поставить печать" и "Поставить печать!!!" выбиралась всегда большая по длине, т.е. "Поставить печать!!!"
Ваша проблема в том, что GetHashCode не согласован с Equals. так делать нельзя. Должно выполняться условие: если Equals возвращает true, то и хэшкоды должны быть равны.
Например, вы можете вернуть 0 в GetHashCode
Для того, чтобы выбрать самую короткую строку, можно попробовать использовать groupby:
CommPers.GroupBy(s => s, new StringIncludeComparer())
.Select(g => g.OrderBy(s => s.Length).First());
Но учтите, что для EqualityComparer'а ваше отношение равенства должно быть транзитивно, как это отмечено в другом ответе. Поэтому код имеет право и не сработать.
Для того, чтобы ваше сравнение гарантировано работало несмотря на то, что оно нетранзитивно, применим тяжёлую артиллерию. Откажемся от IEqualityComparer'а (так как мы всё равно не можем удовлетворить его инвариант), и сделаем группировку, которая вычисляет транзитивное замыкание вашего равенства: если Equals(a, b) и Equals(b, c) оба равны true, то мы считаем элементы a и c равными вне зависимости от Equals(a, c) (и так далее). Заметьте, что нам теперь придётся сравнивать (почти) каждый элемент с каждым, так что производительность пострадает.
static class EnumerableExtensions
{
class TransitiveGrouping
public static IEnumerable
Теперь ваш запрос должен работать так:
CommPers.TransitiveGroupBy(s => s, new StringIncludeComparer().Equals)
.Select(g => g.OrderByDescending(s => s.Length).First());
Вот рабочий пример: http://ideone.com/OT2GqM
Я сильно не отлаживал, так что возможны баги. Если что, сообщайте, пофиксим.
Имеется usbлоггер/мультиметр, к нему есть драйвера, есть оригинальное ПО, но нет ни документации, ни API (производитель не поставляет). Стоит задача: написать ПО для взаимодействия с данным устройством (оригинальное ПО по неизвестным мне причинам не устраивает руководство). Как можно выцыганить,отковырять, слизать методы обмена с данным устройством? Реально ли это вообще? Язык предпочтительно C#, но можно и чистый Си (знания можно восполнить).
На английском языке этой теме (реверс-инженерии) посвящен целый сайт Stack Exchange. Конкретно реверс-инжиниринг устройства через USB обсуждается, например, тут: https://reverseengineering.stackexchange.com/questions/2416/how-to-reverse-engineer-simple-usb-device-windows-linux
Вкратце: используйте VMWare + Virtual USB analyzer, чтобы поймать и визуализировать трафик между USB-устройством и системой (виртуальной машиной).
Сайт
Туториал
Как альтернатива - еще вот такой тул
Читал новые фичи в java 8, но так и не понял, можно ли в java передать метод в качестве параметра другому методу?
Насколько я понимаю, речь всё-таки не о лямбда-выражениях, а о ссылках на методы (method references). Они ходят рядом с лямбда-выражениями, но всё же это отдельная штука.
Предположим, у вас есть метод, которому зачем-то посреди работы нужно преобразование строки в строку. Для этого можно воспользоваться готовым функциональным интерфейсом UnaryOperator
public void myMethod(UnaryOperator
Теперь в этот метод вы можете передать ссылки на подходящие методы. Тут подходят некоторые методы класса String, которые не принимают аргументов и возвращают новую строку. Например, можно вызвать так:
myMethod(String::trim);
Или так:
myMethod(String::toUpperCase);
Тогда, когда вы вызываете stringTransformer.apply(str), это волшебным образом превратится в str.trim() или str.toUpperCase()
Ещё тут вариант — передать ссылку на статический метод с одним параметром. Например, у вас в проекте есть такое:
public class StringUtils {
public static String removeDots(String str) {
return str.replace(".", "");
}
}
Тогда вы можете и ссылкой на такой метод воспользоваться:
myMethod(StringUtils::removeDots);
И stringTransformer.apply(str) волшебным образом превратится в StringUtils.removeDots(str). Ещё можно сделать instance-bound ссылку, привязанную к конкретному объекту. Например:
myMethod(Pattern.compile("foo").matcher("[foo]")::replaceFirst);
Тут уже stringTransformer.apply(str) волшебным образом возьмёт str в квадратные скобки (а точнее — заменит в [foo] подстроку foo на str).
Есть ещё ссылки на методы, создающие объект (типа ArrayList::new) или массив (типа int[]::new). В этом случае функциональный интерфейс должен соответствовать параметрам конструктора (в случае массива подразумевается один целый параметр — его длина). Ссылки на методы — мощная и красивая штука, но нередко всё-таки нужно полноценное лямбда-выражение. Например, последний пример яснее написать так:
myMethod(str -> "["+str+"]");
Что из себя представляет механизм полиморфизма в Java и как он работает? Если это зависит от реализации конкретной JVM, то хотелось бы увидеть это на примере какой-нибудь JVM, например HotSpot.
Для уточнения, в С++ полиморфизм реализуется за счет таблицы виртуальных функций для каждого класса, указатель на которую неявно хранится в каждом экземпляре класса. А как это сделано в Java?
Полиморфизм метода, определённого в классе, достигается за счёт выбора по таблице виртуальных методов примерно как в C++. То есть накладные расходы на вызов — это взять у объекта classword (который записан в его заголовке), добавить к нему известное заранее смещение и вызвать метод по указанному адресу.
Полиморфизм метода, определённого в интерфейсе, достигается более сложным путём: в структуре описания класса ищется запись, относящаяся к данному интерфейсу, и в ней уже ищется нужный метод. То есть, скажем,
public static
public static
Первый случай может оказаться медленнее, потому что мы вызываем метод интерфейса. Хотя метод один и тот же, но разница есть. Даже в байткоде две разные инструкции — invokeinterface и invokevirtual.
JIT-компилятор HotSpot агрессивно использует технику девиртуализации. Естественно в обычный статический вызов превратится вызов final-метода или метода final-класса. Также если runtime-таблица типов говорит, что данный метод нигде не переопределён, вызов будет статическим:
public static
Хотя ArrayList не final-класс и метод get тоже не final, если мы знаем, что он не переопределён на данный момент ни в одном загруженном классе, мы можем сделать вызов статическим. Если будет загружен новый класс, который нарушит это условие, JIT-компилятор перекомпилирует этот метод.
Если есть варианты, используется профиль типов. К примеру, если этот код уже выполнялся 5000 раз и из них в 4990 случаях вызывался конкретный метод ArrayList.get, то JIT-компилированный код станет примерно таким:
public static
Проверка list.getClass() == ArrayList.class весьма быстрая — это достать classword (по скорости как прочитать поле объекта) и сравнить с константой (на момент JIT-компиляции точно известен classword для класса ArrayList). Branch-prediction тоже хорошо отработает, если условие в подавляющем большинстве случаев выполняется.
Если из 5000 вызовов было 3000 ArrayList и 1990 LinkedList, код будет примерно таким:
public static
Это биморфный вызов. Если же популярных вариантов было больше двух, то тогда уж вызов останется честным виртуальным.
Разумеется, если вы в одном методе вызываете несколько методов неизвестного объекта, переданного параметром (или в цикле вызываете метод много раз), то тип проверяться будет только один раз.
Если вызов удалось девиртуализовать (хотя бы в биморфный вариант), то дальше агрессивно применяется инлайнинг (видал своими глазами как в один метод инлайнилось штук 70 других на глубину вызовов до 8-9: в первый инлайнится второй, в него третий и т. д.). Инлайнинг открывает дорогу к тонне других оптимизаций.
Как вы уже поняли, первоначально код выполняется во-первых, медленнее, а во-вторых в режиме профилирования. То есть при каждом вызове метода не просто происходит вызов, но и обновляется таблица статистики, где указывается, какой конкретно класс тут был. Когда статистика собрана, метод перекомпилируется с учётом неё. При этом если есть быстрая и медленная ветка, то медленная будет обновлять статистику дальше. Например, если сценарий использования программы поменялся, то метод может быть снова перекомпилирован.
В чем разница в этих двух примерах, почему рекомендуют как во 2 примере.
Когда нужно использовать конструктор, а когда можно обойтись просто функцией?
Пример 1:
var player_1 = {
name: "robot",
hitpoints: 100,
attack_power: 10,
heal_power: 5
}
var player_2 = {
name: "human",
hitpoints: 200,
attack_power: 20,
heal_power: 20
}
var game = {
attack: function (p1, p2) {
p2.hitpoints -= p1.attack_power
console.log("after hit " + p2.name + "have " + p2.hitpoints + " hitpoints")
},
heal: function (p) {
p.hitpoints += p.heal_power
console.log(p.name + " was heal and now have " + p.hitpoints + " hitpoints")
}
}
game.attack(player_1, player_2)
game.heal(player_2)
Пример 2:
var game = function(name, hitpoints, attack_power, heal_power) {
this.name = name
this.hitpoints = hitpoints
this.attack_power = attack_power
this.heal_power = heal_power
}
game.prototype.attack = function (opponent) {
opponent.hitpoints -= this.attack_power
console.log("after hit " + opponent.name + " have " + opponent.hitpoints + " hitpoints")
}
game.prototype.heal = function () {
this.hitpoints += this.heal_power
console.log(this.name + " was heal and now have " + this.hitpoints + " hitpoints")
}
player_1 = new game("robot", 100, 10, 5)
player_2 = new game("human", 200, 20, 20)
player_1.attack(player_2)
player_2.heal()
Для комментария слишком много, поэтому напишу полноценный ответ.
Дело в том, что первый случай подразумевает, что вы в самой программе сами укажете начальные характеристики. Во втором же их можно считать из файла и как следствие - сама программы будет занимать меньше места. К тому же, если у вас нужно заменить несколько юнитов (по сути, это блок кода в первом случае и вызов конструкотора во втором), то это будет занимать довольно много времени. К тому же можно предусмотреть значения по умолчанию, или, что не особо сложно, даже создать некоторые маски для классов, рас и так далее. Согласитесь, что заменить руками большое количество юнитов в первом случае намного сложнее, чем во втором. К тому же второй случай подразумевает, причём явно, простое добавление новых каких-то параметров для юнитов. Помимо этого во втором случае очень просто будет реализовать взаимодействие между юнитами, соответственно если принимать на вход сами объекты.
Как пример, если добавить, например, два параметра: мана и магическая атака, то в первом случае придётся написать дополнительно 8 строк кода, а во втором 6. Если же юнитов будет не 2, а например, 200, то в первом случае нужно написать дополнительно 1604 строки, а во втором будет всего 212.
В общем случае, пусть юнитов n, пусть видов комманд k, а характеристик юнита - i. Тогда первый код будет занимать в строках: (2+i)*n+4k, а второй: (2+i)+n+4k. (без учёта самой игры) Очевидно, что второй код будет занимать меньше строк.
Есть класс Employee в котором есть ArrayList
Предположим, имеем класс
class Employee {
String name;
double salary;
}
и переменную
ArrayList
Сортировать можно, например, следующим способом:
Collections.sort(
employees,
new Comparator
Зачем (в с++) существует контейнер map, если есть hash_map, который быстрее? Например, std::map чем лучше std::unordered_map'a?
Нет понятия «лучше» или «хуже», есть различные свойства контейнера.
std::map держит данные в отсортированном по ключу виде, в отличие от std::unordered_map. Если вам нужно это свойство, вам нужен std::map. Если нет, достаточно и std::unordered_map
(Как следствие отсортированности, например, в std::map есть функция lower_bound, которой нет в std::unordered_map.)
Я хочу передать в функцию статический массив определённого размера, который будет проверяться при компиляции.
#include
'; //выводит 4 при каждом вызове
for (int i = 0; i < 3; i++) {
std::cout << arr[i] << ' ';
}
std::cout << '
';
}
int main()
{
int staticArr2[2] = {8, 5};
int staticArr3[3] = {2, 4, 7};
std::cout << sizeof(staticArr2) << '
'; //выводит 8
std::cout << sizeof(staticArr3) << '
'; //выводит 12
print(staticArr2); // выводит 3 элемент, указывающий на память вне массива
// хочется чтобы не компилировалось
print(staticArr3); // ок
return 0;
}
Но вот конструкция int arr[3] воспринимается как int * в объявлении входных параметров функции. Подскажите, как можно реализовать передачу массива конкретного размера.
Можно воспользоваться шаблонами для того, чтобы передавать массив как массив, а не как указатель. При таком вызове сохраняется информация о размере массива. Если дополнить код вызовом static_assert, то ошибка будет выдаваться во время компиляции.
template
'; // Размер вычисляется корректно
for (int i = 0; i < 3; i++) {
std::cout << arr[i] << ' ';
}
std::cout << '
';
}
При попытке передать массив из двух элементов будет выведена ошибка:
prog.cpp: In instantiation of 'void print(int (&)[N]) [with unsigned int N = 2u]':
prog.cpp:22:21: required from here
prog.cpp:6:2: error: static assertion failed: Array must contain 3 elements
static_assert(N == 3, "Array must contain 3 elements");
^
Почему при приведении int c = 10000 к типу byte, значение переменной становится равно 16, а не 128, максимальному значению byte?
int c = 10000;
byte d = (byte) c;
System.out.println(d);
Вы не вполне правильно понимаете, как происходит приведение типов.
При приведении int к byte не происходит вычисление «наилучшего приближения». Происходит по-другому: «старшие» байты просто отбрасываются.
10000 = 0x2710 состоит из двух байт: 0x27 и 0x10. Старший байт отбрасывается, остаётся младший 0x10 = 16.
В проекте С++ (который компилируется в динамическую библиотеку) используется библиотека Qt, поэтому в Linker->Input добавлена статическая библиотека QtCore4.lib; почему во время использования проектной dll требуется также QtCore4.dll?
Проблема состоит в том, что файл с расширением lib совершенно не обязан содержать статическую библиотеку. Если кратко, то этот файл содержит внешние по отношению к программе символы и инструкции как с этими символами поступать. Это может быть инструкция о связи с динамически компонуемой библиотекой (DLL) или же инструкция вставки готового откомпилированного кода, содержащегося в lib-файле. Qt стандартно распространяется в shared-версии, т.е. откомпилированные программы требуют её DLL, поэтому почти все её lib-файлы - это просто инструкции связи с DLL. Тем самым QtCore4.lib просто даёт компоновщику информацию о том, что все перечисленные в ней символы нужно брать из QtCore4.dll
Чтобы избавиться от зависимостей, Qt нужно пересобирать статически.
Предположим есть ассоциативный массив `
a = {
"a": "17",
"b": "1",
"d": "3",
"v": "10",
"e": "4",
"f": "9"
}
и есть второй массив
b = {
"a": "1",
"b": "3",
"d": "4",
"v": "5",
"e": "6",
"f": "7"
}
Как мне узнать какие значения есть в ассоциативном массиве a и нет в массиве b ? или как узнать какие значения есть в массиве b и нет в массиве a .
То есть например мы сравниваем ассоциативный массив a c b, и в результате сравнение мы должны узнать что в ассоциативном массиве a есть значения 17, 10, 9 которых нет в ассоциативном массиве b. Или же мы сравниваем b c a , и в результате сравнения мы должны узнать что в ассоциативном массиве b есть 5, 6, 7 которых нет в ассоциативном массиве a.
нужно узнать уникальные значения значений.
Как делать подобные сравнения ?
Мне кажется, ничего сложного. Нужно делать ровно так, как вы описали. Нас интересуют только значения, соответственно отбрасываем ключи:
var a_values = Object.keys(a).map(function(key){
return a[key];
});
var b_values = Object.keys(b).map(function(key){
return b[key];
});
После чего ищем "уникальные" для какого-либо массива:
var res = [];
for (var a_key in a_values) {
if (b_values.indexOf(a_values[a_key]) == -1) {
res.push(a_values[a_key]);
}
}
Рабочий пример: JSFiddle
Читаю вот эту статью про использование Task и async-await в C#
В ней приведён такой код
var client = new WebClient();
var task = client.DownloadStringTaskAsync("/api/blabla");
Console.WriteLine("Hello world!");
var result = await task;
Console.WriteLine("Got some data");
и далее про него говорится вот что
Почему этот код хороший и правильный? Потому что DownloadStringTaskAsync возвращает Task, который инкапсулирует операцию ввода-вывода — то есть I/O bound операцию. И практически весь ввод-вывод является асинхронным — то есть, для его осуществления, нигде, начиная с самого верхнего уровня вызова метода DownloadStringTaskAsync и заканчивая драйвером сетевой карты, абсолютно нигде не нужен дополнительный поток, который будет «ждать» или «обрабатывать» эту операцию.
Точно так же приводится пример из JS/jQuery
$.get('/api/blabla', function(data) {
console.log("Got some data.");
});
console.log("Hello world!")
и комментарий к нему
Это — очень яркий пример асинхронного программирования. Здесь нет никакой многопоточности — Javascript строго однопоточен
В обоих случаях особо отмечается что многопоточности тут нет. И подобное я читал также и в других источниках что при использовании async-await (и асинхронности вообще) далеко не всегда подразумевает использование дополнительного потока. И это мне совершенно непонятно. Возьмем тот же пример на jQuery. Сначала выполняется запрос, у которого есть коллбэк а потом выводится сообщение "Hello world!". Но так как запрос выполняется асинхронно то "Hello world!" выводится раньше. И мне непонятно как тут обойтись без нескольких потоков? Ведь если асинхронный запрос выполняется в одном потоке с основным, то по идее и асинхронности быть не должно потому что поток сначала должен дождаться выполнения запроса а только потом вывести
"Hello world!". То же самое и по C# коду. Объясните пожалуйста почему автор так упорно говорит что многопоточности тут нет? Заранее спасибо!
Дело в том, что сетевые и дисковые вызовы в Windows поддерживают так называемый Overlapped I/O, который позволяет получить уведомление по завершению операции. Т.е. во время выполнения операции с диском или сетью пользовательский поток может делать все что угодно, а не обязательно спать и ждать результатов.
Как работает обычное, неасинхронное чтение:
Ваш код делает синхронный вызов
Поток, сделавший вызов, засыпает
Данные читаются из диска или из сети
Поток просыпается
Вызов возвращает результат
Как работает асинхронное чтение
Ваш код делает асинхронный вызов
Поток, сделавший вызов, освобождается - возвращается в пул
Данные читаются из диска или из сети
Приложение получает уведомление от системы о получении данных (через I/O Completion Port)
Рантайм находит код, который должен обработать результат - продолжение вашего async-метода и ставит его на выполнение.
Ваш код возвращает результат
Разница в том, что между 2 и 6 в асинхронном коде никакой поток не спит в ожидании результата. А потоки в Win - это достаточно ценный ресурс. Их тяжело (относительно тяжело) запустить. Они требуют памяти (около 1Mb на поток). Их надо синхронизировать - чем больше потоков, тем больше накладных расходов.
Кроме того, если между 2 и 6 в вашем коде есть что-то, что можно выполнить (например, вы не сразу потребовали результат чтения с диска или из сети) - то это будет выполнено потоком, вместо пустого ожидания. При этом будет одновременность выполнения вашего кода, и физического чтения данных из сети.
Но многопоточности все еще не будет - поток то у вас останется ровно один. То, что при этом драйвер сетевой карты читает данные - не добавляет еще один поток в ваше приложение. И вы можете спокойно обойтись без синхронизации, и прочих неприятностей, связанных с многопоточностью.
Абстракция, как же без нее:
многопоточное изготовление пиццы - склонировать себя и заставить клона готовить пиццу. по завершению - слиться в одного человека.
асинхронное изготовление пиццы - позвонить в доставку, спокойно делать свои дела, по звонку в дверь открыть и забрать готовую пиццу.
Как при ховере элемента и затемнении его с эффектом прозрачности сделать так, чтобы некоторые внутренние элементы (обе кнопки) были видны с исходной непрозрачностью?
button {
display: block;
background-color: blue;
color: #fff;
padding: 10px;
}
.on-hover {
display: none;
position: absolute;
top: 50%;
left: 10%;
}
.frame {
position: relative;
}
.frame:hover {
opacity: 0.3;
}
.frame:hover .on-hover {
display: block;
background-color: black;
}
текст
Сделайте не .frame:hover {opacity: 0.3}, а .frame:hover * {opacity: 0.3;}
После чего для исключений установите opacity: 1;
https://jsfiddle.net/mh4vqk1c/
button {
display: block;
background-color: blue;
color: #fff;
padding: 10px;
}
.on-hover {
display: none;
position: absolute;
top: 50%;
left: 10%;
}
.frame {
position: relative;
}
.frame:hover * {
opacity: 0.3;
}
.frame:hover .on-hover {
display: block;
background-color: black;
opacity: 1;
}
текст
Предположим у нас есть следующая структура классов:
public class User
{
public int Id {get;set;}
//прочие свойства
public int RoleId {get;set;}
public Role Role {get;set;}
}
public class Role
{
public int Id {get;set;}
//прочие свойства
public ICollection
public Role()
{
Permissions = new List
public Permission()
{
Roles = new List
Как модифицировать указанные выше классы что бы можно было получить связанные сущности средствами Entity Framework?
Для того что бы получить связанные объекты средствами Entity Framework существует несколько способов:
Eager loading - жадная загрузка;
Lazy loading - ленивая загрузка;
Explicitly lоading - явная загрузка;
Жадная загрузка - процесс при котором необходимо указать сущности которые необходимо загрузить сразу, это достигается путем указания необходимых сущностей при помощи метода .Include()
В этом случае для будет сформирован один запрос к бд который вернет все необходимые данные.
Ленивая загрузка - процесс при котором связанные сущности подгружаются при первом обращении, необходимые свойства должны быть объявлены с указанием модификатора доступа virtual
В данном случае при обращение к навигационному свойству будет формироваться запрос к бд для получения необходимых данных
Явная загрузка - процесс при котором связанные сущности подгружаются только если они явно подключены при помощи метода .Load()
в данном случае связанные сущности не будут подгружены до момента их подключения при помощи .Load()
Универсального решения о выборе между ленивой/явной и жадной загрузке - нет.
Загружать много редко используемой информации (особенно часто изменяемой) - не эффективно, еще более не эффективно использовать n+1 запросов вместо одного, так как ленивая загрузка будет означать выполнение отдельного запроса для каждого объект. Если нужно, то можно использовать .Load() вместо .Include()
Например:
Жадная загрузка
var user = context.Roles.Where(x=>x.Name.Contains("Admin")).Include(x=>x.Permissions)
Ленивая загрузка
Установим модификатор доступа virtual у свойства Role у класса User
public virtual Role Role {get;set;}
тогда получить роль пользователя можно будет получить так:
//получаем необходимого пользователя
var user = context.Users.Where(x=>x.Id==5)
//При обращении к свойству будет выполнен запрос к бд получающий связанную сущность.
var userRole = user.Role;
Явная загрузка
может быть использована при отключенной ленивой загрузке(context.Configuration.LazyLoadingEnabled = false;), либо при отсутствии модификатора доступа virtual у необходимого свойства
var role = context.Roles.Where(x=>x.Name.Contains("Admin")).Single();
что бы получить связанные сущности в этом случае необходимо поступить так:
var usersRole = context.Entry(role).Collection(x => x.Users).Load();
Что такое внутреннее и внешнее связывание в языке C++ ?
Стандарт C++:
When a name has external linkage , the entity it denotes can be
referred to by names from scopes of other translation units or from
other scopes of the same translation unit
и
When a name has internal linkage , the entity it denotes can be
referred to by names from other scopes in the same translation unit.
По-русски это можно перевести как: внешнее связывание имеют те сущности, к которым можно обратиться в единице трансляции, отличной от той, где они определены.
Например, имея в заголовке header.h:
extern int object;
в first.cpp
int object;
...
object = 5;
в second.cpp
#include "header.h"
...
object = 3;
Так вот, int object; в first.cpp имеет внешнее связывание, т.е. на него могут ссылаться другие единицы трансляции, что и делает second.cpp. Но чтобы second.cpp узнал, что такая переменная вообще существует, мы ему сказали через extern int object;. Таким образом получается, что несколько единиц трансляции обращаются к одному и тому же объекту в памяти. Это и есть внешнее связывание
Внутренее связывание отличается от внешнего тем, что к сущности имеющей внутренее связывание нельзя обратиться из единицы трансляции, отличной от той, где она определена.
Так, если взять тот же пример, но изменить first.cpp на
static int object;
или на
namespace
{
int object;
}
и не трогать другой код то при линковке second.cpp мы получим ошибку линковщика, говорящую, что он не может найти object. Это происходит потому, что object имеет внутреннее связывание и, как я уже сказал, это значит, что другие единицы трансляции не могут видеть это имя.
Для лучшего понимания, можно воспользоваться следующей аналогией: у классов, в C++, есть несколько уровней доступа, в числе которых есть private и public. Компилятор проверяет, чтобы только внутренние части класса(опустим friend'ов и хаки) обращались к private членам, и любое обращение к таковым извне класса вызовет ошибку компиляции. С другой стороны, public члены доступны всем вокруг,— к ним может обращаться любая внешняя сущность.
Так вот, внутреннее и внешнее связывание ведут себя как private и public у классов, только ошибки тут выявляются на этапе линковки, а не компиляции. Другими словами, это ещё можно сказать так: сущности с внешним связыванием экспортируется за пределы единицы трансляции, тогда как с внутренним связыванием — нет, о них внешний мир вообще не знает.
В своём локальном репозитории можно подключить несколько удалённых репозиториев (git remote add ...) и отправлять в них изменения командой git push имя-репозитория имя-ветки — по одной команде на каждый репозиторий.
А как это сделать одной командой git что-то-там? без написания скрипта или функции или псевдонима (alias-а).
для каждого удалённого репозитория можно задать pushurl, т.е., url, по которому будут отправляться изменения по команде push
этот pushurl, кстати, может и не совпадать с url данного репозитория. вот такой фокус: делаете push, вроде бы, в репозиторий на bitbucket-е, а изменения идут на github
более того: таких pushurl-ов может быть больше одного. и изменения одной командой отправятся сразу по нескольким url-ам.
добавляется pushurl с помощью команды примерно такого содержания:
$ git remote set-url --add --push имя-репозитория url-репозитория
от теории к практике.
создадим три (чтоб наверняка) bare-репозитория:
$ for i in 1 2 3; do git init --bare repo$i; done
Initialized empty Git repository in ./repo1/
Initialized empty Git repository in ./repo2/
Initialized empty Git repository in ./repo3/
и сделаем клон первого из них:
$ git clone repo1 work
Cloning into 'work'...
warning: You appear to have cloned an empty repository.
done.
$ cd work
посмотрим умолчальную конфигурацию remote-ов:
$ git config --get-regexp "^remote"
remote.origin.url ../repo1
remote.origin.fetch +refs/heads/*:refs/remotes/origin/*
а теперь добавим pushurl-ы для всех созданных bare-репозиториев, не забыв и про сам исходный репозиторий (../repo1):
$ for i in 1 2 3; do git remote set-url --add --push origin ../repo$i; done
$ git config --get-regexp "^remote"
remote.origin.url ../repo1
remote.origin.fetch +refs/heads/*:refs/remotes/origin/*
remote.origin.pushurl ../repo1
remote.origin.pushurl ../repo2
remote.origin.pushurl ../repo3
как видно, pushurl-ы благополучно добавились.
создаём коммит и отправляем его командой push
$ date > file
$ git add file
$ git commit -m 1
[master (root-commit) 2d68407] 1
1 file changed, 1 insertion(+)
create mode 100644 file
$ git push
Counting objects: 3, done.
Writing objects: 100% (3/3), 228 bytes | 0 bytes/s, done.
Total 3 (delta 0), reused 0 (delta 0)
To ../repo1
* [new branch] master -> master
Counting objects: 3, done.
Writing objects: 100% (3/3), 228 bytes | 0 bytes/s, done.
Total 3 (delta 0), reused 0 (delta 0)
To ../repo2
* [new branch] master -> master
Counting objects: 3, done.
Writing objects: 100% (3/3), 228 bytes | 0 bytes/s, done.
Total 3 (delta 0), reused 0 (delta 0)
To ../repo3
* [new branch] master -> master
вуаля! коммит отправился во все три bare-репозитория одной командой!
а как насчёт других веток?
создадим ещё одну ветку (new), добавим в неё коммит и отправим изменения:
$ git checkout -b new
Switched to a new branch 'new'
$ date >> file
$ git commit -am 2
[new c82bfe5] 2
1 file changed, 1 insertion(+)
$ git push -u origin new
Counting objects: 3, done.
Writing objects: 100% (3/3), 264 bytes | 0 bytes/s, done.
Total 3 (delta 0), reused 0 (delta 0)
To ../repo1
* [new branch] new -> new
Branch new set up to track remote branch new from origin.
Counting objects: 3, done.
Writing objects: 100% (3/3), 264 bytes | 0 bytes/s, done.
Total 3 (delta 0), reused 0 (delta 0)
To ../repo2
* [new branch] new -> new
Branch new set up to track remote branch new from origin.
Counting objects: 3, done.
Writing objects: 100% (3/3), 264 bytes | 0 bytes/s, done.
Total 3 (delta 0), reused 0 (delta 0)
To ../repo3
* [new branch] new -> new
Branch new set up to track remote branch new from origin.
эта «магия» работает и с новыми ветками! коммит отправился в ветки new во всех трёх bare-репозиториях.
ответ основан на информации из этого и этого ответов.
Есть 4 Активити. Если нажать на стрелку то будет переход с 4 - 3 - 2 - 1.
Мне надо еще добавить функцию в свою программу так чтобы при нажатии на красный круг, был не просто переход на 1 активити, а Нужно закрыть 4 3 и 2 активти.
Это мне нужно чтобы не было утечки памяти и тормозов, помогите
Используйте флаг:
Intent intent = new Intent(FourActivity.this, FirstActivity.class);
intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
startActivity(intent);
он закроет все активности, которые "выше" вызванной
Задача узнать, кто из авторов сколько кода написал. Я знаю, что это необъективная информация для подсчета вклада в проект, но все же хоть какая-то статистика. Если знаете какие-то решения, актуальные на данный момент - прошу поделиться.
Пробовал пользоваться вот этим пакетом, но он устарел, т.к. был написан более семи лет назад. Более новых google не выдал.
Есть команда git log --numstat, но она выдает разрозненные данные по коммитам и ей невозможно воспользоваться для данных целей. Или я все же что-то пропустил?
Есть команда git log --numstat, но она выдает разрозненные данные по коммитам и ей невозможно воспользоваться для данных целей. Или я все же что-то пропустил?
так на основании выдаваемой информации можно подсчитать, сколько строк добавил и сколько удалил (именно такие цифры выдаёт git log --numstat) каждый автор.
примерно вот так (это я быстренько «набросал», можно и улучшить и оптимизировать):
$ git log --pretty=format:==%an --numstat | \
sed -r '/==.*/{s/^==//;h;D};/^$/D;s/-/0/g;s/\t[^\t]+$//;G;s/(.*)
(.*)/\2\t\1/' \
| awk -F '\t' '{add[$1]+=$2;del[$1]+=$3} END {for (i in add) {print i,add[i],del[i]}}'
для упомянутого вами проекта она выдаёт:
Caue Guerra 361 168
Pedro Matiello 729 238
для проекта https://github.com/processone/ejabberd вот такую статистику выдаёт:
Alexey Shchepin 121555 48334
Andreas Köhler 429 335
Antonio Murdaca 63 10
Anton Ryzhov 0 1
Arno B 22 5
Badlop 310727 228783
Balázs Galambosi 2 2
Ben Langfeld 87 110
bLaDe 1 1
Christian Dröge 17 12
Christopher A. Stelma 1 1
Christophe Romain 42755 54608
Christopher tofu Zorn 128 96
colm 8 3
Cor Cornelisse 2 2
Denis Kurochkin 600 2
ekhramtsov 44 4
Elias Rohrer 24 87
Emilio Bustos 82 52
Evgeniy Khramtsov 229257 210283
Evgeny Khramtsov 0 15
Feotov Daniil 67 6
Geoff Cant 279 163
GreenLunar 66 98
Gu Feng 7 3
HAMANO Tsukasa 390 320
Holger Wei 2 0
Holger Weiss 5665 3161
iulianlaz 13 1
jabber 5 0
Jamie Nguyen 401 532
Janusz Dziemidowicz 129 41
Jerome Sautret 1300 199
Jérôme Sautret 1465 1011
Johan Oudinet 16 12
Jonas Ådahl 7 1
jpegger 1 1
Juan Pablo Carlino 2 2
Leif Bredgaard Honore 2 2
liudan 6 4
Marek Foss 12 5
Martin Langhoff 81 7
Mathias Ertl 33 31
Matthias Rieber 22 6
Matwey V. Kornilov 7 13
Maxim Ignatenko 857 567
Mickael Remond 1458 1118
Mickaël Rémond 394 115
Mickaël Rémond 44205 25665
Mikhail-D 1783 0
mrjameshamilton 1 1
Nathan Bruning 13 11
Nikolaus Polak 17 20
Nycholas de Oliveira e Oliveira 3 1
Otavio Fernandes 71 60
oxpa 4 2
Pablo Polvorin 556 152
Paul Donohue 8 4
Paweł Chmielowski 3305 3548
Peter Lemenkov 11 2
Quan Zhuo 4 4
Radosław Szymczyszyn 51 74
Rahul Gautam 9 9
Remco Wendt 8 0
Sergey Abramyan 542 15
Shelley Shyan 91 104
Sonny Scroggin 167 135
Stephen Röttger 43 36
Steven Lehrburger 2 4
stewart 1 1
Taufan Aditya 5 8
thierry 2 0
tjeerd 4 0
tmallard 6553 1300
Tsukasa Hamano 6 12
Tuncer Ayaz 2 2
vesvalo 19 7
Victor Rodrigues 74 73
W. Andrew Loe III 1 0
На данный вопрос уже ответили:
Как вернуть значение из события или из функции обратного вызова? Или хотя бы дождаться их окончания
3 ответа
Как правильно возвратить значение в этой функции ?
function getValue(variable, defaultvalue) {
chrome.storage.sync.get({
[variable]: defaultvalue,
}, function(items) {
if (items[variable]) {
return items[variable];
}
});
}
Вот так не получается,а если return items[variable] заменить на alert(items[variable]) то успешно выводиться что нужно,а если с return то возвращает undefined
Нужно чтобы при alert(getValue('test', 'var')) возвращалось то, что мне нужно, а не undefined .
Так как в данном случае функция getValue ничего не возвращает, то результат выполнения
getValue(variable, defaultvalue)
всегда будет undefined
Возможные пути решения:
Пробросить callback - функцию, которая будет вызвана при успешном выполнении, например
function getValue(variable, defaultvalue, successCallback) {
chrome.storage.sync.get({
[variable]: defaultvalue,
}, function(items) {
if (items[variable]) {
successCallback(items[variable]);//вызываем callback если все хорошо
}
});
}
И вызывать ее следующим образом:
getValue(variable, defaultvalue, function(items){//items внутри этой функции - будут нужным значением
...
})
Можно использовать Promise, например так:
function getValue(variable, defaultvalue, successCallback) {
return new Promise(function(resolve, reject){
chrome.storage.sync.get({
[variable]: defaultvalue,
}, function(items) {
if (items[variable]) {
resolve(items[variable]);//говорим что все хорошо
}else{
reject(/*тут можно указать причину почему все плохо*/);
}
});
});
}
И использовать так
getValue(variable, defaultvalue).then(function success(items){//items внутри этой функции - будут нужным значением
...
});
Директива #pragma once распространяется на один подключаемый файл или на все?
UPDATE:
Понял, она распростаняется на сам файл. Тогда почему, когда я в файле указал #pragma once и пытаюсь его подключить к другим файлам(нескольким) выдаются ошибки линковки:
1>error LNK2005: "void __cdecl logit(class std::basic_string
Вы неверно понимаете эту директиву. Она распространяется на файл, в котором она определена.
То есть, ее нужно добавлять в .h файлы (те, которые подключаются с помощью #include) в самый верх. Она "эквивалентна" следующей, довольно популярной конструкции
#ifndef _GUARD_H_
#define _GUARD_H_
//код
#endif
А вот проблема наблюдается потому, что Ваш h файл попадает в много разных cpp файлов. И естественно, линковщик обнаруживает много одинаковых функций и ругается. Лечиться это так. Либо просто добавьте inline к определению функции в самое начало (но это некрасиво, особенно, если функции не маленькие), либо создайте отдельный cpp файл, вынесите туда тело каждой функции, а в h файле оставьте только прототипы. Это правильный, хороший способ. Но если Ваши функции в h файле занимают по одной-две строки, то можно и через inline.
Следующий код, скомпилированный в VS2015, вызывает конструктор копирования Foo при захвате foo
void bar(Foo& foo) {
auto f = [foo]() {
};
}
Ранее, ошибочно полагал, что внутри лямбды, foo должна была остаться ссылкой, по аналогии с обычными функциями:
template
void bar(const Foo& foo) {
f
baz(Foo());
Не разобрался в спецификации до конца, правильно ли понял, что при захвате по значению будет создана константная переменная (с помощью конструктора копирования), доступная внутри лямбды, имеющая тип Foo, не зависимо от того является внешняя переменная ссылкой на Foo или экземпляром Foo
update
Что интересно, если вызывать не f
Чтобы разобрать Ваш пример, нужно обратиться к стандарту и понимать, что для реализации лямбда-функций компилятор создаёт тип-замыкание. Так вот, когда в списке захвата, некий объект закхватывается по значению, тогда в замыкании создаётся объект такого же типа, какой имеет этот объект, если это не ссылка. Если же это ссылка, то типом в замыкании будет тип, на который эта ссылка ссылается.
Стандарт [expr.prim.lambda]p15:
An entity is captured by copy if it is implicitly captured and the
capture-default is = or if it is explicitly captured with a capture
that is not of the form & identifier or & identifier initializer. For
each entity captured by copy, an unnamed non-static data member is
declared in the closure type. The declaration order of these members
is unspecified. The type of such a data member is the type of the
corresponding captured entity if the entity is not a reference to an
object, or the referenced type otherwise. [ Note: If the captured
entity is a reference to a function, the corresponding data member is
also a reference to a function. — end note ] A member of an anonymous
union shall not be captured by copy
Таким образом, в замыкании Ваш foo будет иметь тип Foo
$ chmod 0777 файл-или-каталог
Что означает 0 перед остальными цифрами?
согласно документации (этот топик можно просмотреть при наличии установленного пакета gnu/info командой info 'file permissions' 'numeric modes') числовые значения обозначают:
Value in Corresponding
Mode Mode Bit
Other users not in the file's group:
1 Execute/search
2 Write
4 Read
Other users in the file's group:
10 Execute/search
20 Write
40 Read
The file's owner:
100 Execute/search
200 Write
400 Read
Special mode bits:
1000 Restricted deletion flag or sticky bit
2000 Set group ID on execution
4000 Set user ID on execution
т.е., 0 в числе 0777 обозначает: убрать все три «специальных» бита — sticky-bit, setguid-bit и setuid-bit.
чтобы меньше «ломать себе голову» над всем этими циферками, удобнее, вероятно, использовать символические эквиваленты (info 'file permissions' 'symbolic modes').
например, вышеприведённую команду chmod 0777 файл-или-каталог можно заменить такой командой:
$ chmod a=rwx,a-st файл-или-каталог
a — для «всех» (комбинация из u — пользователь, g — группа, и o — остальные).
= — установить именно такой набор битов.
a=rwx — установить биты r — чтения, w — записи, и x — исполнения, для «всех».
- — убрать перечисленные биты.
a-st — убрать «специальные биты». эквивалентно u-s,g-s,-t
На данный вопрос уже ответили:
Как в CSS сделать фон со стрелкой-разделителем
1 ответ
Подскажите пожалуйста, как сделать стрелку вправо, как на картинке?
Вариант 1
div{
position: relative;
display: flex;
align-items: center;
justify-content: center;
width: 100px;
height: 100px;
text-align: center;
color: #fff;
font-size: 40px;
background: #FF6A50;
}
div:after{
content: '';
position: absolute; top: 50%; left: 100%;
margin-top: -20px;
width: 0;
height: 0;
border-style: solid;
border-width: 20px 0 20px 20px;
border-color: transparent transparent transparent #FF6A50;
}
int main()
{
char *c[] = {"ENTER", "NEW", "POINT", "FIRST"};
char **cp[] = {c+3, c+2, c+1, c};
char ***cpp = cp;
printf("%s", **++cpp);
printf("%s", *--*++cpp+3);
printf(" %s", *cpp[-2]+3);
printf("%s", cpp[-1][-1]+1);
system("pause");
return 0;
}
Объясните пожалуйста почему вывод: POINTER STEW
На уроке не объяснили толком ничего про указатели, ни инкремент, ни дикремент.
Также не понимаю почему код printf("%s", *(c+1)); компилится, а
printf("%s", *++c); не компилится.
//массив указателей на строковые константы
char *c[] = {"ENTER", "NEW", "POINT", "FIRST"};
char **cp[] = {c+3, c+2, c+1, c}; //первый элемент c+3,
// т.е. мы идем три раза вперед на размерность с и попадаем на POINT
char ***cpp = cp; //ехал указатель через указатель,
// видит в реке указатель,
// сунул указатель в указатель,
// гитлер гитлер гитлер гитлер
printf("%s", **++cpp); //выводится POINT
printf("%s", *--*++cpp+3); //снова шастаем по указателям,
// приходим на ENTER, прыгаем на 3 размера данного указателя вперед
// (теперь это char жизнь, сынок, это просто, как ездить на велосипеде,
// и мы в аду и ты горишь и велосипед горит)
// вместо ENTER получаем ER (ENT ER)
// выводится в итоге POINTER
дальше сам понимаешь.
И да, ужасы у вас какие на уроках.
когда кто-нибудь посмотрит в этот ужасный пример и более подробно разберет, с радостью удалю ответ, мне главное чтобы ОП бритвой по венам не прошелся.
тут намек на решение, спасибо за хороший пример, pointer stew гуглится на ура, задача из книги "The C Puzzle Book"
p.s. Pointer stew переводится как (густой)суп (похлебка, тушеный) указатели. Cуп из указателей. Красиво.
В чем различие ::before и :before? Или ::after и :after?
Ранее с появлением CSS2.1 синтаксис псевдоэлементов (напр. :before) и псевдоклассов (напр. :first-child) не отличался: оба варианта писались с двоеточием в качестве префикса, дабы указать на их псевдосущность.
С появлением CSS3 товарищи из W3C решили указать на их отличие друг от друга, оставив одно двоеточие для псевдоклассов (:not), но введя двойное двоеточие для псевдоэлементов (::before и ::after).
P.S. Всеми любимый IE до версии 9.0 не поддерживает двойные двоеточия, так что надёжнее использовать по-прежнему одинарные, если разработка ведётся не только для современных браузеров.
Подробнее про псевдоэлементы можно почитать по ссылке: псевдоэлемент ::before
Для чего нужен паттерн программирования Builder? Как написано в некоторых учебниках, он используется для того чтобы предотвратить создание конструкторов для сетера всех вариантов филдов.
Как альтернатива используется внутренний класс Builder, в котором дублируются все филды с дефолтными значениями. В классе есть сеттеры всех филдов.
В чем преимущества использования внутреннего класса Builder, ведь дефолтные значения для всех полей можно объявить в самом классе.
private Double emission = 0d;
...
Соответственно если нужный сеттер не вызван, будет использоваться дефолтное значение?
Билдеры необходимы, когда у вас есть класс:
содержащий много полей
поля иммутабельны (final)
не все поля обязательны
Делать конструкторы под все варианты или один конструктор, скажем с 10-ю параметрами, неудобно.
Еще бывает ситуация когда есть некий процесс, на протяжении которого нужно наполнить объект данными (при чем при разных условиях какие-то поля могут быть задействованы, а какие-то - нет), а после этого отдать его иммутабельную версию. В таком случае удобно протаскивать по ходу процесса builder, а когда все будет готово - завершить сборку.
Чем различается перечисление, объявленное так:
[Flags]
public enum ASD
{
None = 0,
Param1 = 1,
Param2 = 2,
Param3 = 4,
}
или так
public enum ASD
{
None = 0,
Param1 = 1,
Param2 = 2,
Param3 = 4,
}
Этот атрибут означает, что значения перечисления, к которому он применяется, могут рассматриваться как битовые поля и к ним можно применять битовые операции, что отразится, в частности, на поведении метода ToString.
Например:
// если перечисление помечено атрибутом
ASD flags = (ASD)5;
Console.WriteLine(flags); // выведет Param1, Param3
// если перечисление не помечено атрибутом
ASD enums = (ASD)5;
Console.WriteLine(enums); // выведет 5
Когда захожу за границу массива, то не получаю ошибку, но если пытаюсь удалить по указателю, то программа падает. Почему?
int main()
{
int * p = new int[5];
p[10] = 5;
delete [] p;
}
Вы можете портить служебную информацию менеджера памяти, только и всего. В результате диспетчер памяти не в состоянии корректно освободить память, и система рушится.
Неопределенное поведение - оно такое неопределенное :). Кстати, рекомендую книгу Безопасное программирование на C и C++ - там об этом (некорректной работе с памятью, которая может оказаться уязвимостью) много рассказывается.
Допустим есть класс Myclass, имеющий 3 конструктора - первый по умолчанию, без параметров, и два таких:
public Myclass(string param1, string param2 = null)
{
Text = param1;
Data = param2;
}
public Myclass(string param1, string param3, string param2 = null)
{
Text = param1;
Url = param3;
Data = param2;
}
Сигнатура разная (или нет?), но какой конструктор будет вызван в таком случае
new Myclass("param1", "param3");
и почему?
Ответы на этот вопрос смотрел, но не нашёл там ответа на свой.
MSDN
Использование именованных и необязательных аргументов следующим образом влияет на разрешение перегрузки:
метод, индексатор или конструктор является кандидатом на выполнение, если каждый из его параметров является необязательным или
соответствует по имени или позиции одному аргументу в инструкции
вызова, а этот аргумент можно преобразовать к типу параметра;
если обнаружено более одного кандидата, правила разрешения перегрузки для предпочтительных преобразований применяются к
аргументам, которые заданы в явном виде. Опущенные аргументы для
необязательных параметров игнорируются;
если два кандидата оказываются одинаково подходящими, предпочтение
отдается кандидату, у которого нет необязательных параметров,
аргументы которых были опущены в вызове. Это последовательность
общего приоритета при разрешении перегрузки для кандидатов с меньшим
числом параметров.
мне кажется в вашем случае применяется второе правило, и будет вызван первый конструктор.
Понятно, что большинство (если не все) крупные энтерпрайз сервисы, приложения и тд. (не только веб) написаны с использованием не одного языка программирования, а нескольких. И эти составные части, написанные на разных языках, как-то взаимодействуют между собой (фронт, бизнес-логика, еще что-то).
Опыта разработки подобных систем у меня нет, поэтому не совсем могу представить, как это происходит. Подозреваю, что взаимодействие идет через независимые от языков средства. Например, нечто написанное на одном языке, шлет через TCP-IP пакет, который ловится и обрабатывается чем-то написанным на другом языке. Либо через HTTP запросы. Либо через запись/чтение из БД. Либо через файловый обмен, XML например.
Хотелось бы, чтобы знающие люди привели пару примеров, как это обычно происходит. Не просто в двух словах, мол "фронт на яваскрипте, бэк на яве", а с техническими нюансами. Заранее спасибо.
Несколько языков могут сосуществовать как в рамках одного процесса, так и в рамках нескольких.
Проще всего сосуществовать в рамках нескольких процессов: если процессы обмениваются данными, то совершенно всё равно (ну, в известных рамках), на каком языке эти данные были созданы, и какой язык их читает. Например, вы можете генерировать данные в виде HTML сервером на ASP.NET, а читать браузером, написанным на C++. (Да, пара из сервера и клиента — тоже взаимодействие языков.)
Теперь, если мы хотим взаимодействие в рамках одного процесса, нам нужно уметь вызывать друг друга. Для этого нужен общий стандарт вызова. Часто таким общим стандартом являются бинарные соглашения C (extern "C", экспорт из DLL в Windows).
Ещё пример общего стандарта — COM: COM-объекты можно писать на многих языках, так что если в языке есть часть, реализующая стандарт COM, он может вполне пользоваться им.
Отдельная возможность, популярная сейчас — языки, компилирующиеся в общий промежуточный код. Например, Java и Scala компилируются в один и тот же код для JVM, поэтому объекты, созданные в Java, просто доступны для Scala-программ (так как доступность определяется не на уровне исходного языка, а на уровне JVM-метаданных). То же касается .NET-языков.
Ну и ещё есть набор glue-технологий. Например, для вызова в .NET нативный функций есть P/Invoke, который создаёт автоматический маршаллирующий stub для нативных функций. (Маршаллирование нужно, чтобы данные в формате, «понятном» .NET, перегнать в данные в формате, ожидаемом нативным кодом.)
Есть картинка-заглушка, выполняющая роль прелодера загружаемой картинки. Размеры загружаемой картинки известны и выведены в теге. Я так-же сделал у тега img max-width:100%, чтобы картинка не выходила за края страницы на маленьких экранах.
С оригинальной картинкой все работает хорошо, (чтобы сохранялись пропорции, я написал height:auto) Но когда ставим заглушку 1х1, пропорции картинки берутся соответственно 1 к 1, а не те, что указаны в теге. Если убрать height:auto ситуация все равно не решается, т.к. размер остается 200, а должен быть меньше.
img{
max-width:100%;
height:auto;
}
Есть ли способ сделать здесь масштабирование с сохранением необходимых пропорций, не прибегая к JS?
Все картинки разных размеров, есть возможность что-то сделать при подстановке заглушек. Некоторые картинки меньше экрана, некоторые — больше. Кроме картинок ничего нет, вокруг теги
с текстом
Решил задачу таким образом.
Можно на лету создавать изображения в формате SVG того-же размера.
Полученный код закодировать и вставить в атрибут src изображения.
Пример реализации на JS:
$('img').each(function() {
//получаем размер изображения
iw = $(this).attr('width')
ih = $(this).attr('height')
//Проверяем, есть ли размеры
if (iw !== undefined && ih !== undefined) {
//Создаем SVG с размерами изображения:
svg = '';
//Вставляем картинку прямо в тег:
$(this).attr("src", "data:image/svg+xml," + encodeURI(svg));
}
})
img {
max-width: 100%;
height: auto;
background: #03ded7;
}
Делает ли добавление в проект reference-ов из .Net Framework его заметно более тяжелым? Или заметно более медленным? Или ущербным?
Имею ввиду те сборки, которые включены в .Net Framework
На всякий случай, поясню зачем. Есть небольшой кусок кода, который выполняется только в Debug mode. Этот кусок я добавил самовольно, никто из команды меня об этом не просил. Если узнают, то могут попросить удалять. Но он мне сильно облегчает жизнь, а удалять и добавлять каждый раз не хочется, не удобно. Для того, чтобы этот кусок работал, надо подгрузить пару reference-ов из .Net Framework. В релизе этот кусок не задействован, но reference-ы остаются. Для упрощения жизни, я бы оставил эти reference-ы даже в релизной версии, несмотря на то, что они в ней не используются. Но, на сколько это критично? Не будет ли это ущербно в каком-либо смысле для релизной версии?
Каждая сборка загружается в бегущее приложение лишь тогда, когда выполняется первый метод, референцирующий типы из этой сборки [1], [2]. (Если у вас создаётся экземпляр класса B из другой сборки в инициализаторе поля класса A, этот код с точки зрения CLR выполняется в конструкторе класса A.)
Поэтому неиспользуемые сборки не должны влиять на время пробега.
Я вижу минус от «лишних» добавленных сборок только в том, что Intellisense будет предлагать вам методы из этих подключенных сборок несмотря на то, что они вам фактически не нужны.
[1]: Back to Basics: When does a .NET Assembly Dependency get loaded
[2]: When exactly are assemblies loaded?
Читаю Ритчи и Кернигана. Си. Говорится, что float представляет собой 32-разрядный тип, но потом написано, что его диапазон 10-38 – 10+38. Почему именно так, если 232 - это вовсе не такое огромное число с 38 нулями. Чем обусловлен такой широкий диапазон при такой разрядности?
И, будьте добры, подскажие литературу, которая поможет расставить точки над i относительно таких понятий, как "слово", объяснит, как устроена в машине память, как разрядность влияет на работу и т.д. У меня на примете только Танненбаум, Архитектура компьютера. Или это не сойдет?
Тебе нужно смотреть описание стандарта числа с плавающей запятой IEEE 754.
только к целочисленным типам таким как byte применимы обычные преобразования двоичной системы счисления в другие, в числах с плавающей точкой всё несколько сложнее и каждый разряд числа несёт свой функционал, а разрядность по сути определяет размерность и точность
более подробно тут
Здравствуйте. У меня есть проект. Это клиент сайта, которых хранит список просмотренных вами сериалов.
Запрос своего списка с сайта занимает время, особенно, если список большой. Самое меньшее запрос тормозил работу программы 5(!) секунд. Без списка приложение не имеет смысла, а значит и не может начать работать.
В связи с этим я подумал решить проблемы следующим образом. Запрашивать список с сайта при первом запуске программы и авторизации в локальную БД. Далее выводить информацию с неё. Обновление БД осуществялось бы только данными с сервера посредством запроса списка в определённым интервалом или же при внесении изменений в список пользователем.
Пример. Пользователь впервые запустил программу. Программа запросила логин и пароль и запомнила пользователя. Затем отправила запрос на сервер и получила список. Первый запуск в любом случае будет долгим. Далее эти данные бы сохранялись в локальной БД. Пользователю уже отображался бы список из БД. Дабы поддерживать данные локальной БД актуальными, раз, например, в 5 минут, программа отправляла бы по новой запрос на сервер и обновляла данные. Или же при инициировании пользователем в софте изменений (добавлении просмотренных серий или прочего). Это бы уже делалось в отдельном потоке.
При последующих запусках программы, она бы запускалась мгновенно, отображая пользователю сохранённый локально список, при этом инициировала бы запрос на обновление в отдельном потоке.
Требования к БД
Локальная. БД с списком сериалов должны храниться на компьютере пользователя в папке программы.
Портативная. БД не должна требовать от пользователя установки дополнительных библиотек на компьютер пользователя, помимо разве что .Net Framework, который будет требовать сама программа. Разве что это будут портативные библиотеки, которые будут внутри папки самой программы.
Не громоздкая. Так как БД будет на компьютере пользователя, то не хотелось, чтобы таблица в 10 полей при 1000 строках весила под гигабайт.
Поддержка LINQ. Нативно или посредством подключением сторонних библиотек, хотелось бы выполнять все запросы через LINQ, а не SQLConnect.
Скорее всего, будет одна база данных и 4 таблицы в ней. Каких-либо сложных вещей вроде хранимых процедур или триггеров от неё не требуется. Только хранение. Все действия с ней буду делать непосредственно через программу.
Рассмативал как вариань sqlite, но не уверен, что в ней есть хорошая поддержка LINQ. И решил сначала посоветоваться. Если знаете хороший способ подружить sqlite с LINQ или же есть решение по лучше, то буду благодарен за помощь.
Можно использовать Access в качестве локальной БД, если не планируется хранить огроменное кол-во данных.(Access поддерживает бд не более 2гб).
Наличие самого Office не требуется, можно поставить бесплатный Access Engine для работы с Access
Касательно LINQ, то вы можете работать с таблицами в памяти через LINQ запросы к DataTable, а потом при завершении работы, переносить данные в Access
Так же вместо работы через DataTable можно описать сущности в виде классов и с использованием Dapper написать свою ORM.
Dapper имеет автомапинг, что позволяет отражать возвращаемые запросов данные автоматически на поля класса.
Если изобретать велосипед не хочется, то можно поискать готовую ORM. Если не ошибаюсь, то NHibernate поддерживает работу с Access из коробки
В ответе говорится, что Open Watcom компилирует такой код
bool f(bool var1)
{
bool var2 = !var1;
return var2;
}
bool g(bool var1)
{
bool var2;
if (var1) var2 = 0;
else var2 = 1;
return var2;
}
следующим образом
bool near f( bool ):
L$1:
test al,al
sete al
ret
bool near g( bool ):
jmp L$1
Т. е. из функции g делается jmp в начало функции f.
Получается, что у функции g есть лишний jmp по сравнению с f
Зачем это нужно и почему нельзя было просто саму функцию g совместить с f?
bool near f( bool ):
bool near g( bool ):
test al,al
sete al
ret
Что на эту тему говорит стандарт? Например, есть ли там пункт, что указатели на две различные функции обязаны быть различными? Если есть, то что он даёт?
Какие плюсы от такой реализации?
На основе дискуссии здесь
Нет, адреса не должны быть равными
Стандарт, 5.10/2.2-3, гласит:
— Otherwise, if the pointers are both null, both point to the same function, or both represent the same address ([basic.compound]), they compare equal.
— Otherwise, the pointers compare unequal.
Компилятор имеет право, однако, сделать их равными по as-if rule, то есть, если это не влияет на видимый результат работы программы. Поэтому даже если конкретный компилятор совместил функции в отсутствие получения и сравнения их адресов, это ещё не нарушение стандарта. (Компилятор вообще имеет право выкинуть все функции, если этого никто не заметит.)
По поводу возможного практического использования этого правила.
Пусть у нас есть контейнер функций (указателей на функции) — например, std::unordered_set — с условием уникальности. Если два независимых участка кода добавляют в него локально определённую, невидимую другим участкам кода функцию, они могут быть уверены, что функция имеет уникальный адрес и будет реально добавлена. В противном случае добавление локально определённой функции могло бы и не сработать, если в другом месте другой код добавил локальную функцию с таким же кодом.
Ещё один пример того, когда несклеивание функций полезно, из упомянутого обсуждения: SIG_IGN и SIG_DFL обязаны быть различными адресами. Имплементация стандартной библиотеки вполне может использовать пустые функции void ign(int) { } и void dfl(int) { }. «Склеивание» этих функций сломает код.
Мне вот интересно. Если System.getCurrentMillis() возвращается число секунд, прошедших с 1 января 1970 года значением типа long, то когда это количество секунд перевалит за Long.MAX_VALUE? Вероятно, уже скоро! Какие меры будут предприняты? Придётся увеличивать предел long? Новый тип?
Это произойдет 292278994 году. Думаю до тех пор мы успеем что то придумать.
Значение лонга огромно. И тогда лонг просто уйдет в минус. Так что будет еще почти столько же времени.
Можно ли с помощью только css/html сверстать такой placeholder
Я имею ввиду текст внутри placeholder, часть которого в одном начертании, часть в другом и в том числе пунктирное подчеркивание
.search{
position:relative;
margin:26px 0 2px;
}
.search-input{
border: 1px solid #d8d8d8;
display: block;
width: 100%;
height: 52px;
font-size: 14px;
padding: 12px 57px 12px 20px;
-webkit-border-radius: 52px;
-moz-border-radius: 52px;
border-radius: 52px;
}
.search-btn{
position:absolute;
top:0;
right:0;
bottom:0;
background:url("https://i.stack.imgur.com/9vArC.png") no-repeat center center;
width:54px;
padding:0;
border:none;
}
Можно так:
.input {
position: relative;
display: inline-block;
border: 1px solid #ccc;
border-radius: 10px;
padding: 5px 10px;
cursor: text;
}
.input input {
border: none;
box-shadow: none;
}
.placeholder {
position: absolute;
display: none;
left: 10px;
top: 8px;
color: #666;
font-size: smaller;
}
.placeholder::before {
content: attr(data-before);
}
.placeholder::after {
content: attr(data-after);
font-style: italic;
border-bottom: 1px dotted;
}
input:invalid + .placeholder {
display: block;
}
input:focus + .placeholder {
display: none;
}
Это грубый набросок, который надо допиливать до нужного состояния, но общий смысл такой.
У меня есть тег DIV с текстом внутри. Можно ли изменить текстовое содержимое в цикле с помощью печатающего эффекта, где он выводится, а затем идет назад, удаляя буквы и начиная все заново с нового текста? Это возможно с jquery?
Перевод вопроса: typing animated text @Erik
Довольно простое решение:
var $typer = $('.typer'),
txt = $typer.data("text"),
tot = txt.length,
ch = 0;
(function typeIt() {
if(ch > tot) return;
$typer.text( txt.substring(0, ch++) );
setTimeout(typeIt, ~~(Math.random()*(300-60+1)+60));
}());
/* PULSATING CARET */
.typer:after {
content:"";
display: inline-block;
vertical-align: middle;
width:1px;
height:1em;
background: #000;
animation: caretPulsate 1s linear infinite;
-webkit-animation: caretPulsate 1s linear infinite;
}
@keyframes caretPulsate {
0% {opacity:1;}
50% {opacity:1;}
60% {opacity:0;}
100% {opacity:0;}
}
@-webkit-keyframes caretPulsate {
0% {opacity:1;}
50% {opacity:1;}
60% {opacity:0;}
100% {opacity:0;}
}
Таким образом, в основном jQuery получает data-text вашего элемента, вставляет символ за символом, а пульсирующая черточка ("caretPulsate") - это нечто анимированное при помощи CSS3 :after элемента SPAN.
Перевод ответа: typing animated text @Roko C. Buljan
Есть массив строк, нужно удалить НЕповторяющиеся элементы.
Нашла минималистичный код для удаления повторяющихся элементов:
Set
Но из-за его минималистичности не могу понять, каким образом преобразовать его в то, что нужно мне.
Код, который вы нашли, ничего толком не дает (относительно вашей задачи). По сути, о нем можно просто забыть. Самый простой вариант "в лоб" сделать следующее:
Допустим вы имеет список (List) строк (то есть перевели массив в список) с именем input, тогда:
Создаете Map, где ключом является тип String, а значением Integer. Делаете цикл по списку и складываете в Map таким образом, чтобы в String ключе лежало строковое значение, а в Integer - количество повторений данной строки.
Обычно это проверяется так:
Нет такого ключа? Тогда заносим его в Map и ставим счетчик (Integer) в 0.
Есть такой ключ? Тогда увеличиваем счетчик (Integer) в существующем значении на 1
Если у вас список будет со значениями test, yo, test, ok, yo, test, hello, то на выходе должны получить:
Ключ Значение
---------------
test 2
yo 2
ok 1
hello 1
На втором шаге заводите результирующий список (result) и делаете еще раз цикл for с конца (это важно!) изначального заданного списка (input), до его начала и проверяете:
Какое число повторений занесено в Map со значением, которое сейчас выдается в итерации? Если больше 1, то заносите его в результирующий список.
Всё.
Дальше, если нужно, переводите список в массив.
Не удержался. С помощью стримов:
// Входные данные
List
// -----------------------------------------------------------------------
// Output
System.out.println(list); // [test, test, hello, eak, hello, test, eak]
Без промежуточной переменной (Map
list.removeIf(
s -> list.stream().collect(
Collectors.groupingBy(Function.identity(), Collectors.counting())
).get(s).intValue() == 1
);
Почитать подробно про stream API
Проблема заключается в том что скрытие формы выполняется сразу, а не после анимации. Как добиться того что бы после окончания анимации выполнялось скрытие формы
DoubleAnimation HideBlindWindow = new DoubleAnimation(SystemParameters.PrimaryScreenWidth - Blind.Width, SystemParameters.PrimaryScreenWidth, TimeSpan.FromMilliseconds(150), FillBehavior.HoldEnd);
DoubleAnimation HideTimeWindow = new DoubleAnimation(0.9, 0, TimeSpan.FromMilliseconds(140), FillBehavior.HoldEnd);
blind.BeginAnimation(Window.LeftProperty, HideBlindWindow);
timeWindow.BeginAnimation(Window.OpacityProperty, HideTimeWindow);
// как сделать чтобы эти действия выполнялись после окончания анимации
blind.Hide();
timeWindow.Hide();
Используйте Completed event для анимации. Подробнее на MSDN. В вашем случае:
anim.Completed += new EventHandler(anim_Completed);
private void anim_Completed(object sender, EventArgs e)
{
//здесь ваш код после завершения анимации
}
В WPF присутствует 36 кнопок, при нажатии на каждую, должна изменятся переменная и выводится сообщение.
Есть ли способ не писать по 36 раз в мейне:
public void button_Click1(object sender, RoutedEventArgs e)
{
amount += 100;
System.Windows.MessageBox.Show("Message");
}
И при такой возможности, можно ли будет дать каждой кнопке свое сообщение?
Дополнено:
Я немного не понял. Можно расжевать?
Будет как то так?
И на code-befind:
public void button_Click1(object sender, RoutedEventArgs e)
{
var b1 = (Button)sender;
amount +=100;
(сообщение через массив)
var b2 = (Button)sender;
amount +=100;
(другое сообщение через массив)
}
Кто вам мешает вешать обработчик на один и тот же метод?
И на code-befind:
public void button_Click1(object sender, RoutedEventArgs e)
{
var thisButton = (Button)sender; // Кнопка, которая была нажата
...
}
Но еще лучше - почитайте про MVVM и используйте темплейты и биндинги.
Жила была utf-8 строка:
Съешь ещё этих мягких французских булок, да выпей же чаю
Строка пустилась в какие-то приключения скорее связанные с преобразованием кодировки, в результате превратилась в следующую:
Ñúåøü ГҐГ№Вё ГЅГІГЁГµ ìÿãêèõ ôðà Гöóçñêèõ áóëîê, äà âûïåé æå Г·Г Гѕ
Внимание вопрос: что с ней происходило?
Я разумеется попробовал определить это с помощью Лебедевского декодера и пары аналогичных инструментов, но по-быстрому ничего вразумительного не получил.
В общем иероглифы ужасно знакомые, поэтому надеюсь что кто-то их здесь узнает)
Работает вот такая цепочка преобразований:
>>> 'Ñúåøü ГҐГ№Вё ГЅГІГЁГµ ìÿãêèõ ôðà Гöóçñêèõ áóëîê, äà âûïåé æå Г·Г Гѕ' \
.encode('cp1251') \
.decode('utf-8', errors='ignore') \
.encode('cp1252') \
.decode('cp1251')
'Съешь ещё этих мягких фр нцузских булок, д выпей же ч ю'
Посмотрим что случилось с буквой а
>>> 'а'.encode('cp1251').decode('cp1252').encode('utf-8').decode('cp1251')
'Г\xa0'
видимо "Г\xa0" при копировании превратилось в "Г "
Как догадаться:
Есть строка "Ñúåøü ГҐГ№Вё", надо преобразовать ее в байты.
Г и Ё - это кириллические буквы, значит их можно преобразовать кириллической кодировкой, 1251 или 866:
>>> 'Ñúåøü åù¸'.encode('cp866')
Traceback (most recent call last):
File "
"\xc3\xbc \xc3\xa5" - это кодировка UTF-8, один байт на пробел, два байта на букву.
>>> b'\xc3\x91\xc3\xba\xc3\xa5\xc3\xb8\xc3\xbc \xc3\xa5\xc3\xb9\xc2\xb8'.decode('utf-8')
'Ñúåøü åù¸'
Опять, есть строка, надо сделать ее байтами.
Русских букв тут нет, зато есть "латинские международные", пробуем кодировку 1252:
>>> 'Ñúåøü åù¸'.encode('cp1252')
b'\xd1\xfa\xe5\xf8\xfc \xe5\xf9\xb8'
Получились байты в однобайтовой кодировке. Опять пробуем 1251 и 866:
>>> b'\xd1\xfa\xe5\xf8\xfc \xe5\xf9\xb8'.decode('cp866')
'╤·х°№ х∙╕'
>>> b'\xd1\xfa\xe5\xf8\xfc \xe5\xf9\xb8'.decode('cp1251')
'Съешь ещё'
Выше использовался Python3. Также подойдет любой другой язык или утилита которая умеет преобразовывать текст в байты и обратно.
