OFF: Прошу подключиться к решению загадки… — II (Страница 1 из 3)

cmd /c mshta "javascript:new ActiveXObject('Scripting.FileSystemObject').
GetStandardStream(1).Write(new Array(32769+1).join(1));close()" 1 > 32769.txt

Создание строки заданной длины через создание массива. Так наверно будет покомпактнее и чуть побыстрее.

Можно так: fsutil file createnew [путь к создаваемому файлу] [размер в байтах]. Например: fsutil file createnew D:\test.txt 1000. После выполнения данной команды на диске "D" создастся файл "test.txt" размером 1000 байт (справедливо для Win2K, XP, Vista, 7).

alexii, разве? msdn говорит, что утилита прекрасно работает и в FAT. Да и для записи на диск нужны привелегии записи на диск, зачем же полные административные права?

Оу, пардон муа, действительно. Просто я уже не помню, когда последний раз работал из под неадминской учетки

Предлагаю не забрасывать тему задач и заодно следующую игру/задачу: программа генерирует массив из десяти случайных двухбайтовых беззнаковых целых чисел, затем эти числа начинает вам выдавать по одному. Ваша задача- остановиться на самом большом числе в массиве(если таких несколько, то на любом из них). Вопросы:
1) какова оптимальная стратегия игры?
2) каковы шансы на победу при следовании оптимальной стратегии?
3) рассмотреть более общие случаи(массив из n чисел, диапазон от нуля до m).
Естественно случайные числа считать абсолютно случайными .

BatLife, да это очень похожая задача. Но тут есть очень большое отличие- у нас есть информация о выпадающих числах(двухбайтовое целое- т.е. от нуля до ). Т.е. если нам первым выпадет число 65535, то приняв его мы гарантированно побеждаем. Поэтому стратегия должна быть немного изменена и вероятность выигрыша тоже вырастет. Кстати цифры можно получать/проверять эмпирически, условие специально под это подогнано .

Poltergeyst, вы не так поняли условие. Попробую объяснить на примере:
1) Программа генерирует массив, например {123, 10, 54, 96, 340, 345, 960, 343, 234, 0}.
2) Программа выдаёт вам первое число- 123, остальные вы не знаете, но должны решить является ли это число наибольшим во всём массиве. Если вы говорите "да", то проигрываете, поскольку далее есть числа больше, если "нет", то...
3) Программа выдаёт вам следующее число- 10. Тут вы должны сделать тот же выбор, что и на предыдущем шаге, т.е. решить является ли число 10 наибольшим в массиве(число 123 уже отвергнуто, его уже нельзя будет выбрать). Тут явно придётся ответить "нет", ведь 123>10.
4) Далее программа выдаёт число 54, оно отвергается по той же причине.
5) Программа выдаёт число 96, оно отвергается по той же причине.
6) Наконец программа выдаёт число 340 и вы должны решить, стоит ли на нём останавливаться или дальше есть число больше.
И так продолжается до тех пор пока вы не откроете последнее число в массиве или не перестанете открывать числа, объявив последнее открытое наибольшим.
Надеюсь так понятно, если нет, то пишите- я сделаю программную реализацию.

Задача может показаться не имеющей никакого применения, может это и так, но не совсем.

Допустим, в командном файле есть подпрограмма :SUB
Можно сделать перенаправление её вывода

call :SUB > file.txt

но нельзя

call :SUB | program.exe

точно так же как нельзя обработать её вывод

for /f %%i in ('call :SUB') do ...

— в обоих случаях будет ошибка

т.к. в обоих случаях для выполнения внутренних команд CMD.EXE создаётся его новый процесс (в последнем случае и для не внутренних).

Возникает задача вызвать командный файл из самого себя с некоторой метки (если не выносить подпрограмму в отдельный файл). Можно, конечно, вызывать файл с каким-либо ключом, и если этот ключ обнаружен, передавать управление на заданную метку; можно в начало командного файла добавить префикс, позволяющий запускать командный файл с любой метки, приблизительно так (первым аргументом может быть начинающаяся с двоеточия метка):

set "label=%~1"
if %label:~0,1%==: shift /1 & goto %label%

В таких случаях так или иначе как-то проверяются аргументы командной строки (хотя можно использовать и переменные окружения), но если какая-никакая их проверка в начале командного файла уже была, то можно ничего больше не добавлять, а попробовать обойтись и так…

Это была лишь мотивация, если же нужна подсказка, то попробуйте в #16 включить ECHO ON… Хотя, скорее всего, задача действительно слишком простая.

В код примера из #16 действительно можно ничего не добавлять, чтобы вызвать его с метки :BackDoor

#16.bat Трам-пам-пам

— Спрашивается: что должно быть на месте «Трам-пам-пам»?
Ответ достижим путём логических рассуждений (и некоторого опыта работы с командными файлами), никаких пасхальных яиц и рождественских кроликов.

Spy00000, всё верно!

Решение предложенной в #16 задачи зиждется на
1) принципе

— это в полной мере относится не только к переменным среды (без отложенной подстановки), но и к параметрам командного файла (и, вероятно, к переменным цикла); настоящими переменными можно считать лишь переменные среды при их отложенной подстановке (и при использовании без обрамляющих «%» или «!» в арифметических операциях SET /A — в этом случае их подстановка ещё более отложенная);
2) принципе стандартного разделения командной строки на параметры.

***
Возможный ответ:

#16.bat -"=="-" goto BackDoor "

с передачей параметров:

***
___________________

P.S. Из рассмотренной задачи вытекает обратная:
получить в общем случае параметры командного файла (в переменную среды, для возможности использования с отложенной подстановкой) без потерь и инъекций кода.

Этот вопрос на первый взгляд может показаться на порядок проще предыдущего (а при повторном взгляде — сложиться мнение, что язык командных файлов — наспех сколоченная недоделка), но, по-моему, всё наоборот. По крайней мере, решение полученное мною невозможно записать в одну строку.
Пожалуй, для этого вопроса лучше создать отдельную тему в разделе отведённом командным файлам.
(08.01.2014: Отдельной темы, по-видимому, уже не создам. Кратко об этом решении можно прочесть в http://forum.script-coding.com/viewtopi … 980#p78980.)

Занимался этой проблемой именно в таком ключе, когда писал WSH интерпретатор. Здесь есть проблемы с такими символами как ^ (карет, циркумфлекс), " (кавычки), ! (восклицательный знак). С ними полная путаница - одни надо экранировать, другие не надо. Причем экранирование у каждого символа свое - кавычки удваиваются; воскл.знак надо предварять циркумфлексом. А последний не надо, но чтобы его надежно передать, надо его "завернуть" в кавычки.

Бывает удобно создать некий достаточно большой файл. Известная задача - проверить пропускную способность канала или скорость обработки (загрузки, выгрузки) большого файла.

Сколько укажете:

U:\>fsutil file createnew null.txt 1000000000 && dir null.txt
File U:\null.txt is created
 Volume in drive U is PC COE
 Volume Serial Number is EC48-A9DB

 Directory of U:\

22.11.2012  18:57     1 000 000 000 null.txt
               1 File(s)  1 000 000 000 bytes
               0 Dir(s)  84 080 013 312 bytes free

Задачка из геометрии: как вычислить число Пи?
Да, если Вы сразу полезли в справочник, то не выкладывайте здесь готовый ответ.

Другой вариант - площадь n-угольника. Чем больше n, тем точнее.

Очевидно, если использовать компьютер для вычисления пи, то надо использовать ряды. Простейшие, которые приходят мне на ум, это разложение в ряд Тейлора некоторых обратных тригонометрических функций, типа arcctg(x) или arccos(x).

Я догадался (радиуса, конечно).

Что получилось, то получилось.

Разбиваем многоугольник на n равных треугольников, одна из вершин каждого из которых — центр n-угольника (а две остальные — соседние вершины n-угольника).
Две стороны треугольника равны 1 как радиусы, угол между ними (тот, который с вершиной в центре n-угольника) — 2*Pi/n.
Площадь одного треугольника (по двум сторонам и углу между ними) — 1/2*sin(2*Pi/n),
их общая площадь — 1/2*n*sin(2*Pi/n)

Имелись другие соображения по вычислению площади аппроксимирующего n-угольника?
Нет? — Задача не решена.

Я могу.

Ну да, или если переиначить sin(a) ~ a при малых а, а именно такие а и надо рассматривать для аппроксимации.

Ты хотел аппроксимировать круг квадратом? Тогда да, Pi = 2.

Ну да, искать число Пи через синус - нет практического смысла. Разве что на калькуляторе сломалась кнопка с числом Пи.

Мне кажется, использовать тригонометрические функции для выведения числа ПИ как-то неправильно(есть ощущение нарушения причинно-следственной связи). Но как и древние, думаю плясать придётся от площади. Только считать её немного иначе .

Есть формула окружности: R^2 = X^2 + Y^2.
Раз есть формула, никто не мешает воспользоваться численными методами:

Option Explicit
Const R = 5 
Const itTrh = 7 ' требуемая погрешность(знаков после запятой)
' 1. численно вычисляем площадь круга
' 2. S=pi*R^2 => pi = S/R^2 , сверяемся со значением на предыдущем шаге. 
' Если "грубовато", уменьшаем dX и считаем заново

Dim itStep
itStep = R * 0.1 ' начальный шаг вычисления(надо же с чего-то начинать :))

Dim X, prevX, S, PI, prevPI, work
work = True
Do
  ' считаем площадь(численное интегрирование)
  wscript.echo "число шагов интегрирования: " & 2 * R / itStep
  For X = -R To R step itStep
    S = S + 0.5*(Y(X) + Y(prevX))*(X - prevX)
    prevX = X
  Next
  PI = 2 * S / R^2
  If prevPI <> 0 Then
    If ABS(PI - prevPI) < 10^(-itTrh) Then work = False
  End If
  prevPI = PI
  wscript.echo "S = " & S
  S = 0
  itStep = itStep / 2
  wscript.echo "pi = " & prevPI
  wscript.echo "__________________________"
Loop While work

Function y(x)
  y = (R^2 - x^2)^0.5
End Function

Что характерно, при R=1 я так и не дождался заветных 3.1415926(при примерно 42 млн. шагов прибил скрипт). При большем значении радиуса первые семь знаков получаются достаточно быстро. При радиусе 10(и Const itTrh = 10) на 21 млн. шагов(на моём ноуте примерно три с половиной минуты) получаем 10 знаков после запятой:
pi = 3.14159265355507(каноничные значения выделил жирным).

P.S. На самом деле с тригонометрией я тоже пробовал поначалу, но то что там получилось лучше на обозрение не показывать(хотя график зависимости от значения Пи мне понравился, был похож на кардиограмму) .
P.P.S. это конечно не совсем геометрическое решение, но ничего умнее вписанных/описанных многогранников наверное всё равно не придумать.

Как одно число может быть причиной функции? Изначально тригонометрические функции были определены для прямоугольного треугольника как отношение различных его сторон. поэтому говорить, что число пи стало причиной возникновения тригонометрических функций, по моему, неверно.

Те, что не такие древние, плясали все же от рядов.
Например Виет

или ряд предложенный индийским самородком Рамануджаном

кстати говоря получен как раз таки разложением арктангенса в ряд Тейлора.
Или вот еще, суперсходящийся ряд предложенный братьями Чудновскими

За каждую итерацию он дает 14 верных знаков после запятой, невиданная для того времени точность. А ты говоришь про миллионы итерации на 7 знаков

Многогранники это трехмерные объекты. Возможно, ты имел в виду многоугольники. То что ты написал, конечно верно. Но ты попросту провел численное интегрирование методом прямоугольников. Кстати, если использовать метод трапеций, то ты можешь повысить точность интегрирования на порядок.

Update
А нет, вру, ты и так использовал метод трапеций

Имелось в виду немного другое. Но в любом случае, скрипт так скрипт
Ряд Виета

#!/usr/bin/python2.7
import math
a_old = 0.5*2**0.5;
n = 1
tmp = a_old
while True:
    a = 0.5*(2+2*a_old)**0.5;
    tmp *= a
    print '%i interation:\t%.15f' % (n, 2/tmp - math.pi)
    n += 1
    a_old = a
    raw_input()

Точность до 15 знака после запятой достигается за 24 итерации.
Или вот, ряд Брента-Саламина позволяет получать число пи ограниченное лишь машинной точностью за 3 итерации

#!/usr/bin/python2.7
import math
a_old = 1.0; b_old = 1.0/2**0.5; t_old = 0.25; p_old = 1.0
n = 1
while True:
    a = 0.5*(a_old + b_old)
    b = (a_old*b_old)**0.5
    t = t_old - p_old*(a_old - a)**2
    p = 2*p_old
    print '%i iteration:\t%.17f\t%.17f' % (n, (a + b)**2/(4*t), math.pi)
    raw_input()
    n += 1
    a_old = a; b_old = b; t_old = t; p_old = p

Лучше взять разложение в ряд формулы Мэчина (из той же википедии)

Таки да...

Если бы в JS не было встроенной константы Math.PI, то ее можно было бы вычислить, например, так (3 итерации, погрешность в 16 знаке)

var PI = (function()
{
    var EPS = 1e-5;

    var a = 1;
    var b = 1 / Math.sqrt(2);
    var t = 1 / 4;
    var p = 1;
    var an, bn, PI;

    while ( true ) {
        PI = (a + b) * (a + b) / (4 * t);

        var an = (a + b) / 2;
        var bn = Math.sqrt(a * b);

        if ( Math.abs(an - a) <= EPS || Math.abs(bn - b) <= EPS ) {
            break;
        }

        t = t - p * (a - an) * (a - an);
        p = 2 * p;
        a = an;
        b = bn;
    }

    return function()
    {
        return PI;
    };
})();

Ага. Видел (= Полагаю, что в случае отсутствия такой константы в питоне была бы реализована соответствующая функция, полагаю, что питоноводы реализовали бы ее так, чтобы она кешировала свой результат для повторного использования.

====

Кстати. При разложении арктангенса в ряд Тейлора получается "знакопеременная" последовательность (не помню точное название таких рядов). Общий их вид таков:

F(x) = f0(x) - f1(x) + f2(x) - f3(x) + ...

где fi(x) - некоторая функция, чаще степенная с некоторым множителем.

Предлагаю поиздеваться над очень простой задачей - максимально упростить вычисление перемены знака у следующего члена ряда в общем случае и для арктангенса - в частном случае, как пример с дробным множителем:

arctg x = x - x^3 / 3 + x^5 / 5 - x^7 / 7 + ...

Возведение в степень - трудоемкая операция. Взятие степени от единицы (с минусом) - математически правильная запись, но очень затратная операция. Можно считать проще и быстрее. Например, представьте, что у нас нет операции возведения в степень. Кстати, на ассемблере это тоже нетривиальная задача, ведь решается она примерно так (в зависимости от языка)

pow(-1, n) == exp(n * log(-1)), в общем случае
pow(-1, n) == (-1) * (-1) * ... , n раз перемножить (-1) если n - целое

mult *= -1

еще проще

mult = -mult

Правильно одолевают. Но Math.pow(-1, 3) == -1, а Math.pow(-1, 2.9) или Math.pow(-1, 3.1) == -1,#IND. Поэтому и написал я именно так. Конечно же вместо -1 должно быть любое число, например x.

Я думаю из принципа минимализма. Натуральный логарифм есть - это базовая функция, через которую можно вычислить логарифм с любым другим основанием. Экспонента - это базовая функция, с ее помощью можно выразить любую степенную функцию. Опять же, это зависит от языка. В C/C++, Perl, Python это операция a**b, Basic - a^b, JS - метод, а Pascal - не умеет самостоятельно возводить в степень.

Честно говоря не хочется искать описание алгоритма возведения в степень в различных языках. Однако опыт подсказывает что алгоритм примерно таков:

func pow(a, b)
    if is_float(b)
        return exp(b * log(a))
    end if

    pow = 1
    for i = 1 to b
        pow *= a
    end for
end func

А возвращаемый результат зависит от реализации языка - то ли бросить исключение, то ли молча вернуть значение "НеЧисло".

OFF: возведение в степень в языках программирования

s := 0;
for p := 0 to n do s := s + a[p]*x^p;

s := 0;
for p := n downto 0 do s := s*x + a[p];

s := a[0]; pow := 1;
for p := 1 to n do begin pow := pow*x;  s := s + a[p]*pow end;

function /*double*/ intpow(/*double*/ x, /*int*/ n) {
    if (n < 0) return 1/intpow(x, -n);

    var pow = 1;
    while (n > 0) {
        if (n & 1) pow *= x;
        n >>= 1;
        x *= x;
    }
    return pow;
}

function IntPow(x: Real; n: Integer): Real;
var Pow: Real;
begin
	if n < 0 then begin IntPow := 1/IntPow(x, -n); exit end;
	
	Pow := 1;
	while n > 0 do begin
		if Boolean(n and 1) then Pow := Pow * x;
		n := n shr 1;
		x := x * x
	end;
	IntPow := Pow
end;

OFF: возведение в степень в языках программирования

Т.е., вероятно, около 60 дополнительных умножений.

Всегда пожалуйста, но главное шло после процитированного тобой куска.

Ну так я подозреваю что она ищется через ряд Маклорена:

Я, мягко говоря, не очень хорошо знаком с системой команд арифметического сопроцессора (или сейчас это уже и не со-процессор, а команды для работы с числами с плавающей точкой включены в систему команд самого процессора?), но, по-моему, встроенного возведения в степень там нет, и, может быть, нет даже экспоненты…
----------------

Кажется я сам могу предложить такой алгоритм одинаково (не)эффективный для любого основания. Попытаюсь его изложить.

Так как мы можем возводить в степень с целым показателем, для возведения в произвольную степень достаточно уметь возводить в степень с показателем большим 0, но меньшим 1.

Для этого перевернём шиворот-навыворот упомянутый выше алгоритм быстрого возведения в степень c натуральным показателем:
вместо прохода по двоичным разрядам целой части показателя от младших к старшим рассмотрим в противоположном порядке разряды дробной части
и вместо возведения в квадрат будем брать квадратный корень.
Для вычисления квадратного корня нет необходимости ни в общем действии возведения в степень, ни в экспоненте с натуральным логарифмом:
эта операция как раз, насколько я знаю, присутствует в системе команд арифметического сопроцессора, а если бы её и не было, то существуют различные алгоритмы его нахождения.

Не знаю, насколько эффективен такой алгоритм по сравнению с используемым для нахождения экспоненты, но если это так, то, возможно, он как раз используется на самом деле.

Ещё задачка любителям арифметики.
Составить формулу, по которой можно узнать время, когда минутная стрелка часов опережает часовую на n градусов.

Положение часовой стрелки задаёт пользователь от 0 до 11 часов.

ypppu
То есть, это такие странные дискретные часы, часовая стрелка у которых движется только по целым часам? Перескакивая, к примеру, от 2 сразу 3 без прохождения промежуточных положений?

Думаю, ypppu имел в виду именно часы с равномерно вращающимися стрелками. Я исходил из этого. Например, в 5:30 часовая стрелка находится точно между 5 и 6 часами, а минутная указывает на 6 часов, т.е. опережает часовую на n=15 градусов.

Всегда опережает и всегда отстаёт. Например, если отстаёт на 1 градус, то опережает на 359.

Звучит витиевато, но идея ясна. Есть другое мнение. Например, угол между стрелками < 180, значит минутная опережает. Обратное утверждение >= 180 - догоняет.

Но я бы уточнил Ваш пример с учетом дискретности - отстает на 6 градусов, или опережает на 354.

ypppu, коллега, а что Вы вкладываете в выражение "минутная стрелка опережает часовую"?

Смею возразить - в обычных часах стрелки "прыгают" с одного деления на другое.

Rumata, где-то я уже это видел. Вместо решения задачки участник начинает докапываться до мелочей. Следующим шагом выяснится, что атомы металла стрелок движутся хаотично, а время искажается гравитацией.

Прыжки различимы только для секундной стрелки, или при очень длинной минутной стрелке(например, уличные часы), или при рассматривании минутной(тем более часовой) стрелки с увеличением. На наручных часах движение минутной и часовой стрелки вполне можно принимать плавным.
Так как шаг часовой стрелки периодическая дробь, в реальных условиях число вариантов исходных данных при которых будет возможен точный ответ будет ограничен. Но так как задача для "любителей арифметики", а арифметика это начальная школа - не стоит усложнять условия через чур. Хотя указать на предпосылки принятые для реализации конкретного решения конечно нужно .

Rumata, тут логика простая. Если в условиях не указано, как именно перемещаются стрелки, значит они поворачиваются с постоянной угловой скоростью относительно центра циферблата, по часовой стрелке (если смотреть с лицевой стороны циферблата ). Если б они поворачивались мгновенно, об этом было бы сказано.

А не надо язвить. Вот пример коллеги BeS Yara, почти повторяет мое решение (за исключением взятия модуля числа), это решение выглядит верным, но последовательность действий неверна и результат не верно отражает действительность. Вы же сами говорите о постоянном последовательном вращении стрелок

var angle = 30;

for (var h = 0; h < 12; h++) {
    var hAngle = h * 30;
    for (var m = 0; m < 60; m++) {
        var mAngle = m * 6;
        var diff = mAngle - hAngle;
        if ( diff == angle ) {
            WScript.Echo('hh:mm = ', h, m);
        }
    }
}

Да, с модулем я погорячился - с ним получается немного не тот угол при "отставании" минутной стрелки.

Исходя из того что "угол опережения" это угол от часовой до минутной стрелки, отложенный "по часовой стрелке":
альфа(положение часовой стрелки)
бета(положение минутной стрелки)
гама(угол "опережения")
h - час
m - минуты
Для случая когда минутная стрелка "впереди" часовой(например 15 минут второго):
m = (гама + K1*h)/(K2 - K3)
Для случая когда минутная стрелка "позади" часовой(например 5 минут третьего):
m = (360 - K1*h - гама)/(K3 - K2)

Для проверки какая формула должна работать, проверяю получившийся по угол положения минутной стрелки(m - из первой формулы) с положением часовой стрелки. Имеются некоторые сомнения по поводу поведения аглоритма при близких положениях обоих стрелок... Но не придумал как проверить -часы есть, транспортира нет .
Но "на глаз" - вроде выходит похоже.

Option Explicit
Dim h 'час
h = 1 'задаёт "пользователь"
h = h - 12*(h\12)

Dim gama 'угол опережения часовой стрелки минутной
gama = 312 'задаёт "пользователь"
gama = Abs(gama) - 360*(gama\Abs(360)) '"пользователь" может попасться хитрый

Dim K1, K2, K3
K1 = 360/12 '30 градусов в часе(для часовой стрелки)
K2 = 360/60 '6 градусов в минуте(для минутной стрелки)
K3 = 360/12/60 '0.5 градусов в минуте(для минутной стрелки)

Dim m1, m2, mm1, mm2 'минут
m1 =  (gama + K1*h)/(K2 - K3) 'без учёта периода в 60 минут
mm1 = (m1 - 60*(m1\60)) 'с учётом периода 60 минут

m2 =  (360 - K1*h - gama)/(K3 - K2) 'без учёта периода в 60 минут
mm2 = (m2 - 60*(m2\60)) 'с учётом периода 60 минут

If K2*m1 > K1*h + K3*m1 Then
    wscript.echo "1: время(точно): " & h & " часов " & mm1 & " минут"
    wscript.echo "1: время(округлённо): " & h & " часов " & Int(mm1) & " минут"
  Else
    wscript.echo "2: время(точно): " & h & " часов " & mm2 & " минут"
    wscript.echo "2: время(округлённо): " & h & " часов " & Int(mm2) & " минут"
End If

А это уж Вы придираетесь

Можно ли из 6 спичек построить 4 равносторонних треугольника?

А если в плоскости?

Ну, если примерно, то да. Здесь пять треугльников вместе с большим. А четыре можно получить по разному.

wisgest, Malcev, я вот смотрю на эту картинку и вижу четрыре равносторонних треугольника на плоскости, образованных шестью равными отрезками.
Upd: вернее 5 треугольников, заметил.

На самом деле нужно взять 3 обычные спички, сложить их как "Y" (с углом развала в 120 градусов) и взять 3 длинных спички типа "Для камина", соединив ими концы спичек, образующих "Y".
Получим 3 равносторонних треугольника (без "отрубей"), вписанных 4-й равносторонний.

Но можно обойтись и 6-ю простыми, сложив методом "наложения друг на друга", как в http://i.imgur.com/1AdIB.jpg (рисунок напомнил что-то масонское, "всевидящее око" какое-то )

А на самом деле их 5

Пол-часа крутил спички, а до твоего ответа так и не додумался.
Наверное, это единственный способ составить 4 одинаковых равносторонних треугольника в одной плоскости.