задача

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

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

Примечание: эта задача имеет дело только с основным тоном, а не с обертонами / другими гармониками.

вход

Ваша программа получает две части данных:

• Строка произвольной длины, представляющая рассматриваемую строку. Эта строка будет помечена знаком X, где она должна удерживаться.

  [-----] is a string divided in six sections (five divisions).
  [--X--] is a string pressed at the exact center of the string.
  [X----] is a string pressed at 1/6 the length of the string. (Length used is 5/6)
  [-X--] is a string pressed at 2/5 of the length of the string. (Length used is 3/5)
  

  Предположим, что нота звучит с использованием части строки справа от X.

• Число (не обязательно целое число), обозначающее частоту настройки строки. Точность этого числа будет не более четырех цифр после запятой.

Можно предположить, что пройденные частоты будут лежать между 10 Hzи 40000 Hz.

Ввод может быть передан в формате по вашему выбору. Пожалуйста, укажите, как вход принят в вашу программу в вашем ответе.

Вывод

Ваша программа должна выводить как самую близкую ноту * в системе настройки равного темперамента из двенадцати тонов, так и количество центов от ближайшей ноты, которой будет обозначен звук, обозначенный строкой (округленный до ближайшего цента).

+nценты следует использовать для обозначения nцентов, острых / выше примечания, и -nцентов для плоских / ниже примечания.

Примечание должно быть выведено в примечании научной подачи. Предположим, А4 настроен на 440Hz. Используйте b и # для плоских / острых нот. Примечание: можно использовать либо острый, либо плоский. Для заметки в 466.16Hz, A#или Bbможет быть выведен для заметки.

Формат вывода зависит от вас, если вывод содержит только две ранее указанные части информации (то есть печать каждого возможного вывода не допускается).

* самая близкая нота относится к ноте, наиболее близкой к звуку, обозначаемому входом, измеренному в количестве центов (следовательно, ноте, которая находится внутри 50 centsзвука). Если звук отсутствует 50 centsв двух разных нотах (после округления), то может быть выведена любая из двух нот.

Примеры

Ваша программа должна работать для всех случаев, а не только для следующих примеров.

Output             Input Frequency   Input String
A4,  +0  cents     220               [-----X-----]
A5,  +0  cents     220               [--------X--]
D5,  -2  cents     440               [--X--------]
B4,  -49 cents     440               [X----------]
A#4, +19 cents*    314.1592          [X-]
Eb9, +8  cents*    400               [-----------------------X]
Eb11,+8  cents*    100               [--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------X]
D#1, +49 cents*    10                [--X]
A0,  -11 cents     11.7103           [---X--]

* Резкий или плоский может быть выведен.

Потенциально полезные ссылки

• Примечания и частоты
• Википедия на научной нотации
• Страница википедии о центах

Это Код-гольф так самый короткий ответ выигрывает.

BBC Basic, 161 #

  REM get frequency and string. Store length of string in n for later.
  INPUT f,s$
  n=LEN(s$)

  REM store floating-point value of note in semitones above (C0-0.5). Store integer value in n% (offset effectively means it will be rounded not truncated.)
  n=LN(f*(n-1)/(n-INSTR(s$,"X"))/15.8861)/LN(2)*12
  n%=n

  REM format printing to whole numbers only
  @%=2^17

  REM Output note name and octave. Output cents (discrepancy between n and n%, minus the offset of 0.5)
  PRINT MID$("C C#D D#E F F#G G#A A#B ",n%MOD12*2+1,2);INT(n/12)'(n-0.5-n%)*100'

Оценка исключает комментарии. Пока не играл в гольф.

Вывод

Выполняется правильно во всех тестовых случаях, кроме двух длинных. Для Eb9него , кажется , есть одна черта отсутствует из теста: Есть 22 -и один X, который делит строку на 24 равных частей. Согласно моим ручным расчетам, это 9600 Гц, что на 37 центов выше D9. Это именно то, что выводит моя программа. Если я добавлю еще одну черту, я получу Eb9 + 8 центов. К сожалению, BBC Basic не может обрабатывать строки длиной более 255 символов, поэтому Eb11регистр выдает ошибку.

С 179

main(n,d){float f;scanf("%*[^X]%nX%*[-]%n]%f",&n,&d,&f);f=log(f*d/(d-n))*17.3123-57.376;n=d=f+.5;n=n%12*7+784;printf("%c%d%c,%+2.0f cents\n",n/12,(d+9)/12,n%12/7*3+32,(f-d)*100);}

Получает изображение ascii на отдельной строке, а частоту на отдельной строке.

Несколько персонажей можно сбросить, уменьшив точность магических чисел 17.3123и 57.376.

Без игры в гольф программа выглядит так:

main(n,d)
{
    float f; // 'float' and '%f' better than 'double' and '%lf'

    scanf("%*[^X]%nX%*[-]%n]%f", &n, &d, &f);
    // n is the number of chars before 'X'
    // d is the number of chars before ']'
    // f is the frequency

    // Calculate the tuned frequency
    f = f * d / (d - n);

    // Convert the frequency to logarithmic scale, relative to pitch A0
    f=log(f)*17.3123-57.376;
    // alternatively: f = log2(f / (440 / 16)) * 12;

    // Round to nearest integer
    n=d=f+.5;

    // Calculate the note name ('A', 'B', etc), multipled by 12 for convenience
    n=n%12*7+784;

    printf("%c%d%c,%+2.0f cents\n", // output example: B4 ,-49 cents
        n/12,        // note name
        (d+9)/12,    // octave number
        n%12/7*3+32, // if n%12 is large enough, it's '#' else ' ' (natural)
        (f-d)*100);  // number of cents; stdio rounds it to integer
}

JavaScript (199)

Назовите это, например, как t('[X-]',314.1592)

t=(s,f)=>{l=s.length-1;p='C C# D D# E F F# G G# A B H'.split(' ');n=12*Math.log2(f*l/(l-s.indexOf('X'))/16.3515978);m=n+.5|0;return p[m%12]+(n/12|0)+' '+((n-m)*100+.5|0)}

Исправлена. (Так как я живу в Европе, я использовал B вместо Bb и H вместо B =)

Питон 3: 175

import math
def t(b,s):l=len(s)-1;n=12*math.log2(b*l/(l-s.index("X"))/16.35);m=round(n);return"%s%s%+d"%(("C C# D D# E F F# G G# A A# B".split()*99)[m],m//12,round(100*(n-m)))

Ungolfed:

import math

c0 = 16.35

def tuning (base_frequency, string):
    return formatted (note_number (frequency (base_frequency, string)))

def formatted (note_number):
    return "{name}{octave:d}{cents:+d}".format (name=note_name (note_number),
                             octave=octave (note_number),
                             cents=cents_out (note_number))

def note_name (note_number):
    return ("C C# D D# E F F# G G# A A# B".split() * 99)[round (note_number)]

def note_number (frequency):
    return 12 * math.log2 (frequency / c0)

def octave (note_number):
    return round (note_number) // 12

def cents_out (note_number):
    return round (100 * (note_number - round (note_number)))

def frequency (base_frequency, string):
    string_length = len (string) - 1
    held_length = string_length - string.index ("X")
    return base_frequency * string_length / held_length

if "__main__" == __name__:

    print ("Testing functions against known values...")
    assert "A4+0"     == tuning (220,      "[-----X-----]")
    assert "A5+0"     == tuning (220,      "[--------X--]")
    assert "D5-2"     == tuning (440,      "[--X--------]")
    assert "B4-49"    == tuning (440,      "[X----------]")
    assert "A#4+19"   == tuning (314.1592, "[X-]")
    assert "D#9+8"    == tuning (400,      "[-----------------------X]")
    assert "D#11+8"   == tuning (100,      "[--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------X]")
    assert "D#1+49"   == tuning (10,       "[--X]")
    assert "A0-11"    == tuning (11.7103,  "[---X--]")
    print ("Tests passed.")