दुनिया एड में समाप्त होती है

21

एसीएम विंटर प्रोग्रामिंग कॉन्टेस्ट 2013 से सीधे लिया गया। आप एक ऐसे व्यक्ति हैं जो सचमुच चीजों को लेना पसंद करते हैं। इसलिए, आपके लिए, द वर्ल्ड का अंत एड है; "द" और "वर्ल्ड" के अंतिम अक्षर संक्षिप्त किए गए।

एक प्रोग्राम बनाएं जो एक वाक्य लेता है, और उस वाक्य में प्रत्येक शब्द के अंतिम अक्षर को जितना संभव हो उतना कम जगह (कुछ सबसे कम बाइट) आउटपुट करता है। शब्द कुछ भी के साथ अलग हो जाते हैं लेकिन वर्णमाला से अक्षर (65 - 90, 97 - 122 ASCII टेबल पर।) इसका मतलब है कि अंडरस्कोर, टिल्ड, कब्र, घुंघराले ब्रेस, आदि विभाजक हैं। प्रत्येक शब्द के बीच एक से अधिक विभाजक हो सकते हैं।

asdf jkl;__zxcv~< vbnm,.qwer| |uiop-> flvmrp
pigs, eat dogs; eat Bob: eat pigs-> ststbts
looc si siht ,gnitirw esreveR-> citwR
99_bottles_of_beer_on_the_wall->sfrnel

code-golf  string 
— beary605
स्रोत
क्या आप अंक और अंडरस्कोर सहित एक परीक्षण मामला जोड़ सकते हैं?
— GRC
10
दुनिया एड में समाप्त होती है? मैं जानता था कि विम और Emacs को माप नहीं सकते हैं!
— जो जेड।
ठीक है, "असली पुरुष एड का उपयोग करते हैं" निबंध एमएसीएस वितरण का हिस्सा रहा है, जब तक कि मुझे याद है।
— जेबी
क्या इनपुट केवल ASCII के होंगे?
— फिल एच।

जवाबों:

16

पर्ल 5, 18 बाइट्स

s/\pL*(\pL)|./$1/g

एक -pकमांड लाइन स्विच की आवश्यकता है। नामित संपत्ति Lकेवल अक्षर अक्षर से मेल खाती है A-Za-z। ऐसे कई सौ नामित गुण हैं, लेकिन जब ASCII पाठ से निपटते हैं, तो उनमें से बहुत कम दिलचस्प होते हैं। इसके अलावा \pL, किसी भी वास्तविक नोट का केवल एक ही अन्य है \pP, जो विराम चिह्न से मेल खाता है।

इसे ऑनलाइन आज़माएं!

पर्ल 5, 17 बाइट्स

डोम हेस्टिंग्स द्वारा एक बाइट सुधार

print/\pL*(\pL)/g

आवश्यकता है -n(और-l कई आदानों का समर्थन करने के लिए)।

इसे ऑनलाइन आज़माएं!

नमूना उपयोग

$ more in.dat
asdf jkl;__zxcv~< vbnm,.qwer| |uiop
pigs, eat dogs; eat Bob: eat pigs
looc si siht ,gnitirw esreveR
99_bottles_of_beer_on_the_wall

$ perl -p ends-in-ed.pl < in.dat
flvmrp
ststbts
citwR
sfrnel
— Primo
स्रोत
मुझे लगता है कि \wअंक और अंडरस्कोर भी मेल खाते हैं।
— gr
हम्म, वास्तव में। जिसे अपडेट करना होगा।
— प्रिमो
2
प्रतिभाशाली। रेगेक्स एक स्पष्ट समाधान |.था , लेकिन स्पष्ट नहीं था (मेरे लिए, कम से कम)।
— पीटर टेलर
1
बस एक -1में देखा print/\pL*(\pL)/g, अपने परीक्षण के मामलों के लिए एक ही उत्पादन लगता है!
— डोम हेस्टिंग्स
18

एड, 35 अक्षर

s/[a-zA-Z]*\([a-zA-Z]\)\|./\1/g
p
Q

तो, दुनिया एड में समाप्त होती है। जैसा कि मुझे बहुत शाब्दिक होना पसंद है, मैंने एड के साथ समाधान लिखने के लिए लिखने का फैसला किया - और जाहिर है कि यह वास्तव में एक प्रोग्रामिंग भाषा है । यह आश्चर्यजनक रूप से छोटा है, यहां तक ​​कि कई छोटे समाधानों पर विचार करना इस धागे में पहले से मौजूद है। यह अच्छा होगा यदि मैं इसके अलावा कुछ और उपयोग कर सकता हूं [a-zA-Z], लेकिन एड को एक प्रोग्रामिंग भाषा नहीं माना जाता है, यह वास्तव में काफी अच्छा है।

पहले, मैं यह कहना चाहूंगा कि केवल फ़ाइल में अंतिम पंक्ति पार्स होती है। यह संभव है कि अधिक पार्स करें, बस टाइप करें, दो पहली लाइनों की शुरुआत में करें (यह निर्दिष्ट "सब कुछ" रेंज, जैसा कि मानक अंतिम लाइन रेंज के विपरीत है), लेकिन इससे कोड आकार 37 अक्षरों तक बढ़ जाएगा।

अब स्पष्टीकरण के लिए। पहली पंक्ति बिल्कुल वही करती है जो पर्ल समाधान करता है (यूनिकोड वर्णों के समर्थन के बिना)। मैंने पर्ल समाधान की नकल नहीं की है, मैंने संयोग से कुछ ऐसा ही आविष्कार किया है।

दूसरी पंक्ति अंतिम पंक्ति प्रिंट करती है, जिससे आप आउटपुट देख सकते हैं। तीसरी पंक्ति के बलों ने छोड़ दिया - मुझे यह करना होगा, अन्यथा edप्रिंट होगा? आपको याद दिलाने के लिए कि आपने फ़ाइल को सहेजा नहीं है।

अब इसे कैसे निष्पादित किया जाए। खैर, यह बहुत आसान है। edमेरे केस को पाइप करते हुए, टेस्ट केस वाले फाइल के साथ ही दौड़ें ।

ed -s testcase < program

-sचुप है। यह edशुरुआत में बदसूरत फ़ाइल आकार के आउटपुट से रोकता है। आखिरकार, मैं इसे एक स्क्रिप्ट के रूप में उपयोग करता हूं, संपादक नहीं, इसलिए मुझे मेटाडेटा की आवश्यकता नहीं है। अगर मैं ऐसा नहीं करता, तो एड फ़ाइल का आकार दिखाएगा जिसे मैं अन्यथा नहीं रोक सकता।

— कोनराड बोरोस्की
स्रोत
मैंने सिर्फ यह कोशिश करने के लिए एड इंस्टॉल किया है।
— प्रिमो
6

जावास्क्रिप्ट, ४ ९

alert(prompt().replace(/.(?=[a-z])|[^a-z]/gi,''))

यह एक अक्षर से पहले आने वाले सभी वर्णों को हटाने के लिए एक नियमित अभिव्यक्ति का उपयोग करता है, साथ ही सभी गैर-अक्षर वर्ण भी। फिर हम प्रत्येक शब्द के अंतिम अक्षर को छोड़ देते हैं।

के लिए धन्यवाद tomsmeding एक अच्छा सुधार के लिए।

— gRC
स्रोत
3
आप शायद रेगेक्स के मामले को असंवेदनशील बनाकर इसमें सुधार कर सकते हैं, जैसे:alert(prompt().replace(/.(?=[a-z])|[^a-z]/gi,''))
— tomsmeding
6

सी, 78

golfed:

main(int c,char**s){for(;c=*s[1]++;)isalpha(c)&&!isalpha(*s[1])?putchar(c):0;}

व्हॉट्सएप के साथ:

main(int c,char**s)
{
  for(;c=*s[1]++;)
    isalpha(c)&&!isalpha(*s[1])?putchar(c):0;
}

आउटपुट:

enter image description here

— JoeFish
स्रोत
1
K & R घोषणा और चूक का उपयोग करके आप 4 बाइट्स बचा सकते हैं c:main(c,s)char**s;{for
— Toby Speight
5

जीएनयू सैड, 40 38 37

s/[a-z]\b/&\n/g; s/[^\n]*\(.\)\n/\1/g

परिक्षण

cat << EOF > data.txt
asdf jkl;__zxcv~< vbnm,.qwer| |uiop
pigs, eat dogs; eat Bob: eat pigs
looc si siht ,gnitirw esreveR
EOF

भागो sed:

sed 's/[A-Za-z]\b/&\n/gi; s/[^\n]*\(.\)\n/\1/g' data.txt

आउटपुट:

flvmrp
ststbts
citwR

व्याख्या

पहला प्रतिस्थापन सभी शब्द सीमाओं को प्रतिस्थापित करता है, जो वांछित मैच समूह द्वारा एक नई-पंक्ति के साथ पहले होते हैं। इससे दूसरे प्रतिस्थापन में सभी बाहरी पात्रों को निकालना आसान हो जाता है।

संपादित करें

  • केस-असंवेदनशील ध्वज (-2) का उपयोग करें, धन्यवाद मैनटवर्क ।
  • व्हॉट्सएप (-1) की गिनती न करें।
— थोर
स्रोत
sedके sआदेश है iमामलों असंवेदनशील मिलान के लिए झंडा: s/[a-z]\b/&\n/gi।
— मैनेटवर्क
@manatwork: अच्छी बात है, यह इसे केवल GNU सेड बनाता है, लेकिन ऐसा लगता है कि यह पहले से ही है, धन्यवाद।
— थोर
\bविचार _करने वाले अक्षर हैं, इसलिए यदि परीक्षण में कोई भी शब्द END के साथ है _, तो उस शब्द का अंतिम अक्षर आउटपुट में शामिल नहीं है
— मार्टी नील
3

ग्रीप एंड पेस्ट, ३६ ३४ २,

> echo 'asdf jkl;__zxcv~< vbnm,.qwer| |uiop' | grep -io '[a-z]\b' | tr -d \\n
flvmrp

> echo 'pigs, eat dogs; eat Bob: eat pigs'   | grep -io '[a-z]\b' | tr -d \\n
ststbts

echo 'looc si siht ,gnitirw esreveR'         | grep -io '[a-z]\b' | tr -d \\n
citwR

यदि एक अंतिम नई-लाइन की आवश्यकता है, तो tr -d \\nसाथ बदलें paste -sd ''।

संपादित करें

  • केस-असंवेदनशील grep (-2) का उपयोग करें, धन्यवाद मैनटवर्क ।
  • (-4) के trबजाय उपयोग करें paste, धन्यवाद मैनटवर्क ।
  • पाइप (-2) के आसपास व्हॉट्सएप की गिनती न करें।
— थोर
स्रोत
इसके साथ काफी रचनात्मक है paste -sd '', लेकिन tr -d \\nकम है। इसके बारे में grep, इसका -iस्विच अर्थ "अनदेखा मामला" है, जो इसे छोटा कर सकता है grep -io '[a-z]\b':।
— मैनेटवर्क
@manatwork, trअंतिम न्यूलाइन को भी हटा दें। केस असंवेदनशील मोड बेशक छोटा है, धन्यवाद।
— थोर
अंतिम न्यूलाइन की आवश्यकता वाला कोई नियम नहीं है।
— मैनेटवर्क
@manatwork: मैं इससे सहमत हूं, अद्यतन जवाब।
— थोर
3

sed, 37 वर्ण

थोर के जवाब के बराबर लंबाई , लेकिन, मुझे लगता है, सरल।

s/[a-z]*\([a-z]\)/\1/ig;s/[^a-z]*//ig

तर्क काफी तुच्छ है - अपने पिछले पत्र के साथ पत्र अनुक्रमों को बदलें, फिर सभी गैर-पत्रों को हटा दें।

— ugoren
स्रोत
3

गणितज्ञ, ३ ९

""<>StringCases[#,(__~~x_)?LetterQ:>x]&

परीक्षा:

""<>StringCases[#,(__~~x_)?LetterQ:>x]& /@
 {"asdf jkl;__zxcv~< vbnm,.qwer| |uiop",
  "pigs, eat dogs; eat Bob: eat pigs",
  "looc si siht ,gnitirw esreveR",
  "99_bottles_of_beer_on_the_wall"}

{"flvmrp", "ststbts", "citwR", "sfrnel"}
— Mr.Wizard
स्रोत
अच्छा था। LetterQबुलाया जाना चाहिए LettersQ:) मैंने पूरे तार के परीक्षण के लिए इसके बारे में नहीं सोचा है।
— डॉ। बेलिसियस
@ काबिलिसियस दरअसल, इस निर्माण के साथ इसे चरित्र-वार लागू किया जाता है, इसलिए यह एक शाब्दिक "लेटरक्यू" हो सकता है और फिर भी काम कर सकता है।
— श्री। छिपकली २ Mr
2

के, ४ ९

{last'f@&"b"$#:'f:"|"\:@[x;&~x in,/.Q`a`A;:;"|"]}

।

k){last'f@&"b"$#:'f:"|"\:@[x;&~x in,/.Q`a`A;:;"|"]}"asdf jkl;__zxcv~< vbnm,.qwer| |uiop"
"flvmrp"
k){last'f@&"b"$#:'f:"|"\:@[x;&~x in,/.Q`a`A;:;"|"]}"pigs, eat dogs; eat Bob: eat pigs"
"ststbts"
k){last'f@&"b"$#:'f:"|"\:@[x;&~x in,/.Q`a`A;:;"|"]}"looc si siht ,gnitirw esreveR"
"citwR"
— tmartin
स्रोत
2

स्काला, 59 (या 43)

पहले से ही में स्ट्रिंग मानते हुए s:

s.split("[^a-zA-Z]+").map(_.last).mkString

आपको एक संदेश मिलता से पढ़ सकते हैं और आरईपीएल उत्पादन, परिवर्तित उपयोग करने के बजाय मुद्रित करने के लिए की जरूरत है sके लिए readLineऔर में लपेट println()59 के लिए।

— रेक्स केर
स्रोत
2

x86: 54 बाइट्स

हस्ताक्षर के साथ एक सीडीसीएल दिनचर्या मान लें void world_end(char *input, char *output):

60 8b 74 24 24 8b 7c 24 28 33 d2 8a 0e 8a c1 24
df 3c 41 72 08 3c 5a 77 04 8a d1 eb 09 84 d2 74
05 88 17 47 33 d2 46 84 c9 75 e0 84 d2 74 03 88
17 47 88 0f 61 c3
— user1354557
स्रोत
1
वैसे, मुझे एहसास है कि सवाल एक कार्यक्रम के लिए पूछता है और दिनचर्या नहीं है , लेकिन मैं कुछ अलग करना चाहता था। समस्या कथन के विपरीत, मुझे लगता है कि मैं एक "व्यक्ति नहीं हूं जो चीजों को सचमुच लेना पसंद करता है"। : पी
— user1354557
2

शी, ३२

println$ @{=>.-1}<>input re"\W+"

शी अभी भी अपने बीटा चरण में एक भाषा है, लेकिन यह कोड गोल्फ के साथ अच्छी तरह से काम करने लगता है इसलिए मुझे लगा कि मैं अभी तक एक और छोटा और कार्यात्मक समाधान दिखा सकता हूं (और भाषा थोड़ी सी विज्ञापित करता हूं)।

— arshajii
स्रोत
2

Mathematica 62 57 52

Row@StringTake[StringCases[#,LetterCharacter..],-1]&

Testing

l = {"asdf jkl;__zxcv~<vbnm,.qwer| |uiop", 
     "pigs,eat dogs;eat Bob:eat pigs", 
     "looc si siht,gnitirw esreveR"}

Row@StringTake[StringCases[#,LetterCharacter..],-1]&/@ l
(*{flvmrp,ststbts,citwR}*)
— Dr. belisarius
स्रोत
I mistakenly edited yours, but then rolled it back. Ooops.
— DavidC
2

Python3, 59 chars

import re;print(re.sub('.(?=[a-z])|[^a-z]','',input(),0,2))

Correctly deals with capital letters and underscores. The 2 is to pass re.sub the re.IGNORECASE flag without having to use re.I.

— Nolen Royalty
स्रोत
2

Python, 76 chars

import re;print "".join(re.findall("([a-zA-Z])(?=$|[^a-zA-Z])",raw_input()))

— indrajeet
स्रोत
You can remove the space after print.
— flornquake
Shorten by porting to Python 3: import re;print(*re.findall("([a-zA-Z])(?=$|[^a-zA-Z])",input()),sep='')
— Steven Rumbalski
1

Python 3.x, 64 bytes

import re;print(''.join(a[-1] for a in re.split('\W+',input())))
— Michael0x2a
स्रोत
2
The last example is not working. Also, an error occurs if the line begins or ends with a separator
— AMK
You can remove the space before for.
— Bakuriu
1

Mathematica 71 47 45 61

Back to the drawing board, after @belisarius found an error in the code.

StringCases[#, RegularExpression["[A-Za-z](?![A-Za-z])"]] <> "" &

Testing

l = {"asdf jkl;__zxcv~<vbnm,.qwer| |uiop", "asdf jkl__zxcv~<vbnm,.qwer| |uiop", 
"pigs,eat dogs;eat Bob:eat pigs", "looc si siht,gnitirw esreveR"};

StringCases[#, RegularExpression["[A-Za-z](?![A-Za-z])"]] <> "" & /@ l

{"flvmrp", "flvmrp", "ststbts", "citwR"}

— DavidC
स्रोत
\\w matches _, so it doesn't work for (for example) "asdf jkl__zxcv~<vbnm,.qwer| |uiop"
— Dr. belisarius
Wait Row@StringTake[ StringCases[#, LetterCharacter ..], -1] &@"asdf jkl__zxcv~<vbnm,.qwer| |uiop" gives me flvmrp, but #~StringCases~RegularExpression@"\\w\\b" <> "" &@"asdf jkl__zxcv~<vbnm,.qwer| |uiop" returns fvmrp here. Are we getting the same results??
— Dr. belisarius
@belisarius You were right about the error in my earlier version. I was testing it with the wrong string!
— DavidC
Hehe , +1 again
— Dr. belisarius
@belisarius guys, please see the answer I posted. If it is correct it's shorter.
— Mr.Wizard
1

Python 2, 88 80 75 69 68

s=p=''
for c in raw_input()+' ':a=c.isalpha();s+=p[a:];p=c*a
print s

Input: 435_ASDC__uio;|d re;fG o55677jkl..f

Output: CodeGolf

This solution can be shortened to 67 characters if you allow the output to include backspace characters (ASCII code 8) at the beginning. The output will be visually identical.

s=p='<BS>'
for c in raw_input()+p:a=c.isalpha();s+=p[a:];p=c*a
print s

Same input, (visually) same output. <BS> is meant to be the backspace character.

— flornquake
स्रोत
1

C#

Method, 105 bytes: (assumes usings for System, System.Text.RegularExpressions and System.Linq)

string R(string i){return string.Concat(Regex.Split(i,"[^a-zA-Z]").Where(x=>x!="").Select(n=>n.Last()));}

Program, 211 bytes:

using System;using System.Text.RegularExpressions;using System.Linq;class A{static void Main(){Console.WriteLine(string.Concat(Regex.Split(Console.ReadLine(),"[^a-zA-Z]").Where(x=>x!="").Select(n=>n.Last())));}}
— It'sNotALie.
स्रोत
1

VBA, 147 161

Sub a(s)
For n=0 To 255:m=Chr(n):s=Replace(s,IIf(m Like"[A-Za-z]","",m)," "):Next
For Each r In Split(s," "):t=t & Right(r,1):Next
MsgBox t
End Sub
— Gaffi
स्रोत
1

Ruby 2.0, 25 (+1) chars

gsub(/(\w+)\W*/){$1[-1]}

Must be run with the -p switch:

 $ ruby -p ed.rb <<< "asdf jkl;__zxcv~< vbnm,.qwer| |uiop"
flvmrp
— daniero
स्रोत
Please specify the ruby version. 1.9.2 outputs “#<Enumerator:0x9f65e10>#<Enumerator:0x9f65d98>#<Enumerator:0x9f65d34>#<Enumerator:0x9f65cd0>”.
— manatwork
You're right. I had completely forgotten that I installed it, but my current Ruby version is 2.0 (ruby 2.0.0p0 (2013-02-24 revision 39474). When running the program with version 1.8.7 it outputs an ASCII value! Didn't know there were so many differences between the versions.
— daniero
Thanks, will definitely have to update my Ruby. (Both the interpreter and the knowledge.) The second capturing group is not necessary: gsub(/(\w+)\W*/){$1[-1]}.
— manatwork
Oh, of course it's not. Thanks, updated :)
— daniero
1

Retina, 16 bytes

Li, -1|""`[a-z]+

Try it online!

Explanation

Li, -1|""`[a-z]+
L         [a-z]+        List all the sequences of letters in the input
 i                      case insensitive
  ,                     Keep all the results
    -1                  but only the last character for each of them
      |""               Use the empty string as separator
— Leo
स्रोत
1

Java 8, 43 bytes

s->s.replaceAll("(?i).(?=[a-z])|[^a-z]","")

Port of @mbomb007's Retina answer.

Explanation:

Try it online.

s->  // Method with String as both parameter and return-type
  s.replaceAll("(?i).(?=[a-z])|[^a-z]","")
     //  Remove every match of this regex, and return as result

Additional explanation for the regex:

"(?i).(?=[a-z])|[^a-z]"  // Main regex to match
 (?i)                    //  Case insensitive
     .                   //   Any character
      (?=[a-z])          //   Followed by a letter (as positive look-ahead)
               |[^a-z]   //   or a non-letter

""                       // Replace it with: nothing
— Kevin Cruijssen
स्रोत
1
That's actually (?i) for the flag.
— Jakob
0

Smalltalk, Squeak/Pharo flavour
122 char with traditional formatting for this method added to String:

endOfWords
    ^(self subStrings: (CharacterSet allCharacters select: #isLetter) complement) collect: #last as: String

62 chars in Pharo 1.4, with regex and weird formatting

endOfWords^''join:(self regex:'[a-zA-Z]+'matchesCollect:#last)
— aka.nice
स्रोत
0

J: 60 characters (or 38 characters for a less correct version)

(#~e.&(,26&{.&(}.&a.)"0(97 65))){:&>;:]`(' '"_)@.(e.&'_:')"0

If we're willing let the program break whenever there are words ending in a colon or an underscore, then we can simplify this to 38 characters.

(#~e.&(,26&{.&(}.&a.)"0(97 65))){:&>;:

Sample run:

    (#~e.&(,26&{.&(}.&a.)"0(97 65))){:&>;:]`(' '"_)@.(e.&'_:')"0'asdf jkl;__zxcv~< vbnm,.qwer| |uiop'
flvmrp
    (#~e.&(,26&{.&(}.&a.)"0(97 65))){:&>;:]`(' '"_)@.(e.&'_:')"0'pigs, eat dogs; eat Bob: eat pigs'
ststbts
    (#~e.&(,26&{.&(}.&a.)"0(97 65))){:&>;:]`(' '"_)@.(e.&'_:')"0'99_bottles_of_beer_on_the_wall'
sfrnel
— SL2
स्रोत
1
38 Bytes (for a correct version): (#~[:2&|64 90 96 122&I.@(u:inv)){:&>;:, or 43 bytes for a non-explicit version: (#~[:2&|64 90 96 122&I.@(u:inv))@:({:@>)@;:. This uses the interval index verb, I., which interprets 64 90 96 122 as the set of intervals (__, 64] (64, 90], (90, 96], (96, 122], (122, _), and returns the index of the iterval to which its argument, the ascii code of the char, belongs. If this index is odd, it's not alphabetical.
— Bolce Bussiere
@BolceBussiere doesn’t work with underscores for some reason (last test case).
— FrownyFrog
@FrownyFrog ah, I see why, ;: interprets abc_ as one word since variable names can contain underscores. +10 bytes to add (#~~:&'_'), probably an inefficient fix
— Bolce Bussiere
@BolceBussiere that’s just '_'-.~ or something similar.
— FrownyFrog
0

It's in PHP. 197 bytes :( I'm beginner

$l=$_GET['line'];
$l=preg_replace('/(\W|_)+/',' ',$l);
$s=explode(' ',$l);
foreach($s as $d){
$a=substr($d,-1,1);
$o=ORD($a);
if(($o>=97 && $o<=122) || ($o>=65 && $o<=90)){
echo $a;
  }
}

EDITED Now it's 171 bytes

<?$l=$_GET['l'];$l=preg_replace('/(\W|_)+/',' ',$l);$s=explode(' ',$l);foreach($s as $d){$a=substr($d,-1,1);$o=ORD($a);if(($o>=97&&$o<=122)||($o>=65&&$o<=90)){echo$a;}}
— Sasori
स्रोत
1
For golf, you should as much as possible reduce your variable names to single characters at the very least.
— Gaffi
1
edited it.Thanks for telling me.I'm new here.
— Sasori
Sure. You may also want to look here for some additional PHP-specific help.
— Gaffi
foreach((' ',preg_replace('/(\W|_)+/',' ',$_GET['line'])) as $d){$a=substr($d,-1,1);$o=ORD();if(($o>=97 && $o<=122) || ($o>=65 && $o<=90)){echo $a;}} is 149, if it works.
— Magic Octopus Urn
\W|_ excludes digits; so you should add \d to your regex or use /[^a-z]+/i
— Titus
0

K 30

q)k)f:{x@&-1=-':(1_x," ")in,/.Q`a`A}
q)f "asdf jkl;__zxcv~< vbnm,.qwer| |uiop"
"flvmrp"
q)f "pigs, eat dogs; eat Bob: eat pigs"
"ststbts"
q)f "looc si siht ,gnitirw esreveR"
"citwR"
q)f "99_bottles_of_beer_on_the_wall"
"sfrnel"
— rrr
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.