ऑटो बैच गोल्फर

25

मैं BATCH से प्यार करता हूं, इसके बावजूद कार्यात्मक कमांड्स की चौंकाने वाली कमी के बावजूद, इसके पूर्ण-गैर-पूर्णांक समर्थन की कमी के कारण। क्यूं कर? क्योंकि यह काम करता है:

SET var=SET
%var% i=0

यह मूल्यांकन करेगा:

SET var=SET
SET i=0

शानदार है, है ना? मैंने इस तकनीक का उपयोग BATCH कार्यक्रम से पहले किया है, क्योंकि यह बाइट्स बचाता है!

आपकी चुनौती, क्या आपको इसे स्वीकार करना चाहिए, इस तरह से "गोल्फ" बैच कार्यक्रम होंगे। आपको ऐसे इनपुट BATCH प्रोग्राम के बाइट का आकार घटाना है, जिसमें ऐसे SETबयान शामिल हैं जो कार्यक्रम के कुछ हिस्सों का मूल्यांकन करेंगे, और किसी अन्य तरीके से कार्यक्रम को संशोधित नहीं करेंगे। (यह कहता है, परिवर्तनशील नाम को कुछ कम करने के लिए, यह अस्वीकार कर दें। ध्यान रखें कि BATCH, वैरिएबल से निकलता है, मामला असंवेदनशील है।) आपका स्कोर इस प्रकार गिना जाता है:

score = # of characters in your program + 5*(net result bytes in test cases below)

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

इस चुनौती के लिए, अपने SETबयान नियंत्रण वर्ण (शामिल नहीं हो सकता |, <, >, %) या लाइनब्रेक। आप एक सेट स्टेटमेंट के अंदर कोड के टुकड़ों को स्थानांतरित करने के अलावा अन्य कोड को संशोधित नहीं कर सकते हैं। (अर्थात्, आप अनावश्यक व्हाट्सएप को नहीं हटा सकते हैं, इसके EQUसाथ प्रतिस्थापित कर सकते हैं ==, आदि) हम मान लेंगे कि लाइनें समाप्त हो रही हैं \n।

परीक्षण के मामलों

प्रत्येक परीक्षण का मामला एक अलग कोड ब्लॉक में है, और प्रत्येक परीक्षण का मामला आत्म-निहित है, जिसका अर्थ है कि आपको केवल यह मानकर चलना चाहिए कि इसके भीतर क्या दिया गया है। (यानी, यदि आप SET d=SETएक कार्यक्रम में हैं, तो वह कथन स्वचालित रूप से किसी अन्य कार्यक्रम को नहीं दिया जाएगा)। प्रत्येक उदाहरण परिणाम प्रत्येक परीक्षण मामले के बाद पाया जा सकता है। परीक्षण मामलों के बीच एक रेखा होती है।

@ECHO रवाना
वेतन वृद्धि = १०
: पाश
यदि% वृद्धि% EQU 0 GOTO समाप्त होती है
ECHO% वेतन वृद्धि%
सेट / ए% वृद्धि% - = 1
गोटो लूप
:समाप्त
बाहर जाएं
@ECHO रवाना
SET / p INPUT = यहां इनपुट दर्ज करें:
सेट R =% 1
ECHO इनपुट का अंतिम चार्ट यहां:% R: ~ -1%
@ECHO रवाना
वेतन वृद्धि = १०
: ई
बचना
ईसीएचओ एफ
: च
गोटो जी
ECHO जी
: जी
गोटो एच
ईसीएचओ एच
: ज
गोटो मैं
ECHO i
:मैं
गोटो जे
ईसीएचओ जे
: j
IF 3 == 4 (ECHO 4) ELSE (ECHO 5)
IF 5 == 3 (GOTO l) ELSE (GOTO k)
: कश्मीर
ECHO हो गया।
ECHO बैट बाहर !!
बाहर जाएं
: एल
गोटो जी
ईसीओ हैलो, हैलो, हैलो, हैलो, हैलो, हैलो, हैलो,!, हैलो, एलो !, लेलो।

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

@ECHO रवाना
वेतन वृद्धि = १०
: पाश
यदि% वृद्धि% EQU 0 GOTO समाप्त होती है
ECHO% वेतन वृद्धि%
सेट / ए% वृद्धि% - = 1
गोटो लूप
:समाप्त
बाहर जाएं
(0 बाइट्स सहेजे गए)

@ECHO रवाना
SET% i% = इनपुट यहां:
SET / p INPUT =% i% दर्ज करें
सेट R =% 1
ECHO% I%% का अंतिम चार्ट R: ~ -1%
(3 बाइट्स प्राप्त)

@ECHO रवाना
वेतन वृद्धि = १०
सेट जी = गोटो 
सेट ई = ईसीएचओ 
: ई
% छ% च
% E% च
: च
% छ% छ
% E% छ
: जी
% छ% ज
%एह
: ज
% छ% i
% E% मैं
:मैं
% छ% j
% E% j
: j
IF 3 == 4 (% e% 4) ELSE (% e% 5)
IF 5 == 3 (% g% l) ELSE (% g% k)
: कश्मीर
% E% हो गया।
% ई% बचन बाहर !!
बाहर जाएं
: एल
% छ% छ
(10 वर्ण सहेजे गए)

SET% h% = ello,
ईसीएचओ एच% एच% एच% एच% एच% एच% एच% एच% एच% एच% एच% एच% नमस्ते !, एच एच एच% एलो !, लेलो।
(1 चरित्र सहेजा गया)

string  metagolf 
— कोनोर ओ ब्रायन
स्रोत
2
मज़ा और लाभ के लिए छोटा बैच!
— एलेक्स कार्लसन
आपको कुछ और विशिष्टताओं की आवश्यकता है। बेशक AAA %increment%→ set a=increment¶AAA %%a%%अमान्य है, और AAA %1 BBB %2→ set a= BBB ¶AAA %1%a%%2वैध है। (iirc) इसलिए आपको इसे औपचारिक रूप देने की आवश्यकता है। ( एक नई
— पंक्ति का
क्या हमें उस कोड को संभालने की आवश्यकता है जिसने विस्तार में सक्षम, प्रतिशत-चिह्न से बचने, या बहु-पंक्ति के लिए / यदि कथन में देरी की है? पिछले परीक्षण के मामले के अनुसार (जो प्रतिध्वनि के रूप में अतिरिक्त आउटपुट उत्पन्न करता है और वहां @पहले से नहीं है SET) गोल्फ प्रोग्राम से एक्स्ट्रोजन आउटपुट स्वीकार्य है?
— Οurous
1
सभी पर फिर से झुकें
— वें
1
इसके बावजूद भी ?
— आदम

जवाबों:

4

जावा 8, जावा 10 , 3884 799/795 प्रोग्राम + 484 आउटपुट = 4368 1283/1279 कुल

इस कोड की दो सीमाएँ हैं:

  • यह मानता है कि A से Z तक के चर स्वतंत्र हैं। (अपरकेस)
  • यह मानता है कि 27 से अधिक प्रतिस्थापन नहीं हैं।
  • ओह, और क्योंकि स्कैनर ने इसे नहीं काटा, खाली इनपुट स्टैकट्रेस को बाहर निकालता है।

लेकिन हे - एक समर्थक है!

  • आउटपुट सबसे अच्छा कोड। हमेशा।

कोड चुनौती लेखक द्वारा प्रदान किए गए उदाहरणों से बेहतर प्रदर्शन करने का प्रबंधन करता है।

इस गोल्फ संस्करण को केविन ने बनाया है ।

जावा 8

c->{List<String>S=new Stack();HashMap<String,Integer>h=new HashMap(),s=new HashMap();int v=65,l=c.length(),b,e;do{for(b=0,l=c.length(),s.clear();b!=l;b++)for(e=b;++e<=l;)S.add(c.substring(b,e));S.removeIf(t->t.length()<5|t.matches(".*[\n|<%>].*"));S.forEach(t->h.merge(t,1,Integer::sum));S.clear();h.entrySet().removeIf(t->t.getValue()==1);String Y=c;int L=l;char V=(char)v;h.forEach((k,x)->{String i=Y,t;for(int j,I,q;i.contains(k);i=t+"%"+V+"%"+i.substring(j+k.length(),i.length())){for(I=-1,t=i.substring(q=0,j=i.indexOf(k));(I=t.indexOf("%",++I))>=0;q++);if(q%2>0)return;}i="SET "+V+"="+k+"\n"+i;if(i.length()<L)s.put(i,L-i.length());});h.clear();v++;c=s.isEmpty()?c:s.entrySet().stream().max((x,y)->x.getValue()>y.getValue()?1:-1).get().getKey();}while(l>c.length());return c;}

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

जावा 10

c->{var S=new Stack<String>();HashMap<String,Integer>h=new HashMap(),s=new HashMap();int v=65,l=c.length(),b,e;do{for(b=0,l=c.length(),s.clear();b!=l;b++)for(e=b;++e<=l;)S.add(c.substring(b,e));S.removeIf(t->t.length()<5|t.matches(".*[\n|<%>].*"));S.forEach(t->h.merge(t,1,(x,y)->x+y));S.clear();h.entrySet().removeIf(t->t.getValue()==1);var Y=c;int L=l;var V=(char)v;h.forEach((k,x)->{String i=Y,t;for(int j,I,q;i.contains(k);i=t+"%"+V+"%"+i.substring(j+k.length(),i.length())){for(I=-1,t=i.substring(q=0,j=i.indexOf(k));(I=t.indexOf("%",++I))>=0;q++);if(q%2>0)return;}i="SET "+V+"="+k+"\n"+i;if(i.length()<L)s.put(i,L-i.length());});h.clear();v++;c=s.isEmpty()?c:s.entrySet().stream().max((x,y)->x.getValue()>y.getValue()?1:-1).get().getKey();}while(l>c.length());return c;}

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

मूल संस्करण

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

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Scanner;
import java.util.function.BiConsumer;
import java.util.function.Consumer;
import java.util.function.Predicate;

public class Main {
	List<String> substrings = new ArrayList<String>();
	HashMap<String, Integer> hm = new HashMap<String, Integer>();
	HashMap<String, Integer> scores = new HashMap<String, Integer>();
	
	private int v1 = 65;
	
	public static String rfos(String inputString, String stringToReplace,
	        String stringToReplaceWith) {

	    int length = stringToReplace.length();
	    int inputLength = inputString.length();

	    int startingIndexofTheStringToReplace = inputString.indexOf(stringToReplace);

	    if(count(inputString.substring(0, startingIndexofTheStringToReplace), "%") % 2 == 1)
	    	return null;
	    
	    String finalString = inputString.substring(0, startingIndexofTheStringToReplace) + stringToReplaceWith
	            + inputString.substring(startingIndexofTheStringToReplace + length, inputLength);

	    return finalString;

	}
	
	public static int count(String text, String find) {
        int index = 0, count = 0, length = find.length();
        while( (index = text.indexOf(find, index)) != -1 ) {                
                index += length; count++;
        }
        return count;
	}
	
	private String process(String program) {
		int begin = 0, end, il = program.length();
		
		scores.clear();
		
		while(begin != program.length()) {
			for(end = begin + 1; end < program.length() + 1; end++)
				substrings.add(program.substring(begin, end));
			begin++;
		}
		
		substrings.removeIf(new Predicate<String>() {
			@Override
			public boolean test(String arg0) {
				return arg0.length() <= 4 || arg0.contains("\n")
						|| arg0.contains("|")
						|| arg0.contains("<")
						|| arg0.contains("%")
						|| arg0.contains(">");
			}
		});
		
		substrings.forEach(new Consumer<String>() {

			@Override
			public void accept(String t) {
				if(hm.containsKey(t)) {
					hm.replace(t, hm.get(t) + 1);
				} else {
					hm.put(t, 1);
				}
			}
			
		});
		
		substrings.clear();
		
		hm.entrySet().removeIf(new Predicate<Map.Entry<String, Integer>>() {

			@Override
			public boolean test(Map.Entry<String, Integer> t) {
				return t.getValue() == 1;
			}
			
		});
		
		hm.forEach(new BiConsumer<String, Integer>() {
			
			@Override
			public void accept(String arg0, Integer arg1) {
				String iteration = program;
				boolean between = false;
				while(iteration.contains(arg0)) {
					iteration = rfos(iteration, arg0, "%" + Character.toString((char) v1) + "%");
					if(iteration == null)
						return;
				}
				iteration = "SET " + Character.toString((char) v1) + "=" + arg0 + "\n" + iteration;
				if(iteration.length() < program.length())
					scores.put(iteration, program.length() - iteration.length());
			}
			
		});
		
		hm.clear();
		v1++;
		
		if(scores.isEmpty())
			return program;
		else
			return scores.entrySet().stream().max((entry1, entry2) -> entry1.getValue() > entry2.getValue() ? 1 : -1).get().getKey();
	}

	public static void main(String[] args) {
		Main processor = new Main();
		int genid = 0, before = 0, after = 0;
		String currentCode = new Scanner(System.in).useDelimiter("\\Z").next();
		
		System.out.println("Calculating first generation...");
		
		do {
			String cc = processor.process(currentCode);
			before = currentCode.length();
			after = cc.length();
			
			currentCode = cc;
			
			if(before > after) {
				System.out.println("Generation " + genid++);
				System.out.println(before + " -> " + after);
				System.out.println("***\n" + cc + "\n***");
			} else {
				System.out.println("Generation FAIL " + genid++);
				System.out.println(before + " -> " + after);
				System.out.println("***\n" + cc + "\n***");
			}
		} while(before > after);
		
		
	}

}

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

SET B=GOTO 
SET A=ECHO 
@%A%OFF
SET increment=10
:e
%B%f
%A%f
:f
%B%g
%A%g
:g
%B%h
%A%h
:h
%B%i
%A%i
:i
%B%j
%A%j
:j
IF 3==4 ( %A%4 ) ELSE ( %A%5 )
IF 5==3 ( %B%l ) ELSE ( %B%k )
:k
%A%Done.
%A%BATCH OUT!!
EXIT
:l
%B%g

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

— क्रेज़सटेस्टो ज़्वेज़्स्की
स्रोत
मुझे लगता है कि सभी "java.util।" दोहराव है। आप अपने कोड को सरल बनाना चाहते हैं import java.util.*।
— एक
मैंने सोचा कि jdk आयात की गिनती नहीं है?
— मार्क जेरोनिमस
@A_ आप आप चाहते हैं के रूप में (जब तक यह मान्य है और इसे भावना रखता है) मेरा उत्तर संशोधित कर सकते हैं
— Krzysztof Szewczyk
1
" यदि आप, प्रिय पाठक, इस जवाब को पसंद करना चाहते हैं, तो कृपया इसे करें। " जावा 8 में जावा में 899 या 795 बाइट्स में 799 बाइट्स । आपका स्वागत है। :) निश्चित रूप से कुछ और गोल्फ हो सकता है, लेकिन यह अभी के लिए करेगा।
— केविन क्रूज़सेन
2
@KevinCruijssen योगदान के लिए धन्यवाद। मैंने आपके संस्करण को पोस्ट में जोड़ दिया है। अगर आपको कुछ बेहतर लगे तो मुझसे पूछे बिना इसे संपादित करने के लिए स्वतंत्र महसूस करें।
— Krzysztof Szewczyk
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.