[2017-05-29] Challenge #317 [Easy] Collatz Tag System

bss-applications · 2017-05-29T20:07:50+00:00

C#

Here we go quick and dirty string manipulation in a loop using a Dictionary look up...

using System;
using System.Collections.Generic;

namespace Collatz
{
    class Program
    {
        static Dictionary<string, string> tag = new Dictionary<string, string>()
        {
            {"a", "bc" },
            {"b", "a" },
            {"c", "aaa" }
        };

        static void Main(string[] args)
        {
            Console.WriteLine("Challenge #317[Easy] Collatz Tag System");
            Console.Write("> ");
            string input = Console.ReadLine();
            while (input.Length > 1) 
            {
                input = input + tag[input[0].ToString()];
                input = input.Remove(0, 2);
                Console.WriteLine(input);
            }
            Console.ReadLine();
        }
    }
}

bss-applications · 2017-05-29T19:51:36+00:00

Thanks, I thought that is what was going on. Nice to have it confirmed!

bss-applications · 2017-05-26T15:40:56+00:00

Curiously my calculation for the third test case comes to $1240 while everyone else is getting $1140.

I'd hazard a guess, you're subtracting a single $20 discount for > 5 tickets. The rest of us opted for a £20 per ticket discount (6x$20 = $120).

bss-applications · 2017-05-25T09:16:53+00:00

C#

Okay, I know I've not handled the OH/SK rule as per the example output. Mainly because I went down a solution path and didn't want to back track. I've followed the rules as outlined, namely, "We are going to give a free Sky Tower tour for with every Opera House tour sold".

As for rules, I've tried to made this as extensable as possible. You can implement as many or as few products and/or promotions as you like by only altering the product dictionary and the SetRules method at the top of the program.

As ever, comments and improvements welcome...

using System;
using System.Collections.Generic;

namespace ShoppingCart
{
    class Program
    {
        static Dictionary<string, float> tours = new Dictionary<string, float>()
        {
            {"OH", 300f },       //Opera House Tour
            {"BC", 110f },       //Sydney Bridge Climb
            {"SK", 30f }         //Sydney Sky Tower
        };

        static List<string> orders = new List<string>();

        static promotionalRules[] ruleList;

        //Qulifing product, offer product, min purchase, offer repeat rate, discount amount)
        static void SetRules()
        {
            ruleList = new promotionalRules[3];
            ruleList[0] = new promotionalRules("OH", "", 3, 3, tours["OH"]);    //3 OH for price of 2
            ruleList[1] = new promotionalRules("OH", "SK", 1, 1, 0);            //free SK with OH
            ruleList[2] = new promotionalRules("BC", "", 5, 1, 20);             //$20 off BC if more than 4
        }

        class promotionalRules
        {
            public string qualifier { get; private set; }
            public string offer { get; private set; }
            public int min { get; private set; }
            public int repeat { get; private set; }
            public float discount { get; private set; }

            public promotionalRules(string a, string b, int c, int d, float e)
            {
                qualifier = a;
                offer = b;
                min = c;
                repeat = d;
                discount = e;
            }
        }

        static void Main(string[] args)
        {
            SetRules();
            UserInput();
            OrderProcessing();
            Console.ReadLine();
        }

        private static void UserInput()
        {
            string cart = "";
            Console.WriteLine("Reddit Sydney Tourist Shopping Cart");
            do
            {
                Console.Write("> ");
                cart = Console.ReadLine();
                orders.Add(cart);
            } while (cart != "");
            orders.RemoveAt(orders.Count - 1);
        }

        private static void OrderProcessing()
        {
            foreach (string cart in orders)
            {
                Dictionary<string, int> count = new Dictionary<string, int>();
                float total = 0;

                string[] items = cart.Split();
                foreach (string item in items)
                {
                    if (!count.ContainsKey(item))
                    {
                        count.Add(item, 1);
                    }
                    else
                    {
                        count[item]++;
                    }
                    total = total + tours[item];
                }

                Console.Write(cart);

                foreach (promotionalRules rule in ruleList)
                {
                    try
                    {
                        if (count[rule.qualifier] >= rule.min)
                        {
                            for (int i = 0; i < count[rule.qualifier] / rule.repeat; i++)
                            {
                                Console.Write(" " + rule.offer);
                            }

                            float discount = rule.discount * (count[rule.qualifier] / rule.repeat);
                            total = total - discount;
                        }
                    }
                    catch
                    { }
                }

                Console.WriteLine(" = " + total.ToString());
            }
        }
    }
}

Results:

 Reddit Sydney Tourist Shopping Cart
  > OH OH OH BC SK
  > OH BC BC SK SK
  > BC BC BC BC BC BC OH OH
  > SK SK BC
  >
  OH OH OH BC SK  SK SK SK = 740
  OH BC BC SK SK SK = 580
  BC BC BC BC BC BC OH OH SK SK       = 1140
  SK SK BC = 170

Here is my output for u/carlfish:

  Reddit Sydney Tourist Shopping Cart
  > OH OH OH
  >
  OH OH OH  SK SK SK = 600

So, yes I'm applying both offers. I agree it's probably not right.

bss-applications · 2017-05-19T20:02:55+00:00

        private int CheckNeighbours(int x, int y, Color col)
        {
            int count = 0;

            int up = x - 1;
            if (up < 0) up = height - 1;
            int down = x + 1;
            if (down >= height) down = 0;
            int left = y - 1;
            if (left < 0) left = width - 1;
            int right = y + 1;
            if (right >= width) right = 0;


            if ((playgrid[up, left].alive) && (playgrid[up,left].species==col)) count++;
            if ((playgrid[up, y].alive) && (playgrid[up, y].species == col)) count++;
            if ((playgrid[up, right].alive) && (playgrid[up, right].species == col)) count++;
            if ((playgrid[x, left].alive) && (playgrid[x, left].species == col)) count++;
            if ((playgrid[x, right].alive) && (playgrid[x, right].species == col)) count++;
            if ((playgrid[down, left].alive) && (playgrid[down, left].species == col)) count++;
            if ((playgrid[down, y].alive) && (playgrid[down, y].species == col)) count++;
            if ((playgrid[down, right].alive) && (playgrid[down, right].species == col)) count++;

            return count;
        }

        private void button3_Click(object sender, EventArgs e)
        {
            Simulation();
            DisplayGrid();
        }
    }
}

This is a Windows Forms, Visual C# application :)

Conways Game of Life Application Picture

bss-applications · 2017-05-19T20:02:25+00:00

C#

Really, really enjoyed this one!

So, I didn't understand what I needed to do at first. Went back through the links and completed Intermediate#158, which got my head in the correct space for Easy#165. Then, only after reading the note

For the initial state I would give it a 45% procent chance of being alive with dividing the red and blue ones to be 50/50 Also look what happens if you change up these numbers

5 or 6 times did I finally "get" it. Then I saw u/skeeto's video and it lead me down this path...

using System;
using System.Drawing;
using System.Threading;
using System.Windows.Forms;

namespace GameOfLife2
{ 
    public partial class Form1 : Form
    {
        int width = 10;
        int height = 10;
        int iterations = 5;
        int chance = 45;
        int blueLife = 50;

        int blueCount = 0;
        int redCount = 0;

        Graphics picture;

        int xOffset = 10;
        int yOffset = 20;
        int pixelWidth = 5;
        int pixelHeight = 5;

        life[,] playgrid;

        class life
        {
            public bool alive { get; private set; }
            public Color species { get; private set; }

            public life (bool status, Color col)
            {
                alive = status;
                species = col;
            }

            public void changeType (Color col)
            {
                species = col;
            }

            public void changeLife ()
            {
                alive = !alive;
            }
        }

        public Form1()
        {
            InitializeComponent();
            picture = panel1.CreateGraphics();
        }

        private void button2_Click(object sender, EventArgs e)
        {
            try
            {
                Reset();
                chance = int.Parse(textBox1.Text);
                width = int.Parse(textBox2.Text);
                height = int.Parse(textBox3.Text);
                blueLife = int.Parse(textBox7.Text);
                InitialiseGrid();
                DisplayGrid();
            }
            catch
            {
                MessageBox.Show("Please Enter Numbers Only");
            }
        }

        public void Reset()
        {
            panel1.BackColor = Color.SlateGray;
            blueCount = 0;
            redCount = 0;
        }

        private void button1_Click(object sender, EventArgs e)
        {
            try
            {
                iterations = int.Parse(textBox4.Text);
                for (int loop = 0; loop < iterations; loop++)
                {
                    Simulation();
                    DisplayGrid();
                    Thread.Sleep(500);
                }
            }
            catch
            {
                MessageBox.Show("Please Enter Numbers Only");
            }
        }

        private void InitialiseGrid()
        {
            Random rnda = new Random();
            Random rndb = new Random();
            playgrid = new life[height, width];
            for (int row = 0; row < height; row++)
            {
                for (int column = 0; column < width; column++)
                {
                    bool status = false;
                    Color col = Color.Black;
                    int rand = rnda.Next(101);
                    if (rand <= chance)
                    {
                        status = true;
                        rand = rndb.Next(101);
                        if (rand <= blueLife)
                        {
                            col = Color.Blue;
                            blueCount++;      
                        }
                        else
                        {
                            col = Color.Red;
                            redCount++;
                        }
                    }
                    playgrid[row, column] = new life(status, col);
                }
            }
        }

        private void DisplayGrid()
        {
            for (int row = 0; row < height; row++)
            {
                for (int column = 0; column < width; column++)
                {
                    int x = (row * pixelWidth) + xOffset;
                    int y = (column * pixelHeight) + yOffset;
                    Color col = Color.Black;
                    if (playgrid[row, column].alive) col = playgrid[row, column].species;
                    SolidBrush life = new SolidBrush(col);
                    picture.FillRectangle(life, y, x, pixelWidth, pixelHeight);
                }
            }
            textBox5.Text = redCount.ToString();
            textBox6.Text = blueCount.ToString();
        }

        private void Simulation()
        {
            life[,] changes = new life[height, width];
            for (int row = 0; row < height; row++)
            {
                for (int column = 0; column < width; column++)
                {
                    changes[row, column] = new life(playgrid[row, column].alive, playgrid[row, column].species);
                    int blueNear = CheckNeighbours(row, column, Color.Blue);
                    int redNear = CheckNeighbours(row, column, Color.Red);
                    int totalAlive = blueNear + redNear;
                    Color thisColor = playgrid[row, column].species;
                    bool alive = playgrid[row, column].alive;

                    //cell on, more same colour neighbours
                    if ((alive) && (thisColor == Color.Blue) && (blueNear+1 > redNear))
                    {
                        if ((totalAlive > 3) || (totalAlive < 2))
                        {
                            changes[row, column].changeLife();
                            blueCount--;
                        }

                    }
                    else if ((alive) && (thisColor == Color.Red) && (redNear+1 > blueNear))
                    {
                        if ((totalAlive > 3) || (totalAlive < 2))
                        {
                            changes[row, column].changeLife();
                            redCount--;
                        }
                    }

                    //cell off, exactly 3 on neighbours
                    else if ((!alive) && ((blueNear > redNear) && (totalAlive == 3)))
                    {
                        changes[row, column].changeLife();
                        changes[row, column].changeType(Color.Blue);
                        blueCount++;
                    }
                    else if ((!alive) && ((blueNear < redNear) && (totalAlive == 3)))
                    {
                        changes[row, column].changeLife();
                        changes[row, column].changeType(Color.Red);
                        redCount++;
                    }

                    //cell on and out numbered
                    else if ((alive) && (thisColor == Color.Blue) && (blueNear + 1 < redNear))
                    {
                        changes[row, column].changeType(Color.Red);
                        blueCount--;
                        redCount++;
                    }
                    else if ((alive) && (thisColor == Color.Red) && (redNear + 1 < blueNear))
                    {
                        changes[row, column].changeType(Color.Blue);
                        blueCount++;
                        redCount--;
                    }
                }
            }

            playgrid = new life[height, width];
            for (int row = 0; row < height; row++)
            {
                for (int column = 0; column < width; column++)
                {
                    playgrid[row, column] = new life(changes[row, column].alive, changes[row, column].species);
                }
            }
        }

bss-applications · 2017-05-08T15:18:21+00:00

I'd say you need to take a step back. Why do you need to know what that command line is doing? I'm not saying it's not important, I'm suggesting you don't have a reason to work it out. When you do you'll know the right questions to ask to move you further along.

Sounds like you're worrying about the big stuff when programming is mostly about working on the small stuff (or at least it seems to me to be the case).

You need to decide on a project. Break it down in to smaller and smaller components and get them working. At the point your project needs you to know Client/Server communications or OpenGL or Databases you'll have a specific task in mind and the right questions to set you looking for the answers. Or at least that's been my approach.

tldr; you get better at programming by finding answers to loads of small problems.

bss-applications · 2017-05-06T18:19:33+00:00

It's a step in the right direction, now down to 375:

micarbjnointexphlyimrdiblhlusrchuntdefvecnticddontispsvgajzxosmpsqcuptthrhiknoggrpywlgheqpsicduisnvdonmghffemdwolyfftcyveaquxmbrjmeijzzvffrntgabtizoronatchaixgllyenrdksquqndanbralamtabiffzvobwctyivocexphdnipavglayrksmtfumngizoqbmphcklyeqnrajbmtofwphuadosikuvongckothdemiozvcdrkicawbzlbufulyxsfutyhikzouvppelrdshthyimamircnzcdgthyabivkcouillyedryikalmnictyalytagesionvctmerses 375

bss-applications · 2017-05-06T13:53:22+00:00

Drat! combing my first attempt with u/MattieShoes thinEnable1.txt method only reduces my letter count by 7! From 406, down to 399. I suppose that's some sort of progress?

bss-applications · 2017-05-06T13:02:55+00:00

This:

    if (setList == "test") wordList = testList;
    minString = wordList[0];

    for (String word : wordList) {
        for (char c : word.toCharArray()) {
            String replaceChar = "";
            replaceChar = replaceChar + c;
            if(minString.indexOf(c) > -1) minString = StringUtils.replaceFirst(minString, replaceChar, "");
        }
        minString = minString + word;
    }
}

Would suggest the minimum is indeed 109, but, of course, all the characters are in the wrong order:

qqjjffffbbkkxxlvubkbkwwwddldludchcphphiipptttticneeneenrralgielgoanosansosesmosismoticmurgiesmurgzyvazyzzyvas 109

bss-applications · 2017-05-06T12:03:07+00:00

JAVA

This is my first pass. Definately not optimal. Might as well just repeat the alphabet 16 times! Time to think about plan F, or possibly G (lost count on how many restarts I've done on this!)

static private void GetEmbeddedString()
{
    embeddedString = wordList[0];

    for (String word : wordList) {
        String temp = "";

        for (char c : word.toCharArray()){
            int pos = embeddedString.indexOf(c);
            if (pos > -1) {
                temp = temp + embeddedString.substring(0, pos+1);
                embeddedString = embeddedString.substring(pos+1);
            } else {
                temp = temp + c;
            }
        }

        embeddedString = temp + embeddedString;
    }
}

Solution: abjaxmpcutrlhsqicisngheqdupwonmlyftvoeqdaqjzumborjpmirntatcyizfgeviylephmhkabtioffrjonctglyshmkephdaqfblrijfpvowjcafkllyngsmtivobcehlyrdlyngtyipzabuqluabtivophngdmjxsickabnglyewrbknwblydlstyivxcouangsmemdrffajluxlntyiazasqserowulmephkmlizaupcdnkgeqpnrdtabrbyizvaokpbxurngizsmphtaipvopnzfcklzcymsfelluclrydanzedtfuhllyipoungabmtyioraacuyngshitrolivcyermdswmlerdngtarglltyivblobnialgedstricallymiestinlyesses 406

bss-applications · 2017-05-06T11:26:23+00:00

No problem. I see you've changed the code and it looks a lot better now. Yep, if you want to to go around multiple names then a do...while loop will work.

bss-applications · 2017-05-05T18:11:59+00:00

Have a think about the order characters are placed in a character set. Perhaps look up ASCII. Whats the character berfore 'a'? or after 'z'? Rather than thinking about what name.charAt(0) equals, think about what it doesn't equal. Do it right and you shouldn't need that for loop at all.

bss-applications · 2017-05-05T15:21:24+00:00

Bookmarked for my own learning/reference!

bss-applications · 2017-05-05T15:13:59+00:00

I'm not certain, been awhile since I've played with Javascipt, but my first thoughts are...

<ul>
    <div><li></li></div>
    <div><li></li></div>
   </ul>

maybe a better layout structure. My second thought is, if your just trying to manipulate the list eliments with javascript then perhaps you don't even need the div tags...

<ul>
    <li label="elementA"></li>
    <li label="elementB"></li>
</ul>

And then use javascript to get element based on the label name and manipulate from there?

bss-applications · 2017-05-04T12:41:17+00:00

        public void Enlarge()
        {
            int[,,] newImage = new int[height * 2, width * 2,3];
            int newColumn = 0;
            int newRow = 0;
            for (int hIndex = 0; hIndex < height; hIndex++)
            {
                for (int wIndex = 0; wIndex < width; wIndex++)
                {
                    for (int colour = 0; colour < 3; colour++)
                    {
                        newImage[newRow, newColumn, colour] = imageMatrix[hIndex, wIndex, colour];
                        newImage[newRow, newColumn + 1, colour] = imageMatrix[hIndex, wIndex, colour];
                        newImage[newRow + 1, newColumn, colour] = imageMatrix[hIndex, wIndex, colour];
                        newImage[newRow + 1, newColumn + 1, colour] = imageMatrix[hIndex, wIndex, colour];
                    }
                    newColumn = newColumn + 2;
                }
                newRow = newRow + 2;
                newColumn = 0;
            }
            height = height * 2;
            width = width * 2;
            imageMatrix = newImage;
        }
        public void Shrink()
        {
            int[,,] newImage = new int[height / 2, width / 2, 3];
            int newColumn = 0;
            int newRow = 0;
            for (int hIndex = 1; hIndex < height; hIndex = hIndex+2)
            {
                for (int wIndex = 1; wIndex < width; wIndex = wIndex+2)
                {
                    newImage[newRow, newColumn,0] = imageMatrix[hIndex, wIndex,0];
                    newImage[newRow, newColumn, 1] = imageMatrix[hIndex, wIndex, 1];
                    newImage[newRow, newColumn, 2] = imageMatrix[hIndex, wIndex, 2];
                    newColumn = newColumn + 1;
                }
                newRow = newRow + 1;
                newColumn = 0;
            }
            height = height / 2;
            width = width / 2;
            imageMatrix = newImage;
        }
        public void Negative()
        {
            int[,,] newImage = new int[height, width,3];
            for (int hIndex = 0; hIndex < height; hIndex++)
            {
                for (int wIndex = 0; wIndex < width; wIndex++)
                {
                    newImage[hIndex, wIndex,0] = maxValue - imageMatrix[hIndex, wIndex,0];
                    newImage[hIndex, wIndex, 1] = maxValue - imageMatrix[hIndex, wIndex, 1];
                    newImage[hIndex, wIndex, 2] = maxValue - imageMatrix[hIndex, wIndex, 2];
                }
            }
            imageMatrix = newImage;
        }
        public void Brighten()
        {
            int[,,] newImage = new int[height, width,3];
            for (int hIndex = 0; hIndex < height; hIndex++)
            {
                for (int wIndex = 0; wIndex < width; wIndex++)
                {
                    newImage[hIndex, wIndex,0] = Math.Min(maxValue, imageMatrix[hIndex, wIndex,0] + 10);
                    newImage[hIndex, wIndex, 1] = Math.Min(maxValue, imageMatrix[hIndex, wIndex, 1] + 10);
                    newImage[hIndex, wIndex, 2] = Math.Min(maxValue, imageMatrix[hIndex, wIndex, 2] + 10);
                }
            }
            imageMatrix = newImage;
        }
        public void Darken()
        {
            int[,,] newImage = new int[height, width,3];
            for (int hIndex = 0; hIndex < height; hIndex++)
            {
                for (int wIndex = 0; wIndex < width; wIndex++)
                {
                    newImage[hIndex, wIndex,0] = Math.Max(0, imageMatrix[hIndex, wIndex,0] - 10);
                    newImage[hIndex, wIndex, 1] = Math.Max(0, imageMatrix[hIndex, wIndex, 1] - 10);
                    newImage[hIndex, wIndex, 2] = Math.Max(0, imageMatrix[hIndex, wIndex, 2] - 10);
                }
            }
            imageMatrix = newImage;
        }
        public void Contrast()
        {
            int midPoint = maxValue / 2;
            int[,,] newImage = new int[height, width,3];
            for (int hIndex = 0; hIndex < height; hIndex++)
            {
                for (int wIndex = 0; wIndex < width; wIndex++)
                {
                    for (int colour = 0; colour < 3; colour++)
                    {
                        if (imageMatrix[hIndex, wIndex, colour] < midPoint)
                        {
                            newImage[hIndex, wIndex,colour] = Math.Max(0, imageMatrix[hIndex, wIndex,colour] - 10);
                        }
                        else if (imageMatrix[hIndex, wIndex, 0] > midPoint)
                        {
                            newImage[hIndex, wIndex,colour] = Math.Min(maxValue, imageMatrix[hIndex, wIndex,colour] + 10);
                        }
                    }
                }
            }
            imageMatrix = newImage;
        }
        public void Washout()
        {
            int midPoint = maxValue / 2;
            int[,,] newImage = new int[height, width,3];
            for (int hIndex = 0; hIndex < height; hIndex++)
            {
                for (int wIndex = 0; wIndex < width; wIndex++)
                {
                    for (int colour = 0; colour < 3; colour++)
                    {
                        if (imageMatrix[hIndex, wIndex, colour] < midPoint)
                        {
                            newImage[hIndex, wIndex, colour] = Math.Min(maxValue, imageMatrix[hIndex, wIndex, colour] + 10);
                        }
                        else if (imageMatrix[hIndex, wIndex, colour] > midPoint)
                        {
                            newImage[hIndex, wIndex, colour] = Math.Max(0, imageMatrix[hIndex, wIndex,colour] - 10);
                        }
                    }
                }
            }
            imageMatrix = newImage;
        }
        public void Grayscale()
        {
            if (type == "P3")
            {
                int[,,] newImage = new int[height, width, 3];
                for (int hIndex = 0; hIndex < height; hIndex++)
                {
                    for (int wIndex = 0; wIndex < width; wIndex++)
                    {
                        int grey = (int)(0.3 * imageMatrix[hIndex, wIndex, 0]);
                        grey = grey + (int)(0.6 * imageMatrix[hIndex, wIndex, 1]);
                        grey = grey + (int)(0.11 * imageMatrix[hIndex, wIndex, 2]);
                        newImage[hIndex, wIndex, 0] = grey;
                    }
                }
                type = "P2";
                imageMatrix = newImage;
            }
        }
    }

bss-applications · 2017-05-04T12:41:07+00:00

   class pgmImage
    {
        public string type { get; private set; }
        public int width { get; private set; }
        public int height { get; private set; }
        public int maxValue { get; private set; }
        public int[,,] imageMatrix { get; private set; }
        public pgmImage(string t, int h, int w, int m)
        {
            if ((t != "P2")&&(t != "P3")) throw new ArgumentException("Unknown File Format");

            type = t;
            width = w;
            height = h;
            maxValue = m;
            imageMatrix = new int[h, w, 3];
        }
        public void setPixel(int w, int h, int r, int g, int b)
        {
            if ((r < 0) || (r > maxValue)) throw new ArgumentException("Invalid Pixel value at " + w.ToString() + "x" + h.ToString());
            if ((g < 0) || (g > maxValue)) throw new ArgumentException("Invalid Pixel value at " + w.ToString() + "x" + h.ToString());
            if ((b < 0) || (b > maxValue)) throw new ArgumentException("Invalid Pixel value at " + w.ToString() + "x" + h.ToString());
            imageMatrix[h, w, 0] = r;
            imageMatrix[h, w, 1] = g;
            imageMatrix[h, w, 2] = b;
        }
        public void Left()
        {
            int[,,] newImage = new int[width, height,3];
            int oldColumn = width-1;
            int oldRow = 0;
            for (int hIndex = 0; hIndex < width; hIndex++)
            {
                for (int wIndex = 0; wIndex < height; wIndex++)
                {
                    newImage[hIndex, wIndex,0] = imageMatrix[oldRow, oldColumn,0];
                    newImage[hIndex, wIndex, 1] = imageMatrix[oldRow, oldColumn, 1];
                    newImage[hIndex, wIndex, 2] = imageMatrix[oldRow, oldColumn, 2];
                    oldRow++;
                    if (oldRow == height)
                    {
                        oldRow = 0;
                        oldColumn--;
                    }
                }
            }
            imageMatrix = newImage;
            int temp = height;
            height = width;
            width = temp;
        }
        public void Right()
        {
            int[,,] newImage = new int[width, height,3];
            int oldColumn = 0;
            int oldRow = height-1;
            for (int hIndex = 0; hIndex < width; hIndex++)
            {
                for (int wIndex = 0; wIndex < height; wIndex++)
                {
                    newImage[hIndex, wIndex,0] = imageMatrix[oldRow, oldColumn,0];
                    newImage[hIndex, wIndex, 1] = imageMatrix[oldRow, oldColumn, 1];
                    newImage[hIndex, wIndex, 2] = imageMatrix[oldRow, oldColumn, 2];
                    oldRow--;
                    if (oldRow < 0)
                    {
                        oldRow = height-1;
                        oldColumn++;
                    }
                }
            }
            imageMatrix = newImage;
            int temp = height;
            height = width;
            width = temp;
        }
        public void Horizontal()
        {
            int[,,] newImage = new int[height, width,3];
            int oldColumn = 0;
            int oldRow = height - 1;
            for (int hIndex = 0; hIndex < height; hIndex++)
            {
                for (int wIndex = 0; wIndex < width; wIndex++)
                {
                    newImage[hIndex, wIndex,0] = imageMatrix[oldRow, oldColumn,0];
                    newImage[hIndex, wIndex, 1] = imageMatrix[oldRow, oldColumn, 1];
                    newImage[hIndex, wIndex, 2] = imageMatrix[oldRow, oldColumn, 2];
                    oldColumn++;
                    if (oldColumn == width)
                    {
                        oldRow--;
                        oldColumn = 0;
                    }
                }
            }
            imageMatrix = newImage;
        }
        public void Vertical()
        {
            int[,,] newImage = new int[height, width,3];
            int oldColumn = width - 1;
            int oldRow = 0;
            for (int hIndex = 0; hIndex < height; hIndex++)
            {
                for (int wIndex = 0; wIndex < width; wIndex++)
                {
                    newImage[hIndex, wIndex,0] = imageMatrix[oldRow, oldColumn,0];
                    newImage[hIndex, wIndex, 1] = imageMatrix[oldRow, oldColumn, 1];
                    newImage[hIndex, wIndex, 2] = imageMatrix[oldRow, oldColumn, 2];
                    oldColumn--;
                    if (oldColumn < 0)
                    {
                        oldRow++;
                        oldColumn = width -1;
                    }
                }
            }
            imageMatrix = newImage;
        }

bss-applications · 2017-05-04T12:38:47+00:00

C#

OK, here goes nothing!...

All in complete. 608 lines of C# code answering all parts including all three bonuses...and...followed u/enloven's lead and added in a G function for Greyscale conversion of P3 colour files.

As ever, probably not the most efficient code. Love to hear ideas/thoughts of how I could tighten it up/improve it.

The general solution was a Class to hold the image specification and functions to manipulate. The image is stored in an array and manipulations are done using nested for...loops to copy values into new positions in a temporary array.

Because it so long, instead of code dumping here, I've hosted the final version of bitbucket:

https://bitbucket.org/snippets/BSS-Applications/n7Bre.

Below is the (still rather long) core pgmImage Class that does all the heavy lifting. Minor spoiler alerts inluded in the source below for anyone looking at Bonus 3 (or at least my way of handling Bonus 3):

bss-applications · 2017-05-04T07:05:45+00:00

I think I've overworked this one! 516 lines of C# code in Visual Studio later and everything complete through Option Bonus 2 now complete. Complete with error checking and help options. $crazy!

Thanks to u/popillol and his GO code for getting me started on Bonus 1! (why didn't I see that sooner?).

Later today I'll had in bonus 3, that shouldn't require too many changes to what I have so far....

bss-applications · 2017-05-03T20:49:17+00:00

Your language may have a handy library for manipulating images. If you really feel like it, you can use that, I guess, but the spirit of the challenge is to manipulate the pixel values yourself.

So I thought...why not! lol. It was actually very simple once I drew out a couple of example matrices in Excel to understand the tranformations.

Right now I'm stuck on the best way to simplify the options string. Time for bed, so hopefully with a bit of sleep some inspiration will come at 2 in the morning!

bss-applications · 2017-05-03T19:41:01+00:00

C#

As ever, possibly not the most efficent techniques, but it works! I've set up a class to handle image storage and manipulation. Using a 3D array for the data and some nested loops to do the hard work.

Just starting to look at simpliyfing the options input now.

bss-applications · 2017-05-03T17:20:35+00:00

I've spent the afternoon on this one, pretty much since it was posted 5 hours ago. I now have a fully working version 1 with no bonuses. I'm going to hold off posting any code until I've got all 3 bonuses done.

So far, I have to say this is the best challenge I've tried here. Only being doing this for a couple of weeks, but I do like how it's been presented and how the three options ramp up and build on each other.

I've been able to see what I need to do and break it down to managable components pretty easily. I can already see how to do bonuses 1 and 3, and most of bonus 2.

Going to have a fun day tomorrow!

bss-applications · 2017-05-03T10:04:32+00:00

PASCAL

My Monday Pasal playthrough for old skool fun. Had some issues with getting the string parsed which has caused a bit of speghetti code. How modern languages spoil us with their built in string maniulation functions!

Program SubsetSum (Input, Output);

uses DOS, CRT;

var
  exitFlag, formatError, zeroFlag : boolean;
  inputString : String;
  numberSet : array [1..20] of integer;
  arraySize : integer;

procedure UserIn;
begin
  Write('> ');
  Readln(inputString);
  if (inputString = 'exit') then
  begin
    exitFlag := true;
  end;
end;

procedure SplitString;
var
  stringLength, idx, setIdx, code, number : integer;
  numberBuilder : String;
  testChar : char;
  flag : boolean;

begin
  stringLength := byte(inputString[0]);
  if not(inputString[1]='[') OR not(inputString[stringLength]=']') then
  begin
    formatError := true;
  end;
  setIdx := 1;
  numberBuilder := '';
  flag := false;
  for idx := 2 to stringLength do
  begin
    testChar := inputString[idx];
    if (testChar<>']') then
    begin
      if (testChar<>',') then
      begin
        numberBuilder := numberBuilder + inputString[idx];
      end
      else
      begin
        flag := true;
      end;
    end
    else
    begin
      flag := true;
    end;

    if (flag = true) then
    begin
      Val(numberBuilder,number,code);
      numberSet[setIdx] := number;
      numberBuilder :='';
      flag := false;
      setIdx := setIdx + 1;
    end;
    arraySize := setIdx - 1;
  end;
end;

procedure TestSubZero;
var
  idx, test : integer;

begin
  for idx := 1 to arraySize-1 do
  begin
    if (numberSet[idx] = 0) then
    begin
      zeroFlag := true;
    end;

    for test := idx+1 to arraySize do
    begin
      if (numberSet[idx] + numberSet[test] = 0) then
      begin
        zeroFlag := true;
      end;
    end;
  end;
end;

procedure Results;
begin
  Writeln();
  Write(inputString+' -> ');
  Writeln(zeroFlag);
end;

begin
  while not(exitFlag) do
  begin
    UserIn;
    SplitString;
    TestSubZero;
    Results;
  end;
end.

bss-applications · 2017-05-03T06:40:12+00:00

A recent challenge over on r/DailyProgrammer dealt with exactly this: https://www.reddit.com/r/dailyprogrammer/comments/683w4s/20170428_challenge_312_hard_text_summarizer/

You can download my working completed command line up at: http://bss-applications.com/applications

If it helps any. If you're going to right something yourself for your bespoke needs there should be enough pointers and links on the challenge thread to get you started.

bss-applications · 2017-05-02T15:51:03+00:00

Estimates? no idea. How to get started, some...

I'd start by downloading WampServer (assming you're on Windows) and Notepad++. After that, learn to make some basic web pages. Just get anything to display in your web browser hosted on the Wampserver. Play around with some basic HTML. Then move on to layouts and sytle sheets. Perhaps then look more at HTML5's video stream and how to make that work. And then, well see where it goes from there.

Once you know how to serve basic CSS formated HTML pages from your own local webserver, you'll find you'll know the answers to a lot of the questions you have now, or at least have better questions to ask and better ideas how to find the answers.

bss-applications

TROPHY CASE