ध्वनि समारोह

Question

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

नोट: आप PHP में शामिल फ़ंक्शन या अन्य प्रोग्रामिंग भाषाओं में समकक्ष का उपयोग नहीं कर सकते soundex()हैं।

उदाहरण:

WASHINGTON W-252
LEE L-000
GUTIERREZ G-362
PFISTER P-236 
JACKSON J-250 
TYMCZAK T-522
VANDEUSEN V-532
ASHCRAFT A-261

Answer 1

पर्ल, 143 150 वर्ण

sub f{$_="$_[0]000";/./;$t=$&;s/(?<=.)[HW]//g;s/[BFPV]+/1/g;s/[CGJKQSXZ]+/2/g;s/[DT]+/3/g;s/L+/4/g;s/[MN]+/5/g;s/R+/6/g;s/(?<=.)\D//g;/.(...)/;"$t$1"}

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

एक ही संस्करण लेकिन थोड़ा अधिक पठनीय:

sub f{
  $_="$_[0]000";        # take first argument and append "000"
  /./;$t=$&;            # save first char to variable $t
  s/(?<=.)[HW]//g;      # remove and H or W but not the first one
  s/[BFPV]+/1/g;        # replace one or more BFPV by 1
  s/[CGJKQSXZ]+/2/g;    # replace one or more CGJKQSXZ by 2
  s/[DT]+/3/g;          # replace one or more DT by 3
  s/L+/4/g;             # replace one or more L by 4
  s/[MN]+/5/g;          # replace one or more MN by 5
  s/R+/6/g;             # replace one or more R by 6
  s/(?<=.)\D//g;        # remove and non-digit from the result but not the first char
  /.(...)/;"$t$1"       # take $t plus the characters 2 to 4 from result
}

संपादन 1: अब समाधान एक फ़ंक्शन के रूप में लिखा गया है। पिछला वाला / STDIN / STDOUT को / से लिख रहा था। यह मेरे चारों ओर काम करने के लिए सात वर्ण हैं।

Answer 2

ईटीएक्स, 377।

\let\E\expandafter
\def\x#1;#2#3{\def\s##1#2{##1\s#3}\edef\t{\s#1\iffalse#2\fi}\E\x\t;}
\def\a[#1#2]{\if{{\fi\uppercase{\x#1,#2};B1F1P1V1C2G2J2K2Q2S2X2Z2D3T3L4M5N5R6A7E7I7O7U7
    H{}W{}Y{}{11}1{22}2{33}3{44}4{55}5{66}6{{}\toks0\bgroup}!}\E\$\t0000!#1}}
\def\$#1,#2{\if#1#2\relax\E\%\else\E\%\E#2\fi}
\def\%{\catcode`79 \scantokens\bgroup\^}
\def\^#1#2#3#4!#5{\message{#5#1#2#3}\end}
\E\a

के रूप में चलाएँ etex filename.tex [Ashcraft]।

Answer 3

पायथन, 274 285 241 235 225 200 190 183 179 174 166 161

- फिक्स्ड अंतिम क्लॉज (एच या डब्ल्यू व्यंजन विभाजक के रूप में)। आश्कासन का अब सही परिणाम है। - मेड dict छोटे - फॉर्मेटिंग छोटा होता है (अजगर 2.6 की आवश्यकता नहीं है) - के लिए सरल dict खोज k से बदल स्वर मूल्य - '*'करने के लिए ''और .appendकरने के लिए +=[i] करने के लिए निकाला गया कॉल - सूची समझ FTW - upper: डी

मैं किसी भी आगे गोल्फ नहीं कर सकता। वास्तव में मैंने किया। अब मुझे लगता है कि मैं किसी भी आगे गोल्फ नहीं कर सकता! दोबरा किया...

अनुवाद तालिका का उपयोग करना:

def f(n):z=n.translate(65*'_'+'#123#12_#22455#12623#1_2#2'+165*'_').replace('_','');return n[0]+(''.join(('',j)[j>'#']for i,j in zip(z[0]+z,z)if i!=j)+'000')[:3]

पुरानी सूची समझ कोड:

x=dict(zip('CGJKQSXZDTLMNRBFPV','2'*8+'3345561111'))
def f(n):z=[x.get(i,'')for i in n if i not in'HW'];return n[0]+(''.join(j for i,j in zip([x.get(n[0])]+z,z)if i!=j)+'000')[:3]

पुराना कोड:

x=dict(zip('CGJKQSXZDTLMNRBFPV','2'*8+'3345561111'))
def f(n):
 e=a=[];k=n[0]in x
 for i in[x.get(i,'')for i in n.upper()if i not in'HW']:
  if i!=a:e+=[i]
  a=i
 return n[0]+(''.join(e)+'000')[k:3+k]

परीक्षा:

[f(i) for i in ['WASHINGTON', 'LEE', 'GUTIERREZ', 'PFSTER', 'JACKSON',
                'TYMCZAK', 'VANDEUSEN', 'ASHCRAFT']]

देता है:

['W252', 'L000', 'G362', 'P236', 'J250', 'T522', 'V532', 'A261']

जैसा सोचा था।

Comments

महान। आपको इनपुट को अपरकेस में बदलने की आवश्यकता नहीं है; आप मान सकते हैं कि यह पहले से ही है।

— प्लीजस्टैंड

»मैं किसी भी आगे गोल्फ नहीं कर सकता« उन शब्दों शायद ही कभी उपयुक्त हैं :-)

— जॉय

@ जॉय पायथन कोड गोल्फ के लिए सबसे अच्छी भाषा नहीं है ... अगर केवल पर्ल के रूप में प्रथम श्रेणी का

— रेग्ज था

यह बहुत लंबे समय तक पहचान करने वालों से अधिक, imho से ग्रस्त है। आमतौर पर मैं पाइथन को पॉवरशेल से हरा सकता हूं, लेकिन सूची की समझदारी को हरा देना मुश्किल है।

— जॉय

@ जॉय अब आपको पावरशेल के साथ पायथन को हराने के लिए थोड़ा और काम करना होगा: पी

— जर्नार्डो

Answer 4

पर्ल, 110

sub f{$_="$_[0]000";/./;$t=$&;s/(?<=.)[HW]//g;y/A-Z/:123:12_:22455:12623:1_2:2/s;s/(?<=.)\D//g;/.(...)/;$t.$1}

मैं अपनी अनुवाद तालिका के साथ हावर्ड के समाधान का उपयोग कर रहा हूं ( y/A-Z/table/sहर के बजाय s/[ABC]+/N/g)

Answer 5

जे - ९९

{.,([:-.&' '@":3{.!.0[:(#~1,}.~:}:)^:#,@(;:@]>:@I.@:(e.&>"0 _~)[#~e.))&'BFPV CGJKQSXZ DT L MN R'@}.

परिक्षण:

  sndx=: {.,([:-.&' '@":3{.!.0[:(#~1,}.~:}:)^:#,@(;:@]>:@I.@:(e.&>"0 _~)[#~e.))&'BFPV CGJKQSXZ DT L MN R'@}.
  test=: ;: 'JACKSON PFISTER TYMCZAK GUTIERREZ ASHCRAFT ASHCROFT VANDEUSEN ROBERT RUPERT RUBIN WASHINGTON LEE'
  (,. sndx&.>) test


+-------+-------+-------+---------+--------+--------+---------+------+------+-----+----------+----+
|JACKSON|PFISTER|TYMCZAK|GUTIERREZ|ASHCRAFT|ASHCROFT|VANDEUSEN|ROBERT|RUPERT|RUBIN|WASHINGTON|LEE |
+-------+-------+-------+---------+--------+--------+---------+------+------+-----+----------+----+
|J250   |P123   |T520   |G362     |A261    |A261    |V532     |R163  |R163  |R150 |W252      |L000|
+-------+-------+-------+---------+--------+--------+---------+------+------+-----+----------+----+

Answer 6

गोल्फस्क्रिप्ट (74 वर्ण)

यह कार्यान्वयन एक जादुई स्ट्रिंग का उपयोग करता है जिसमें गैर-मुद्रण योग्य वर्ण होते हैं। में xxdउत्पादन रूप यह है

0000000: 7b2e 313c 5c5b 7b36 3326 2741 4c15 c252  {.1<\[{63&'AL..R
0000010: d056 4c1e 8227 3235 3662 6173 6520 3862  .VL..'256base 8b
0000020: 6173 653d 7d25 7b2e 373d 2432 243d 7b3b  ase=}%{.7=$2$={;
0000030: 7d2a 7d2a 5d31 3e31 2c2d 5b30 2e2e 5d2b  }*}*]1>1,-[0..]+
0000040: 333c 7b2b 7d2f 7d3a 533b                 3<{+}/}:S;

3-बिट संख्याओं की सूची को संपीड़ित करने के लिए आधार परिवर्तनों का उपयोग किए बिना, यह होगा

{.1<\[{63&[1 0 1 2 3 0 1 2 7 0 2 2 4 5 5 0 1 2 6 2 3 0 1 7 2 0 2]=}%{.7=$2$={;}*}*]1>1,-[0..]+3<{+}/}:S;

ऑनलाइन टेस्ट

यह मूल रूप से उबाऊ छोरों का एक गुच्छा है, लेकिन एक दिलचस्प चाल है:

.7=$2$=

यह एक तह के अंदर है जिसका उद्देश्य दोहरे अक्षरों को संभालना है। समान कोड वाले आसन्न अक्षरों को एक इकाई में विलय कर दिया जाता है, भले ही Ha या a के द्वारा अलग किया गया हो W। लेकिन यह स्ट्रिंग से सभी Hएस और Wएस को हटाकर तुच्छ रूप से लागू नहीं किया जा सकता है , क्योंकि (वास्तव में वास्तविक जीवन में संभावना नहीं है, लेकिन कल्पना से इंकार नहीं किया गया है) मामला है कि पहला अक्षर है Hया Wदूसरा अक्षर एक व्यंजन है , जब हम पहले अक्षर को हटाते हैं तो हमें उस व्यंजन के साथ नहीं होना चाहिए। (मैंने एक परीक्षण मामला जोड़ा WMजो इसे W500जांचने के लिए देना चाहिए )।

तो जिस तरह से मैं संभालता हूं कि एक गुना करना है और पहले के अलावा प्रत्येक अक्षर को हटाना है (गुना का उपयोग करने का एक सुविधाजनक साइड-इफ़ेक्ट) जो कि पिछले एक के बराबर या उसके बराबर है 7, के लिए आंतरिक कोड Hऔर W।

दिया aऔर bस्टैक पर, यह जांचने का भोला तरीका है कि क्या a == b || b == 7होगा

.2$=1$7=+

लेकिन एक संगणित प्रतिलिपि-से-स्टैक का उपयोग करके 2-वर्ण की बचत है:

.7=$

अगर bबराबर है 7तो वह नकल करता है a; अन्यथा यह कॉपी करता है b। तो फिर साथ तुलना करके aहम एक गारंटीकृत truthy मूल्य प्राप्त करता है, तो bथा 7की मूल्य की परवाह किए बिना a। (इससे पहले कि कोई भी पेड वजन में हो, गोल्फस्क्रिप्ट में NaN नहीं है)।

Answer 7

पॉवरशेल, 150 161

पहले कोशिश करो और मुझे यकीन है कि वहाँ थोड़ा और अधिक गोल्फ हो सकता है।

filter s{$s=-join$_[1..9]
1..6+'$1','',$_[0]|%{$s=$s-replace('2[bfpv]2[cgjkqsxz]2[dt]2l2[mn]2r2(.)\1+2\D|^.2^'-split2)[++$a],$_}
-join"${s}000"[0..3]}

लिंक किए गए पृष्ठ और विकिपीडिया लेख दोनों से परीक्षण मामलों के साथ सही ढंग से काम करता है:

जैक्सन, पिफिस्टर, टायमबैक, गुटिएरेज़, ऐशक्राफ्ट, एशक्रॉफ्ट, वैनड्यूसेन, रॉबर्ट, रूपर्ट, रुबिन, वाशिंगटन, ली

Answer 8

रूबी 140

मैं रूबी 2.0 का उपयोग कर रहा हूं, लेकिन मुझे लगता है कि इसे पहले के संस्करणों के साथ भी काम करना चाहिए।

def f s
a=s[i=0]
%w(HW BFPV CGJKQSXZ DT L MN R).each{|x|s.gsub!(/[#{x}]+/){i>0&&$`[0]?i: ''};i+=1}
a+(s[1..-1].gsub(/\D/,'')+'000')[0,3]
end

उदाहरण:

puts f "PFISTER" => P236

Answer 9

एपीएल (83)

{(⊃⍵),,/⍕¨3↑0~⍨1↓K/⍨~K=1⌽K←0,⍨{7|+/' '=S↑⍨⍵⍳⍨S←' BFPV CGJKQSXZ DT L MN R'}¨⍵~'HW'}⍞