एक असली सॉसेज फेस्ट


35

चूँकि अक्टूबर का पहला सप्ताहांत निकट आ रहा है, तो चलिए अपना खुद का Oktoberfest है!

पृष्ठभूमि

आपको और कुछ अन्य प्रोग्रामर को म्यूनिख, जर्मनी में स्थानीय सॉसेज लोगों द्वारा काम पर रखा गया है। सॉसेज लोग सभी सॉसेज को विशाल वोक्सफेस्ट की जरूरत के साथ ओकट्रफेस्ट प्रदान करते हैं। आप अपने बॉस को अन्य कर्मचारियों से बात करने के लिए प्रबंधित करते हैं कि आप और अन्य लोगों को बिना किसी पिछले सॉसेज-संबंधित अनुभव के क्यों काम पर रखा गया है। आपको एहसास होता है कि आप अपने त्रुटिहीन प्रोग्रामिंग कौशल के लिए काम पर रखे गए थे - और आपका बॉस स्पष्ट रूप से आपको सॉसेज विश्लेषक कोड करना चाहता है।

इस साल के आसपास, सॉसेज लोगों ने ओकटेर्फेस्ट में सॉसेज की विविधता को बढ़ाने का फैसला किया है - लेकिन उन्हें इस बात का कोई पता नहीं है कि उन्होंने कितना आयात किया है।

चुनौती

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

इनपुट

कई सॉसेज पर stdin, प्रत्येक सॉसेज एक स्थान से अलग हो गया। निम्नलिखित प्रारूप पर सॉसेज दिए गए हैं:

प्रिंस्कोरव (P)

 ¤
| |
| |
| |
 ¤

सालीचोन (एस)

 l
| |
| |
| |
| |
 l

लैंडजैगर (L)

\ /
| |
| |
| |
| |
/ \

कबानोस (के)

.
|
|
|
|
|
.

Cotechino Modena (C)

 ___
|   |
|   |
|   |
|___|

Rød pølse (R)

 ^
| |
| |
| |
| |
 v

उत्पादन

किसी दिए गए सॉसेज के होने के साथ-साथ यह भी पता चल जाता है कि यह सॉसेज किस तरह का है। पहचानकर्ता सॉसेज के नाम का पहला अक्षर है। आदेश महत्वपूर्ण नहीं है।

आउटपुट के लिए लिखा जाएगा stdout, अनुगामी newlines और रिक्त स्थान की अनुमति है।

उदाहरण

इनपुट

 ^   ^   ^   ^  .
| | | | | | | | |
| | | | | | | | |
| | | | | | | | |
| | | | | | | | |
 v   v   v   v  |
                .

उत्पादन

4R 1K

इनपुट

\ /  ___   l   ¤   ¤
| | |   | | | | | | |
| | |   | | | | | | |
| | |   | | | | | | |
| | |___| | |  ¤   ¤
/ \        l

उत्पादन

1L 1C 1S 2P

इनपुट

 l   ¤   l
| | | | | |
| | | | | |
| | | | | |
| |  ¤  | |
 l       l

उत्पादन

2S 1P

बाइट्स में सबसे कम कार्यक्रम वाला प्रोग्रामर सॉसेज दोस्तों (जीत) द्वारा भुगतान किया जाता है!

सॉसेज ट्रिविया

प्रिंस्कोरव
प्रिन्स्कोरव जो सीधे "राजकुमार-सॉसेज" में अनुवाद करता है, एक छोटा स्वीडिश सॉसेज है जिसे अक्सर लिंक्स में बेचा जाता है। आमतौर पर एक फ्राइंग पैन में तला हुआ और सरसों की एक उदार मदद के साथ परोसा जाता है।

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

Landjäger
Landjäger दक्षिणी जर्मनी, ऑस्ट्रिया, स्विटज़रलैंड और Alsace में पारंपरिक रूप से बनाया जाने वाला एक अर्ध-सूखा सॉसेज है। यह लंबी पैदल यात्रा जैसी गतिविधियों के दौरान स्नैक फूड के रूप में लोकप्रिय है। इसका सिपाही के भोजन के रूप में एक इतिहास भी है क्योंकि यह बिना प्रशीतन के रहता है और एकल-भोजन के हिस्से में आता है।

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

Cotechino मोडेना
Cotechino मोडेना या Cotechino di Modena एक ताजा सॉसेज है जो सूअर के मांस, फेटबैक और पोर्क रिंड से बनाया जाता है और यह मोडेना, इटली से आता है, जहां इसे PGI का दर्जा प्राप्त है। Cotechino को अक्सर मसले हुए आलू के साथ चटनी के साथ दाल या कैनेलिनी बीन्स के साथ परोसा जाता है, खासकर नए साल के आसपास।

Rød pølse
Rød pølse (लाल सॉसेज) एक प्रकार का चमकीला लाल, उबला हुआ पोर्क सॉसेज डेनमार्क में बहुत आम है। चूंकि डेनमार्क में हॉट डॉग स्टैंड सर्वव्यापी हैं, इसलिए कुछ लोग रॉल पोल्ज़र को राष्ट्रीय व्यंजनों में से एक मानते हैं।

सभी सॉसेज की जानकारी बेशर्मी से विकिपीडिया से कॉपी की गई


32
आप सॉसेज के बारे में एक ओकट्रोबफेस्ट-थीम वाली चुनौती लिख रहे हैं, और इसमें वेवुरस्ट शामिल नहीं है ? -1
मार्टिन एंडर

3
मैं उन नृशंस सॉसेज लोगों को दोष देता हूं!
स्वेरापोटो 10

31
आपने सॉसेज जानकारी को बिगाड़ने वाले टैग में क्यों डाला? यह है कि यह बुरा जा रहा से रखने के लिए?
एलेक्स ए।

10
@ MartinBüttner खैर मुझे लगता है कि आप कह सकते हैं ... यह सबसे तेज़ विचार था!
DankMemes

2
ट्रेलिंग रिक्त स्थान की अनुमति है। मुझे लगता है कि मेरा मतलब नई कहानियों को पीछे छोड़ने के बजाय ट्रेलिंग स्पेस लिखना था .. अब दोनों की अनुमति है!
स्वेरापॉटो

जवाबों:


8

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

jdm+hd@"SKLCRP"%Ced45rS-czd\/8

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

स्पष्टीकरण:

अन्य सभी प्रतिभागियों के रूप में मैं केवल इनपुट की पहली पंक्ति को देखता हूं। मान लीजिए कि इनपुट की पहली पंक्ति है \ / ___ l ¤ ¤ ____

सबसे पहले मैं रिक्त स्थान से विभाजित होता हूं, जो मुझे सूची देता है

['\\', '/', '', '___', '', '', 'l', '', '', '¤', '', '', '¤', '', '___']

अब हम '/'एस और ''एस की सवारी प्राप्त करना चाहते हैं और शेष चीजों को क्रमबद्ध करना चाहते हैं ।

['\\', '___', '___', 'l', '¤', '¤']

अब मैं रन-लेंथ-एनकोड कर सकता हूं।

[[1, '\\'], [2, '___'], [1, 'l'], [2, '¤']]

जैसा कि यह पता चला है, इन वर्णों या स्ट्रिंग के क्रम (ascii-value) को '___' अच्छी तरह से संख्याओं में मैप किया जा सकता है [0, 1, 2, 3, 4, 5]

char/string |  l   .   \    ___    ^   ¤  
-------------------------------------------
value       | 108  46  92 6250335  94 164  
value%45    |  18   1   2      15   4  29    
(value%45)%6|   0   1   2       3   4   5     

और इसका उपयोग उन्हें सीधे अक्षरों में मैप करने के लिए किया जा सकता है SKLCRP

jdm+hd@"SKLCRP"%Ced45rS-czd\/8
                        czd     split the input string at spaces
                       -   \/   remove "/"s (and also ""s)
                      S         sort
                     r       8  run-length-encode
  m                             map each pair d of ^ to:
   +hd                            d[0] + 
                Ced               convert d[1] to a number
               %   45             mod 45
      @"SKLCRP"                   take the ^th element in the string (mod 6)
jd                              join by spaces

19

पायथ, 36 34 32 30 बाइट्स

XjdsMrShM-czd\\8"¤_l/^.KRLSCP

अभी तक एक और 2 बाइट्स के लिए धन्यवाद बचा ... लगता है कि कौन? : डी

पहली पंक्ति को छोड़कर सभी इनपुट को अनदेखा करता है, सभी /s और रिक्त स्थान को हटाता है , इसे लक्ष्य पहचानकर्ताओं में अनुवाद करता है, इसे सॉर्ट करता है, रन-लंबाई एन्कोडिंग का उपयोग करता है, और परिणाम प्रिंट करता है।

लाइव डेमो।

32-बाइट संस्करण

XjdsMrS-hMfTczd\\8"¤_l/^.KRLSCP

लाइव डेमो।

@Jakube की बदौलत एक और 2 बाइट्स बचाए!

34-बाइट संस्करण

jdsMrSX-hMfTczd\\"¤_l/^.KRLSCP")8

लाइव डेमो।

2 बाइट्स @Jakube की बदौलत बची!

36-बाइट संस्करण

jdsMrSX-hMfTczd\/"¤_l\\^.""PCSLRK"8

लाइव डेमो।


6
मैंने आपको एक +1 दिया क्योंकि मुझे किर्बी
नचत - मोनिका

6
मैंने आपको +1 नहीं दिया क्योंकि आप बिल्कुल 4k प्रतिनिधि पर हैं :)
ETHproductions

मैं तुम्हें एक -1 आपको 4k पर वापस लाने के लिए देता हूं: डी
बीटा डेके

1
एक और दो बाइट ;-) hM-czd\\समान है-hMfTczd\\
जकुबे

1
@sweerpotato यहाँ देखें । ¤दो बाइट्स है।
kirbyfan64sos

8

जावास्क्रिप्ट (ईएस 6), 105

a=>[...'¤l/._^'].map((g,h)=>(f=(a.split(g).length-1)/'222261'[h],f?f+'PSLKCR'[h]:0)).filter(b=>b).join` `

यह बहुत आसान है, लेकिन यहाँ एक स्पष्टीकरण वैसे भी है:

input=>
  // list of all unique characters of the sausages
  [...'¤l/._^'].map((sausage_char, index)=>(
    // find all occurrences of the character in the string
    occurrences = (input.split(sausage_char).length - 1)
      / '222261'[index], // divide by the number of that character in its sausage
      // when dividing and multiplying by numbers in strings, JS automatically casts them
    occurrences ? // is there anything for this sausage?
      occurrences + 'PSLKCR'[index] : // add the sausage's letter and count
      0 // return 0 so it can be filtered out
  ))
  // filter out the 0s
  .filter(b=>b)
  // return a space-separated string
  .join` `

3
बहुत चालाक! इस संस्करण को गोल्फ के लिए ES7 के सरणी बोध का उपयोग करते हुए, मुझे 91 मिला: a=>(h=-1,[for(g of'¤l/._^')if(f=(a.split(g).length-1)/'222261'[++h])f+'PSLKCR'[h]].join` `)यदि केवल मैं ही घोषणा को सरल बना सकता h...
ETHproductions

@ETHproductions शांत! मुझे
DankMemes

8

CJam, 38 35 33 बाइट्स

l'_%'C*"l¤\^./""SPLRK "erS-$e`S*

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

व्याख्या

सॉसेज के प्रत्येक प्रकार की पहली पंक्ति अद्वितीय है, और चूंकि सॉसेज शीर्ष पर संरेखित हैं, इसलिए उस पहली पंक्ति में संबंधित वर्णों को गिनना पर्याप्त है। दो प्रकार के विशेष उपचार की आवश्यकता होती है:

  • Landjäger (L) में दोनों \और हैं /। हम उनमें से एक से छुटकारा चाहते हैं, फिर हम अन्य पात्रों की तरह एक दूसरे को गिन सकते हैं।
  • Cotechino Modena (C) के तीन अंडरस्कोर हैं, इसलिए हमें 3. से अंडरस्कोर काउंट को विभाजित करने की आवश्यकता है। हालाँकि, यह वास्तव में अंडरस्कोर को व्यक्तिगत रूप से उपचारित करने के लिए कम है, बस इनपुट में उनमें से रन को बदलकर (जो हमेशा केवल एक सॉसेज से संबंधित होता है) Cतुरंत लक्ष्य चरित्र ।

अब वास्तविक कोड के लिए:

l         e# Read one line from STDIN.
'_%       e# Split on runs of underscores.
'C*       e# Join back together by C's.
"l¤\^./"  e# Push a string with characters corresponding to each type, and a slash.
"SPLRK "  e# Push a string with the corresponding letters and a space.
er        e# Transliterate, turning each identifying character into the correct
          e# letter and all slashes into spaces.
S-        e# Remove spaces (which also gets rid of what used to be slashes).
$         e# Sort the string to group each letter.
e`        e# Run-length encode.
S*        e# Join by spaces.

जो कुछ भी आप करते हैं, स्प्लर्क के लिए मत भूलना।
टेलर लोपेज

6

गणितज्ञ ११६

कुछ बाइट्स शायद मुंडा हो सकते हैं, लेकिन गोल्फ भाषाओं से संपर्क करने के लिए कुछ भी नहीं।

Row[Row/@Reverse/@Tally@ImportString[#,"Table"][[1]]/.{"¤"->"P","l"->"S","/"->"L","___"->"C","."->"K","^"->"R"}," "] &

ImportString[#,"Table"][[1]]इनपुट की शीर्ष पंक्ति में दिखाई देने वाले अंतरिक्ष-पृथक स्ट्रिंग्स की एक सूची देता है। स्ट्रिंग सूची में किसी भी तत्व को {"¤","l","/","___",".","^"}दोहरा सकती है, जिसमें दोहराव भी शामिल है। प्रत्येक तत्व एक विशिष्ट प्रकार के सॉसेज के साथ जुड़ा हुआ है।

Tally इस तरह के प्रत्येक स्ट्रिंग के प्रकट होने की संख्या को गिना जाता है।

/.{"¤"->"P","l"->"S",...के ¤साथ की जगह P, के lसाथ Sऔर इतने पर।

Reverse आइटम से पहले प्रत्येक मिलान को इसके साथ जोड़ा जाता है।

Rowआउटपुट में दो का प्रारूप है।


6

MATLAB, 113

यह मानते हुए कि अनुगामी स्थानों की अनुमति है (हां वे हैं), यहां MATLAB गुमनाम फ़ंक्शन है:

@(a)arrayfun(@(p,m)fprintf([(m>32&&p)*'%d%c ' ''],p,m),histc(strtok(strrep(a,'___','_'),10),'./\^_l¤'),'K LRCSP')

और एक स्पष्टीकरण:

@(a) %Anonymous function, with an input a
    arrayfun(@(p,m) %Loop through the two input arrays (see later)
                   fprintf( %Print to console
                           [(m>32&&p)*'%d%c ' ''] %Essentially this means if p>0 and m>' ', print an integer followed by a char, then a space
                                                 ,p,m) %The values from the array input is what is getting printed
                                                      ,histc( %Make an array of how many times 
                                                                       strtok(strrep(a,'___','_'),10), %Keep only the first line (as that is where the interesting bit is) and also replace ___ with _ for the 'C'
                                                             './\^_l¤'), %these inputs appear (which will be passed in turn as the 'p' variable to cellfun)
                                                                        'K LRCSP' %These are the characters to be printed with the count representing each sausage (it will be placed in the 'm' input of arrayfun)
             )

सही ढंग से काम करने की अपील करता है। अभी भी अनुगामी स्थान है, लेकिन अब सभी सॉसेज को सही ढंग से संभालता है।


3

पर्ल, 84 77 बाइट्स

किसी को शायद यह थोड़ा दूर दाढ़ी कर सकता है ...

84 बाइट्स

($s=<>)=~y|_^\.l\\¤|CRKSLP|d;$$_++for split//,$s;$C/=3;for(A..Z){print"$$_$_ "if$$_}

77 बाइट्स

$$_++for split//,<>=~y|_^\.l\\¤|CRKSLP|dr;$C/=3;for(A..Z){print"$$_$_ "if$$_}

टूट - फूट:

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

प्रत्येक वर्ण के लिए चर बनाने और / या वृद्धि के लिए प्रतीकात्मक संदर्भ का उपयोग करें।

$$_++ for split //, <> =~ y|_^\.l\\¤|CRKSLP|dr;

ट्रिपल-अंडरस्कोर के कारण सी चर को 3 से विभाजित करें

$C /= 3;

यदि वे शून्य से अधिक का मान रखते हैं, तो वर्णमाला के माध्यम से लूप और पत्र के साथ एकल-अक्षर कैपिटल चर को प्रिंट करें

for (A..Z) {
    print "$$_$_ " if $$_;
}

परीक्षा परिणाम: http://ideone.com/alpUlI

संपादित करें : ट्रांसपेरेट पास अनाम रिटर्न वैल्यू को सीधे करके 7 बाइट्स काटता है split


2

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

डारसे को इस सॉसेज को अभी भी और अधिक कटा जा सकता है, लेकिन यहां दस के लिए एक स्टार्टर है।

$a=<>;$a=~s/¤/h/g;$a=~s/_+/_/g;$a=~s/(\/| |\n)//g;$a=~s/\\/x/g;$h{$_}++ for split(//,$a);foreach (sort keys %h){print $h{$_};$_=~tr/^.hlx_/RKPSLC/;print "$_ ";}print "\n"

अनप्लग्ड संस्करण

$a=<>;              # get 1st line
$a=~s/¤/h/g;        # convert ¤ to h, avoid unicode hassles
$a=~s/_+/_/g;       # multiple consecutive _ to single _
$a=~s/(\/| |\n)//g; # strip / and spaces
$a=~s/\\/x/g;       # convert \\ to x to avoid regexp hassles

# build hash that counts occurences of character
$h{$_}++ for split(//,$a);

# print the answers
foreach (sort keys %h) {
 print $h{$_};
 $_=~tr/^.hlx_/RKPSLC/;
 print "$_ ";
}
print "\n";

परीक्षण के परिणाम

$ perl meaty.pl <test1.txt
1K 4R
$ perl meaty.pl <test2.txt
1C 2P 1S 1L
$ perl meaty.pl <test3.txt
1P 2S
$

2

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

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

x=input()
a={z:x.count(y)for y,z in zip('¤l/.^_','PSLKRC')}
a['C']//=3
print(' '.join(str(a[x])+x for x in a if a[x]))

व्याख्या

यह बहुत आसान है, कुछ भी पठनीय कह सकते हैं, लेकिन यहाँ एक छोटी व्याख्या वैसे भी है:

इनपुट की पहली एक पंक्ति पढ़ी जाती है, क्योंकि प्रत्येक सॉसेज को केवल पहली पंक्ति से निर्धारित किया जा सकता है।

अब a={z:x.count(y)for y,z in zip('¤l/.^_','PSLKRC')}एक शब्दकोश समझ है जो प्रत्येक प्रकार के सॉसेज (प्रत्येक प्रकार के सॉसेज zकी गिनती के लिए x.count(y), जहां ) के पहचानकर्ता को मैप करता हैy सॉसेज को परिभाषित चरित्र है)।

हम फिर Cotechino Modena (C) की गिनती को विभाजित करते हैं ट्रिपल अंडरस्कोर के कारण सॉसेज 3 से भाग देते हैं।

अंत में हम प्रिंट आउट परिणाम: print(' '.join(str(a[x])+x for x in a if a[x]))। यह एक बार में प्रत्येक सॉसेज के आउटपुट काउंट को बनाता है, लेकिन केवल अगर उस सॉसेज को कम से कम एक बार देखा गया ( a[x]शून्य नहीं है>> सत्य)। प्रत्येक गणना स्ट्रिंग को एक स्थान से जोड़ा जाता है और मुद्रित किया जाता है।


'a [x]' + '+ + a [x] के लिए ... को काम करना चाहिए (परीक्षण नहीं किया गया) और 5 बाइट्स बचाता है। 'एक बैकटिक होने के साथ।
agtoever
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.