স্ট্যাক এক্সচেঞ্জ স্টক এক্সচেঞ্জ ~ সংশোধিত [বন্ধ]


35

পটভূমি

আপনি নামী স্টক ফার্মের চেয়ে কিছুটা কম দামের জন্য সমস্ত ব্যবসায়ী। আপনারা সবাই ব্যবসায়ীদের একটি গ্রুপের অংশ যারা কেবলমাত্র একটি নির্দিষ্ট স্টককে কেন্দ্র করে।

প্রতি ঘন্টা প্রতিটি ট্রেডারের এক্স স্টক বা এক্স স্টক বিক্রয় করার সুযোগ রয়েছে। প্রতি রাউন্ডে 50 ঘন্টা এবং প্রতিযোগিতায় 3 রাউন্ড রয়েছে। রাউন্ডগুলির শেষে সর্বমোট গড় মূল্য সহ ব্যবসায়ী জামাইকা ভ্রমণে জয়ী হয়!

গেমপ্লের

প্রতিটিতে 50 টি করে 3 রাউন্ড রয়েছে।

প্রতিটি ব্যবসায়ী $ 5000 সঙ্গে বৃত্তাকার এবং শুরু 20 থেকে 30 জনের মতো শেয়ারের একটি র্যান্ডম সংখ্যা ভাগ করে। শেয়ারের দাম 10 থেকে 150 এর মধ্যে একটি এলোমেলো সংখ্যায় শুরু হয়।

প্রতিটি টার্ন প্রতিটি ব্যবসায়ী তাদের সামর্থ্যযুক্ত যে কোনও সংখ্যক শেয়ার কিনতে বা বর্তমানে তাদের কাছে থাকা যে কোনও শেয়ার বিক্রয় করতে পারে, প্রতিটি শেয়ারের বর্তমান দামের জন্য।

শেয়ার প্রতি মূল্য ক্রয়কৃত প্রতিটি শেয়ারের জন্য 1 এবং 5 এর মধ্যে একটি এলোমেলো সংখ্যায় বৃদ্ধি পায় এবং বিক্রি হওয়া প্রতিটি শেয়ারের জন্য 2 এবং 6 এর মধ্যে এলোমেলো মূল্য হ্রাস পায়। সর্বনিম্ন দাম $ 1।

এটি লক্ষণীয় গুরুত্বপূর্ণ যে সমস্ত ব্যবসায়ী একই সাথে তাদের লেনদেন প্রক্রিয়া করে, যার অর্থ যে কোনও ব্যবসায়ী শেয়ার কেনা / বেচার পরের মোড় পর্যন্ত দামকে প্রভাবিত করবে না।

3 রাউন্ডের শেষে সর্বোচ্চ গড় মানের খেলোয়াড় জিতল। রাউন্ড শেষে অবশিষ্ট অর্থের পরিমাণ নিয়ে এবং ব্যবসায়ীর মালিকানাধীন শেয়ারের সংখ্যা * বাজারের দাম বন্ধ করে মূল্য নির্ধারণ করা হয়।

আর্গুমেন্ট

আপনার প্রোগ্রামটি প্রতিটি বাজারের বর্তমান বাজারমূল্য, ব্যবসায়ীর বর্তমান অর্থের পরিমাণ এবং সেই ব্যবসায়ীর মালিকানাধীন শেয়ারের সংখ্যার শুরুতে পুনরায় চালু হবে।

উদা:

120 5000 0

আউটপুট

আপনার ট্রেডার প্রোগ্রামটি অবশ্যই পরিমাণটি অনুসরণ করতে চায় এমন ক্রিয়াটির সাথে সম্পর্কিত একটি চিঠি আউটপুট করতে হবে।

উদা:

B10 //Buy 10 shares

অথবা

S3 //Sell 3 shares

ব্যবসায়ীর মোড় ঘুরিয়ে এমন কিছু না করার বিকল্পও রয়েছে। এটি ডাব্লু বা অন্য কোনও কমান্ড আউটপুট দ্বারা অর্জন করা যেতে পারে যা 'বি> অ্যামেন্ট <' বা 'এস> অ্যামেন্ট <' নয়

জমা

আপনার প্রোগ্রামটি একটি 'প্লেয়ার /> আপনার প্রোগ্রামের নাম <' ডিরেক্টরিতে থাকবে:

+-- players
|   +-- BotNameFolder
|       +-- BotProgram   

আপনার কোডটি 'প্লেয়ার্স' ডিরেক্টরিটির ভিতরে থেকে চালানোর জন্য কমান্ড লাইন যুক্তির পাশাপাশি সরবরাহ করুন। উদাহরণস্বরূপ, টেস্ট 1 ব্যবসায়ী দিয়ে চালানো যেতে পারেjava -cp "Test1" Test1

অতিরিক্ত বিধি

এগিয়ে যান, নিজেকে ইমোওয়াল্ফ, আইডিসি অঙ্কুর করুন।

আপনার বটনেমফোল্ডার ডিরেক্টরিটির বাইরের কোনও কিছুর সাথে গোলযোগ নেই, রাউন্ড / টার্নগুলি জুড়ে অবিরাম তথ্যের জন্য সেখানে ফাইল তৈরি করতে দ্বিধা বোধ করবেন না।

সিমুলেশন ক্র্যাশ করার জন্য ইচ্ছাকৃতভাবে প্রোগ্রামগুলি তৈরি করবেন না।

আমি ব্যবহারকারী হিসাবে একাধিক এন্ট্রি গ্রহণ করব, যতক্ষণ না এন্ট্রিগুলি পৃথক সত্তা হিসাবে কাজ করে (কোনও অভ্যন্তরীণ ট্রেডিং নেই)।

লিডারবোর্ড

[java&-cp&"TestPlayer"&Test1]:$10027395221
[python&daydreamer/daydreamer.py]:$5000
[java&-cp&"DayTrader"&DayTrader]:$4713199930331196453

আমি প্রতিদিন অন্তত একবার লিডারবোর্ড আপডেট করার চেষ্টা করব

নিয়ামক

import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.InputStreamReader;
import java.math.BigInteger;
import java.util.Date;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Queue;
import java.util.Random;


public class Controller {

    public static BigInteger marketValue = BigInteger.valueOf(100);
    public static BigInteger newValue = BigInteger.valueOf(100);

    public static final char BUY = 'B';
    public static final char SELL = 'S';

    public static final int MARKET_INDEX = 1;
    public static final int MONEY_INDEX = 2;
    public static final int SHARE_INDEX = 3;

    public static int numRunning = 0;
    public static final int MAX_RUNNING = 10;

    public static void main(String[] args){
        try {
            BufferedReader br1 = new BufferedReader(new InputStreamReader(new FileInputStream("resources/config")));

            int numRounds = Integer.parseInt(br1.readLine());
            int turnsPerRound = Integer.parseInt(br1.readLine());

            //Create the array of players
            List<String> players = new LinkedList<String>();
            String line1 = null;
            while((line1 = br1.readLine()) != null){
                players.add(line1);
            }
            BigInteger[] totalVals = new BigInteger[players.size()];
            for(int i = 0; i < totalVals.length; i++){
                totalVals[i] = BigInteger.valueOf(0);
            }
            br1.close();

            //Begin processing
            for(int round = 0; round < numRounds; round++){
                //Create players' shares and currency array
                Map<String,BigInteger[]> vals = new HashMap<String, BigInteger[]>();
                for(int i = 0; i < players.size(); i++){
                    vals.put(players.get(i), new BigInteger[]{BigInteger.valueOf(5000), BigInteger.valueOf(getRandInt(20,30))});
                }
                marketValue = BigInteger.valueOf(getRandInt(10,150));
                newValue = marketValue;
                for(int turn = 0; turn < turnsPerRound; turn++){
                    marketValue = newValue;
                    Queue<Object[]> processQueue = new LinkedList<Object[]>();
                    for(String playerKey : vals.keySet()){
                        BigInteger[] valSet = vals.get(playerKey);
                        String[] pkParts = playerKey.split("&");
                        String[] parts = new String[pkParts.length + 3];
                        for(int i = 0; i < pkParts.length; i++){
                            parts[i] = pkParts[i];
                        }
                        parts[pkParts.length] = marketValue + "";
                        parts[pkParts.length + 1] = valSet[0] + "";
                        parts[pkParts.length + 2] = valSet[1] + "";
                        processQueue.add(new Object[]{playerKey, parts});
                    }

                    while(!processQueue.isEmpty() || numRunning > 0){
                        if(numRunning < MAX_RUNNING && !processQueue.isEmpty()){
                            numRunning++;
                            Object[] o = processQueue.poll();
                            String pKey = (String)(o[0]);
                            String[] p = (String[])(o[1]);
                            try {
                                Process proc = new ProcessBuilder(p).directory(new File("resources/players").getAbsoluteFile()).start();
                                BufferedReader br = new BufferedReader(new InputStreamReader(proc.getInputStream()));
                                String line = br.readLine();
                                br.close();
                                switch(line.charAt(0)){
                                case BUY :
                                    BigInteger numShares = new BigInteger(line.substring(1).trim());
                                    if(numShares.multiply(marketValue).compareTo(vals.get(pKey)[0]) <= 0){
                                        BigInteger[] tempVals = vals.get(pKey);
                                        tempVals[0] = tempVals[0].subtract(numShares.multiply(marketValue));
                                        tempVals[1] = tempVals[1].add(numShares);
                                        vals.put(pKey, tempVals);
                                        newValue = newValue.add(numShares.multiply(BigInteger.valueOf(getRandInt(0,2))));
                                        if(newValue.compareTo(BigInteger.valueOf(Integer.MAX_VALUE)) >= 1){
                                            newValue = BigInteger.valueOf(Integer.MAX_VALUE - 1);
                                        }
                                    }
                                    break;
                                case SELL:
                                    BigInteger shares = new BigInteger(line.substring(1).trim());
                                    if(shares.compareTo(vals.get(pKey)[1]) <= 0){
                                        BigInteger[] tempVals = vals.get(pKey);
                                        tempVals[0] = tempVals[0].add(shares.multiply(marketValue));
                                        tempVals[1] = tempVals[1].subtract(shares);
                                        vals.put(pKey, tempVals);
                                        newValue = newValue.subtract(shares.multiply(BigInteger.valueOf(getRandInt(5,10))));
                                        if(newValue.compareTo(BigInteger.valueOf(1)) <= -1){
                                            newValue = BigInteger.valueOf(1);
                                        }
                                    }
                                    break;
                                }
                            } catch (Exception e) {
                                System.err.println("[" + pKey + "] threw error:");
                                e.printStackTrace();
                            } finally{
                                numRunning--;
                            }
                        }else{
                            try{
                                Thread.sleep(50);
                                continue;
                            }catch(InterruptedException e){
                                continue;
                            }
                        }
                    }
                    System.out.println("Turn " + turn + " over: " + marketValue);
                }
                System.out.println("End of round market value is: " + marketValue);
                int count = 0;
                for(String player : vals.keySet()){
                    totalVals[count] = totalVals[count].add(vals.get(player)[0].add(vals.get(player)[1].multiply(marketValue)));
                    count++;
                }
                newValue = BigInteger.valueOf(100);
            }
            for(int i = 0; i < players.size(); i++){
                System.out.println("[" + players.get(i) + "]:$" + (totalVals[i].divide(BigInteger.valueOf(numRounds))));
            }
        } catch (Exception e) {
            System.err.println("An exception occured while running the controller.");
            e.printStackTrace();
        }
    }
    public static Random r = new Random(new Date().getTime());
    public static int getRandInt(int min, int max){
        return r.nextInt(max - min) + min;
    }
}

এটি সংকলন করুন java Controller.javaএবং নীচের মতো ডিরেক্টরি সহ একটি ডিরেক্টরি থেকে চালান:

+-- resources
|   +-- config
|   +-- players
|       +-- Player1Folder
|           +-- Player1Program
|       +-- Player2Folder
|           +-- Player2Program

ফাইলটি এর configমতো দেখতে হবে:

3
50
java&-cp&"TestPlayer"&Test1
python&daydreamer/daydreamer.py
java&-cp&"DayTrader"&DayTrader

প্রথম সংখ্যাটি রাউন্ডের সংখ্যা, দ্বিতীয় সংখ্যাটি প্রতি রাউন্ডে ঘুরানো হয় এবং তারপরে প্রতিটি খেলোয়াড়কে চালানোর আদেশ দেয়।

এম্পারস্যান্ডগুলির সাথে স্পেসগুলি প্রতিস্থাপন করুন! ( '&')

I আমি কি এই পোস্টের শব্দটি আদৌ উন্নত করতে পারি এবং আমাকে খুশি ট্রেডিংয়ে তা জানতে দিন!


4
দেখে মনে হচ্ছে একটি ব্যস্ত বাজারে দীর্ঘমেয়াদী প্রবণতাটি দেখতে পাবে যে শেয়ারটির নেতিবাচক মূল্য রয়েছে।
পিটার টেলর

6
আপনি কি গিথুব জাতীয় কিছুতে আপনার নিয়ামক প্রোগ্রাম রাখতে পারেন এবং একটি লিঙ্ক অন্তর্ভুক্ত করতে পারেন যাতে আমরা বাড়িতে পরীক্ষা করতে পারি?
পিটার টেলর

6
লিডারবোর্ডের দিকে তাকিয়ে আমার মনে হয় খেলাটি বর্তমানে ত্রুটিযুক্ত। উদাহরণস্বরূপ, $ 14 / শ থেকে শুরু করুন, 357 কিনুন (ব্যাংকে নিজের 357, $ 0)। এলোমেলো নম্বর চয়ন করুন (3) দাম 3 * 357 দ্বারা বেড়ে $ 1085 / sh হয়। পরের পর্ব. সমস্ত 357 টি শেয়ার (ব্যাংকে নিজের 0, $ 387,345) বিক্রয় করুন। এলোমেলো নম্বর চয়ন করুন (3) দাম 3 * 357 থেকে 14 ডলারে চলেছে sh পরের পর্ব. দুটি রাউন্ডের পরেও দাম পরিবর্তন হয়নি এবং আপনার ব্যাঙ্কে 77x বৃদ্ধি পেয়েছে (অন্যান্য শুরুতে এলোমেলো ভেরিয়েবলের সাথে মিল থাকলেও এর চেয়ে কম নাটকীয় ফলাফল হতে পারে)। আমি আরও যুক্তিসঙ্গত মানের জন্য প্রতিটি ভাগের পরিবর্তে প্রতিটি লেনদেনের পরিবর্তনের প্রস্তাব করছি ।

4
অথবা কেবল একটি বাস্তব অর্ডার বই তৈরি করুন।
o0 '

3
কেন এলোমেলো শেয়ার দিয়ে শুরু করবেন?
অ্যাভেরোয়েস

উত্তর:


18

আমি 'দিবস্বরূপ' উপস্থাপন করি, যিনি সর্বদা ঘুমিয়ে থাকেন এবং যে কোনও কিছু কেনা বা বিক্রয় করতে ভুলে যান। তিনি আশা করেন যে অন্যান্য খেলোয়াড়ের নেট ক্ষতি হবে। পাইথন কোড:

if __name__ == "__main__":
    print "W"

python daydreamer\daydreamer.py 120 5000 0আপনি চান যা মান সঙ্গে চালান ।

আমি পরে আরও গুরুতর উত্তর পোস্ট করব, এটি কেবল বল রোলিংয়ের জন্য :)


3
আমি মনে করি না এটি চলবে - আপনার প্রিন্টটি ইনডেন্ট করতে হবে।
isaacg

6
দেওয়া হয়েছে যে শেয়ারের দাম দীর্ঘমেয়াদে হ্রাস পাবে, ট্রেডিং না করা একটি দুর্দান্ত কৌশল হতে পারে।

5
একটি অদ্ভুত খেলা: একমাত্র বিজয়ী পদক্ষেপটি খেলাই নয়। দাবা খেলার দুর্দান্ত খেলা কেমন?
টিম এস

13

দিন ব্যবসায়ী

8/21/2014 এ করা নিয়ম পরিবর্তনের জন্য আপডেট হয়েছে, যেখানে খেলোয়াড়রা এখন 20-30 শেয়ার দিয়ে শুরু করেন।

যতটা সম্ভব কিনে, তারপরে যতটা সম্ভব বিক্রি করে।

দর্শন

আমরা আশা করি যে নীচের প্যাটার্নটি নিজেকে বারবার পুনরাবৃত্তি করবে। নোট করুন যে এই প্যাটার্নটি মেনে চলার দ্বারা আমরা এতেও অবদান রাখছি।

  • প্রত্যেকেই কেবল একটিকে কিনতে বা ধরে রাখতে পারে। মানটি কেবল বাড়তে পারে, তাই আমরা কিনতে পারি।
  • প্রত্যেকে আরও দুটি কিনতে, ধরে রাখতে বা বিক্রি করতে পারে round আমরা আশা করি না অনেক খেলোয়াড় রাউন্ড টুতে কিনবেন, তাই আমরা বিক্রি করি।

প্যাটার্নটি শুরুতে স্ফটিক স্পষ্ট। একের পর মান বাড়বে increase এটি দুই রাউন্ড পরে হ্রাস করা উচিত। এর বাইরে, অনুমানগুলি অস্পষ্ট হয়ে যায়। বাজার স্থিতিশীল হওয়ার আগে, আমি প্রথম রাউন্ডে ভাল করার প্রত্যাশা করি।

import java.math.BigInteger;

/**
 * Submission for http://codegolf.stackexchange.com/q/36515/18487
 * @author Rainbolt
 */
public class DayTrader {

    /**
     * @param args the command line arguments containing the current 
     * market value, our current money, and our current shares
     */
    public static void main(String[] args) {
        BigInteger marketValue = new BigInteger(args[0]);
        BigInteger myMoney = new BigInteger(args[1]);
        BigInteger myShares = new BigInteger(args[2]);

        // If we have less than or equal to 30 shares, buy as much as possible
        if (myShares.compareTo(new BigInteger("30")) <= 0) {
            System.out.println("B" + myMoney.divide(marketValue).toString());
        // Otherwise, sell as much as possible
        } else {
            System.out.println("S" + myShares.toString());
        }
    }

}

সঙ্গে সংকলন javac DayTrader.java। সাথে চালাও java -cp "DayTrader" DayTrader


1
ইয়া জাভা! আমার পক্ষে চালানো সহজ করে তোলে।
স্পোকট

6
আপনার বট তৈরির বাজারটি পূর্ণসংখ্যার জন্য সর্বাধিক সংখ্যার ছাড়িয়ে প্রসারিত, তাই আমি কোডটিতে বিগইন্টিজারগুলি প্রয়োগ করেছি। যেহেতু প্রত্যেকের কোড
ইনট

@ স্পোকট আমি বিগইন্টিজারটি ব্যবহার করতে আমার বাস্তবায়ন সম্পাদনা করেছি। আশা করি এটি সাহায্য করবে
রেইনবোল্ট

5
আমি মনে করি এটি নিয়মের একটি অন্তর্নিহিত সমস্যা। যদি কোনও ব্যবসায়ী 140 টি শেয়ারের মতো হয়ে থাকে তবে সে নিজেই বাজারটি নিয়ন্ত্রণ করতে পারে। দুটি দফায় তিনি 10 টির জন্য শেয়ার কিনতে পারবেন এবং সেগুলি প্রতি 140 টিতে বিক্রি করতে পারবেন, যার ফলে 1300% জয়ের দিকে যাবে (ধরে নিবেন কেউ এর বিপরীতে কাজ করে না)। এটি 5000 * 13 ^ 25 এর মতো কিছুতে বাড়বে, যা বড় to
Optokopper

2
@ স্পোকট আমি আপনাকে পিং করতে চেয়েছিলাম কারণ আপনার সাম্প্রতিক বিধি পরিবর্তনের পরে আমি আমার জমাটি পরিবর্তন করেছি।
রেইনবোল্ট

9

ওয়াল্ট ডিজনি - পাইথন 3

শেয়ারটি শৈল নীচে আঘাত না হওয়া পর্যন্ত ওয়াল্ট অপেক্ষা করে এবং তারপরে তার অর্থ যতটা অনুমতি দেয় তা কিনে ys তারপরে, দাম যখন বেড়ে যায় তখন সে সমস্ত বিক্রি করে দেয়।

ওয়াল স্ট্রিট ক্র্যাশের মধ্য দিয়ে যখন তিনি 'বেঁচে' গিয়েছিলেন ডিজনির কৌশলের উপর ভিত্তি করে। দুর্ভাগ্যক্রমে, আমার প্রোগ্রাম থিম পার্কগুলি তৈরি করতে পারে না ... কেবল যদি ...

চালান:

python3 waltdisney.py

কোড:

from sys import argv
import os

price=int(argv[1])
money=int(argv[2])
share=int(argv[3])

if os.path.exists('./buyingprice.txt'):
    f = open('buyingprice.txt', 'r')
    buyingprice=int(f.read())
    f.close()
else:
    buyingprice=0

if share > 0:
    if price > buyingprice*10:
        print('S'+str(share))
    else:
        print('W')
elif money > 0:
    if buyingprice==0:
        print('B10')
        m=open('buyingprice.txt', 'w')
        m.write(str(price))
        m.close()
    elif price <= buyingprice:
        print('B'+str(int(money/price)))
        g=open('buyingprice.txt', 'w')
        g.write(str(price))
        g.close()
    else:
        print('W')

আপনি আপনার প্রথম মুদ্রণ লাইনে একটি বন্ধ হওয়া প্রথম বন্ধনী অনুপস্থিত।
supersam654

@ সুপারসাম 654 ওহ হ্যাঁ, ধন্যবাদ
বিটা

ওয়াল্ট ডিজনি আসলে এই কৌশলটি ব্যবহার করেছিল বলে আপনার দৃ for়তার জন্য আপনি কোনও উত্সকে নির্দেশ করতে পারেন? স্টক এক্সচেঞ্জে ওয়াল্ট ডিজনি কো নামে একটি সংস্থা দেওয়া আছে এটি অনুসন্ধান করা কঠিন এবং ওয়াল্টের উইকিপিডিয়া পৃষ্ঠায় এটি উল্লেখ করা হয়নি।
মাইকেল


@ মিশেল আমি আমার ইতিহাসের শিক্ষকের কাছ থেকে তথ্যটি পেয়েছিলাম, তবে উত্সটি কিছুটা দুর্বল হলে দুঃখিত।
বিটা ক্ষয়

8

রূটি

কেবল তার কী আছে তা জানেন তবে তিনি বাজারে যাবতীয় ঝুঁকি নিয়ে দৃ .়প্রতিজ্ঞ। তিনি কিনতে পারলে তিনি পাবেন। যদি সে না পারে তবে তার নিজের যা আছে তা বিক্রি করে তাই পরের দিকে ঘুরে আসতে পারে। (এটি ডেট্রেডারের মতো চরম ব্যক্তির সাথে ভালভাবে কাজ করবে তবে মানটি যখন বাড়বে বলে মনে হয় তখন তা হ্রাস পাবে যদি স্বতঃ সংশোধন করে))

import java.math.BigInteger;

public class Tommy {
    public static void main(String[] args) {
        BigInteger Value = new BigInteger(args[0]);
        BigInteger Money = new BigInteger(args[1]);
        BigInteger Shares = new BigInteger(args[2]);

       if (Money.compareTo(Value)<1) {
           System.out.print("S" + Shares.toString());
       } else {
           System.out.print("B" + Money.divide(Value).toString());
       }
    }

}

Golfscript

এটি একই কোড তবে এটি যদি পছন্দসই হয়। বিগইন্টিজার জিনিসটির প্রয়োজন হলে আমি জাভা লিখেছিলাম। সহজ যেটি ব্যবহার করুন।

2$2$>{@@;;"S"\}{;\/"B"\} if

ভবিষ্যতের রেফারেন্সের জন্য, জিএসে সমস্ত সংখ্যা বড় সংখ্যার হয়।
পিটার টেলর

আমার ধারণা আমি তখন আর চিন্তা না করে মূল পোস্টটি করতে পারতাম! ভাল খবর.
কেইন

আমি প্রথমে মন্তব্য করেছিলাম যে আমি ভেবেছিলাম এটি ডেট্রেডারের সদৃশ, তবে তখন আমি বুঝতে পারি যে পরিস্থিতির কারণে আচরণটি একই রকম, এবং তারা অন্যান্য পরিস্থিতিতে ডাইভারেজ করতে পারে। আমি যদি কাউকে অসন্তুষ্ট করি তবে দুঃখিত। একসাথে সমৃদ্ধ করা যাক!
রেনবোল্ট

@ রেনবোল্ট আমি এটি লিখেছিলাম গল্ফস্ক্রিপ্ট, জমা দেওয়ার আগে ডুপ্লিকেটগুলির সন্ধান করা আপনার পড়া এবং জাভা সংস্করণটি লেখার জন্য কিছু বা আপনার কোড ব্যবহার করা হয়েছিল। মূল অংশটি কোনও সদৃশ নয় (বা আমি এটি জমা দিইনি) তবে এই ভলিটাইল মার্কেটগুলিতে একসাথে হওয়া শেষ। আমি অসন্তুষ্ট নই তবে আপনি যদি এটি খুব কাছাকাছি অনুভব করেন তবে আমি এটি অযোগ্য হওয়ার অনুরোধ করব (তবে কোডটি রয়ে গেছে, আমি এটি লিখতে শিখেছি যা পুরো বিষয়টি)। আপনার অগ্রাধিকার হিসাবে আমি এমনকি এক্ষেত্রে বিরক্ত হব না। দ্রষ্টব্য ভূমিকম্পগুলি প্রায় আপনার অনুরূপ তবে এটি অন্যভাবে করে (ফাইলগুলিতে সংরক্ষণ করে)।
কেইন

@ কেইন না, এটি মুছবেন না। আমি যেমন বলেছিলাম, আমি ভেবেছিলাম সেগুলি সদৃশ, তবে তারা অবশ্যই তা নয় । এগুলি আচরণের ক্ষেত্রে কেবল একই কারণে। আপনারা কী করছেন তা পুরোপুরি বুঝতে পারার আগে আমি একটি মন্তব্য পোস্ট করা ভুল ছিল যে সেগুলি সদৃশ ছিল।
রেইনবোল্ট

6

বাইঅ্যান্ডহোল্ড - সি

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

/* BuyAndHold
 * Code revised from OptoKopper's WaitForCrash.c
 */
int main(int argc, char *argv[]) {
    long long int share_price = strtoll(argv[1], NULL, 0);
    long long int money = strtoll(argv[2], NULL, 0);

    if (money >= share_price) {
        printf("B%lld\n", money / share_price);
    } else {
        printf("W\n");
    }

    return 0;
}

এর সাথে সংকলন করুন: জিসিসি বায়ানহোল্ড

এটি /। বাইন্ডহোল্ড মূল্যের অর্থগুলি ভাগ করে চালান


1
হাহা আমি আশা করছিলাম যে কেউ বয়অ্যান্ডহোল্ডের সাথে ডে-ট্রেডার পরিপূরক হবে। সাবাশ!
রেনবোল্ট

6

আলফ্রেড পেনিওয়ার্থ - পাইথন 2

আমি এক রাতে টহল দেওয়ার সময়, আলফ্রেড আমার অজান্তেই একটি স্টক ট্রেডিং প্রোগ্রাম তৈরি করার চেষ্টা করেছিল। সে ভেবেছিল সে আমার কাছ থেকে এটি গোপন করতে পারে তবে আমি এটি খুঁজে পেয়েছি এবং এটি কী করেছে তা অনুধাবন করে। কারণ আমি ব্যাটম্যান। এখন আমি সিদ্ধান্ত নিয়েছি যে তাকে একটি পাঠ শেখানোর জন্য এটি একটি প্রতিযোগিতায় প্রবেশ করবে।

আলফ্রেডের কাছে অর্থের কোনও আপত্তি নেই কারণ আমি সত্যই ধনী, তবে তিনি এখনও তার ব্যবসায়ের বিষয়ে স্মার্ট। যখন সে শেয়ারের বাইরে চলে যায়, বাজারের দাম নির্বিশেষে সে তার সাধ্যমতো ক্রয় করে। তারপরে তিনি প্রতিবার 10 টি (বা বাকি সমস্ত) শেয়ার বিক্রি করে বাজার মূল্য যে মূল্যে কিনেছিল তার চেয়ে বেশি।

import argparse

parser = argparse.ArgumentParser(description="This is a private matter, Master Bruce. Learn how to make your own bed and I will tell you.")
parser.add_argument("Stuff", type=int, nargs='+', help="You don't need to know, Master Bruce.")

args=parser.parse_args()
vals=[]
for x in args:
    vals.append(x)

a=vals[0]
b=vals[1]
c=vals[2]

if c==0:
    x=1
    while x*a<b:
        x+=1
    print "B"+str(x)
    with open("lastval.txt", w) as f:
        f.write(a)

else:
    lastval=next(open("lastval.txt"))
    if a>lastval:print "S10" if c>10 else "S"+str(c)
    else:print 'W'

সাথে চালান: python GoAwayMasterBruce.py <args>


AttributeError: 'ArgumentParser' object has no attribute 'parseargs'পাইথনের কোন সংস্করণটির প্রয়োজন?
পিটার টেলর

আমার ভুল, একটা আন্ডারস্কোর আছে parse_args()
র‌্যাজকেজ

5

NaiveBot

নাইভবট এই সমস্ত "স্টক মার্কেট" হুপলাহে নতুন। তিনি কেবল ধরে নিয়েছেন যে দাম বাড়ার সাথে সাথে তার কিনে নেওয়া উচিত, এবং দাম কমে গেলে তার বিক্রি করা উচিত। কিন্তু সে কোনও ঝাপটা নয়, সে নিজের হাতের কৌশলটি পেয়েছে! সে তার সাধ্যের মধ্যে কেবলমাত্র অর্ধেক ক্রয় করে এবং কেবল তার যা আছে তার অর্ধেক বিক্রি করে।

নাইভবটের জন্য ফ্রিওয়ের নীচে একটি বাক্সে আর বাস করবেন না!

<?php
$cur = array('price' => $argv[1], 'funds' => $argv[2], 'shares' => $argv[3]);

$cachefile = 'cache.json';
if( ! file_exists($cachefile) ) { $cache = array(); }
else { $cache = json_decode(file_get_contents($cachefile), true); }

// determine action
if( empty($cache) ) {
    $action = 'buy'; // always buy on first turn
} else if( $cur['price'] > $cache[count($cache)-1]['price'] ) {
    $action = 'buy';
} else if( $cur['price'] < $cache[count($cache)-1]['price'] ) {
    $action = 'sell';
} else {
    $action = 'hold';
}

// determine volume
if( $action == 'hold' ) {
    $volume = 0;
} else if( $action == 'buy' ) {
    // spend half my money on shares!
    $volume = floor(($cur['funds']/2)/$cur['price']);
} else if( $action == 'sell' ) {
    // sell half my shares!
    $volume = floor($cur['shares']/2);
}

// do a thing!
if( $action == 'hold' ) { echo 'W'; }
else if( $action == 'buy' ) { echo "B $volume"; }
else { echo "S $volume"; }
echo "\n";

$cache[] = $cur;
if( count($cache) == 50 ) { unlink($cachefile); } // wipe cache on last turn
else { file_put_contents($cachefile,json_encode($cache)); } // write cache

এর সাথে চলুন php Naivebot.php $1 $2 $3, cache.jsonএটির বর্তমান ফোল্ডারে একটি তৈরি করে।


5

লাভ - হাস্কেল

  1. দাম 1 / সর্বোচ্চ মূল্য না হওয়া পর্যন্ত অপেক্ষা করুন
  2. সমস্ত কিছু কিনুন / বিক্রয় করুন
  3. ????
  4. লাভ !!!

import System.Environment (getArgs)

main = putStrLn . trade . map read =<< getArgs

trade :: [Integer] -> String
trade [p,m,s] -- not intended
  | p == 1 = "B" ++ (show m)
  | p == (fromIntegral $ (maxBound::Int) - 1) = "S" ++ (show s)
  | otherwise = "W"

সংকলন ghc profit.hsএবং সাথে চালানো./profit price money stock

যদি এটি যথেষ্ট দক্ষ না হয় তবে -O3পতাকা যুক্ত করুন, যদিও এটি সম্ভবত ওভারকিল: ডি


সম্পাদনা:

"অনুকূলিত", যখন দাম সমান হয় তখন এখন সমস্ত কিছু বিক্রি করে Integer.MAX_VALUE


কেন হবে না main = putStrLn . trade . map read =<< getArgs? কম গোলমাল
recursion.ninja

@ ওয়াশবার্ন যেহেতু আমি মনদেব সম্পর্কে ভালভাবে পড়ি না;)
থ্রিএফএক্স

আমি আশা করি আমার মন্তব্য আপনাকে নতুন কিছু শিখতে সহায়তা করেছে!
recursion.ninja

@ থ্রিএফএক্স-এর জন্য একটি প্রোগ্রাম রয়েছে cabal install pointfree, এখন সকলেই ভাববেন আপনি প্রাতঃরাশের জন্য স্নাতক খান।
শান ডি

@ সানডি ধন্যবাদ, আমি এটি একবার দেখে নেব
থ্রিএফএক্স

4

WaitForCrash

সম্পাদনা: ধারণায় স্থির ত্রুটি

সম্পাদনা: এখন দীর্ঘ দীর্ঘ অন্তর্ ব্যবহার

এটি আমার প্রথম চেষ্টা। এটি সত্যই সরল আচরণ করে এবং প্রথম ভাগ বা তার পরেরটি হলে একটি ভাগ আলাদা করে রাখে। প্রথম রাউন্ডে কিছুই হারাতে পারে না, তাই এটি শেয়ার কিনে। যদি এর শেয়ার থাকে তবে সেগুলি তাদের বিক্রি করে। অবশেষে শেয়ারের দাম 10 এ নেমে গেলে এটি আবার কিনে ফেলবে।

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

int main(int argc, char *argv[]) {
    long long int share_price = strtoll(argv[1], NULL, 0);
    long long int money = strtoll(argv[2], NULL, 0);
    long long int shares_owned = strtoll(argv[3], NULL, 0);

    if(shares_owned > 1) {
        printf("S%lld\n", shares_owned - 1);
    } else if (shares_owned == 0 || share_price == 10) {
        printf("B%lld\n", money / share_price);
    } else {
        printf("W\n");
    }

    return 0;
}

সংকলন: gcc waitforcrash.c -o waitforcrash

এটি হিসাবে চালান ./waitforcrash PRICE MONEY SHARES


আশা করি আপনি আপত্তি করবেন না আমি বায়অ্যান্ডহোল্ড সমাধানের ভিত্তি হিসাবে আপনার কোডটি ব্যবহার করতে সোয়াইপ করেছি। দীর্ঘ দীর্ঘ ints সহ BTW,% d সতর্কতা এড়াতে% LD হওয়া দরকার (বা এটি% lld? কোনটিই আমাকে একটি সতর্কতা দেয় না)।
গ্লেন রেন্ডার্স-পেহারসন

ঠিক আছে. হ্যাঁ আমার কোডে% lld ছিল, আপডেটে অবশ্যই এগুলি ভুলে গিয়েছিল।
Optokopper

3

Earthquaker

সমস্ত কিছু কেনার এবং সমস্ত কিছু বিক্রি করার বিকল্প (তবে একটি)। এটি যতটা বিজয়ী করে তাতে অন্য সবাইকে বিঘ্নিত করে তোলে তার লক্ষ্য অর্জন করে না।

using System;
using System.IO;

namespace Earthquaker
{
    class Program
    {
        static void Main(string[] args)
        {
            if (args.Length < 3)
                return;

            int stockPrice = int.Parse(args[0]);
            int money = int.Parse(args[1]);
            int stocks = int.Parse(args[2]);

            bool shouldBuy = true;

            if (stocks != 0)
            {
                StreamReader sr = new StreamReader("brain.txt");
                if (sr.ReadLine() == "B")
                    shouldBuy = false;
                else
                    shouldBuy = true;
                sr.Close();
            }

            if (shouldBuy)
                Console.Write("B" + (money / stockPrice));
            else
                Console.Write("S" + (stocks - 1));

            StreamWriter sw = new StreamWriter("brain.txt", false);
            sw.Write(shouldBuy ? 'B' : 'S');
            sw.Close();
        }
    }
}

সঙ্গে সংকলন csc Earthquaker.cs। সাথে চালাও Earthquaker


। নেট রয়েছে System.IO.File.ReadAllTextএবং WriteAllTextতাই আপনি নিজের ইতিহাস ট্র্যাকিংটিকে কিছুটা সহজ করতে পারবেন।
পিটার টেলর

এটির brain.txtফাইল না পেলে এটি ক্র্যাশ হয়ে যায় ।
পিটার টেলর

3

MonkeyTrader (JAVA এ)

একটি প্রবাদ আছে যে বানরগুলি ভাল ব্যবসায়ী। আমি প্রমাণ করি। "কিনুন" এবং "বিক্রয়" এর মধ্যে সিদ্ধান্তগুলি সম্পূর্ণ এলোমেলো।

import java.math.BigInteger;
import java.util.Random;

public class MonkeyTrader {
    /**
     * @param args the command line arguments containing the current 
     * market value, our current money, and our current shares
     */
    public static void main(String[] args) {
        BigInteger marketValue = new BigInteger(args[0]);
        BigInteger myMoney = new BigInteger(args[1]);
        BigInteger myShares = new BigInteger(args[2]);
        Random random=new Random();

        switch (random.nextInt(2)) {
        case 0:
            System.out.println("B" + myMoney.divide(marketValue));
            break;
        case 1:
            System.out.println("S" + myShares);
            break;
        }
    }
}

3

IntelliTrader

1 ম রাউন্ড তিনি তার শেয়ারগুলি ভাল দামে বিক্রি করবেন: $ 80 বা তার বেশি। তারপরে তার বিক্রি হওয়া সর্বশেষ দামের চেয়ে দামটি একই বা ভাল হলে সে বিক্রি করবে, দামটি সে কেনা শেষ দামের চেয়ে একই বা কম হলে কিনে ফেলবে।

IntelliTrader.java

import java.io.*;
import java.math.BigInteger;
import java.util.Properties;

public class IntelliTrader {

    private static final String ROUND_NUM = "roundNum";
    private static final String LAST_BUY = "lastBuy";
    private static final String LAST_SELL = "lastSell";
    private static final String FILE = "IntelliTrader/memory.txt";

    private Properties memory;
    private int roundNum;

    private IntelliTrader(Properties memory) {
        this.memory = memory;
        roundNum = new Integer(memory.getProperty(ROUND_NUM, "0"));
    }

    public String evaluate(BigInteger market, BigInteger money, BigInteger shares) {
        String command = "W";
        if (roundNum == 0) {
            if (market.intValue() > 80) {
                command = sell(market, shares);
            } else {
                command = buy(market, money);
            }
        } else {
            if (market.compareTo(new BigInteger(memory.getProperty(LAST_SELL, "0"))) >= 0) {
                command = sell(market, shares);
            } else if (market.compareTo(new BigInteger(memory.getProperty(LAST_BUY, "999999999"))) <= 0) {
                command = buy(market, money);
            }
        }
        return command;
    }

    private String buy(BigInteger cost, BigInteger money) {
        memory.setProperty(LAST_BUY, cost.toString());
        return "B" + money.divide(cost).toString();
    }

    private String sell(BigInteger cost, BigInteger shares) {
        memory.setProperty(LAST_SELL, cost.toString());
        return "S"+shares.toString();
    }


    public static void main(String[] args) {    
        BigInteger marketValue = new BigInteger(args[0]);
        BigInteger myMoney = new BigInteger(args[1]);
        BigInteger myShares = new BigInteger(args[2]);

        Properties memory = new Properties();
        try {
            memory.load(new FileReader(FILE));
        } catch (IOException e) {
            //ignore, file probably doesn't exist yet
        }

        int roundNum = new Integer(memory.getProperty(ROUND_NUM, "0"));
        if (roundNum > 49) {
            roundNum = 0;
            memory.setProperty(ROUND_NUM, "0");
            memory.setProperty(LAST_BUY, "0");
            memory.setProperty(LAST_SELL, "0");
        }

        IntelliTrader it = new IntelliTrader(memory);
        String command = it.evaluate(marketValue, myMoney, myShares);
        System.out.println(command);

        roundNum++;
        memory.setProperty(ROUND_NUM, ""+roundNum);
        try {
            memory.store(new FileWriter(FILE), "IntelliTrader memory properties");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

জাভাক ইন্টেলিট্রেডার দিয়ে সংকলন করুনJava -cp "IntelliTrader" IntelliTrader দিয়ে চালান


আমার পরীক্ষায় এটি দ্বিতীয় সেরা ব্যবসায়ী বলে মনে হচ্ছে।
পিটার টেইলর

2

theAnswerOfLifeIs42.py

আমার প্রোগ্রামটি 42 নম্বর পছন্দ করে

নিয়মটি সহজ: আমি হয় 42 স্টক কিনতে পারি বা 42 স্টক বিক্রয় করতে পারি sell

import sys
price, money, shares = [int(arg) for arg in sys.argv[1:]]

if money>42*price:
 print "B 42"
else:
 print "S 42"

2

LeesonLearnt v1.1 (জাভা, রক্ষণশীল)

যেহেতু নিয়ম পরিবর্তনের অর্থ হ'ল আমরা এখন কিছু শেয়ার দিয়ে শুরু করি, এর আগে আর কোনও গ্যারান্টিযুক্ত সেরা প্রথম পদক্ষেপ নেই, তাই প্রথম বারের জন্য বিশেষ কেসটি সরিয়ে আমি এটিকে সহজ করে তুলেছি।

import java.math.BigInteger;

public class LeesonLearnt {
    private static final BigInteger THRESHOLD = new BigInteger("100");

    public static void main(String[] args){
        BigInteger price = new BigInteger(args[0]);
        BigInteger capital = new BigInteger(args[1]);
        BigInteger shareholding = new BigInteger(args[2]);

        BigInteger affordable = capital.divide(price);

        // In the long run, the shares will probably lose all their value.
        // But if they're cheap, buying them will pump them and they can be sold at a profit.
        // The target amount of our value held in shares varies exponentially with their price.
        BigInteger targetShareholding = price.compareTo(THRESHOLD) > 0
            ? BigInteger.ZERO
            : affordable.add(shareholding).shiftRight(price.intValue() - 1);
        if (targetShareholding.compareTo(shareholding) <= 0) {
            System.out.println("S" + shareholding.subtract(targetShareholding));
        }
        else {
            BigInteger diff = targetShareholding.subtract(shareholding);
            System.out.println("B" + diff.min(affordable));
        }
    }
}

হিসাবে আহ্বান

java -cp LeesonLearnt LeesonLearnt <price> <capital> <shareholding>

1

ডলার ব্যয়ের অ্যাভারেজার - পাইথন 3

এই কৌশলটি একটি নির্দিষ্ট পরিমাণ অর্থ (নির্বিচারে 150 এ সেট করা হয়েছে যাতে প্রতিটি মোড়ের শেষে সম্ভবত তার বেশিরভাগ অর্থ ব্যয় করতে পারে) কেনার মাধ্যমে ডলার ব্যয়কে গড় হিসাবে ব্যবহার করার চেষ্টা করে।

import sys
price, money, shares = [int(arg) for arg in sys.argv[1:]]
target_per_day = 150
buy = round(min(target_per_day, money) / price)
if buy * price > money:
    buy -= 1
if buy > 0:
    print("B" + str(buy))
else:
    print("W")

1

নগদ ইজ কিং - পাইথন 2 বা 3

এই লোকটি শেয়ার বাজার সম্পর্কে খুব নিরাশাবাদী। তিনি বরং তার অর্থ নগদে রাখবেন যেখানে তিনি নিজের গদিতে এটি নিরাপদ রাখতে পারবেন।

import sys
shares = int(sys.argv[3])
if shares > 0:
    print("S" + str(shares))
else:
    print("W")

1

ধীর গতির এবং অবিচলিত

যতক্ষণ না এটির অর্থ রয়েছে, এটি 165 ডলার মূল্যের শেয়ার কিনে। অন্যথায় এটি তার সমস্ত শেয়ার আরও বেশি অর্থ পাওয়ার জন্য, আরও বেশি শেয়ার কেনার জন্য বিক্রি করে। 50 তম রাউন্ডে এটি সমস্ত শেয়ার বিক্রয় নিশ্চিত করে, কারণ শেষ পর্যন্ত আমরা নগদ চাই।

import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;
import java.math.BigInteger;
import java.nio.file.Files;
import java.nio.file.Paths;

public class SlowAndSteady{
    public static void main(String[] args) {
        BigInteger price = new BigInteger(args[0]);
        BigInteger cash= new BigInteger(args[1]);
        long shares= Long.parseLong(args[2]);
        BigInteger number = new BigInteger("165");
        String count = "0";


        try {
            count = new String(Files.readAllBytes(Paths.get("counter.txt")));
        } catch (IOException e) {

        }

        int c = Integer.parseInt(count)+1;

        if (c >= 50)
        {
            System.out.println("S" + shares);
            c=0;
        }

        else if(cash.compareTo(number) > 0)     System.out.println("B" + (number.divide(price)));

        else System.out.println("S" + shares);


        try {
            Writer wr = new FileWriter("counter.txt");
            wr.write(Integer.toString(c));
            wr.close();
        } catch (IOException e) {
        }
   }
}

জাভাক স্লোঅ্যান্ডস্টেডি.জভা দিয়ে সংকলন করুন। জাভা -cp "স্লোঅ্যান্ডস্টেডি" স্লোঅ্যান্ডস্টেডি দিয়ে চালান। কাউন্টারটি রাউন্ডগুলির মধ্যে পুনরায় সেট করা উচিত তবে ফাইলটি মোছা হয়ে গেলে এটিও কাজ করবে।


1

BuyHighSellLow

বাজারের ইতিহাসের সন্ধান করে এবং যখন দাম কম থাকে এবং বেশি থাকে তখন বিক্রি করে।

import sys

storage = 'BuyHighSellLow'
turn = 0
turns = 50
max_start_price = 150
limit = 0.25

price = int(sys.argv[1])
money = int(sys.argv[2])
shares = int(sys.argv[3])

# Calculate average price
with open(storage+'/history', mode='a') as f:
            pass # Create file if it doesn't exist
with open(storage+'/history', mode='r') as f:
    values = list((int(line) for line in f))
    turn = len(values) + 1
    if turn > turns: turn = 1
    if turn == 1:
            average = max_start_price + 1
            turn = 1
    else:
            average = sum((value / turn for value in values))

# Buy low and sell high
if price < average:
    print('B' + str(int(limit * money / price)))
elif price > average:
    print('S' + str(int(limit * shares)))
else:
    print('W')

# Save history
if turn == 1: mode='w'
else: mode = 'a'
with open(storage+'/history', mode=mode) as f:
    print(price, file=f)

সাথে চালান:

python3 BuyHighSellLow/buyhighselllow.py

1

সময় সঠিক - পাইথন 3

আমি বিরক্ত হয়েছি তাই আমি অন্য একজন প্রবেশদ্বার লিখেছি ...

এই তরুণ এন্টারপেনিয়র তার জীবনকে ঘড়ির কাঁটা বেঁধে রাখে। সময়টি সঠিক হলে তিনি সিদ্ধান্ত নেন। তিনি বিরক্তিকরভাবে ফরাসি ব্যবহারের বাইরেও ব্যবহার করেন ...;)

চালান:

python3 timeisright.py [arg1] [arg2] [arg3]

কোড:

import sys, time

price = int(sys.argv[1])
money = int(sys.argv[2])
shares = int(sys.argv[3])

lheure = int(time.time())

if lheure % 3 == 0:
    print('S'+str(int(shares/4)))
elif lheure % 3 == 1:
    print('B'+str(int(money/4*price)))
else:
    print('W')

1

ওল 'টাইমার - ফোর্টরান 77

এই বৃদ্ধা অফিস ক্লার্ক হিসাবে ষাট বছর কাজ করার পরে তার পেনশন নষ্ট করতে চলেছেন। যদিও তার বৃদ্ধ বয়সে তিনি বেশ অন্ধ হয়ে গিয়েছিলেন, তাই তিনি কেবল প্রতিটি যুক্তির প্রথম সংখ্যা দেখতে পাচ্ছেন, তাই তিনি দামটি অনুমান করেন। ওয়াল্টের মতো তার পদ্ধতিটিও অনুরূপ, ওয়াল 'টাইমার ব্যতীত একটু বেশি গাফিল is

ফোর্টরান প্রিন্টিংয়ের সমস্যাগুলির কারণে, আমি একটি পাইথন প্রোগ্রাম লিখেছি যা সাহায্য করবে। প্রোগ্রামটি সরবরাহ করা যুক্তিগুলি গ্রহণ করে এবং ফোর্টরান প্রোগ্রামের মাধ্যমে সেগুলি পাইপ করে। তারপরে পাইথন প্রোগ্রাম আউটপুটটিকে প্রত্যাশিত বিন্যাসে পুনরায় রূপ দেয়।

কম্পাইল:

gfortran oltimer.for -o oltimer.exe

চালান:

python3 assistant.py [arg1] [arg2] [arg3]

পাইথন সহকারী কোড:

from subprocess import Popen, PIPE
import sys, re

ret = Popen('./oltimer.exe '+sys.argv[1]+' '+sys.argv[2]+' '+sys.argv[3], stdout=PIPE, shell=True).communicate()[0].decode('utf-8')
value=re.findall(r'\d+',ret)

if 'W' in ret:
     print('W')

elif 'B' in ret:
     print('B'+str(value[0]))

elif 'S' in ret:
     print('S'+str(value[0]))

ফরটেন মূল কোড:

      PROGRAM OLTIMER
C DEFINE VARIABLES
          INTEGER :: PRICE
          INTEGER :: STOCK
          INTEGER :: MONEY
          INTEGER :: INTBUFFER
          CHARACTER :: BUFFER
C GET CMD ARGUMENTS & CONVERT TO INT
          CALL getarg(1, BUFFER)
          READ (BUFFER, '(i10)') PRICE
          CALL getarg(2, BUFFER)
          READ (BUFFER, '(i10)') MONEY
          CALL getarg(3, BUFFER)
          READ (BUFFER, '(i10)') STOCK
C EVALUATE SITUTATION AND MAKE DECISION
          IF (PRICE.LT.5) THEN
            IF (MONEY.GT.0) THEN
                INTBUFFER=(MONEY*50)/(5-PRICE)
                PRINT*,'B',INTBUFFER
            ELSE
                PRINT*,'W'
            END IF
          ELSE
            IF (PRICE.GT.9) THEN
                IF (STOCK.GT.0) THEN
                    INTBUFFER=STOCK/(PRICE-9)
                    PRINT*,'S',INTBUFFER
                ELSE
                    PRINT*,'W'
                END IF
            ELSE
                PRINT*,'W'
            END IF
          END IF      
      END PROGRAM

1
আপনি যেভাবেই পাইথন প্রয়োজন, এবং পাইথনে অন্য উত্তর রয়েছে তবে ফোর্ত্রানে কোনও উত্তর নেই, আপনি কি মনে করেন না পাইথনে পুরো জিনিসটি প্রয়োগ করা এবং ওপি ইনস্টল করতে হবে এমন সংকলকগুলির বোঝা হ্রাস করা কি বোধগম্য হবে?
পিটার টেলর

@ পিটার আমি কিন্তু আমি ভেবেছিলাম সম্পূর্ণ ভিন্ন ভাষা পেয়ে মজা পাবে এবং এটি কীভাবে সম্পাদন করে তা দেখুন।
বিটা ক্ষয়

0

টেস্ট 1 ব্যবসায়ী

public class Test1 {

    public static void main(String[] args){
        int marketValue = Integer.parseInt(args[0]);
        int myMoney = Integer.parseInt(args[1]);
        int myShares = Integer.parseInt(args[2]);

        //Buy 10 if we don't have any.
        if(myShares <= 0){
            System.out.println("B10");
        }else{
            System.out.println("S1");
        }
    }
}

সঙ্গে javac Test1.javaরান সঙ্গে সংকলনjava -cp "Test1" Test1


0

হেজহগ - অজগর 2.7

এটি বেশিরভাগ নাম সংরক্ষণ করার জন্য

from __future__ import print_function
from sys import argv

storage = 'prices.txt'
price,cash,shares = map(long, argv[1:])
turn = 1
buy = lambda x: print('B%d' % long(x))
sell = lambda x: print('S%d' % long(x))
cashtoshares = lambda c: long(c/price)
TURN,PRICE,CASH,SHARES=range(4)

try:   
    data = [map(long, line.split()) for line in open(storage)]
    if data:
        turn = data[-1][TURN] + 1
except IOError:
    pass
with open(storage, 'a') as pricelist:
    pricelist.write('%d %d %d %d\n' % (turn, price, cash, shares))

if turn == 1:
    buy(cashtoshares(cash)) # convert all cash into shares
elif price == 1:
    buy(cashtoshares(cash)) # cannot buy at a better deal
elif price < 10:
    buy(cashtoshares(cash/2))
elif shares < 10:
    buy(cashtoshares(cash/2))
else:
    sell(shares/2)

হিসাবে চালান

python hedgehog.py PRICE CASH SHARES

0

বাইঅ্যান্ডসেল - সি

অনুরূপ তবে টমির সদৃশ নয়। আতঙ্কের মধ্যে বিকল্প হিসাবে যথাসম্ভব কেনা এবং সবকিছু বিক্রি করা। প্রায় ভূমিকম্পের একটি সদৃশ যা বায়আন্ডসেল সমস্ত শেয়ার বিক্রি করে এমন এক ভাগ ধরে রাখে। বেইন্ডসেল যখন বিক্রি করার মতো শেয়ার না রাখে কিন্তু কোনও শেয়ার কেনার মতো পর্যাপ্ত অর্থ পায় না তখন কোনও পদক্ষেপ নেয় না।

/* BuyAndSell
 * Code revised from OptoKopper's WaitForCrash.c and my BuyAndHold.c
 * Alternates between buying as many shares as possible and selling everything
 * Run it as ./buyandsell PRICE MONEY SHARES
 */
int main(int argc, char *argv[]) {
    long long int share_price = strtoll(argv[1], NULL, 0);
    long long int money = strtoll(argv[2], NULL, 0);
    long long int shares = strtoll(argv[3], NULL, 0);

    if (money >= share_price) {
        printf("B%lld\n", money / share_price);
    } else {
        if (money == 0) {
            printf("S%lld\n", shares);
        } else {
            printf("W\n");
        }
    }

    return 0;
}

"জিসিসি বায়ানডসেল। -ও বায়ানডসেল" দিয়ে সংকলন করুন

"। / বাইন্ডসেল দামের অর্থ ভাগ হিসাবে চালান


0

গর্জে সোরোস

price = ARGV.shift
money = ARGV.shift
stock = ARGV.shift
if price*10<money
  puts "B10"
else
  puts "S#{stock}"
end

বাজার ক্র্যাশ করার চেষ্টায় সবকিছু বিক্রি করার চেয়ে ধীরে ধীরে কেনে।

সাথে চালান:Soros.rb price money stock


1
এটি স্পষ্টভাবে প্রশ্নের পাঠ্যে বলেছেDo not intentionally create programs to crash the simulation.
বিটা ডেকায়

@ বেটাডেকে বলতে চাইছিলাম নিয়ামকটিকে ক্র্যাশ করার চেষ্টা করবেন না। বাজার ক্রাশ করার চেষ্টা করা গেমের একটি অংশ।
স্পট

@ স্পোকট ওহ, আমি ভেবেছিলাম যে আপনি বাজারটি ক্র্যাশ করার প্রোগ্রাম তৈরি করবেন না to আরও বিভ্রান্তি রোধ করার জন্য আপনার এমন বাক্যটি বলা উচিত।
বিটা ক্ষয়
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.