"ट्विंकल ट्विंकल लिटिल स्टार" के लिए गीत प्रिंट करें


24

आपका लक्ष्य गीत के बोलों को "ट्विंकल ट्विंकल लिटिल स्टार" के रूप में प्रिंट करना है क्योंकि प्रत्येक नोट खेला जाता है।

कंप्यूटर के माइक्रोफ़ोन को नोट्स सुनाई देंगे। यदि नोट की पिच (लेकिन जरूरी नहीं कि लंबाई) सही है, तो उपयुक्त शब्दांश प्रिंट करें। नहीं तो कुछ न करें। प्रत्येक नोट कम से कम आधा सेकंड लंबा होगा, और नोटों के बीच एक सेकंड के कम से कम एक चौथाई का ब्रेक होगा।

यहां दिए गए संगीत नोट्स और निम्नलिखित गीतों का उपयोग करें: (लंबवत रेखाएं शब्दांश विराम को दर्शाती हैं।)

ट्विन | क्ले, ट्विन | क्ले, लिट्ल | टीएलई स्टार

मैं कैसे जीता? डर तुम क्या हो।

ऊपर एक | दुनिया इतनी ऊंची,

जैसे एक दीया | आकाश में मन्द।

ट्विन | क्ले, ट्विन | क्ले, लिट्ल | टीएलई स्टार

मैं कैसे जीता? डर तुम क्या हो।

संगीत की रिकॉर्डिंग यहां मिल सकती है

उदाहरण

कंप्यूटर एक मध्य C सुनता है और "ट्विन" प्रिंट करता है

यह एक और मध्य C सुनता है और "kle," प्रिंट करता है

फिर यह एक और मध्यम सी (गलत नोट) सुनता है और कुछ भी नहीं करता है।

फिर यह मध्य सी के ऊपर जी सुनता है और "जुड़वां" और इतने पर प्रिंट करता है।

नियम

  • दिखावा के रूप में विराम चिह्न होना चाहिए।
  • रिक्ति को दिखाया जाना चाहिए (रिक्त स्थान और newlines के साथ)।
  • व्हाट्सएप को पिछले या अगले शब्दांश के साथ मुद्रित किया जा सकता है।

2
क्या आराम करने का कोई तरीका है "नोट समाप्त होने से पहले मुद्रित किया जाना चाहिए?" 1/16 दूसरे नोटों के साथ, भले ही आप उस समय के 3/4 नमूने के लिए समर्पित करते हैं, आपके पास काम करने के लिए केवल ~ 47ms की ध्वनि है। जो कि मध्यम-श्रेणी के नोटों के लिए बहुत बढ़िया फ्रीक्वेंसी रिज़ॉल्यूशन देता है।
जोबिट्स

@Geobits अच्छा बिंदु; मैंने वह नियम हटा दिया।
यपनीपं

1
यह ऑडियो इनपुट का उपयोग करके पहली पहेली है जो मुझे मिल सकती है! बधाई!
नहीं कि चार्ल्स

1
क्या शीर्षक दो झुर्रियों को अलग करने के उद्देश्य से गलत है?
रेनबोल्ट

1
क्या हमारे पास परीक्षण के लिए एक ऑडियो फ़ाइल का लिंक हो सकता है?
केल्विन के शौक

जवाबों:


7

पायथन 3 - आंशिक समाधान ( 760 742 734 710 705 657 वर्ण)

(अंतिम संपादन; मैं वादा करता हूँ)

यह वास्तव में, सुंदर, बहुत कठिन समस्या की तरह लगता है (विशेषकर यह पहचानना कि नोट कहां से शुरू होते हैं या समाप्त होते हैं)। संगीत का स्वचालित ट्रांसक्रिप्शन एक खुले शोध विषय की तरह लगता है (यह नहीं कि मैं इसके बारे में कुछ भी जानता हूं)। तो यहाँ एक आंशिक समाधान है जो किसी भी नोट विभाजन को नहीं करता है (जैसे कि यह "ट्विंकल" को एक ही बार में प्रिंट करता है जब यह आवृत्ति सुनता है) और शायद केवल उस विशिष्ट ओग फ़ाइल के लिए काम करता है:

A=-52
F=44100
C=4096
import pyaudio as P
import array
import scipy.signal as G
import numpy as N
import math
L=math.log
i=0
j=[9,2,0,2,4,5,7,9]
k=[2,4,5,7]
n=j+k+k+j
w="Twinkle, |twinkle, |little |star,\n|How I |wonder |what you |are.\n|Up a|bove the |world so |high,\n|Like a |diamond |in the |sky.\n".split('|')
w+=w[:8]
e=P.PyAudio().open(F,1,8,1,0,None,0,C)
while i<24:
 g=array.array('h',e.read(C));b=sum(map(abs,g))/C
 if b>0 and 20*L(b/32768,10)>A:
  f=G.fftconvolve(g,g[::-1])[C:];d=N.diff(f);s=0
  while d[s]<=0:s+=1
  x=N.argmax(f[s:])+s;u=f[x-1];v=f[x+1]
  if int(12*L(((u-v)/2/(u-2*f[x]+v)+x)*F/C/440,2))==n[i]+15:print(w[i],end='',flush=1);i+=1

ये आवश्यक...

अपने माइक्रोफ़ोन के आधार पर शीर्ष लाइन पर ए = -52 (न्यूनतम आयाम) बदलें, परिवेशी ध्वनि के अनुसार, गाना कितना जोर से बज रहा है, आदि। मेरे माइक्रोफोन पर, -57 से कम समय में बहुत अधिक बाहरी शोर लगता है। और -49 से अधिक की आवश्यकता है कि आप इसे बहुत जोर से बजाएं।

यह बहुत अधिक गोल्फ हो सकता है; मुझे यकीन है कि विशेष रूप से शब्द सरणी पर वर्णों के एक समूह को बचाने के तरीके हैं। यह अजगर में मेरा पहला गैर-तुच्छ कार्यक्रम है, इसलिए मैं अभी तक भाषा से बहुत परिचित नहीं हूं।

मैंने https://gist.github.com/endolith/255291 से ऑटोक्रॉलेशन के माध्यम से आवृत्ति का पता लगाने के लिए कोड चुराया

Ungolfed:

import pyaudio
from array import array
import scipy.signal
import numpy
import math
import sys

MIN_AMPLITUDE = -52
FRAMERATE = 44100

def first(list):
    for i in range(len(list)):
        if(list[i] > 0):
            return i
    return 0

# Based on: https://en.wikipedia.org/wiki/Decibel#Acoustics
def getAmplitude(sig):
    total = 0;
    elems = float(len(sig))
    for x in sig:
        total += numpy.abs(x) / elems
    if(total == 0):
        return -99
    else:
        return 20 * math.log(total / 32768., 10)    

# Based on: https://en.wikipedia.org/wiki/Piano_key_frequencies
def getNote(freq):
    return int(12 * math.log(freq / 440, 2) + 49)

# --------------------------------------------------------------------------
# This is stolen straight from here w/ very slight modifications: https://gist.github.com/endolith/255291
def parabolic(f, x):
    return 1/2. * (f[x-1] - f[x+1]) / (f[x-1] - 2 * f[x] + f[x+1]) + x

def getFrequency(sig):
    # Calculate autocorrelation (same thing as convolution, but with
    # one input reversed in time), and throw away the negative lags
    corr = scipy.signal.fftconvolve(sig, sig[::-1], mode='full')
    corr = corr[len(corr)/2:]

    # Find the first low point
    diffs = numpy.diff(corr)

    # Find the next peak after the low point (other than 0 lag). This bit is
    # not reliable for long signals, due to the desired peak occurring between
    # samples, and other peaks appearing higher.
    # Should use a weighting function to de-emphasize the peaks at longer lags.
    start = first(diffs)
    peak = numpy.argmax(corr[start:]) + start
    return parabolic(corr, peak) * (FRAMERATE / len(sig))
# --------------------------------------------------------------------------

# These are the wrong keys (ie it is detecting middle C as an A), but I'm far too lazy to figure out why.
# Anyway, these are what are detected from the Wikipedia .ogg file:
notes = [73,          66,           64,       66,         68,       69,        71,          73,       66,     68,          69,         71,         66,        68,         69,        71      ] 
words = ["Twinkle, ", "twinkle, ", "little ", "star,\n",  "How I ", "wonder ", "what you ", "are.\n", "Up a", "bove the ", "world so ", "high,\n", "Like a ", "diamond ", "in the ", "sky.\n"]
notes += notes[:8]
words += words[:8]

pa = pyaudio.PyAudio()
stream = pa.open(format=pyaudio.paInt16, channels = 1, rate = FRAMERATE, input = True, frames_per_buffer = 4096)
idx = 0
while(idx < len(notes)):
    # Read signal
    sig = array('h', stream.read(4096))
    if(getAmplitude(sig) > MIN_AMPLITUDE):
        note = getNote(getFrequency(sig))
        if(note == notes[idx]):
            sys.stdout.write(words[idx])
            sys.stdout.flush()
            idx += 1

मैंने आपके लिए थोड़ी सी वाक्य रचना की मदद लिखी। 14-29 और 80-88 लाइनों की जांच करें। pastebin.com/W9XSYwMJ
seequ

@ सीग - बहुत बढ़िया; धन्यवाद! पुरानी आदतों को तोड़ना कठिन है;
रॉबर्ट फ्रेजर
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.