28

यहाँ लक्ष्य बस एक स्ट्रिंग को उल्टा करना है, एक मोड़ के साथ: एक
ही स्थानों में पूंजीकरण रखें।

उदाहरण इनपुट 1: Hello, Midnightas
उदाहरण आउटपुट 1:SathginDim ,olleh

उदाहरण इनपुट 2: .Q
निर्गमन आउटपुट 2:q.

नियम :

एसटीडी के लिए आउटपुट, एसटीडीआईएन से इनपुट
विजेता को 13 जुलाई को GMT + 3 12:00 (एक सप्ताह) में चुना जाएगा
इनपुट में केवल ASCII प्रतीक शामिल हो सकते हैं, यह उन कार्यक्रमों के लिए आसान बनाता है जो किसी भी एन्कोडिंग का उपयोग नहीं करते हैं जिसमें गैर-ASCII वर्ण शामिल हैं।
किसी भी स्थिति में समाप्त होने वाले किसी भी विराम चिह्नों को अनदेखा किया जाना चाहिए।

code-golf string

यह है कि या outprinting के बिना? स्ट्रिंग के साथ या उसके बिना है?

"किसी भी स्थिति में समाप्त होने वाले किसी भी विराम चिह्नों को अनदेखा किया जाना चाहिए।" , इस नियम के साथ दूसरा उदाहरण असंगत नहीं है?

— स्टेफानो सैनफिलिपो

यह नियम के अनुरूप है क्योंकि विराम चिह्न में अपरकेस भिन्नता नहीं है।

7

टीसीसी - 4 बाइट्स

<>ci

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

स्पष्टीकरण:

     - output is implicit in TCC
<>   - reverse string
  c  - preserve capitalization
   i - get input

— brianush1
स्रोत

9

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

— डेनिस

16

पायथन, 71 बाइट्स

lambda s:''.join((z*2).title()[c.isupper()-1]for c,z in zip(s,s[::-1]))

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

Ruud से -3 बाइट्स, और 2 और के लिए प्रेरणा।

FryAmTheEggman से -4 और बाइट्स

— मै जाऊं
स्रोत

lambda s:''.join([z.lower(),z.upper()][c.isupper()]for c,z in zip(s,s[::-1]))तीन बाइट्स छोटी है

— एर्फी

1

@Rudud धन्यवाद! सूची चयन के बाहर फ़ंक्शन कॉल को स्थानांतरित करने से 2 और बचते हैं!

— Mego

2

(z*2).title()[c.isupper()-1]कार्य करना चाहिए।

— FryAmTheEggman

6

आप ~c.isupper()इसके बजाय एक और बाइट जीत सकते हैंc.isupper()-1

— लूलह

यह

— स्टडआउट

13

पायथन 2, 73 बाइट्स

चूंकि नियम निर्दिष्ट करते हैं इनपुट ascii है:

lambda s:''.join([z.lower,z.upper]['@'<c<'[']()for c,z in zip(s,s[::-1]))

सारा श्रेय हालांकि @Mego को जाता है, लेकिन मुझे उनके जवाब पर टिप्पणी करने की प्रतिष्ठा नहीं थी।

— Lulhum
स्रोत

क्या आप 2 बाइट हासिल करने के लिए '@' और '[' की एससीआई वैल्यू का उपयोग कर सकते हैं?

— aloisdg

दुर्भाग्य से नहीं, मुझे ऑर्ड (सी), पूर्णांक और स्ट्रिंग की तुलना पायथन में बहुत अच्छी तरह से सामना नहीं करना होगा

— लूलह

बहुत कुछ जो मुझे मिला, लेकिन आप पहली बार +1

— orlp

13

पर्ल, 31 + 2 ( `-lp`) = 33 बाइट्स

यह समाधान @ टॉन हास्पेल (13 बाइट्स से छोटा थाट मेरा) से है।

s%.%(lc$&gt$&?u:l)."c chop"%eeg

लेकिन आपको जरूरत होगी lऔर pस्विच ऑन करने की। इसे चलाने के लिए:

perl -lpe 's%.%(lc$&gt$&?u:l)."c chop"%eeg'

— बापू
स्रोत

5

नमस्कार, और PPCG में आपका स्वागत है! यह भी खूब रही!

— NoOneIsHere

वाकई बहूत बढिया! मैंने कभी भी -aऑटोसप्लिट का उपयोग नहीं किया है , मुझे लगता है कि मैं इसे अतीत में कई बार इस्तेमाल कर सकता था! मुझे याद है कि जरूरत है! मुझे लगता है कि आप map...,...इसके बजाय एक और बाइट का उपयोग कर सकते हैं map{...}...जैसा कि आपके पास $Fशुरू में है! :)

— डोम हेस्टिंग्स

शॉर्टर कोड (31 + 2 बाइट्स):perl -lpe 's%.%(lc$&gt$&?u:l)."c chop"%eeg

— टोन हास्पेल

सूचना है कि -aद्वारा निहित है-F

— टन Hospel

@ टोनहोस्ट वाह, बहुत बहुत धन्यवाद और अच्छा काम किया, यह कुछ बहुत अच्छा कोड है! के बारे में -aऔर -n) द्वारा गर्भित होने के बारे में -F, मैंने इसे कुछ समय पहले पेरलुन पर पढ़ा था, कोशिश की थी, लेकिन यह काम नहीं किया; लेकिन मैंने इसे फिर से आजमाया और यह ठीक काम करता है इसलिए मैं अनुमान लगा रहा हूं कि मैंने कुछ गलत किया था। धन्यवाद।

— दादा

9

पायथ, 13 11 10 9 बाइट्स

@FryAmTheEggman के बारे में Vऔर दूसरी बाइट के लिए @LeakyNun की याद दिलाने के लिए धन्यवाद ।

srV_Qm!/G

इसे ऑनलाइन आज़माएं! _{अब मोबाइल पर, लिंक को थोड़ा अपडेट कर रहा है}

— PurkkaKoodari
स्रोत

srV_Qm!rId011 है, लेकिन मुझे लगता है कि उस नक्शे को छोटा करना संभव हो सकता है ...

— FryAmTheEggman

@FryAmTheEggman निकालें dऔर आपने एक बाइट को बचाया।

— लीक नन

srV_Qm!/Gएक बाइट बचाना चाहिए

— लीक नून

8

पायथन, 66 बाइट्स

f=lambda s,i=0:s[i:]and(s[~i]*2).title()[~('@'<s[i]<'[')]+f(s,i+1)

सूचकांकों के माध्यम से पीछे से iचरित्र लेता है s[~i]और s[i]सामने से मामला । पूंजी होने के नाते सन्निहित सीमा में झूठ के रूप में जाँच की जाती है @ABC...XYZ[। (_*2).title()ट्रिक से FryAmTheEggman को क्रेडिट ।

— XNOR
स्रोत

5

रेटिना , 75 67 65 बाइट्स

बाइट गिनती आईएसओ 8859-1 एन्कोडिंग मानती है।

$
±·$`
O$^`\G[^·]

s{T`L`l`±.
T01`l`L`±.*·[A-Z]
±·

±(.)
$1±
·.
·

इसे ऑनलाइन आज़माएं! (पहली पंक्ति कई लाइनफीड-अलग-अलग परीक्षण मामलों के साथ एक परीक्षण सूट को सक्षम करती है।)

— मार्टिन एंडर
स्रोत

5

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

s=>[...t=s.toLowerCase()].reverse().map((c,i)=>s[i]==t[i]?c:c.toUpperCase()).join``

संपादित करें: @ edc65 के लिए एक बड़े पैमाने पर 12 बाइट्स को सहेजा गया।

— नील
स्रोत

।। एस => r = [... एल = s.toLowerCase ()] रिवर्स () मानचित्र ((ग, मैं) => रों [i] = एल [i] c.toUpperCase ():!? ग) .join`` -10

— edc65

@ edc65 धन्यवाद! (नोट: r=अनावश्यक है।)

— नील

5

पाइके, 11 10 9 बाइट्स

_FQo@UhAl

यहाँ यह कोशिश करो!

_         -   reversed(input)
 F        -  for i in ^
   o      -      o+=1
  Q @     -     input[^]
     Uh   -    ^.is_upper()+1
       Al -   [len, str.lower, str.upper, ...][^](i)
          - "".join(^)

— नीला
स्रोत

इसने पहले मुझे एक त्रुटि दी, फिर उसी समय सही उत्तर। i.imgur.com/uTcH27F.png

ऐसा हमेशा होता है, आप उसे बंद करने के लिए अक्षम चेतावनी पर क्लिक कर सकते हैं।

— ब्लू

अहा, ठीक है। क्षमा करें, मैं Pyke के साथ अच्छा नहीं हूं

हो सकता है क्योंकि मैं इसका इस्तेमाल करने वाला एकमात्र व्यक्ति हूं

— ब्लू

4

05AB1E , 19 16 15 13 बाइट्स

3 बाइट बचाने के लिए Emigna को धन्यवाद !

शायद जेली द्वारा हरा दिया जा रहा है ... कोड:

Âuvy¹Nè.lil}?

CP-1252 एन्कोडिंग का उपयोग करता है । इसे ऑनलाइन आज़माएं! ।

— अदनान
स्रोत

S.l_v¹lRNèyiu}?1 बाइट छोटा है

— Emigna

@Emigna वाह धन्यवाद! यह बहुत चालाक है।

— अदनान

Âuvy¹Nè.lilë}?है 14. बस खुश मैं एक बार के लिए आपकी मदद कर सकता हूँ :)

— Emigna

@Emigna यह अद्भुत है! बाइफ़रसेट का बहुत अच्छा उपयोग :)।

— अदनान

Ruvy¹Nè.lil}?वास्तव में। मैंने द्विभाजन का उपयोग नहीं किया और दूसरे को निकालना भूल गया। तो 13.

— एमिग्ना जूल

4

MATL , 13 बाइट्स

PktGtk<)Xk5M(

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

Pk      % Implicit inpput. Flip, lowercase
t       % Duplicate
Gtk<    % Logical index of uppercase letters in the input string
)       % Get letters at those positions in the flipped string
Xk      % Make them uppercase
5M(     % Assign them to the indicated positions. Implicit display

— लुइस मेंडो
स्रोत

3

जे , 30 बाइट्स

(={"_1 toupper@]|.@,.])tolower

गैर- ASCII का समर्थन नहीं करता है

— मील की दूरी पर
स्रोत

"टॉपर" "टोलवर" आप इसे छोटा करने के लिए कोड बिंदुओं का उपयोग नहीं कर सकते हैं?

— लीक नून

@LeakyNun शायद, लेकिन मैं वास्तव में यकीन के लिए नहीं कह सकता

— मील की दूरी

3

ब्रेकीलॉग , 28 बाइट्स

@lr:?z:1ac.
h@u.,@A@um~t?|h.

व्याख्या

मुख्य विधेय:

@lr                 Reverse the lowercase version of the Input
   :?z              Zip that reversed string with the Input
      :1a           Apply predicate 1 to each couple [char i of reverse, char i of Input]
         c.         Output is the concatenation of the result

1 समर्पित करें:

h@u.,               Output is the uppercase version of the first char of Input
     @A@um~t?       The second char of Input is an uppercase letter
             |      Or
              h.    Output is the first char of Input

— Fatalize
स्रोत

3

TSQL, 175 बाइट्स

golfed:

DECLARE @ varchar(99)='Hello, Midnightas'

,@o varchar(99)='',@i INT=0WHILE @i<LEN(@)SELECT
@i+=1,@o+=IIF(ascii(x)=ascii(lower(x)),lower(y),upper(y))FROM(SELECT
SUBSTRING(@,@i+1,1)x,SUBSTRING(@,len(@)-@i,1)y)z
PRINT @o

Ungolfed

DECLARE @ varchar(99)='Hello, Midnightas'

,@o varchar(99)=''
,@i INT=0

WHILE @i<LEN(@)
  SELECT @i+=1,@o+=IIF(ascii(x)=ascii(lower(x)),lower(y),upper(y))
  FROM
    (SELECT SUBSTRING(@,@i+1,1)x,SUBSTRING(@,len(@)-@i,1)y)z

PRINT @o

बेला

— t-clausen.dk
स्रोत

इनपुट को हार्डकोड करना?

— बिल्ली

@cat ही एकमात्र रास्ता है। Sql में, कोई STDIN या इनपुट कमांड नहीं है। यदि आप स्टैकओवरफ़्लो को देखते हैं कि कैसे सभी प्रश्नों को हल किया जाता है - आप कोडगॉल्फ पर मेरे अन्य उत्तरों को भी देख सकते हैं

— t-clausen.dk

ओह, हाँ, मुझे निश्चित रूप से याद है कि यह वार्तालाप SQL उपयोगकर्ता से पहले (आप, हो सकता है)। यह अजीब है, लेकिन ठीक होना चाहिए।

— बिल्ली

1

@ हमें इस बातचीत से पहले नहीं मिला है, लेकिन आपने पहले एक बाइट गिनती के साथ मेरी मदद की थी

— t-clausen.dk

3

दरअसल, 25 बाइट्स

;`úíuY"ùû"E£`M@ùRZ`i@ƒ`MΣ

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

स्पष्टीकरण:

;`úíuY"ùû"E£`M@ùRZ`i@ƒ`MΣ
;                          create a copy of the input
 `úíuY"ùû"E£`M             for each character in input:
  úíuY                       0-based index in lowercase English letters, or -1 if not found, increment, boolean negate (1 if uppercase else 0)
      "ùû"E£                 `û` if the character is lowercase else `ù` (str.lower vs str.upper)
              @ùRZ         make the other copy of the input lowercase, reverse it, and zip it with the map result
                  `i@ƒ`M   for each (string, function) pair:
                   i@ƒ       flatten, swap, apply (apply the function to the string)
                        Σ  concatenate the strings

— Mego
स्रोत

3

Haskell, 83 80 75 71 bytes

The most straightforward way I could think of.

import Data.Char
f a|isUpper a=toUpper|1>0=toLower
zipWith f<*>reverse

— flawr
स्रोत

If you swap the parameters of (#), k can be rewritten in point-free style: k=reverse>>=zipWith(#), that saves a couple bytes :)

— Flonk

The second line can be point-free in b as f a|isUpper a=toUpper|1>0=toLower, though this conflicts with Flonk's improvement.

— xnor

You can use xnor's version of f and rewrite Flonk's k to zipWith f<*>reverse.

— nimi

Don’t you need to eliminate the parameter s?

— Lynn

Yes, and you're also allowed to cut the k=.

— xnor

3

PowerShell, 154, 152, 99, 86 bytes

Thank you @TimmyD for saving me a whopping 47 bytes (I also saved an additional 6)

Thank you @TessellatingHeckler for saving an additional 13 bytes.

Latest:

param($a)-join($a[$a.length..0]|%{("$_".ToLower(),"$_".ToUpper())[$a[$i++]-in65..90]})

Original:

param($a);$x=0;(($a[-1..-$a.length])|%{$_=$_.tostring().tolower();if([regex]::matches($a,"[A-Z]").index-contains$x){$_.toupper()}else{$_};$x++})-join''

Normal formatting:

Latest (looks best as two lines in my opinion):

param($a)
-join($a[$a.length..0] | %{("$_".ToLower(), "$_".ToUpper())[$a[$i++] -in 65..90]})

Explanation:

param($a)-join($a[$a.length..0]|%{("$_".ToLower(),"$_".ToUpper())[$a[$i++]-in65..90]})
param($a)
# Sets the first passed parameter to variable $a
         -join(                                                                      )
# Converts a char array to a string
               $a[$a.length..0]
# Reverses $a as a char array
                               |%{                                                  }
# Shorthand pipe to foreach loop
                                  ("$_".ToLower(),"$_".ToUpper())
# Creates an array of the looped char in lower and upper cases
                                                                 [$a[$i++]-in65..90]
# Resolves to 1 if the current index of $a is upper, which would output "$_".ToUpper() which is index 1 of the previous array

Original:

param($a)
$x = 0
(($a[-1..-$a.length]) | %{
    $_ = $_.tostring().tolower()
    if([regex]::matches($a,"[A-Z]").index -contains $x){
            $_.toupper()
        }else{
            $_
        }
        $x++
    }
) -join ''

First time poster here, was motivated because I rarely see PowerShell, ~~but at ~~154~~ 152 bytes on this one... I can see why!~~ Any suggestions appreciated.

I have learned that I must completely change my way of thinking to golf in code and its fun!

— ThePoShWolf
स्रोत

Hello, and welcome to PPCG! This is great!

— NoOneIsHere

PPCG में आपका स्वागत है! यहाँ आसपास एक और PowerShell उपयोगकर्ता को देखकर अच्छा लगा। आप .tostring()उद्धरणों के साथ बदलकर और रेगेक्स के बजाय ASCII पूर्णांक हेरफेर का उपयोग करके काफी कम कटौती कर सकते हैं । निम्न प्रयास करें, 105 बाइट्स के लिए - param($a)-join($a[$a.length..0]|%{if(($x=$a[$i++])-le90-and$x-ge65){"$_".ToUpper()}else{"$_".ToLower()}})।

— AdmBorkBork

प्रतिभाशाली! हम -le और -ge के बजाय एक रेंज का उपयोग करके इसे और भी छोटा बना सकते हैं:param($a)-join($a[$a.length..0]|%{if(65..90-contains$a[$i++]){"$_".ToUpper()}else{"$_".ToLower()}})

— ThePoShWolf

X-inYकी तुलना में कम है Y-containsX, और आप 86 बाइट पाने के ifलिए नकली टर्नरी ऑपरेटर के लिए अपने को बदल सकते हैं -param($a)-join($a[$a.length..0]|%{("$_".ToLower(),"$_".ToUpper())[$a[$i++]-in65..90]})

— TessellatingHeckler

यार, मुझे ऐसा लगता है कि मैंने बहुत सी ट्रिक्स को याद किया है, जिनके पहले कभी कोड नहीं हुआ था। यह लगभग सभी को फिर से कोड करने के लिए सीखने की तरह है!

— thePoShWolf

2

दिल्लोग एपीएल , 12 बाइट्स

⌽f¨⍨⊢≠f←819⌶

819⌶ मामला तह समारोह है

f←क्योंकि इसका नाम लंबा है, हम इसे f से असाइन करते हैं

⊢≠f बूलियन जहां पाठ निचले आवरण वाले पाठ से भिन्न होता है

f¨⍨ प्रत्येक अक्षर को मोड़ने के लिए उपयोग करें (1 का मतलब अपरकेस, 0 का मतलब लोअरकेस) ...

⌽ ... उलटा पाठ

यूनिकोड कंसोर्टियम के नियमों के अनुसार गैर-एएससीआईआई संभालती है।

— एडम
स्रोत

2

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

q_W%.{el\'[,65>&{eu}&}

इसका परीक्षण यहां करें।

— मार्टिन एंडर
स्रोत

2

रैकेट, 146 बाइट्स

(λ(s)(build-string(string-length s)(λ(n)((if(char-upper-case?(string-ref s n))char-upcase char-downcase)(list-ref(reverse(string->list s))n)))))

रैकेट इस पूरी "गोल्फिंग" चीज़ पर बुरा है।

श्रग हमेशा की तरह, इसे छोटा करने के साथ किसी भी मदद की बहुत सराहना की जाएगी।

— स्टीवन एच।
स्रोत

5

रैकेट / स्कीम में गोल्फ के लिए टिप्स

— बिल्ली

2

जोल्फ, 21 बाइट्स

यहाँ यह कोशिश करो!

Μid?&γ._pXiS=pxHHpxγγ

व्याख्या

Μid?&γ._pXiS=pxHHpxγγ
Μid                   (Μ)ap (i)nput with (d)is fucntion:
   ?        =pxHH     (H is current element) if H = lowercase(H)
    &γ._pXiS          and set γ to the uppercase entity in the reversed string
                 pxγ  lowercase γ
                    γ else, return γ

— कोनोर ओ ब्रायन
स्रोत

(d)is function... गोल्फ की खातिर बलिदान की वर्तनी!

— स्टीवन एच।

2

पर्ल 6 , 29 बाइट्स

$_=get;put .flip.samecase($_)

— ब्रैड गिल्बर्ट b2gills
स्रोत

2

सी #, 86 85 बाइट्स

s=>string.Concat(s.Reverse().Select((c,i)=>s[i]>96?char.ToLower(c):char.ToUpper(c)));

एसी # लैम्ब्डा जहां इनपुट और आउटपुट एक स्ट्रिंग है। आप इसे .NetFiddle पर आज़मा सकते हैं ।

मैं यह समझने के लिए संघर्ष कर रहा हूं कि मैं इसे करने के char.ToLower(c)लिए क्यों नहीं प्राप्त कर सकता हूं c+32। मुझे इसे ठीक करने की उम्मीद है!

12 बाइट्स ने @PeterTaylor को धन्यवाद दिया ( c|3232 को ascii मान जोड़ने के लिए cऔर c&~3232 को बदलने के लिए)। परिणाम 72 बाइट्स होगा (लेकिन गैर अल्फा चार पर विफल हो सकता है)।

s=>string.Join("",s.Reverse().Select((c,i)=>(char)(s[i]>96?c|32:c&~32)));

— aloisdg का कहना है कि मोनिका को बहाल करें
स्रोत

1

इसके c|32बजाय यह होगा c+32, लेकिन यह गैर-अल्फा वर्णों के साथ काम नहीं करेगा।

— पीटर टेलर

@PeterTaylor यह बहुत अच्छा काम करता है! धन्यवाद!

— aloisdg

1

PHP, 128 बाइट्स

$s=$argv[1];$l=strrev($s);for($i=0;$i<strlen($s);++$i){echo(strtolower($s[$i])!==$s[$i]?strtoupper($l[$i]):strtolower($l[$i]));}

मैं इसे और अधिक अनुकूलित करने का प्रयास कर सकता हूं, लेकिन मैं इसे अभी के लिए छोड़ दूंगा।

— MonkeyZeus
स्रोत

1

ऑक्टेव, 51 50 बाइट्स

~~@(s)merge(isupper(s),b=flip(toupper(s)),tolower(b))~~

@(s)merge(s>64&s<91,b=flip(toupper(s)),tolower(b))

— मार्को
स्रोत

1

वीआईएम, 46 बाइट्स

यह तीन बाइट्स होगा g~Gअगर हमें स्टड से पढ़ने या stdout को लिखने की ज़रूरत नहीं थी, लेकिन ओह ठीक है ...

vim -es '+normal! g~G' '+%print|q!' /dev/stdin

इसका परीक्षण करने के लिए, दौड़ें

echo "testString" | vim -es '+normal! g~G' '+%print|q!' /dev/stdin

यहाँ मेरा यह पहला सबमिशन है, यकीन नहीं तो इस तरह का सबमिशन स्वीकार्य है।

— DoYouEvenCodeBro
स्रोत

अच्छा, मैं विम में गोल्फ प्यार करता हूँ! हालाँकि, यह प्रोग्राम वास्तव में स्ट्रिंग को उल्टा नहीं करता है, यह केवल पूंजीकरण को बढ़ा देता है। आप स्ट्रिंग को उल्टा कर सकते हैं :se ri<cr>C<C-r>"लेकिन फिर आपको यह पता लगाना होगा कि सही अक्षरों को कैसे कैपिटल किया जाए।

— डीजेमेक्मे

@DrGreenEggsandIronMan ओह यार मैं पूरी तरह से चूक गया! ड्रॉइंग बोर्ड पर वापस!

— DoYouEvenCodeBro 14

1

जावास्क्रिप्ट (बाहरी पुस्तकालय का उपयोग करके) (224 बाइट्स)

(s)=>{t=_.From(s);var cnt=t.Count();var caps=t.Select(x=>{return x.toUpperCase()===x&&x.toLowerCase()!==x}).ToArray(),i=-1;return t.AggregateRight((a,b)=>{i++;var c=caps[i];return c?a+b.toUpperCase():a+b.toLowerCase()},"");}

अस्वीकरण: एक पुस्तकालय का उपयोग करते हुए मैंने जावास्क्रिप्ट के लिए C # का LINQ लाने के लिए लिखा

— applejacks01
स्रोत

एक स्पष्टीकरण के बिना इसको कम करने वाले व्यक्ति को बाहर बुला रहा है। उसका कोई कारण?

— सेबजैक 01

यह संभावना है कि वे चाहते थे कि आप पुस्तकालय को भी गिनें, हालांकि बाहरी पुस्तकालय का उपयोग पूरी तरह से मानक नीति की सीमाओं के भीतर है।

— Addison Crump

1

मैं नीच नहीं हूं, लेकिन यदि आप बाहरी पुस्तकालय का उपयोग कर रहे हैं, तो कम से कम अपने उत्तर में नाम का उल्लेख करें, और अस्पष्ट पुस्तकालय के लिए, कृपया रिपॉजिटरी का लिंक प्रदान करें।

— n --h'a̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳

1

सेड, 113 + 1 = 114 बाइट्स

क्यूं कर? क्योंकि गलत का उपयोग करना मजेदार है चीजों टूल का : पी

उपयोग: भागो sed -rf file, पाठ दर्ज करें और Ctrl+ D(ईओएफ भेजें) दबाएँ ।

golfed:

s/[A-Z]/\a\l&/g;s/^.*$/\f&\v/;:x;s/\f\a/\a\f/;s/\a\v/\v\a/;s/\f(.)(.*)(.)\v/\3\f\2\v\1/;tx;s/\f|\v//g;s/\a./\U&/g

Ungolfed:

s/[A-Z]/\a\l&/g #Prepend all upper-case letters with a 
                #BEL ASCII character and make them lowercase
s/^.*$/\f&\v/   #Wrap text between a from feed (\f) and a vertical tab (\v)
                #These are used as markers

:x #Define a label named x

s/\f\a/\a\f/;s/\a\v/\v\a/ #Move BEL characters outside of the boundary, so they're not moved later
s/\f(.)(.*)(.)\v/\3\2\1/  #This part does the switching itself
                          #It grabs a character preceded by a form feed and another 
                          #one followed by a vertical tab and swaps them, while keeping the text in-between
                          #and replaces the marker \f and \v

tx             #Conditional jump (t) to label x
               #Jumps to the label x if the last substitution (s command) was successful 
s/\f|\v//g     #Delete markers
s/\a(.)/\u\1/g #Make letters preceded by a BEL upper-case

— someonewithpc
स्रोत

1

जावा 7, 221 217 180 बाइट्स

void c(char[]s){int x=0,y=s.length-1;for(char t;x<y;s[x]=s(t,s[y]),s[y]=s(s[y],t),x++,y--)t=s[x];}char s(char a,char b){return(char)(64<a&a<91?96<b&b<123?b-32:b:64<b&b<91?b+32:b);}

@LeakuNun के दृष्टिकोण के लिए बाइट्स के भार ने बचत की ।

अनगढ़ और परीक्षण के मामले:

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

class Main{
  void c(char[] s){
    int x = 0,
        y = s.length-1;
    for(char t; x < y; s[x] = s(t, s[y]),
                       s[y] = s(s[y], t),
                       x++,
                       y--){
       t = s[x];
    }
  }

  char s(char a, char b){
    return (char)(64 < a & a < 91
                    ? 96 < b & b < 123
                        ? b-32
                        : b
                    : 64 < b & b < 91
                        ? b+32
                        : b);
  }

  public static void main(String[] a){
    print("Hello, Midnightas");
    print("TEST");
    print("test");
    print("Test");
    print(".,..,,!@");
    print("ABCDefgHijklMNOPqrsTuVWxyz");
    print("AbCdEfGHIJKlmnop123");
  }

  static void print(String s){
    char[] t = s.toCharArray();
    c(t);
    System.out.println(t);
  }
}

आउटपुट:

SathginDim ,olleh
q.
TSET
tset
Tset
@!,,..,.
ZYXWvutSrqpoNMLKjihGfEDcba
321pOnMLKJIhgfedcba

— केविन क्रूज़सेन
स्रोत

आप इनपुट और आउटपुट कर सकते हैं char[]।

— लीक नन

@LeakyNun वास्तव में मैं (विश्वास करता हूं) कम मात्रा में बाइट्स नहीं कर सकता। यह बाइट्स को हटाने String a="";और बदलने के o+=लिए अनुमति देगा 0[i]=, लेकिन जावा में एक चरित्र .toUpperCase()/ .toLowerCase()विधि नहीं है, और चार से स्ट्रिंग में परिवर्तित करना, ऊपरी / निचले विधि का उपयोग करना, और फिर वापस चार में फिर से (बहुत) की आवश्यकता होगी बाइट्स। लेकिन लिंक किए गए विचारधारा को कांटा करने के लिए स्वतंत्र महसूस करें और char[]कम बाइट्स में काम करने के लिए कुछ के साथ आएं ।

— केविन क्रूज़सेन

1

180 बाइट्स जो आगे गोल्फ हो सकते हैं (इसे जगह में संशोधित नहीं करके)।

— लीक नन

0

सी

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main(int argc, char *argv[])
{
  char *a,*b,*c;

  a=c=strdup(argv[1]);
  b=&argv[1][strlen(a)-1];
  for(;*a;a++,b--){
    *a=(*a>='A'&&*a<='Z')?((*b>='a'&&*b<='z')?*b-32:*b):((*b>='A'&&*b<='Z')?*b+32:*b);
  }
  puts(c);
  free(c);
  return 0;
}

— user56095
स्रोत

स्टड से इनपुट लिया जाना चाहिए।

— अनमोल सिंह जग्गी

जैसा कि यह कोड-गोल्फ है कृपया बाइट की संख्या में डाल दें, इस कार्यक्रम की लागत होगी।

मैं नियमों के आधार पर इसे काफी कम कर सकता था, लेकिन मुझे कोई नियम नहीं मिले।

— उपयोगकर्ता 56095

समान स्थानों में पूंजीकरण को बनाए रखते हुए एक स्ट्रिंग को उल्टा करें

टीसीसी - 4 बाइट्स

पायथन, 71 बाइट्स

पायथन 2, 73 बाइट्स

पर्ल, 31 + 2 ( -lp) = 33 बाइट्स

पायथ, 13 11 10 9 बाइट्स

पायथन, 66 बाइट्स

रेटिना , 75 67 65 बाइट्स

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

पाइके, 11 10 9 बाइट्स

05AB1E , 19 16 15 13 बाइट्स

MATL , 13 बाइट्स

जे , 30 बाइट्स

ब्रेकीलॉग , 28 बाइट्स

व्याख्या

TSQL, 175 बाइट्स

दरअसल, 25 बाइट्स

Haskell, 83 80 75 71 bytes

PowerShell, 154, 152, 99, 86 bytes

दिल्लोग एपीएल , 12 बाइट्स

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

रैकेट, 146 बाइट्स

जोल्फ, 21 बाइट्स

व्याख्या

पर्ल 6 , 29 बाइट्स

सी #, 86 85 बाइट्स

PHP, 128 बाइट्स

ऑक्टेव, 51 50 बाइट्स

वीआईएम, 46 बाइट्स

जावास्क्रिप्ट (बाहरी पुस्तकालय का उपयोग करके) (224 बाइट्स)

सेड, 113 + 1 = 114 बाइट्स

जावा 7, 221 217 180 बाइट्स

पर्ल, 31 + 2 ( `-lp`) = 33 बाइट्स