बिल्ली का बच्चा कमान

65

बिल्ली का बच्चा बिल्ली की तरह होता है। कुछ मुख्य अंतर क्यूटनेस, बुद्धिमत्ता की कमी और आकार के हैं। इसी तरह, catकमांड कमांड से अलग है kitten। सौभाग्य से, इस मामले में केवल एक अंतर है। बिल्ली के बच्चे की कमान में, सभी बड़े अक्षरों को लोअरकेस अक्षरों से बदल दिया जाता है।

उद्देश्य

ऐसे कार्यक्रम को लागू करने के लिए जो समान व्यवहार करता है cat। सभी वर्ण [A-Z]लोअरकेस आउटपुट हैं।

इनपुट

कमांड लाइन तर्कों के रूप में फ़ाइलों की एक सूची। यदि कोई फ़ाइल सूचीबद्ध नहीं है, तो मानक इनपुट से पढ़ें। इनपुट में ASCII रेंज के बाहर अनपेक्षित वर्ण और वर्ण हो सकते हैं।

उत्पादन

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

नोट: केवल वर्णों को [A-Z]छोटा करें। यदि किसी अन्य पात्र को लोअरकेस किया जाता है, तो यह अस्वीकार्य है।

उदाहरण

$ echo "HelLo" > file.txt
$ kitten file.txt
hello
$ echo "Good Bye" | kitten
good bye
$ echo "Ä" | kitten
Ä

कोड-गोल्फ के साथ हमेशा की तरह , कम से कम बाइट्स जीतता है।

लीडरबोर्ड

यहां एक नियमित लीडरबोर्ड और भाषा के अनुसार विजेताओं का अवलोकन करने के लिए एक स्टैक स्निपेट है।

यह सुनिश्चित करने के लिए कि आपका उत्तर दिख रहा है, कृपया अपना उत्तर शीर्षक मार्कडाउन टेम्पलेट का उपयोग करके शीर्षक के साथ शुरू करें:

# Language Name, N bytes

Nआपके सबमिशन का आकार कहां है। यदि आप अपने स्कोर में सुधार करते हैं, तो आप पुराने अंकों को हेडलाइन में रख सकते हैं , उनके माध्यम से स्ट्राइक करके। उदाहरण के लिए:

# Ruby, <s>104</s> <s>101</s> 96 bytes

यदि आप अपने हेडर में कई संख्याओं को शामिल करना चाहते हैं (जैसे कि आपका स्कोर दो फ़ाइलों का योग है या आप दुभाषिया ध्वज दंड को अलग से सूचीबद्ध करना चाहते हैं), तो सुनिश्चित करें कि हेडर में वास्तविक अंक अंतिम संख्या है:

# Perl, 43 + 2 (-p flag) = 45 bytes

आप भाषा के नाम को एक लिंक भी बना सकते हैं जो लीडरबोर्ड स्निपेट में दिखाई देगा:

# [><>](http://esolangs.org/wiki/Fish), 121 bytes

कोड स्निपेट दिखाएं

code-golf  string  file-system 
— नंबर एक
स्रोत
2
स्पष्ट रूप से "केवल चरित्रों को [A-Z]कमतर करें" के बारे में बताते हुए क्या आप यूनिकोड इनपुट की आशा कर रहे हैं?
— AdmBorkBork
2
@ टिमिमड हां, लेकिन यह मुख्य रूप से लोगों को निचले कार्यों के लिए निर्मित उपयोग करने से रोकने के लिए है।
— TheNumberOne
3
— डेनिस
1
कैसे Ü, Ñऔर पसंद के बारे में ?
— मस्तूल
2
यह तो अच्छा है जब आप किसी भी Pyth बिल्कुल एक codegolf में ... देख पा रहे हैं
— झामुमो

जवाबों:

52

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

5 बाइट्स कोड + 1 बाइट कमांड लाइन

$_=lc

उदाहरण का उपयोग:

echo ABCdef | perl -p kitten.pl
abcdef

सही यूनिकोड व्यवहार की पुष्टि:

echo "HelloÉ" | perl -p kitten.pl
helloÉ
— स्टीव
स्रोत
2
क्या आप सुनिश्चित हैं कि यह यूनिकोड वर्णों को प्रभावित नहीं करता है?
— मार्टिन एंडर
7
@ मार्टिनबटनर यह नहीं करता है । हम यहां "अन्यथा" श्रेणी में हैं: "ASCII नियम केस परिवर्तन के लिए उपयोग किए जाते हैं। ASCII रेंज के बाहर किसी भी वर्ण का निचला भाग ही चरित्र है। ”उत्तर के लिए मेरा +1।
— xebtl
178

बैश, 19 बाइट्स

cat "$@"|tr A-Z a-z

बिल्ली के बच्चे बनाने का सबसे अच्छा तरीका वास्तविक बिल्लियों का उपयोग करना है।

उदाहरण चलाते हैं

$ ./kitten kitten
cat "$@"|tr a-z a-z
— डेनिस
स्रोत
39
नौकरी के लिए सही उपकरण।
— डिजिटल ट्रॉमा
120
एक बिल्ली का बच्चा बनाने के लिए केवल एक बिल्ली की आवश्यकता होती है, हमेशा मुझे दो बिल्लियां लेती हैं
— SnoringFrog
4
अब यह मुझे उन man womanचुटकुलों की याद दिलाता है ...
— xebtl
2
संतान पैदा करने की संभोग विधि के बजाय बिल्ली की क्लोनिंग के लिए +1
— MD-Tech
25
@SnoringFrog उन्होंने दूसरे को टक्कर दी।
— TheNumberOne
22

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

10 बाइट्स कोड + 1 बाइट कमांड लाइन

y/A-Z/a-z/

उदाहरण का उपयोग:

perl -p entry.pl input1.txt input2.txt
echo "ABCdef" | perl -p entry.pl
— Jarmex
स्रोत
15

पायथन 3, 77 बाइट्स

from fileinput import*
print(end=b''.join(input(mode='rb')).lower().decode())
— एंडर्स कसीगोर
स्रोत
1
यह चतुर है, गैर-एएससीआईआई को बदलने से बचने के लिए बाइट्स का उपयोग करना।
— मैटजॉयस
11

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

बाइट काउंट में pध्वज के लिए 1 बाइट शामिल है । इतना है कि यह चलाएँ: ruby -p kitten.rb।

$_.downcase!

स्टड या फ़ाइल तर्कों से इनपुट लेता है, जैसे कि बिल्ली का बच्चा।

— daniero
स्रोत
क्या यह केवल ASCII, या अन्य वर्णों को भी पसंद करता है Ä?
— पाओलो एबरमन
1
@ Pa @loEbermann: मैंने अभी इसका परीक्षण किया: echo "HelloÉ" | ruby -p kitten.rb->helloÉ
— नील स्लेटर
मैं कसम खाता हूँ कि कल के बारे में यहाँ टिप्पणियों का एक पूरा गुच्छा था। मुझे नहीं पता कि वे कहाँ गए थे, लेकिन: हाँ, यह कल्पना के अनुसार काम करता है।
— डेनियरो
5

पावरशेल, 112 बाइट्स

function l([string]$a){97..122|%{[char]$b=$_;$a=$a-split$b-join$b};$a}if($args){$args|%{l(gc $_)}}else{l $input}

भयावह रूप से अपठनीय। यहाँ नीचे थोड़ा विस्तारित संस्करण दिया गया है:

function l([string]$a){
  97..122|%{
    [char]$b=$_
    $a=$a-split$b-join$b
  }
  $a
}

if($args){
  $args|%{
    l(gc $_)
  }
}
else{
  l $input
}

एक आंतरिक फ़ंक्शन को परिभाषित करता है lजो 97 से 112 (यानी, एएससीआईआई aसे एएससीआईआई z) तक लूप से अधिक होता है । उस चरित्र पर इनपुट स्ट्रिंग को विभाजित करता है (या केस-असंवेदनशील डिफ़ॉल्ट), इसे "सही" निचले मामले के साथ जोड़ता है। ध्यान दें कि हां, इसका मतलब है कि "टेस्ट" संक्षेप में "टी सेंट" बन जाएगा क्योंकि यह eउदाहरण के लिए, के माध्यम से पुनरावृत्ति करता है । आउटपुट को प्रभावित नहीं करता है।

यदि हम पाइपलाइन इनपुट (पॉवरशेल के लिए स्टड के बराबर) या कमांड-लाइन इनपुट करते हैं, तो दूसरी छमाही मुश्किल है। विशेष चर $argsकेवल मौजूद है यदि कमांड-लाइन इनपुट मौजूद है, तो हम प्रत्येक पर लूप करते हैं, gc(के लिए Get-Content) और जो कि ऊपर है l। अन्यथा, हम सिर्फ हमारे $inputअप करने के लिए schlep l। ध्यान दें कि हम अपने if / if स्टेटमेंट (यानी if($input)) को स्वैप कर सकते हैं , लेकिन चूंकि "इनपुट" "args" की तुलना में एक वर्ण लंबा है, इसलिए यह छोटा है।

— AdmBorkBork
स्रोत
@ नाज़ेक बिल्ट-इन "String".ToLower()भी यूनिकोड वर्णों को कम करेगा, जो नियमों के विरुद्ध है। बहुत सारा सामान है जो पावरशेल यूनिकोड के संबंध में सही नहीं करता है, लेकिन दुर्भाग्य से यह एक उदाहरण है कि यह सही तरीके से काम करता है।
— AdmBorkBork
5

आर, 97 बाइट्स

cat(chartr("A-Z","a-z",sapply(if(length(a<-commandArgs(T))){a}else{"stdin"},readLines)),sep="\n")

उपयोग:

$ echo "HeLlo" > file.txt
$ Rscript kitten.R file.txt
hello
$ echo "Good Bye" | Rscript kitten.R
good bye
$ echo "bLABLa" > file2.txt
$ Rscript kitten.R file.txt file2.txt
hello
blabla
$ echo Ä | Rscript kitten.R
Ä
— plannapus
स्रोत
5

कॉफ़ीस्क्रिप्ट , 292 बाइट्स

f=require 'fs';d='';p=process;v=p.argv;s=p.stdin;l=((d)=>console.log d.replace /([A-Z])/g,(a,l)=>l.toLowerCase());if v.length>2 then(v.forEach (v,i)=>if i>1 then(f.exists v, (e) =>if e then(f.readFile v,'utf-8',(r,d)=>l d) else l v))else(s.resume();(s.on 'data',(c)=>d+=c);s.on 'end',()=>l d)

उपयोग:

$ echo "HelLo" > file.txt
$ coffee kitten.coffee file.txt
hello
$ echo "Good Bye" | coffee kitten.coffee
good bye
$ echo "Ä" | kitten
Ä
$ coffee kitten.coffee file.txt SoMeTeXt
sometext
hello

कोडगुल्फ़ पर मेरी पहली भागीदारी तो असभ्य मत बनो :)।

यह सुनिश्चित करने के लिए कि यह कोड अधिक हो सकता है और कॉफी / जावास्क्रिप्ट ऐसा करने का सबसे अच्छा विकल्प नहीं है, लेकिन यह वही है जो अपेक्षित है।

जब यह तर्क पढ़ता है तो यह फ़ाइल अस्तित्व के बारे में भी ध्यान रखता है (यदि फ़ाइल मौजूद नहीं है, तो स्ट्रिंग को बिल्ली का बच्चा है)।

इस कोड को बेहतर बनाने के लिए किसी भी मदद या सलाह का स्वागत है!

— dunpeal69
स्रोत
4

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

f(s)=for l=readlines(s) print(replace(l,r"[A-Z]",lowercase))end
A=ARGS
length(A)>0?for i=A open(f,i)end:open(f,readline())

Ungolfed:

function file_to_lower(s::Stream)
    # Loop over the lines of the input stream
    for l in readlines(r)
        # Print the lowercased line
        print(replace(l, r"[A-Z]", lowercase))
    end
end

if length(ARGS) > 0
    # Loop over the files specified from the command line
    for i in ARGS
        # Open the file, apply the function, then close it
        open(file_to_lower, i)
    end
else
    # Get the input file from STDIN
    open(file_to_lower, readline())
end
— एलेक्स ए।
स्रोत
4

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

ea_:gs{q}?'_,_eler

फ़ाइलों की सूची को URL के रूप में आपूर्ति की जानी चाहिए, जो कि CJam का एकमात्र प्रारूप है।

उदाहरण चलता है

$ cjam kitten <<< "AaÁáÄä"
aaÁáÄä
$ cjam kitten file:///home/dennis/kitten file:///home/dennis/kitten
ea_:gs{q}?'_,_elerea_:gs{q}?'_,_eler

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

ea                  Push the array of command-line arguments.
  _                 Push a copy.
   :g               Retrieve the contents of all files with those URLS.
     s              Flatten the resulting array of strings.
      {q}           Push a block that reads all input from STDIN.
         ?          Select the string of the array of args is non-empty.
                    Otherwise, execute the code block.
          '_,       Push the string of all ASCII characters before _.
             _el    Push a copy and convert it to lowercase.
                er  Perform transliteration.
— डेनिस
स्रोत
4

पायथन 2, 100 102 97 बाइट्स

कार्यक्षमता को सही किया (और 4 बाइट्स जोड़ा गया) matsjoyce द्वारा। सौभाग्य से, मैंने पायथन 2 पर स्विच करके दो बाइट्स बचाए।

from sys import*;print''.join(f.read().lower()for f in(map(open,argv[1:])if argv[1:]else[stdin]))

यदि कोई तर्क नहीं मिलता है, तो कमांड लाइन से या STDIN से तर्क लेते हैं।

यह कुछ कार्यों के डिफ़ॉल्ट तर्कों का दुरुपयोग करता है। डिफ़ॉल्ट रूप से, openकेवल-पढ़ने के लिए पाठ मोड का उपयोग करता है, जो वास्तव में हम चाहते हैं। read, अगर कोई तर्कों के साथ नहीं बुलाया जाता है, तो धारा में सभी पाठ वापस आ जाएंगे।

Ungolfed:

import sys

if len(sys.argv) > 1:              # If we have command-line arguments:
    source = []                    # Initialize an empty list
    for path in sys.argv[1:]:      # Iterate through every filename we have
        kitfile = open(path, 'rt') # Open the file in read-only text mode
        source.append(kitfile)     # Add it to the list
else:                              # Otherwise, if the args are empty:
    source = [sys.stdin]           # Set our source to STDIN wrapped in a list

kittened = []                      # Initialize an empty list
for kitfile in source:             # Iterate through every file (or just STDIN)
    text = kitfile.read()          # Read everything from the stream
    kitten_text = text.lower()     # Make it lowercase
    kittened.append(kitten_text)   # Add it to the list
final = ''.join(kittened)          # Join everything together
print final                        # Print the result
— bkul
स्रोत
1
यह स्टडिन के लिए काम नहीं करेगा, क्योंकि आप केवल एक लाइन पढ़ते हैं, और इसे कम नहीं करते हैं।
— मैटजॉयस सिप
@matsjoyce मैंने अपना कोड तय कर लिया है। याद दिलाने के लिए शुक्रिया! दुर्भाग्य से, इसने चार बाइट्स जोड़े, लेकिन अब inputमूल्यांकन न करने के आधार पर , मैं पायथन 2 पर स्विच कर सकता हूं और कोष्ठक को हटा सकता हूं print।
— bkul
3

सी, 106 108 बाइट्स

संपादित करें: बाइट को निचोड़ते समय एक गलती को ठीक किया गया। स्टडिन काम नहीं कर रहा था, अब यह है।

मुझे पूरा यकीन है कि मैं कुछ बाइट्स दूर कर सकता हूं, लेकिन यहाँ एक आसान-से-समझ है, न कि सभी भाषा में अपमानजनक, प्रस्तुत करना:

main(n,s,f,c)void**s;{for(f=n-1?open(*++s,0,0):0;read(f,&c,1);putchar(64<c&c<91?c+32:c));n-->2&&main(n,s);}

और पढ़ने के लिए कुछ हद तक बड़े करीने से स्वरूपित संस्करण:

main(n,s,f,c)
void**s;
{
    for(f=n-1?open(*++s,0,0):0; read(f,&c,1); putchar(64<c&c<91?c+32:c));
    n-->2&&main(n,s);
}
— algmyr
स्रोत
+1 क्योंकि यह मुझे सिखाता है कि अंतर्निहित int पैरामीटर केवल K & R सिंटैक्स के साथ संभव हैं।
— फेलिक्स डॉमबेक
2

मैथेमेटिका, 66 बाइट्स

kit=StringReplace[#,x:RegularExpression["[A-Z]"]:>ToLowerCase[x]]&

के रूप में पुकारा गया 

kit@"HelLo"

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

— Verbeia
स्रोत
@ TheNumberOne - यह है कि यह Mathematica में कैसे काम करता है। इसे करने के लिए अधिक कोड की आवश्यकता नहीं है। यदि आप एक निष्पादन योग्य चाहते हैं, तो गणितज्ञ उपकरण नहीं है।
— वेरिबिया
क्या यह अधिनिर्णित फाइलें जिनके नाम इनपुट-लाइन तर्कों के रूप में आवश्यक हैं, के रूप में हैं?
— msh210
Mathematica में कमांड-लाइन आर्ग्स मौजूद नहीं है। यह अपने फंक्शन इनपुट्स को बताता है। इसके अलावा, आपको एक चर को निर्दिष्ट करने की आवश्यकता नहीं है।
— कैलक्यूलेटरफ्लिन
2

सी #, 230 226 बाइट्स

namespace System{using Linq;class P{static void Main(string[]a){Console.Write(string.Concat((a.Length>0?string.Concat(a.Select(f=>IO.File.ReadAllText(f))):Console.In.ReadToEnd()).Select(c=>c>'@'&&c<'['?char.ToLower(c):c)));}}}

Ungolfed: 

namespace System
{
    using Linq;
    class P
    {
        static void Main(string[] a)
        {
            Console.Write(                                                  // Print...
                string.Concat(                                                  // ...all chars combined to a string...
                    (a.Length > 0 ?                                             // ...commandline arguments?...
                        string.Concat(a.Select(f => IO.File.ReadAllText(f))) :  // ...then all files as single string...
                        Console.In.ReadToEnd()                                  // ...else STDIN input
                    ).Select(c => c > '@' && c < '[' ? char.ToLower(c) : c)     // ...Lowercase only A..Z
                )
            );  
        }
    }
}
— RobIII
स्रोत
2

हास्केल, 133

import System.Environment
main=getArgs>>=mapM_(>>=putStr.map l).f
f[]=[getContents]
f n=map readFile n
l x=[x..]!!sum[32|x>'@',x<'[']

कैट-स्टाइल आर्ग्स प्रोसेसिंग इस ट्यूटोरियल से ली गई है , फिर शेव पात्रों को फिर से बनाया गया है।

समझा l, एक चरित्र को कम करने का कार्य:

  • sum[32|condition]का छोटा रूप है if condition then 32 else 0।
  • [x..]!!countहै iterate succ x !! countहै toEnum $ fromEnum x + countऔर आयात और का उपयोग कर की तुलना में कम Data.Char.toLowerएक शर्त के साथ ASCII तक प्रतिबंधित करना।
  • '@'और '['अक्षर तुरंत पूर्ववर्ती Aऔर निम्नलिखित हैं Z, ताकि मैं <इसके बजाय उपयोग कर सकूं <=।

ट्रिक्स sum[...|...]और योगदान के लिए एंडर्स कासोर्ग का धन्यवाद [x..]!!।

— केविन रीड
स्रोत
1
l x=[x..]!!sum[32|x>'@',x<'[']
— एंडर्स कासोर्ग
1

सी #, 342 बाइट्स

  • पारित तर्कों से फ़ाइल सूची लेता है।
  • हर फ़ाइल में हर चार को पढ़ने की तुलना में केवल निचले मामले में कनवर्ट करता है यदि और केवल अगर ए..जेड में वर्ण इसे भेजने के बजाय।
  • अगर कोई फ़ाइल सूची नहीं है, तो STDIN को पढ़ता है, हर चार को पढ़ता है, निचले मामले में धर्मान्तरित होता है, यदि केवल तभी और जब A..Z वर्ण में वर्ण इसे STDOUT पर भेजने के बजाय।
namespace System{
using IO;
using Linq;
class P{
static void Main(string[]a){
Action<char>e=C=>{var c=char.ToLower(C);Console.Out.Write(c>='a'&&c<='z'?c:C);};
if(a.Length>0)a.ToList().ForEach(f=>File.ReadAllText(f).ToCharArray().ToList().ForEach(e));
else 
while(true) Console.In.ReadLine().ToCharArray().ToList().ForEach(e);
}
}
}

सी #, 319 बाइट्स

एकल-लाइनर, ऊपर के समान:

namespace System{using IO;using Linq;class P{static void Main(string[]a){Action<char>e=C=>{var c=char.ToLower(C);Console.Out.Write(c>='a'&&c<='z'?c:C);};if(a.Length>0)a.ToList().ForEach(f=>File.ReadAllText(f).ToCharArray().ToList().ForEach(e));else while(true)Console.In.ReadLine().ToCharArray().ToList().ForEach(e);}}}
— बल देना
स्रोत
1

एसआईओएस 179 वर्ण

loadLine :
a = 256
x = get a
lbla
X = x
B = x
C = 91
B - 64
if B c
printChar x
GOTO x
lblc
C - x
if C D
printChar x
GOTO x
lblD
x + 32
printChar x
lblx
a + 1
x = get a
if x a
lblb

इस कोड को ऑनलाइन आज़माने के लिए स्वतंत्र महसूस करें !

अनिवार्य रूप से यह pusedocode में इसका अनुवाद करता है।

String input = input();
for(char c in input)
if(c is uppercase) print c + 32/*lowercase c*/else print c
— रोहन झुनझुनवाला
स्रोत
0

सी, 91 बाइट्स

#include <stdio.h>
main(){int c;while(EOF!=(c=getc(stdin))){c=tolower(c);putc(c,stdout);}}

सी, 98 बाइट्स

#include <stdio.h>
main(){int c;while(EOF!=(c=getc(stdin))){if(c>64&&c<91)c+=32;putc(c,stdout);}}

हालाँकि यदि पठनीयता बाइट से अधिक मायने रखती है तो वही तर्क नीचे लिखा गया है:

#include <stdio.h>
main()
{
int c;
        while (EOF != (c = getc(stdin))) {
                if ((c >= 'A') && ((c <= 'Z')))
                        c = (c - 'A') + 'a';
                putc(c,stdout);
        }
}
— डेव थॉम्पसन
स्रोत
यह पहले परीक्षण मामले में विफल रहता है।
— TheNumberOne
इससे युक्ति पूरी नहीं होती। यह इस तरह से व्यवहार करना चाहिए जैसे कि आप फ़ाइलनाम को तर्क के रूप में लेते हैं और यदि कोई फ़ाइल नाम नहीं दिया जाता है, तो स्टडिन से पढ़ें। आप वर्तमान में केवल स्टड से पढ़ते हैं।
— अल्जीमर
0

sed, 14 बाइट्स

s/[A-Z]/\L\0/g

के साथ भागो env -i sed -f kitten.sed।

— देवदूत
स्रोत
1
चूंकि यह कहने के लिए सिर्फ एक फैंसी तरीका है LANG=C sed -f kitten.sed, मैं अनिश्चित हूं अगर मुझे इसके लिए एक दंड लागू करना चाहिए। यह प्रश्न निर्दिष्ट नहीं करता है कि प्रोग्राम कॉल की गणना कैसे करें, और यह मेटा में संबोधित नहीं लगता है।
— 25ngel
क्या यह अधिनिर्णित फाइलें जिनके नाम इनपुट-लाइन तर्कों के रूप में आवश्यक हैं, के रूप में हैं?
— msh210
@ msh210 हां, बिल्कुल।
— .ngel
1
@ s/.*/\L&/नौ बाइट्स समाधान के लिए
— somengel
धन्यवाद @someonewithpc दोनों s/.*/\L&/और s/./\L&/gवास्तव में 9-बाइट समाधान हैं!
— Ángel
0

जावा, 198 बाइट्स

b->B->{B="";for(java.io.File c:b)B+=new java.util.Scanner(c).useDelimiter("\\Z").next();for(int c=0;c++<B.length;)if(B.charAt(c)>64&B.charAt(c)<91)B=B.replace(B.charAt(c),B.charAt(c)|32);return B;};

आप फ़ाइलों के साथ उपरोक्त लैम्ब्डा का उपयोग करने के लिए मजबूर हैं, इसलिए एसटीडीआईएन से इनपुट लेने की कोई आवश्यकता नहीं है! इसके अलावा, यह एक है Function<File[], UnaryOperator<String>>। इसका उपयोग किया जाता है foo.apply(anArrayOfFiles).apply(anything)।

कुछ के रूप में जो जावा के लिए नए हैं के लिए अधिक समझ में आता है, यह 223 बाइट्स लेता है:

String A(java.io.File[]b){String B="";for(java.io.File c:b)B+=new java.util.Scanner(c).useDelimiter("\\Z").next();for(int c=0;c++<B.length;)if(B.charAt(c)>64&B.charAt(c)<91)B=B.replace(B.charAt(c),B.charAt(c)|32);return B;}

जैसा कि कुछ संकलन करता है, इसमें 232 बाइट्स लगते हैं:

class a{String A(java.io.File[]b){String B="";for(java.io.File c:b)B+=new java.util.Scanner(c).useDelimiter("\\Z").next();for(int c=0;c++<B.length;)if(B.charAt(c)>64&B.charAt(c)<91)B=B.replace(B.charAt(c),B.charAt(c)|32);return B;}}
— dorukayhan
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.