मेरी बेटी की वर्णमाला

Question

दूसरे दिन हम अपनी बेटी के साथ फ्रिज चुंबक पत्र के साथ वाक्य लिख रहे थे। जबकि हम कुछ ( I love cat) बनाने में सक्षम थे , हमारे पास पर्याप्त I love you tooमात्रा में पत्र o(/ ) के कारण दूसरों ( ) को बनाने के लिए पर्याप्त पत्र नहीं थे।

मुझे तब पता चला कि जबकि एक सेट में 3 eअक्षर शामिल थे, इसमें केवल 2 oअक्षर थे। शायद http://en.wikipedia.org/wiki/Letter_frequency से प्रेरित यह अभी भी "फ्रिज पर" वास्तविक स्थिति को प्रतिबिंबित नहीं करेगा।

मुसीबत

पाठ फ़ाइल को देखते हुए जहां प्रत्येक पंक्ति में एक "नमूना वाक्य" होता है, जिसमें से एक को फ्रिज पर लिखना चाहते हैं, अक्षरों की न्यूनतम राशि के साथ एक वर्णमाला सेट करें, लेकिन फिर भी प्रत्येक वाक्य को व्यक्तिगत रूप से लिखने के लिए पर्याप्त है।

नोट: मामलों को अनदेखा करें, सभी चुंबक पत्र वैसे भी राजधानियाँ हैं।

इनपुट

फ़ाइल में नई अलग-अलग वाक्य हैं:

hello
i love cat
i love dog
i love mommy
mommy loves daddy

उत्पादन

अक्षरों की क्रमबद्ध सूची प्रदान करें, जहां प्रत्येक अक्षर किसी भी वाक्य को लिखने के लिए पर्याप्त रूप से केवल कई बार दिखाई देता है:

acdddeghillmmmoostvyy

(धन्यवाद, isaacg!)

विजेता

सबसे छोटा कार्यान्वयन (कोड)

अद्यतन: परीक्षण

मैंने एक अतिरिक्त परीक्षण बनाया है और यहां विभिन्न उत्तरों के साथ प्रयास किया है:

https://gist.github.com/romaninsh/11159751

Comments

vआउटपुट में एक पत्र होना चाहिए ;)

— एंटोनियो रागागिन

हम / एक उलटा स्थानापन्न करने के लिए आवश्यक अनुमति दी जाती है Mएक के लिए W, या एक बग़ल में Nएक के लिए Z? ;-)

— इल्मरी करोनें

मूल रूप से आप किसी भी अक्षर का निर्माण कर सकते हैं I।

— swish

अधिक गंभीरता से, जब आप "मामलों की उपेक्षा" कहते हैं, तो क्या आपका मतलब है कि हम यह मान सकते हैं कि इनपुट पहले से ही एक ही मामले में है, या कि हमें इसे एक ही मामले में बदलना चाहिए? इसके अलावा, क्या आउटपुट के लिए कुछ प्रमुख स्थानों को शामिल करना ठीक है?

— इल्मरी करोनें

@ डोरकोनोब:_\¯

— इल्मरी करोनन

Answer 1

गोल्फस्क्रिप्ट, 28/34 चार्ट

n/:a{|}*{a{.[2$]--}%*$-1=}%$

28-वर्ण से ऊपर का कार्यक्रम मानता है कि सभी इनपुट पत्र एक ही मामले में हैं। यदि यह आवश्यक नहीं है, तो हम उन्हें {95&}%कुल मामले में ऊपरी 34 मामलों में बाध्य कर सकते हैं , कुल 34 वर्णों के लिए:

{95&}%n/:a{|}*{a{.[2$]--}%*$-1=}%$

टिप्पणियाँ:

• सही संचालन के लिए, इनपुट में कम से कम एक नई पंक्ति शामिल होनी चाहिए। यह प्रत्येक पंक्ति के अंत में newlines के साथ सामान्य पाठ फ़ाइलों के लिए सही होगा, लेकिन यह सच नहीं हो सकता है यदि इनपुट में केवल एक पंक्ति शामिल है जिसमें कोई नई रेखा नहीं है। यह दो अतिरिक्त वर्णों की लागत पर तय किया जा सकता है, n+कोड के लिए तैयार करके।

• 34-वर्ण संस्करण में प्रयुक्त अपरकेसिंग वास्तव में क्रूड है - यह ASCII अक्षरों को उनके अपरकेस समतुल्य (और NULएस के लिए रिक्त स्थान ) में मैप करता है, लेकिन संख्याओं और अधिकांश विराम चिह्नों की पूरी गड़बड़ी करता है। मैं मान रहा हूं कि इनपुट में ऐसे कोई भी चरित्र शामिल नहीं होंगे।

• 28-वर्ण संस्करण सभी इनपुट पात्रों (newlines और NULs को छोड़कर ) को समान रूप से मानता है । विशेष रूप से, यदि इनपुट में कोई रिक्त स्थान है, तो कुछ आउटपुट में भी दिखाई देगा; आसानी से, वे किसी भी अन्य मुद्रण योग्य ASCII वर्णों से पहले सॉर्ट करेंगे। 34-वर्ण संस्करण, हालांकि, रिक्त स्थान को अनदेखा करता है (क्योंकि यह पता चला है कि मैं ऐसा कर सकता हूं, इसके बिना मुझे कोई अतिरिक्त शुल्क चुकाना पड़ता है)।

व्याख्या:

• वैकल्पिक {95&}%उपसर्ग प्रत्येक इनपुट बाइट ( ) के ASCII कोड के छठे बिट को शून्य करके इनपुट को बढ़ाता है । यह मानचित्र ASCII अक्षरों को अपरकेस, रिक्त बाइट्स को रिक्त करने के लिए रिक्त स्थान, और अपरिवर्तित नए सिरे को छोड़ता है।95 = 64 + 31 = 10111112

• n/इनपुट को newlines पर विभाजित करता है, और :aपरिणामस्वरूप सरणी को चर में असाइन करता है a। फिर {|}*सरणी में स्ट्रिंग्स के सेट यूनियन की गणना करता है, जो (यह मानते हुए कि सरणी में कम से कम दो तत्व हैं) इनपुट में सभी अद्वितीय (गैर-न्यूलाइन) वर्णों के साथ एक स्ट्रिंग उत्पन्न करता है।

• निम्न { }%लूप तब इन अद्वितीय वर्णों में से प्रत्येक पर पुनरावृति करता है। लूप बॉडी के अंदर, आंतरिक लूप a{.[2$]--}%सरणी में तारों पर पुनरावृत्त होता है a, प्रत्येक स्ट्रिंग से हटाकर सभी वर्ण एक से अधिक नहीं होते हैं जो बाहरी लूप से अधिक होता है।

  आंतरिक लूप फ़िल्टर किए गए सरणी के नीचे, स्टैक पर वर्तमान वर्ण का ASCII कोड छोड़ देता है। हम फ़िल्टर किए गए सरणी को दोहराते हुए इसका उपयोग ASCII कोड ( *) को छांटने से पहले ( $) और अंतिम तत्व ( -1=) लेने से पहले करते हैं । वास्तव में, यह फ़िल्टर की गई सरणी में सबसे लंबी स्ट्रिंग उत्पन्न करता है (जैसा कि वे सभी एक ही वर्ण के दोहराव से मिलकर होते हैं, लेक्सिकोग्राफ़िक उन्हें लंबाई से छांटते हैं), सिवाय इसके कि चरित्र में ASCII कोड शून्य है, जिस स्थिति में कुछ भी नहीं होता है।

• अंत में, $अंत में केवल वर्णानुक्रम में आउटपुट को सॉर्ट करता है।

Comments

गजब का। TODO: जानें गोल्फस्क्रिप्ट!

— DLosc 13/14

तुम भी 26 तक कम हो सकता है: n/:a{|}*{{{=}+,}+a%$-1=}%$।

— हावर्ड

Answer 2

जे - 37 चार

स्टड से पढ़ता है, कंसोल के लिए आउटपुट।

dlb#&a.>./+/"2=/&a.tolower;._2[1!:1]3

1!:1]3स्टड करने के लिए कॉल है। tolower;._2लाइनों को विभाजित करके और उन्हें एक साथ लोअरकेस करके डबल ड्यूटी करता है। फिर हम गिनते हैं कि प्रत्येक पंक्ति में कोई वर्ण कितनी बार होता है +/"2=/&a., और सभी पंक्तियों के साथ बिंदुवार अधिकतम ले >./।

अंत में, हम उस प्रत्येक वर्ण को वर्णमाला से बाहर खींचते हैं #&a.। इसमें रिक्त स्थान शामिल हैं - सभी को उनके कम ASCII मूल्य के कारण मोर्चे पर पाया गया है - इसलिए हम सिर्फ प्रमुख रिक्त स्थान हटाते हैं dlb।

Answer 3

जावास्क्रिप्ट (ECMAScript 6) - 148 139 135 अक्षर

संस्करण 2:

सरणी समझ का उपयोग करने के लिए अद्यतन:

[a[i][0]for(i in a=[].concat(...s.split('\n').map(x=>x.split(/ */).sort().map((x,i,a)=>x+(a[i-1]==x?++j:j=0)))).sort())if(a[i-1]<a[i])]

संस्करण 1:

[].concat(...s.split('\n').map(x=>x.split(/ */).sort().map((x,i,a)=>x+(a[i-1]==x?++j:j=0)))).sort().filter((x,i,a)=>a[i-1]!=x).map(x=>x[0])

मान लेता है कि:

• इनपुट स्ट्रिंग चर में है s;
• हम इनपुट के मामले को अनदेखा कर सकते हैं (जैसा कि प्रश्न द्वारा निर्दिष्ट किया गया है - यानी यह ऊपरी या निचले मामले में है);
• आउटपुट वर्णों की एक सरणी है (जो कि लगभग उतना ही है जितना जावास्क्रिप्ट ओपी को पात्रों की सूची की आवश्यकता के लिए मिल सकता है); तथा
• आउटपुट को कंसोल पर प्रदर्शित किया जाना है।

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

var l = s.split('\n')             // split the input up into sentences
         .map(x=>x.split(/ */)   // split each sentence up into letters ignoring any
                                  // whitespace
                  .sort()         // sort the letters in each sentence alphabetically
                  .map((x,i,a)=>x+(a[i-1]==x?++j:j=0)))
                                  // append the frequency of previously occurring identical
                                  // letters in the same sentence to each letter.
                                  // I.e. "HELLO WORLD" =>
                                  // ["D0","E0","H0","L0","L1","L2","O0","O1","R0","W0"]
[].concat(...l)                   // Flatten the array of arrays of letters+frequencies
                                  // into a single array.
  .sort()                         // Sort all the letters and appended frequencies
                                  // alphabetically.
  .filter((x,i,a)=>a[i-1]!=x)     // Remove duplicates and return the sorted
  .map(x=>x[0])                   // Get the first letter of each entry (removing the
                                  // frequencies) and return the array.

यदि आप चाहते हैं:

• इसे एक स्ट्रिंग के रूप में लौटाएं और फिर .join('')अंत में जोड़ें ;
• एक उपयोगकर्ता से इनपुट लें और उसके बाद sवेरिएबल को बदलें prompt(); या
• इसे एक फ़ंक्शन के रूप में लिखें fफिर f=s=>शुरुआत में जोड़ें ।

चल रहा है:

s="HELLO\nI LOVE CAT\nI LOVE DOG\nI LOVE MOMMY\nMOMMY LOVE DADDY";
[].concat(...s.split('\n').map(x=>x.split(/ */).sort().map((x,i,a)=>x+(a[i-1]==x?++j:j=0)))).sort().filter((x,i,a)=>a[i-1]!=x).map(x=>x[0])

आउटपुट देता है:

["A","C","D","D","D","E","G","H","I","L","L","M","M","M","O","O","T","V","Y","Y"]

Comments

अच्छा! /\s*// */j=0

— पार्स

के ...बजाय आप का उपयोग नहीं कर सकता apply?

— शुक्र

आप दोनों का धन्यवाद - जो 9 पात्रों को बचाता है - प्रसार ( ...) ऑपरेटर वह है जिसे मैंने पहले नहीं देखा है।

— MT0

[].concat(...s.split`N`.map(x=>x.split(/ */).map((x,i,a)=>x+(a[x]=a[x]?++j:j=1)))).sort().map((x,i,a)=>a[i-1]<x?x[0]:'').join``;

— l4m2

Answer 4

पर्ल - 46 बाइट्स

#!perl -p
$s=~s/$_//ifor/./g;$s.=uc}for(sort$s=~/\w/g){

शेबंग की गिनती 1. इस रूबी समाधान का एक ढीला अनुवाद है।

---

रूबी 1.8 - 72 बाइट्स

s='';s+=$_.upcase.scan(/./){s.sub!$&,''}while gets;$><<s.scan(/\w/).sort

इनपुट से लिया जाता है stdin।

नमूना उपयोग:

$ more in.dat
Hello
I love cat
I love dog
I love mommy
Mommy loves daddy

$ ruby fridge-letters.rb < in.dat
ACDDDEGHILLMMMOOSTVYY

Comments

आउटपुट को क्रमबद्ध करने की आवश्यकता है।

— मैट

@ अब तय हो गया।

— प्रिमो

अच्छा लगा। यदि आपका पर्ल हाल ही में अस्पष्ट है, तो आप /iऔर के बीच एक स्थान चाहते हैं for।

— टोबिंक

Answer 5

पायथन - 206 204 199 177 145 129 117 94 88 चार्ट

print(''.join(c*max(l.lower().count(c)for l in open(f))for c in map(chr,range(97,123))))

मुझे यकीन नहीं था कि मैं फ़ाइल नाम कैसे प्राप्त करने वाला था, इसलिए फिलहाल कोड मानता है कि यह एक चर नाम में निहित है f। कृपया मुझे बताएं कि क्या मुझे इसे बदलने की आवश्यकता है।

Comments

यूनिक्स की भावना में - आप स्टडिन से पढ़ सकते हैं।

— रोमिंश

हमेशा फ़ाइल नाम को एक वर्ण लंबा

@ मैं नया भी हूँ, लेकिन अगर यह पात्रों को बचाता है, तो क्यों नहीं?

यह मानते हुए कि करके fइनपुट फ़ाइल नाम के लिए और अपरकेस का उपयोग कर (सभी चुंबक पत्र वैसे भी अपरकेस कर रहे हैं), तो आप इसे 91 करने के लिए नीचे लाने के लिए कर सकते हैं:print(''.join([chr(i)*max(l.upper().count(chr(i))for l in open(f))for i in range(65,91)]))

— Gabe

@ njzk2 अच्छी तरह से, अगर हम इसे कंसोल में चलाते हैं, तो सिद्धांत रूप में यह केवल परिणाम को खुद ही प्रिंट करेगा ...

— ताल

Answer 6

रूबी 1.9+, 51 (या 58 या 60)

a=*$<
?a.upto(?z){|c|$><<c*a.map{|l|l.count c}.max}

सब कुछ लोअरकेस में मानता है। केस असंवेदनशीलता के माध्यम से 7 वर्णों की लागत होती है .upcase, जबकि मामले की असंवेदनशीलता और लोअरकेस आउटपुट के माध्यम से 9 वर्णों की लागत होती है .downcase।

Answer 7

आर (156, इंक्ल फ़ाइल फ़ाइल)

तालिका के साथ मैं प्रत्येक वाक्य के लिए पत्र आवृत्ति तालिका का निर्माण करता हूं। फिर मैं प्रत्येक अक्षर के लिए अधिकतम मूल्य लेने के साथ समाप्त करता हूं।

a=c();for(w in tolower(read.csv(fn,h=F)$V1))a=c(a,table(strsplit(w,"")[[1]]));a=tapply(seq(a),names(a),function(i)max(a[i]))[-1];cat(rep(names(a),a),sep="")

Ungolfed:

a=c()
words = read.csv(fn,h=F)$V1
for(w in tolower(words))
  a=c(a, table(strsplit(w, "")[[1]]))
a = tapply(seq(a), names(a), function(i) max(a[i]))[-1] ## The -1 excludes the space count.
cat(rep(names(a), a), sep="")

उपाय:

acdddeghillmmmoooooostuvyy

Comments

@lambruscoAcido आप तीन पहली पंक्तियों (असम्बद्ध कोड की) को वेक्टर कर सकते हैं जो आपको देगा a=unlist(lapply(readLines(fn),function(x)table(strsplit(tolower(x),""))));a=tapply(seq(a),names(a),function(i)max(a[i]))[-1];cat(rep(names(a),a),sep=""), लेकिन यह केवल 3 वर्णों से छोटा है

— jkd

केवल 112 वर्णों के साथ एक और दृष्टिकोण cat(unlist(sapply(letters,function(i)rep(i,max(sapply(gregexpr(i,readLines(f)),function(x)sum(x>0)))))),sep="")यह माना जाएगा कि fइसका नाम है

— jdd

Answer 8

हास्केल, 109 108

import Data.List
import Data.Char
main=interact$sort.filter(/=' ').foldl1(\x y->x++(y\\x)).lines.map toLower

कार्यक्रम स्टड से पढ़ता है और sdtout को लिखता है।

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

Comments

अरे वाह, मैंने (\\) पहले कभी क्यों नहीं सुना?

— १५:१४ पर फ्लोंक

@Flonk haskell.org/ghc/docs/7.6-lestest/html/lbooks/base-4.6.0.1/……

— lortabac

Answer 9

पर्ल 6: 56 53 वर्ण; 58 55 बाइट्स

say |sort
([∪] lines.map:{bag comb /\S/,.lc}).pick(*)

प्रत्येक पंक्ति के लिए, यह निम्न-आवरण स्ट्रिंग ( comb /\S/,.lc) के गैर-स्थान वर्णों के लिए इसके माध्यम से आता है Bag, और प्रत्येक वर्ण का एक संग्रह, या कितनी बार होता है। सभी रेखाओं [∪]के बीच में Bags का मिलन होता है , जिससे वर्ण की अधिकतम संख्या प्राप्त होती है। .pick(*)यहाँ हैक-वाई है, लेकिन यह Bagजितनी बार हुआ, उतने बार द्वारा सभी वर्णों को प्राप्त करने का सबसे छोटा तरीका है ।

संपादित करें: यह देखने के लिए कि क्या यह छोटा होगा, मैंने हिस्टोक्रेट के रूबी जवाब का अनुवाद करने की कोशिश की । यह 63 अक्षर है, लेकिन मुझे अभी भी बहुत पसंद है:

$!=lines».lc;->$c{print $c x max $!.map:{+m:g/$c/}} for"a".."z"

Answer 10

हास्केल, 183 162 159

फ़ाइल को मान लिया गया है file.txt!

import Data.Char
import Data.List
main=readFile"file.txt">>=putStr.concat.tail.map(tail.maximum).transpose.map(group.sort.(++' ':['a'..'z'])).lines.map toLower

उदाहरण के लिए, file.txt सम्‍मिलित है

abcde
abcdef
aaf

स्क्रिप्ट आउटपुट देगी

aabcdef

मूल रूप से मैं पूरी वर्णमाला को प्रत्येक पंक्ति में जोड़ रहा हूं, ताकि समूह बनाते और क्रमबद्ध करते समय, मुझे यकीन है कि मैं एक सूची के साथ समाप्त हो जाऊंगा जिसमें 27 तत्व शामिल हैं। अगला, मैं "आवृत्ति तालिका" को स्थानांतरित करता हूं, ताकि इस सरणी में प्रत्येक पंक्ति में प्रत्येक पंक्ति में एक अक्षर की आवृत्तियों शामिल हों, जैसे ["a","","aaa","aa","aaaa"]। मैं तब प्रत्येक सरणी का अधिकतम चयन करता हूं (जो काम वैसे ही करता है जैसे मैं चाहता हूं कि कैसे-कैसे Ordस्ट्रिंग्स काम करें), और उस पत्र को छोड़ दें जिसे मैंने शुरुआत में जोड़ा था, रिक्त स्थान से छुटकारा पाएं, और परिणाम का उत्पादन करें।

Comments

इसके बजाय drop 1, बस का उपयोग करेंtail

— बेर्गी

@Bergi Haha derp, धन्यवाद! मैंने इसे पोस्ट में बदल दिया।

— फ्लोंक

Answer 11

C, 99 वर्ण

t[256];main(c){for(--*t;++t[1+tolower(getchar())];);for(c=97;c<123;c++)while(t[c]--)putchar(c-1);}

यदि एक से कम नईलाइन प्रदान की जाए तो यह दुर्घटनाग्रस्त हो जाती है। मुझे लगता है कि यह काफी आसानी से तय किया जा सकता है।

Comments

मैंने कोशिश की, लेकिन यह सही परिणाम नहीं दे पाया। gist.github.com/romaninsh/11159751

— romaninsh

Answer 12

kdb (q / k): 59 वर्ण:

d:.Q.a! 26#0
.z.pi:{d|:.Q.a##:'=_y}.z.exit:{-1@,/.:[d]#'!:d}

• वर्णमाला से पूर्व-क्रमबद्ध बीज शब्दकोश उत्पन्न करें ।Qa
• इनपुट की प्रत्येक पंक्ति को संसाधित करें, लोअरकेस में बदलें, समूह को शब्दकोश में बदलें, प्रत्येक तत्व को गिनें, परिणाम से वर्णानुक्रमिक वर्ण लें (इस चरण में इने प्रून स्पेस, नईलाइन्स इत्यादि) और चल रहे कुल को रखने के लिए ग्लोबल डी के लिए अधिकतम-असाइन का उपयोग करें।
• एग्जिट हैंडलर को परिभाषित करें, जो कि एक सीमांकक को बचाने के लिए .z.pi में पास हो जाता है लेकिन अन्यथा अप्रयुक्त होता है। वर्णों की सूची बनाने के लिए प्रत्येक कुंजी-मूल्य से लें, समतल करें और अंत में stdout में प्रिंट करें।

-1 एक नई पंक्ति जोड़ता है, 1 का उपयोग करके एक चरित्र को बचाया जाएगा, लेकिन निर्दिष्ट आउटपुट उत्पन्न नहीं करता है। काश मैं .z.pi / .z.exit बॉयलरप्लेट से छुटकारा पाता, जो 14 वर्णों को हटा देता।

संपादित करें: बीज शब्दकोश का उपयोग करके अंतर / asc के उपयोग से बचें।

Answer 13

पर्ल, ४६

for$:(a..z){$a[ord$:]|=$:x s/$://gi}}{print@a

यहां एक और पर्ल समाधान है, STDIN से पढ़ता है, -nस्विच की आवश्यकता होती है (+1 से गिनती), प्राइमो के स्कोर के साथ संबंध लेकिन शिकायतों के बिना चलता है :-)। यह इस तथ्य का फायदा उठाता है कि बिटवाइज़ orके परिणाम में लंबे समय तक तर्क की लंबाई होती है।

Comments

मेरे परीक्षण के साथ की कोशिश की और यह बहुत अच्छा काम किया।

— रोमिंश

Answer 14

मैं अपना समाधान जोड़ रहा हूं:

बैश - 72

मानता है कि इनपुट फ़ाइल "i" में है

for x in {A..Z};do echo -n `cat i|sed "s/[^$x]//g"|sort -r|head -1`;done

व्याख्या

प्रत्येक संभावित पत्र के लिए, इसे केवल इनपुट फ़ाइल से फ़िल्टर किया जाता है जिसके परिणामस्वरूप कुछ इस तरह होता है:

AAA
A
A

AAAA

A
AAAAAAAAAAAAAAAA

फिर परिणाम को क्रमबद्ध किया जाता है और सबसे लंबी रेखा का चयन किया जाता है। echo -nवहाँ नए सिरे से हटाने के लिए है।

Answer 15

बैश, 171 159 जंक आउटपुट के साथ 158, 138

लोअरकेस-केवल इनपुट की आवश्यकता है। मान लेता है कि फ़ाइल को _(अंडरस्कोर) कहा जाता है । कष्टप्रद फाइलनाम जो splitबनाता है (xaa, xab ... xaz, ???) के कारण इनपुट फ़ाइल में अधिकतम 26 लाइनें । "

में bash, {a..z}आउटपुट a b c d e f ...।

touch {a..z}
split _ -1
for l in {a..z}
do for s in {a..z}
do grep -so $l xa$s>b$l
if [ `wc -l<b$l` -ge `wc -l<$l` ]
then mv b$l $l
fi
done
tr -d '\n'<$l
done

नमूना उत्पादन

acdddeghillmmmoostvyy

व्याख्या

touch {a..z}

ऐसी फ़ाइलें बनाएँ, जिन्हें हम बाद में पढ़ेंगे ताकि बाश की शिकायत न हो कि वे मौजूद नहीं हैं। यदि आप इस लाइन को हटाते हैं तो आप 13 वर्णों को बचाएंगे लेकिन बहुत अधिक रद्दी आउटपुट प्राप्त करेंगे।

split _ -1

इनपुट फ़ाइल को अनुभागों में विभाजित करें, प्रत्येक में 1 पंक्ति जमा हो। इस कमांड को बनाने वाली फाइलों का नाम xaa, xab, xac और इसी तरह है, मुझे पता नहीं क्यों।

for l in {a..z}
do for s in {a..z}

प्रत्येक पत्र के लिए $lफ़ाइलों में संग्रहीत सभी लाइनों के माध्यम से पढ़ा जाता है xa$s।

do grep -so $l xa$s>b$l

-s1 char को बचाने के लिए स्विच निकालें और बहुत सारे जंक आउटपुट प्राप्त करें। यह बिना grepफाइल के शिकायत करने से रोकता है (तब तक घटित होगा जब तक कि आपके पास इनपुट की 26 लाइनें न हों)। यह फ़ाइल xa$sको संसाधित करता है , लेकिन कुछ भी निकालता है $lऔर फ़ाइल में आउटपुट भेजता है b$l। इसलिए "आई लव मॉमी" प्रत्येक अक्षर के बाद एम होने पर नई लाइनों के साथ "एमएमएम" बन जाता $lहै।

if [ `wc -l<b$l` -ge `wc -l<$l` ]

अगर हमारे द्वारा बनाई गई फ़ाइल में लाइनों की संख्या (यानी एक अक्षर से अधिक अक्षरों के बराबर) से अधिक है (यानी प्रति पंक्ति में एक अक्षर है) हमारे उच्चतम परिणाम में लाइनों की संख्या अब तक (संग्रहीत $l) ...

then mv b$l $l

... हमारे नए रिकॉर्ड को फ़ाइल में संग्रहीत करें $l। इस लूप के अंत में, जब हम सभी लाइनों से गुजरे हैं, तो फ़ाइल $lप्रत्येक अक्षर में x लाइनों को संग्रहीत करेगी $l, जहां x एकल पंक्ति में उस अक्षर के होने की उच्चतम संख्या है।

fi
done
tr -d '\n'<$l

नई लाइनों को हटाते हुए, उस विशेष पत्र के लिए हमारी फ़ाइल की सामग्री का उत्पादन करें। आप नई लाइनों को हटाने के लिए नहीं करना चाहते हैं, के साथ लाइन को बदलने trके लिए echo $l6 वर्ण बचत,।

done

Comments

GNU बैश के साथ की कोशिश की, संस्करण 3.2.51 (सेब), लेकिन इनपुट डेटा वाले एक मौजूदा फ़ोल्डर में '-l1aa' फ़ाइल ..

— romaninsh

@romaninsh यह हो सकता है कि आपके पास split( कोरुटिल से) का एक अलग संस्करण हो । मैं वर्तमान में Ubuntu 14.04 पर GNU बैश 4.3.8 और GNU कोरूटिल्स 8.21 चला रहा हूं और यह ठीक काम करता है (यह मैंने अपग्रेड करने से पहले Ubuntu 13.10 पर भी काम किया)। हालाँकि, मुझे प्रोग्राम और इनपुट फ़ाइल को एक अलग निर्देशिका में ठीक से काम करने के लिए रखना था - मुझे संदेह है कि यह केवल मेरे होम फ़ोल्डर में लाखों जंक फ़ाइलों के कारण था ।

@romaninsh वास्तव में, यदि आप स्क्रिप्ट में सटीक कमांड को split _ -l1देखते हैं : और आप ध्यान देते हैं कि आपका इनपुट सहेजा जा रहा है -l1aa, तो मुझे लगता है कि आपके संस्करण को विकल्प के रूप में split पहचानना नहीं -l1है और इसके बजाय इसे आउटपुट के लिए एक उपसर्ग बनाना है। । के बीच एक स्थान रखने की कोशिश करें -lऔर 1, या डाल --lines=1, या बस -1(यह एक अप्रचलित और अधिक गोल्फ सिंटैक्स प्रतीत होता है जो अब मैं पोस्ट को अपडेट करूंगा)।

Answer 16

सी #, 172 बाइट्स

var x="";foreach(var i in File.ReadAllText(t).ToLower().Split('\r','\n'))foreach(var j in i)if(x.Count(c=>c==j)<i.Count(c=>c==j))x+=j;string.Concat(x.OrderBy(o=>o)).Trim();

Comments

चतुर ... चालाक ... मैंने सोचा कि लिनक के साथ खेल रहा हूं, लेकिन संदेह है कि यह इन विपरीत प्राणियों के जितना छोटा होगा :)

— Noctis

Answer 17

अजगर 2 - 129

@ टैल से आइडिया

a,r=[0]*26,range(26)
for l in open('f'):a=[max(a[i],l.lower().count(chr(i+97)))for i in r]
print''.join(chr(i+97)*a[i]for i in r)

कुछ और वर्णों में समान कार्य करने के लिए कुछ और तरीके:

a=[0]*26
b='(chr(i+97)))for i in range(26)'
exec'for l in open("f"):a=[max(a[i],l.lower().count'+b+']\nprint"".join(a[i]*('+b+')'

a=[0]*26
b='(chr(i+97)))for i in range(26))'
exec'for l in open("f"):a=list(max(a[i],l.lower().count'+b+'\nprint"".join(a[i]*('+b

यह मानता है कि फ़ाइल को एक सुलभ निर्देशिका में f के रूप में सहेजा गया है। यह कार्यक्रम सीधे चलने योग्य है, जिसमें कोई अतिरिक्त इनपुट आवश्यक नहीं है।

Comments

क्यों गिरा वोट? क्षमा करें अगर मैंने कुछ गलत किया।

— ईसैक

Answer 18

गणितज्ञ v10 - 110

यह अभी तक बाहर नहीं है, लेकिन नए दस्तावेज को बहुत ध्यान से पढ़ना , मुझे लगता है कि यह काम करना चाहिए:

StringJoin@MapIndexed[#2~Table~{#1}&,Rest@Merge[Counts/@Characters@StringSplit[ToLowerCase@Input[],"\n"],Max]]

Answer 19

स्काला, 125 वर्ण

val i=""::io.Source.stdin.getLines.toList.map(_.toLowerCase);println('a'to'z'map(c=>(""+c)*i.map(_.count(_==c)).max)mkString)

पहले मैंने इनपुट पढ़ा, इसे लोअर केस में परिवर्तित किया और एक खाली लाइन जोड़ी।

फिर प्रत्येक पत्र के aलिए zमैं उस पत्र को अधिकतम बार दोहराता हूं जो किसी भी पंक्ति में दिखाई देता है (इसीलिए मुझे खाली पंक्ति की आवश्यकता है:max किसी रिक्त इनपुट पर कॉल नहीं किया जा सकता)। फिर मैं सिर्फ परिणामों में शामिल होता हूं और आउटपुट पर प्रिंट करता हूं।

किसी फ़ाइल से पढ़ने के लिए, कोड के आकार को बढ़ाकर 132 अक्षरों + फ़ाइल नाम की लंबाई के stdinसाथ बदलना fromFile("FILENAME")।

Answer 20

जावास्क्रिप्ट, 261 वर्ण

eval('s=prompt().toUpperCase().split("\\n");Z=[########0,0];H=Z.slice();s@r){h=Z.slice();r.split("")@c){if(c.match(/\\w/))h[c.charCodeAt(0)-65]++});H=H@V,i){return V>h[i]?V:h[i]})});s="";H@n,i){s+=Array(n+1).join(String.fromCharCode(i+97))});s'.replace(/@/g,".map(function(").replace(/#/g,"0,0,0,"))

eval(...)वास्तविक कोड प्राप्त करने के लिए निकालें और निष्पादित करें; यह ( कुछ ) संकुचित है।

sबहु-कार्य लाइनों की सरणी के रूप में और आउटपुट स्ट्रिंग के रूप में, hप्रति पंक्ति वर्णों Hका हिस्टोग्राम होता है और अब तक अधिकतम मूल्यों के साथ हिस्टोग्राम होता है। यह केस-असंवेदनशील है, और बस कुछ भी अनदेखा करता है, लेकिन अज़ और एज़ (मुझे लगता है ... जेएस सरणियां कभी-कभी अजीब होती हैं)।

_{अब सही :)}

Comments

यह सिर्फ वर्णों को दर्शाता है, न कि यह कि प्रश्न क्या पूछा गया है। पत्रों को इनपुट में किसी भी एक वाक्य को बनाने के लिए नंगे न्यूनतम सेट होने के लिए कुल होना चाहिए, उन सभी को नहीं। हालांकि आउटपुट को छाँटने की आवश्यकता को रोकने के लिए मुझे आपका दृष्टिकोण काफी पसंद है।

— मैट

@ मैट ओह यह सही है ... मैं इसे बाद में ठीक करूँगा। वास्तव में अभी समय नहीं मिला है।

— tomsmeding

सोच रहा था @कि अंत तक मेरे साथ क्या हो रहा है। मुझे यह पसंद है :)

— मैट

Answer 21

जावास्क्रिप्ट ( ईएस 5 ) 141 बाइट्स

मान लिया गया चर sबिना किसी मामले की जाँच आवश्यकताओं और सरणी आउटपुट के साथ इनपुट स्ट्रिंग है:

for(a in s=s[o=_='',y='split']('\n'))for(i=0;x=s[a][i++];)o+=x!=0&&(l=s[a][y](x).length-~-o[y](x).length)>0?Array(l).join(x):_;o[y](_).sort()

Comments

मैंने आपके समाधान का परीक्षण किया और आउटपुट के लिए "ओ" के अंदर देख रहा था, लेकिन यह ठीक से सॉर्ट नहीं किया गया लगता है। (देखें gist.github.com/romaninsh/11159751 )

— रोमनिंश

@romaninsh आउटपुट जो मैं आपके जिस्ट में देख रहा हूं वह ठीक तरह से सॉर्ट किया हुआ लगता है

— अंडरस्कोर

हां, यह एक संदर्भ / सही आउटपुट है। जब मैंने आपके कोड की कोशिश की, तो मुझे यह मिल गया है: gist.github.com/romaninsh/11161018

— romaninsh

माफी अगर मैंने आपके उदाहरण को गलत तरीके से निष्पादित किया है।

— रोमनिंश

@romaninsh आह, मैंने इसके लिए केवल ब्राउज़र के कंसोल में चलने का इरादा किया था। यहां एक संस्करण का सुधार किया गया है जो नोड पर काम करता है: gist.github.com/nderscore/96aa888c77d275c26c15

— nderscore

Answer 22

पॉवरशेल - 141

'A' नामक फाइल से टेक्स्ट पढ़ता है।

$x=@{}
gc a|%{[char[]]$_|group|%{$c=$_.name.tolower().trim()
$n=$_.count;$x[$c]=($n,$x[$c])[$n-lt$x[$c]]}}
($x.Keys|sort|%{$_*$x[$_]})-join""

Answer 23

ग्रूवी, 113/127 102/116 वर्ण

फ़ाइल को एक मामले में सभी मानते हैं (102 वर्ण):

t=new File('f').text;t.findAll('[A-Z]').unique().sort().each{c->print c*t.readLines()*.count(c).max()}

फ़ाइल को मिश्रित मामले में माना जाता है (116 वर्ण):

t=new File('f').text.toUpperCase();t.findAll('[A-Z]').unique().sort().each{c->print c*t.readLines()*.count(c).max()}

मूल रूप से:

• t=new File('f').text फ़ाइल का पाठ प्राप्त करने के लिए।
• t.findAll('[A-Z]').unique().sort().each{c-> अद्वितीय वर्ण प्राप्त करने के लिए, उन्हें क्रमबद्ध करें, और पुनरावृति करें।
• print c*t.readLines()*.count(c).max() एक ही पंक्ति में अधिकतम घटनाएँ प्राप्त करें और चरित्र को कई बार प्रिंट करें।

Answer 24

बैश (ज्यादातर जाग) - 172 163 157

awk -v FS="" '{delete l;for(i=1;i<=NF;i++)l[toupper($i)]++;for(i in l)o[i]=(o[i]>l[i]?o[i]:l[i])}END{for(i in o)for(j=0;j<o[i];j++)print i}'|sort|tr -d ' \n'

टेक्स्ट को जागृत करने के लिए (या फ़ाइल के रूप में निर्दिष्ट) करने की आवश्यकता है।

उदाहरण इनपुट

Hello
I love cat
I love dog
I love mommy
Mommy loves daddy

उदाहरण आउटपुट

ACDDDEGHILLMMMOOSTVYY

PHP (शायद बेहतर हो सकती है) - 174 210

$o=array();foreach(explode("\n",$s) as $a){$l=array();$i=0;while($i<strlen($a)){$k=ucfirst($a[$i++]);if($k==' ')continue;$o[$k]=max($o[$k],++$l[$k]);}}ksort($o);foreach($o as $k=>$v)for($i=0;$i<$v;$i++)echo $k;

मान लेता है कि स्ट्रिंग चर $ s में समाहित है

उदाहरण इनपुट

Hello
I love cat
I love dog
I love mommy
Mommy loves daddy

उदाहरण आउटपुट

ACDDDEGHILLMMMOOSTVYY

Answer 25

मुझे पता है कि यह शायद सबसे कुशल जवाब नहीं है, लेकिन मैं इस समस्या को हल करने की कोशिश करना चाहता था। यहाँ मेरी ओब्जेक भिन्नता है:

- (NSArray *) lettersNeededForString:(NSString *)sourceString {
    sourceString = [sourceString stringByReplacingOccurrencesOfString:@"\n" withString:@""];
    sourceString = [sourceString stringByReplacingOccurrencesOfString:@" " withString:@""];
    const char * sourceChars = sourceString.UTF8String;
    NSMutableArray * arr = [NSMutableArray new];
    for (int i = 0; i < sourceString.length; i++) {
        [arr addObject:[NSString stringWithFormat:@"%c", sourceChars[i]]];
    }
    return [arr sortedArrayUsingSelector:@selector(localizedCaseInsensitiveCompare:)];
}    

फिर आप इसे स्ट्रिंग के लिए कह सकते हैं:

NSArray * letters = [self lettersNeededForString:@"Hello\nI love cat\nI love dog\nI love mommy\nMommy loves daddy"];
NSLog(@"%@",letters);

मैं बड़ी मात्रा में पाठ के साथ अनुप्रयोगों के बारे में सोच रहा था और मुझे अपनी सरणी गिनने की आवश्यकता नहीं थी। इसके लिए, मैंने इसे प्राप्त करने के लिए विधि में जोड़ा:

- (NSDictionary *) numberOfLettersNeededFromString:(NSString *)sourceString {

    sourceString = [sourceString stringByReplacingOccurrencesOfString:@"\n" withString:@""];
    sourceString = [sourceString stringByReplacingOccurrencesOfString:@" " withString:@""];
    const char * sourceChars = sourceString.UTF8String;
    NSMutableArray * arr = [NSMutableArray new];
    for (int i = 0; i < sourceString.length; i++) {
        [arr addObject:[NSString stringWithFormat:@"%c", sourceChars[i]]];
    }

    static NSString * alphabet = @"abcdefghijklmnopqrstuvwxyz";
    NSMutableDictionary * masterDictionary = [NSMutableDictionary new];
    for (int i = 0; i < alphabet.length; i++) {
        NSString * alphabetLetter = [alphabet substringWithRange:NSMakeRange(i, 1)];
        NSIndexSet * indexes = [arr indexesOfObjectsPassingTest:^BOOL(id obj, NSUInteger idx, BOOL *stop) {
            if ([[(NSString *)obj lowercaseString] isEqualToString:alphabetLetter]) {
                return YES;
            }
            else {
                return NO;
            }
        }];

        masterDictionary[alphabetLetter] = @(indexes.count);
    }

    return masterDictionary;
}

जैसे भागो:

NSDictionary * lettersNeeded = [self numberOfLettersNeededFromString:@"Hello\nI love cat\nI love dog\nI love mommy\nMommy loves daddy"];
NSLog(@"%@", lettersNeeded);

तुम्हे दूंगा:

{a = 2; बी = 0; सी = 1; डी = 4; ई = 5; एफ = 0; जी = 1; एच = 1; i = 3; j = 0; के = 0; एल = 6; एम = 6; n = 0; ओ = 8; पी = 0; क्यू = 0; आर = 0; s = 1; टी = 1; यू = 0; v = 4; डब्ल्यू = 0; x = 0; y = 3; z = 0; }

जो मुझे लगता है कि अगर मेरे पास बहुत बड़ी मात्रा में पाठ है तो मुझे बेहतर होगा और मुझे यह जानने की जरूरत है कि मुझे प्रत्येक पत्र की कितनी आवश्यकता होगी।

Answer 26

के, ३४

{`$a@<a:,/(.:a)#'!:a:|/#:''=:'0:x}

Answer 27

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

import collections
c = collections.Counter()
for line in open("input.txt"):
    c |= collections.Counter(line.upper())
print "".join(sorted(c.elements()))

Comments

PCG में आपका स्वागत है! यह साइट मार्कडाउन सिंटैक्स का समर्थन करती है, जिसका उपयोग आप अपने कोड को प्रारूपित करने के लिए कर सकते हैं, ताकि यह अच्छा प्रतीत हो: कोड 4 रिक्त स्थान की प्रत्येक पंक्ति को इंडेंट करें।

— एल्गोरिथमशार्क

आपको संग्रह आयात करने के लिए आवश्यक वर्ण जोड़ना होगा।

— isacacg

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

— nzzk2

आप कथन sके अंत में गायब हैं importऔर withब्लॉक में इंडेंटेशन का अभाव है। और चूंकि यह कोड गोल्फ है, इसलिए आपको अनावश्यक व्हाट्सएप को हटाने के लिए बहुत लाभ होगा जहां संभव हो।

— फ्रैक्स्टिल

चूँकि यह कोड गोल्फ है, स्टेटमेंट के साथ हटा दें (सिर्फ एक कॉल को खोलने के लिए लूप) और मुझे नहीं लगता कि तत्वों को छांटने की आवश्यकता है।

— रेमकोगर्लिच

Answer 28

सी, 298 बाइट्स

char c;
int j,n;
char C[26];
char D[26];
int main()
{
char a='a';
while((c=getchar())>=0)
{
c=tolower(c);
if(c>=a&&c<='z'){j=c-a;D[j]++;}
if(c=='\n'){
for(j=0;j<26;j++){
if(D[j]>C[j])
{C[j]=D[j];}
D[j]=0;
}
}
}
for(j=0;j<26;j++)
{
n=C[j];
while(n--)
{
putchar(a+j);
}
}
}

एरे डी प्रत्येक पंक्ति के लिए अक्षरों का मिलान रखता है, फिर अधिकतम गणना सी में कॉपी की जाती है।

नोट: मैंने अपना जवाब कल दे दिया था लेकिन अब सूचीबद्ध नहीं है, हो सकता है कि मैंने गलती से संपादित करने के बजाय डिलीट दबाया हो?

Comments

यह केवल 271 बाइट्स है। आपके पास बहुत से एक्सट्रॉनिक न्यूलाइन्स भी हैं। इसके अलावा, आप कर सकते हैं intसे int main()और छोड़ सकते हैं int j,n;।

— nyuszika7h

साथ ही, आपका पिछला उत्तर अभी भी है।

— nyuszika7h

Answer 29

PHP, 143 बाइट्स

यह मानते हुए कि इनपुट को चर में पारित किया गया है $s:

$i=explode("\n",$s);foreach(range('a','z')as$c){$x=array_map(function($l)use($c){return substr_count($l,$c);},$i);echo str_repeat($c,max($x));}

व्याख्या

प्रत्येक संभावित पत्र के लिए, मैं एक उपयोगकर्ता-परिभाषित फ़ंक्शन के माध्यम से स्ट्रिंग की सूची युक्त मानचित्रण कर रहा हूं जो प्रत्येक पंक्ति को उपयोग किए गए वर्णों की संख्या के साथ बदल देता है। अक्षर 'd' के लिए "मम्मी डैडी से प्यार करता है" को 3 में मैप किया जाएगा।

बाद में मुझे यह कई बार सरणी और आउटपुट पत्र के अंदर अधिकतम मूल्य लगता है। यहाँ बहु-पंक्ति संस्करण है:

$i=explode("\n",$s);
foreach(range('A','Z')as $c){
    $x=array_map(function($l)use($c){
        return substr_count($l,$c);
    },$i);
    echo str_repeat($c,max($x));
}

Answer 30

पायथन (209, जिसमें नमूना शामिल है, 136 बिना।):

from collections import*;c=Counter()
for i in ["Hello","I love cat", "I love Dog", "I love mommy", "Mommy loves daddy"]:
 for j in i.lower(): c[j]=max(c[j],list(i).count(j))
print "".join(sorted(c.elements()))

मैं आज दोपहर एक PYG नमूना पोस्ट करूँगा।

Comments

मुझे नहीं पता था कि पायथन स्ट्रिंग्स की एक गणना पद्धति थी ... मुझे नहीं लगता कि इस नए पाए गए ज्ञान का उपयोग करने के लिए प्रश्न के उत्तर को बदलने के लिए इसे वैध माना जाए? : पी

— ताल

@ वे नहीं करते। यह एक सूची की एक विधि है, अगर आप करीब देखो

— ɐɔıʇǝɥʇuʎs

ओह, मैं देख रहा हूँ ... लेकिन एक अप्रत्याशित मोड़ में यह पता चलता है कि तार स्पष्ट रूप से इस विधि के साथ ही (3.x में भी) है

— ताल