एक स्ट्रिंग के पहले अक्षर की सभी घटनाओं को पूरी स्ट्रिंग से निकालें


24

केवल एक इनपुट स्ट्रिंग होती है जिसमें केवल वर्ण A-Z, a-zऔर रिक्त स्थान होते हैं, स्ट्रिंग के पहले वर्ण के अपरकेस और लोअरकेस संस्करणों की सभी घटनाओं को हटा दें (यदि पहला वर्ण Aसभी As और as हटा दें , यदि पहला वर्ण है (स्थान) निकालें सभी स्थान), और आउटपुट प्रिंट करें।

उदाहरण के मामले:

  • Testing Testing One Two Three -> esing esing One wo hree
  • Programming Puzzles and Code Golf -> rogramming uzzles and Code Golf
  • How much wood would a woodchuck chuck if a woodchuck could chuck wood -> ow muc wood would a woodcuck cuck if a woodcuck could cuck wood
  • {space}hello world -> helloworld
  • welcome to WATER WORLD -> elcome to ATER ORLD

यह , बाइट्स जीत में सबसे छोटा कोड!

टिप्पणियाँ:

  • इनपुट हमेशा 2 या अधिक मान्य वर्ण का होगा।
  • आउटपुट कभी खाली स्ट्रिंग नहीं होगा।

क्या हमें उस मामले को संभालने की ज़रूरत है जहां आउटपुट खाली स्ट्रिंग है? क्या होगा अगर इनपुट खाली स्ट्रिंग है?
lirtosiast

@ThomasKwa आप मान सकते हैं कि उत्पादन 2 या अधिक वर्णों का हो जाएगा
GamrCorps

@ThomasKwa और आउटपुट कभी खाली नहीं होगा
GamrCorps

जवाबों:


9

अजगर, 7 बाइट्स

-zrBhz2

इसे ऑनलाइन आज़माएँ: प्रदर्शन या टेस्ट सूट

अच्छा लगा। नया बिफुरसेट ऑपरेटर (केवल 8 दिन पुराना) यहां एक चर को बचाने में मदद करता है। मुझे लगता है कि यह पहला कोड है, जो इस सुविधा का उपयोग करता है।

व्याख्या

-zrBhz2   implicit: z = input string
    hz    take the first character of z
  rB  2   B generates a list, containing the original char and the  
          result of r.2 applied to the char, which swaps the case
-z        remove these two chars from z and print the result 

2
नीट, उस के बारे में पता नहीं था। +1
FryAmTheEggman

14

ब्रेनफक, 219 बाइट्स

+[+[>+<+<]>],[<+<+>>-]>[<<[->]>[<]>-]++++[<++++++++>-]<<[[-]----[>-<----]>-<<[>+>+<<-]<,[[>+>>>+>>+>+<<<<<<<-]>>[<<+>>-]<<[>->+<<-]>[[-]+<]>[>]<<[>>+<<-]>>[<-<+>>-]<[[-]+>]>>[<]<<<<[>>>+<<<-]>>>-[>>.<<-]>>>[[-]<]<<<<<,]

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

यह वास्तव में बहुत आसान निकला! मुझे आश्चर्य नहीं होगा अगर यह गोल्फ है (मुझे कुछ पता है कि वहाँ बर्बाद बाइट्स हो सकते हैं लेकिन मुझे यकीन नहीं है कि यह पैन होगा)। फिर भी, यह काम करना वास्तव में एक चुनौती नहीं थी।

यह कोड 97 से ऊपर के मान के साथ सब कुछ को एक बड़े अक्षर के रूप में मानता है। यदि पहला वर्ण स्थान है, तो यह स्ट्रिंग से "लोअरकेस स्पेस" (यानी chr(32+32), @) की किसी भी घटना को हटाने का प्रयास करेगा । यह ठीक है, क्योंकि केवल पत्र और रिक्त स्थान कभी भी मौजूद होंगे।

टिप्पणियों के साथ:

to make comments shorter: everywhere it says "fc" means "first character"

#################################### GET FC ####################################

+[+[>+<+<]>]        shortest way to get 96
                    any number above 89 and less than 97 would work because this
                    is only for figuring out if the first character is capital

,[<+<+>>-]          create two copies of the first character


### current tape: | fc | fc | 000 | 096 | ###
###      pointer:              ^          ###

########################### FIND MAX(FC MINUS 96; 0) ###########################


>[                  96 times:

  <<                  go to the cell with the first char

  [->]                if not 0: sub one and move right


  ### current tape: | fc | char being worked on | 000 | 096 | ###
  ###      pointer:                           ^ OR ^          ###      


  >[<]>               collapse the wavefunction; sync the branches

-]


### current tape: | fc | fc is lowercase ? nonzero : zero | 000 | 000 | ###
###      pointer:                                                  ^    ###

############################# GET BOTH CASES OF FC #############################

++++[<++++++++>-]   get 32 (add to uppercase character to get lowercase)

<<[                 if the character is already lowercase:

  [-]                 clear the lowercase flag

  ----[>-<----]>-     sub 64 from the cell with 32

<]

<[>+>+<<-]          add fc to the 32 or minus 32 to get both cases


### current tape: | 000 | fc | other case of fc | ###
###      pointer:    ^                            ###

###################### LOOP THROUGH REMAINING CHARACTERS #######################

<,[                 for each character:

  [>+>>>+>>+>+<<<<<<<-]
                      make four copies
                      (only 3 are strictly needed; 4th will resync a branch)

  >>                  go to the first case of fc

  [<<+>>-]<<[>->+<<-] subtract one case of fc from one copy

  >[[-]+<]            if the result is nonzero set it to 1

  >[>]<<              go to the other case of fc (and resync branches)

  [>>+<<-]>>[<-<+>>-] subtract other case of fc from other copy

  <[[-]+>]            if the result is nonzero set it to 1

  >>[<]               resync branches using extra copy

  <<<<[>>>+<<<-]>>>   add results together

  -                   subtract 1

   if the character exactly matched either case: 1 plus 0 minus 1 = 0
  if the character exactly matched neither case: 1 plus 1 minus 1 = 1
    if the character exactly matched both cases: impossible

  [                   if the result is 1:

    >>.<<               output character

    -                   set cell to 0 to kill loop

  ]

  >>>[[-]<]           clean up remaining copies

  <<<<<,              get next character; or end loop if done

]

कृपया इसे बहुत नीचे गोल्फ न करें । c: मैंने इतनी मेहनत की ...
Addison Crump

13

पर्ल, 13 बाइट्स

#!perl -p
/./,s/$&//gi

शेबबैंग को एक के रूप में गिना जाता है, इनपुट को स्टड से लिया जाता है।


नमूना उपयोग

$ echo Testing Testing One Two Three | perl remove-first.pl
esing esing One wo hree

$ echo \ Testing Testing One Two Three | perl primo-remove.pl
TestingTestingOneTwoThree

अच्छा लगा। मैं इस बारे में सोच रहा था कि लिखने की ज़रूरत के कारण पर्ल शायद कितना बुरा करेगा substrलेकिन निश्चित रूप से आप बहुत बेहतर तरीके से आए थे!
हॉब्स

हैशबैंग को एक बाइट के रूप में क्यों गिना जाता है?
ज़ेरेगेस

@ स्क्रिप्ट को आवश्यक नहीं है, यदि स्क्रिप्ट के रूप में लागू किया गया है perl -p script.pl। कम से कम इस साइट पर कमांड लाइन विकल्प को प्रत्येक एक बाइट के रूप में गिना जाता है।
प्राइमो

@primo मैं देख रहा हूँ, धन्यवाद।
ज़ेरेगेस

10

सीजेएम, 8 बाइट्स

q(_32^+-

CJam दुभाषिया में इसे ऑनलाइन आज़माएं ।

यह काम किस प्रकार करता है

q        e# Read all input from STDIN.
 (       e# Shift out the first character.
  _32^   e# Push a copy and XOR its character code with 32.
         e#   For a letter, this swaps its case.
         e#   For a space, this pushes a null byte.
      +  e# Concatenate these two characters.
       - e# Remove all occurrences of both from the input string.

मैंने मूल रूप से CJam सीखने के लिए यह चुनौती बनाई थी, और मुझे XOR के बारे में कभी पता नहीं था!
GamrCorps

2
मुझे व्यक्तिगत रूप से यह आश्चर्यजनक लगता है कि किसी भी भाषा - शायद सेड के अपवाद के साथ - इस चुनौती में पर्ल को हरा सकती है।
Primo

@primo - आपने ध्यान नहीं दिया है कि CJam और / या Pyth इनमे से 99% जीतते हैं? हालांकि यह विशेष रूप से एक गोल्फ भाषा के रूप में नहीं बनाया गया है, यह देखते हुए पर्ल ने बहुत अच्छा किया।
डारेल हॉफमैन

Pyth और CJam का ऑपरेटर ओवरलोडिंग हास्यास्पद है। प्रति-वर्ण निष्कासन करने वाला माइनस (स्ट्रिंग, स्ट्रिंग) मेरे द्वारा सामना की गई किसी अन्य भाषा में एक कोर ऑपरेशन नहीं है।
शुक्राणु

@ शेपर एपीएल में एक ही बिल्ट-इन है। (इसे ~हालांकि कहा जाता है।)
डेनिस

7

पायथ, 8 बाइट्स

-zr*2hz3

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

str.titleपहले अक्षर के स्ट्रिंग को दो बार रूप में परिवर्तित करने के लिए अजगर के अजगर के संस्करण का उपयोग करता है "<Upper><Lower>"। फिर यह उस स्ट्रिंग में लगे इनपुट से प्रत्येक तत्व को हटा देता है। रिक्त स्थान ठीक काम करते हैं क्योंकि वे अप्रभावित रहते हैं str.title



5

जावास्क्रिप्ट (ईएस 6), 38 36 बाइट्स

यह उस flagsपैरामीटर पर निर्भर नहीं करता है जो मोज़िला-विशिष्ट है।

f=x=>x.replace(RegExp(x[0],'gi'),'')

कॉफीस्क्रिप्ट, 39 37 बाइट्स

एक बार के लिए यह जेएस में कॉफी की तुलना में छोटा है!

f=(x)->x.replace RegExp(x[0],'gi'),''

3
कम से कम ब्राउज़रों में मैंने कोशिश की, newवैकल्पिक है, इसलिए RegExp(x[0],'gi')कम है।
नील

4

PHP, 41 बाइट्स

एक कमांड-लाइन तर्क लेता है । PHP के लिए छोटे खुले टैग को सक्षम करने की आवश्यकता है <5.4।

<?=str_ireplace($argv[1][0],'',$argv[1]);

1
आप एक चर युक्त घोषणा करके इसे छोटा कर सकते हैं $argv[1]:<?=str_ireplace(($a=$argv[1])[0],'',$a);
बेनोइट एस्नर्ड

3

पर्ल, 27 बाइट्स

यह एक पूर्ण कार्यक्रम है, हालांकि यह सिर्फ 2 रीजैक्स पर आधारित है जो संभवतः I / O पर बाइट्स को बचाने के लिए रेटिना प्रोग्राम में कॉपी किया जा सकता है।

$_=<>;m/(.)/;s/$1//gi;print

संपादित करें: ऐसा लगता है कि -pविकल्प का उपयोग करके किसी के साथ पहले ही पिटाई हो चुकी है। ओह, और के $&बजाय का उपयोग कर $1


1
भले ही पूरे शबंग को गिना जाता है (अर्थात एक "पूर्ण" कार्यक्रम), #!perl -pअभी भी दो बाइट्स से छोटा है $_=<>;print
प्राइमो

@primo मैंने कभी भी अपने गोल्फ में किसी भी विकल्प का उपयोग नहीं किया है। मैं सिर्फ googled क्या -pविकल्प करता है। वास्तव में ऐसा कोई भी संपादन नहीं है, जिसे मैं अपने उत्तर के बिना बना सकता हूं, यह आपके लिए समान है।
PhiNotPi

3

मिंकोलंग 0.9 , 23 33 बाइट्स

किसी भी तरह से यह नहीं जीतेगा लेकिन एह, यह मजेदार है!

" Z"od0c`1c*-$I[odd0c`1c*-2c=?O].

इसे यहाँ आज़माएँ।

व्याख्या

" Z"                                 Makes it easier to uppercase
    od                               Take first character of input and duplicate
      0c`1c*-                        Uppercase if needed
             $I[               ]     Loop over the input
                odd                  Take character from input and duplicate twice
                   0c`1c*-           If it's lowercase, uppercase it.
                          0c=?       Check to see if it's equal to first character
                              O      If not, output as character
                                .    Exit

(यह कुछ किनारे के मामलों में विफल हो सकता है, जैसे कि पहला चरित्र एक प्रतीक है।)


3

TECO , 15 14 बाइट्स

पाठ का संपादन? जब संदेह में, पाठ संपादक और सुधारक का उपयोग करें!

बहुत परीक्षण और त्रुटि (ज्यादातर त्रुटि) के बाद, मुझे लगता है कि यह सबसे छोटा जेनेरिक TECO प्रोग्राम है जो काम करेगा।

0,1XA<S^EQA$-D>

या, मानव-पठनीय रूप में

0,1XA    ! Read the first character of the string into the text area of !
         ! Q-buffer A.                                                  !
<        ! Loop,                                                        !
S^EQA$   ! searching for the text in Q-buffer A in either lowercase or  !
         ! uppercase,                                                   !
-D       ! and deleting it,                                             !
>        ! until the search fails.                                      !

$ भागने की कुंजी का प्रतिनिधित्व करता है, और ^E प्रतिनिधित्व करता है अनुक्रम CTRL+ का प्रतिनिधित्व करता है E। आपके द्वारा उपयोग किए जा रहे TECO के स्वाद के आधार पर, यह इन ASCII प्रतिस्थापनों को पहचान सकता है, या यह नहीं हो सकता है।

मैनुअल के अनुसार, टीईसीओ की कुछ बोलियां इस 13-बाइट संस्करण को स्वीकार करती हैं (इसके बजाय अलग-अलग "खोज" और "डिलीट" कमांड) के बजाय एक खोज-और-हटाए गए आदेश का उपयोग करें:

0,1XA<FD^EQA$>

3

पिप, 8 बाइट्स

aR-Xa@0x

स्ट्रिंग को कमांड-लाइन तर्क के रूप में लेता है (यदि इसमें रिक्त स्थान हैं, तो उद्धृत करने की आवश्यकता होगी)। स्पष्टीकरण:

          a gets cmdline arg; x is "" (implicit)
    a@0   First character of a
   X      Convert to regex
  -       Make regex case-insensitive
aR     x  Replace all matches of that regex in a with empty string
          Autoprint (implicit)

इस समाधान में किसी भी मुद्रण योग्य ASCII वर्ण वाले स्ट्रिंग्स पर काम करने का अतिरिक्त बोनस है । ( Xऑपरेटर बैकस्लैश-कुछ भी बचता है जो अल्फ़ान्यूमेरिक नहीं है।)



3

जूलिया, 34 बाइट्स

s->replace(s,Regex(s[1:1],"i"),"")

यह एक अनाम फ़ंक्शन बनाता है जो एक स्ट्रिंग को स्वीकार करता है और एक स्ट्रिंग लौटाता है। यह इनपुट में पहले चरित्र से एक केस-असंवेदनशील नियमित अभिव्यक्ति का निर्माण करता है और एक खाली स्ट्रिंग के साथ सभी घटनाओं को प्रतिस्थापित करता है।



2

आर, 43 बाइट्स

cat(gsub(substr(s,1,1),"",s<-readline(),T))

यह एक पूर्ण कार्यक्रम है जो STDIN की एक पंक्ति को पढ़ता है और संशोधित परिणाम को STDOUT में लिखता है।

Ungolfed:

# Read a line from STDIN
s <- readline()

# Replace all occurrences of the first character with an empty
# string, ignoring case
r <- gsub(substr(s, 1, 1), "", s, ignore.case = TRUE)

# Write the result to STDOUT
cat(r)

2

रूबी, 25 बाइट्स

अनाम फ़ंक्शन:

->s{s.gsub /#{s[0]}/i,""}

पूर्ण प्राग, 29 बाइट्स:

puts gets.gsub /#{$_[0]}/i,""

2

अजगर, 61 बाइट्स (वैसे बहुत सारे)

lambda x:"".join(map(lambda y:(y.lower()!=x[0].lower())*y,x))

मुझे लगता है कि ऐसा करने के बारे में जाने का एक बेहतर तरीका है, लेकिन मैं इसे ढूंढ नहीं सकता। हटाने पर कोई विचार "".join(...)?


1
@ThomasKwa शायद आपको अपने स्वयं के उत्तर के रूप में प्रस्तुत करना चाहिए; यह मेरे जमा करने के रूप में गिनती करने के लिए खान से बहुत अलग लगता है।
कोल

@ThomasKwa छोटा करने के लिए x[0]+x[0].swapcase()
xnor

1
@ThomasKwa या, FryAmTheEggman के Pyth समाधान से चोरी, (x[0]*2).title()
xnor

@xnor हाँ, मैंने पाया कि जब मैंने कुछ घंटों पहले उनका पढ़ा था।
lirtosiast

lambda x:x.replace(x[0].upper(),'').replace(x[0].lower(),'')- 60 बाइट्स
मेगो

2

Ouroboros , 61 बाइट्स

अरे, यह C ++ से कम है! हा।

i..91<\64>*32*+m1(
)L!34*.(;Si.1+!24*(Y.@@.@=@.@32-=\@+2*.(yo

ऑरोबोरोस में, कार्यक्रम की प्रत्येक पंक्ति अपने मुंह में अपनी पूंछ के साथ एक सांप का प्रतिनिधित्व करती है। सांपों के बीच तालमेल बिठाने के लिए शेयर्ड स्टैक के साथ, पूंछ के खाने या फिर से रिसर्ज करने से कंट्रोल फ्लो पूरा होता है।

साँप १

i.इनपुट से एक चरित्र को पढ़ता है और इसे डुप्लिकेट करता है। यदि चरित्र एक बड़ा अक्षर था, अन्यथा .91<\64>*32*धक्का । आईएनजी कि चरित्र अपरकेस अक्षरों को लोवरकेस में परिवर्तित करता है जबकि लोअरकेस अक्षर और रिक्त स्थान को अपरिवर्तित छोड़ देता है। यह सब सांप 1 के ढेर पर हो रहा है, इसलिए हम अब सांप 2 को संसाधित करने के लिए साझा ढेर ( ) के लिए मूल्य को धक्का देते हैं । आखिरकार,320+m1( सांप 1 की पूंछ के अंतिम पात्र को खाता है। चूंकि वह निर्देश सूचक है, जहां सांप मर जाता है।

साँप २

)पहली बार के माध्यम से कोई प्रभाव नहीं है। साझा स्टैक खाली होने पर L!34*धक्का देता 34है, 0अन्यथा। हम तो .dup और (है कि कई अक्षर खाते हैं।

  • यदि साझा स्टैक खाली था, तो यह साँप के अंत को सही ठहराता है जब (हम बस निष्पादित करते हैं। इसलिए, नियंत्रण रेखा की शुरुआत में वापस आ जाता है, जहां )हम उन पात्रों को फिर से प्राप्त करते हैं जिन्हें हमने खाया था (पहले एक अतिरिक्त प्रतिलिपि को धक्का दिया था)34 ) और स्टैक-लंबाई परीक्षण दोहराएं।
  • यदि साझा स्टैक खाली नहीं था, तो कोई वर्ण नहीं खाया जाता है, ';' अतिरिक्त बूँदें 0, और निष्पादन जारी है:

Siसाझा स्टैक पर स्विच करता है और किसी अन्य वर्ण को इनपुट करता है। अगर वह पात्र -1 / EOF था, तो .1+!24*धक्का देता है । ईओएफ पर, 24 वर्णों को निगलता है - आईपी सहित - और सांप मर जाता है। अन्यथा, निष्पादन जारी है।240(

Yभविष्य के उपयोग के लिए 2 के स्वयं के ढेर को साझा करने के लिए साझा किए गए स्टैक के शीर्ष की एक प्रति (जो चरित्र हम अभी पढ़ते हैं) की नकल करते हैं। फिर .@@.@=@.@32-=\@+2*गणना करता है कि नया वर्ण पहले वर्ण के बराबर है या पहले वर्ण माइनस 32 के बराबर है, 2यदि ऐसा है और 0नहीं तो धक्का । हम कई पात्रों की .नकल करते हैं और (खाते हैं:

  • यदि वर्णों का मिलान होता है, तो हम सीधे सांप के सिर पर वापस जाते हैं, जहां (उन 2 पात्रों को पुन: एकत्रित करते हैं जिन्हें हमने खाया और अगले चरित्र के साथ निष्पादन किया।
  • यदि नहीं, तो हम yसांप 2 के ढेर से चरित्र को वापस oनिकालते हैं, इसे हिलाते हैं, और फिर लूप करते हैं।

इसे एक्शन में देखें


2

सी, 60 बाइट्स

n,c,d;main(){for(;read(0,&c-n,1);n=2)d-c&31&&n&&putchar(d);}

संपादित करें: एक बग फिक्स्ड जो शुरुआत में एक शून्य बाइट को मुद्रित करने का कारण बना


क्या यह भी संकलन करता है?
अब्राहम

1
हाँ। यह मेरी मशीन पर (चेतावनियों के साथ) और काम करता है। आप इस पेज पर इसका परीक्षण भी कर सकते हैं: golf.shinh.org/check.rb
xsot

हाँ यह करता है; +1
अब्राहम

2

पायथन 2, 43

lambda s:s.translate(None,(s[0]*2).title())

यह कुछ हद तक मेरे पाइथ उत्तर पर आधारित है, लेकिन यह थॉमसकेवा और एक्सनोर की कुछ टिप्पणियों से भी संबंधित है । ज्यादातर पोस्टिंग क्योंकि मैं चाहता था कि यह जवाब मौजूद है।


2

विम, 30 कीस्ट्रोक्स

क्षमा करने के लिए क्षमा करें, लेकिन मुझे कोई Vim उत्तर D नहीं दिख रहा है:

If<Right>xh@x.<Esc>"xy07|@x2|~0"xd7|@x0x

स्पष्टीकरण:

  1. If<Right>xh@x.<Esc>
    पहले चरित्र के चारों ओर एक (पुनरावर्ती) मैक्रो लिखें
    बाईं ओर चलना ( h) अगले अपठित चरित्र के बाईं ओर रहने के लिए आवश्यक है
    किसी भी चरित्र को जोड़ना ( .) अंत में दूसरे को हटाए जाने की स्थिति में आवश्यक है
  2. "xy0 मैक्रो को रजिस्टर में कॉपी करें x
  3. 7| 7 वें चरण में जाएं
  4. @x से मैक्रो को चलाएं x
  5. 2|~ पहले चार के मामले को स्विच करें (वास्तव में दूसरे स्थान पर)
  6. 0"xd7| रजिस्टर में मैक्रो को काटें x
  7. @x से मैक्रो को चलाएं x
  8. 0x स्थान-धारक को हटा दें .

1
:Dमैं हमेशा विम अपवोट करता हूँ!
DJMcMayhem


1

टीआई-बेसिक, 164 बाइट्स

TI-83 + / 84 + श्रृंखला रेखांकन कैलकुलेटर के लिए।

Input Str1
1→X
"sub(Str1,X,1→u
"ABCDEFGHIJKLMNOPQRSTUVWXYZ zyxwvutsrqponmlkjihgfedcba
u+sub(Ans,54-inString(Ans,u),1
For(X,2,length(Str1
If 2<inString(Ans+Str1,u
Ans+u
End
sub(Ans,3,length(Ans)-2

TI-BASIC स्पष्ट रूप से नौकरी के लिए गलत उपकरण है।

  • इसमें वर्णों को हटाने की आज्ञा नहीं है, इसलिए हमें स्ट्रिंग के माध्यम से लूप करने की आवश्यकता है और यदि वे हटाए जाने वाले चीज़ों से मेल नहीं खाते हैं, तो वे पात्रों को जोड़ सकते हैं।
  • यह खाली तारों का समर्थन नहीं करता है, इसलिए हमें हटाए जाने वाले दो अक्षरों के साथ स्ट्रिंग शुरू करने की आवश्यकता है, अंत में आउटपुट का निर्माण करें, और पहले दो वर्णों को काट दें।
  • इसमें केस-परिवर्तन कमांड नहीं है, इसलिए हमें पूरे वर्णमाला को हार्डकोड करने की आवश्यकता है ...
    • दो बार ...
    • क्या मैंने TI-BASIC एन्कोडिंग में लोअरकेस अक्षरों में से प्रत्येक में दो बाइट्स का उल्लेख किया था?

मुझे 100% यकीन नहीं है, लेकिन मैंने इस पर छह घंटे बिताए हैं, और यह सबसे कम संभव समाधान है।

गैर-अपरकेस इनपुट (या इसे अपने कैलकुलेटर में टाइप करने के लिए) के साथ इसका परीक्षण करने के लिए AsmPrgmFDCB24DEC9, सामग्री के साथ एक अलग कार्यक्रम बनाएं , और Asm([whatever you named it]लोअरकेस टाइपिंग मोड को सक्षम करने के लिए इसका उपयोग करें।



1

आम लिस्प, 77

(princ(let((x(read-char)))(remove-if(lambda(y)(char-equal x y))(read-line))))

इन लंबे फ़ंक्शन नामों (और कोष्ठक) को शाप दें (लेकिन मैं अभी भी उन्हें वैसे भी प्यार करता हूं: (3)))।


1

सी, 65 61 बाइट्स

main(c,v)char**v;{for(c=**++v;*++*v;**v-c&31&&putchar(**v));}

चेतावनियों के साथ संकलन। से स्ट्रिंग पढ़ता है argv[1]ऑनलाइन उदाहरण


1
आप छोटा कर सकते हैं main(int c,char**v)करने के लिए main(c,v)char**v;, और (**v-c)%32करने के लिए **v-c&31
डेनिस

1

सी ++, 100 99 98 बाइट्स

#include<ios>
int main(){for(int c,f=getchar();~(c=getchar());)tolower(c)-tolower(f)&&putchar(c);}

100 से नीचे पाने के लिए बस एक और बाइट। getchar()रिटर्न -1जब धारा के अंत को पढ़ता है, तो इसलिए यह चक्र ~में forहै। ( ~-1 == 0)

Ungolfed

#include <ios>
int main()
{
    for (int c, f = getchar(); ~(c = getchar()); )
        tolower(c) - tolower(f) && putchar(c);
}

के &&putchar(c)बजाय आप का उपयोग नहीं कर सकते ?putchar(c):0?
नील

@ नील धन्यवाद, अब मैं 100 बाइट के नीचे हूँ!
Zereges

@ThomasKwa बेशक, मैं कर सकता हूँ, धन्यवाद।
ज़ेरेगेस

1
क्या आप f-c&31सी उत्तर में कर सकते हैं ?
lirtosiast

1

AppleScript, 209 201 बाइट्स

मेरी एकमात्र सांत्वना यह है कि मैंने ब्रेनफक को हराया।

एक सेट (प्रदर्शन संवाद "" डिफ़ॉल्ट उत्तर "") का पाठ वापस आ गया
किसी वर्ण के नंबर पर n सेट करें
"ओ" पर सेट करें
दोहराना n
यदि चरित्र n = का वर्ण नहीं है तो 1 को एक वर्ण n & o में सेट करें
n से n में सेट करें -1
समाप्त
ओ

यह कैसे काम करता है कि मैं इनपुट लेता हूं a, इसकी लंबाई प्राप्त करता हूं aऔर इसे चिह्नित करता हूं n, और आउटपुट चर सेट करता हूं o। प्रत्येक वर्ण के लिए जो मुझे लगता है कि इसमें पहला वर्ण नहीं है ( a's character 1), मैं इसे संक्षिप्त करता हूं o। अंतिम पंक्ति प्रिंट o

नोट: यह स्वचालित रूप से सभी यूनिकोड का समर्थन करता है। सी:


3
My only consolation is that I beat Brainfuck.ऐसा लगता है कि मैं बेहतर गोल्फ प्राप्त करूंगा;)
भूमिगत

1

रेटिना , 16 बाइट्स

i`(.)(?<=^\1.*)

कोड को अनुगामी लाइनफ़ीड के साथ सहेजें और -sध्वज के साथ चलाएँ ।

यह कैसे काम करता है: अनुगामी लाइनफीड यह एक प्रतिस्थापन चरण बनाता है, जैसे कि दिए गए रेगेक्स के किसी भी मैच को एक खाली स्ट्रिंग के साथ बदल दिया जाता है। iकेस-संवेदी मोड जो भी backreferences केस-संवेदी बनाता है पर बदल जाता है। अंत में, रेगेक्स बस एक ही अक्षर से मेल खाता है और कैप्चर करता है और फिर जाँचता है कि स्ट्रिंग में पहला वर्ण बैकर का उपयोग करके समान (केस के लिए) है या नहीं।

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.