Answer is a - b - c or a - b * c

using System;
using System.Collections.Generic;
namespace Order {
    class Banknotes {
        public long value = 0;
        public int count = 0;
        public Banknotes(long value) {
            this.value = value;
        }
    }

    class Program {
        public static Banknotes FindMaxValue (List<Banknotes> list) {
            int _maxValue = list[0].count;
            Banknotes _maxBanknote = list[0];
            for (int index = 1; index < list.Count; index++) {
                if (list[index].count > _maxValue) {
                    _maxBanknote = list[index];
                    _maxValue = list[index].count;
                }
            }

            return _maxBanknote;
        }

        public static void Main (string[] args) {
            List<Banknotes> banknotes = new List<Banknotes>();
            int length = Convert.ToInt32(Console.ReadLine());
            if (length == 0) return;

            banknotes.Add(new Banknotes(Convert.ToInt64(Console.ReadLine())));
            banknotes[0].count = 1;
            for (int iterable = 1; iterable < length; iterable++) {
                long number = Convert.ToInt64(Console.ReadLine());
                for (int jterable = 0; jterable < banknotes.Count; jterable++) {
                    // Console.WriteLine($"{number} is {numbers[jterable].value}?");
                    if (number == banknotes[jterable].value) {
                        banknotes[jterable].count++;
                        // Console.WriteLine("yes");
                        break;
                    } else if (jterable + 1 == banknotes.Count) {
                      // Console.WriteLine("no");
                        banknotes.Add(new Banknotes(number));
                    }
                }
            }

            Console.WriteLine(FindMaxValue(banknotes).value);
        }
    }
}

pls give me some tests,i don't know,what's wrong with my code
#include<iostream>


#define  endl '\n'
#define ll long long
# define ld long double
using namespace std;

ll d[1100][1100];
int main() {
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
#ifdef LOCAL
freopen("input.txt","r",stdin);
freopen("output.txt","w",stdout);
#endif // LOCALfr

int n,m;


            for (int i=1;i<=1000;i++) {
    for (int j=1;j<=1000;j++) {
        d[i][j] = d[i][j-1] + d[i - 1][j - 1] + 1;
    }
            }
n=1;m=1;
while (n && m) {
    cin>>n>>m;
    if (n &&m) {
        int l=1,r=m+1000,mi;
        while (l<r) {
            mi=(l+r)/2;
            if (d[n][mi]>=m) {
                r=mi;
            }
            else l=mi+1;
        }
        cout<<l<<endl;
    }
}
    return 0;
}

Edited by author 03.11.2021 00:01

Edited by author 03.11.2021 00:01

Edited by author 03.11.2021 00:01

Here are some tests that helped me figure out what was wrong with my program:

316496
out => 317559 317560

318533
out => 318659 318660

945999
out => 950509 950510

055099
out => 055109 055110

00510059
out => 00504999 00505000

00450010
out => 00460019 00460020

00504010
out => 00504999 00505000

0019
out => 4509 4510

00510059
out => 00510059 00510060

945999
out => 950509 950510

008359
out => 009449 009450

3000
out => 4509 4510

4509
out => 4509 4510

4099
out => 4509 4510

9999
out => No solution

373730020389
out => 373730021389 373730021390

373730030290
out => 373730031289 373730031290

373730030289
out => 373730031289 373730031290

Good luck!

1) Input text
2) Compare each character with:
    letter
    punctuation
3) Output with changes

using System;
using System.Collections.Generic;
namespace AntiCAPS {
    public class Program {
        public static void Main(string[] args) {
            bool _newSentence = true;
            string message = Console.In.ReadToEnd().ToLower();
            List<char> punctuation = new List<char>(new char[] { '!', '.', '?' });
            for (int iterable = 0; iterable < message.Length; iterable++) {
                if ((int)message[iterable] >= 97 && (int)message[iterable] <= 122) {
                    if (_newSentence) {
                        Console.Write(Char.ToUpper(message[iterable]));
                        _newSentence = false;
                    } else Console.Write(message[iterable]);
                } else if (punctuation.Contains(message[iterable])) {
                    _newSentence = true;
                    Console.Write(message[iterable]);
                } else Console.Write(message[iterable]);
            }
        }
    }
}

Edited by author 02.11.2021 00:10

N = input().split()

res = int(N[0]) * int(N[1]) * int(N[2]) * 2


NVM... forgot to use print

Edited by author 01.11.2021 23:13

Try this
4
a b c
a p d
b e w
b t y

ans:2

/


Edited by author 01.11.2021 14:38

This is an example of how you shouldn't make the problem

using System;
namespace EasyHack_ {
    class Coder {
        private short[] unicode;
        private string word;
        public static readonly string alphabet = "abcdefghijklmnopqrstuvwxyz";
        public string GetCoderWord() {
            this.UnicodeToCoder();
            this.SetUnicode();
            return this.word;
        }

        public string GetOutCoderWord() {
            this.UnicodeOutCoder();
            this.SetUnicode();
            return this.word;
        }

        public Coder(string word) {
            this.word = word.ToLower();
            this.unicode = new short[word.Length];
            this.GetUnicode();
        }

        public string GetWord () {
            return this.word;
        }

        public short[] GetWordUnicode () {
            return this.unicode;
        }

        private void GetUnicode () {
            for (int iterable = 0; iterable < unicode.Length; iterable++) {
                this.unicode[iterable] = (short)Coder.alphabet.IndexOf(this.word[iterable]);
            }
        }

        private void SetUnicode () {
            this.word = "";
            for (int iterable = 0; iterable < unicode.Length; iterable++) {
                this.word += Coder.alphabet[unicode[iterable]];
            }
        }

        private void UnicodeToCoder () {
            if (unicode[0] == 21) unicode[0] = 0;
            else this.unicode[0] = (this.unicode[0] + 5 > 25) ?
                (short)(this.unicode[0] + 5 - 25) :
                (short)(this.unicode[0] + 5);
            for (int iterable = 1; iterable < this.unicode.Length; iterable++) {
                this.unicode[iterable] = (this.unicode[iterable] + this.unicode[iterable - 1] > 25) ?
                    (short)((this.unicode[iterable] + this.unicode[iterable - 1]) % 26) :
                    (short)(this.unicode[iterable] + this.unicode[iterable - 1]);
            }
        }

        private void UnicodeOutCoder () {
            for (int iterable = 1; iterable < this.unicode.Length; iterable++) {
                while (this.unicode[iterable] < this.unicode[iterable - 1]) this.unicode[iterable] += 26;
            }

            short _lastUnicode = this.unicode[0];
            if (this.unicode[0] == 0) this.unicode[0] = 21;
            else this.unicode[0] = (this.unicode[0] - 5 < 0) ?
                (short)(25 + this.unicode[0] - 5) :
                (short)(this.unicode[0] - 5);
            for (int iterable = 0; iterable < this.unicode.Length - 1; iterable++) {
                short element = this.unicode[iterable + 1];
                this.unicode[iterable + 1] -= _lastUnicode;
                _lastUnicode = element;
            }
        }
    }

    class Program {
        public static void Main(string[] args) {
            string coderWord = Console.ReadLine();
            Coder word = new Coder(coderWord);
            Console.WriteLine(word.GetOutCoderWord());
        }
    }
}

Edited by author 31.10.2021 14:59

Edited by author 31.10.2021 15:11

in this test the footspeed is lower than one.
sorry for my poor english.

GOOD LUCK!!!

Use Fenwick tree instead of segment tree

Considering that d[i][j] indicate the number of i bricks divided into j columns steps.So if we cut away the downmost brick of every steps, and we can get d[i][j] = d[i-j][j-1](if the 1st step only have one brick) + d[i-j][j](if the 1st step have more than one brick).
Thus q = d[n][2->max_j]

What is in this Test? What is the difference from previous ones? There are no big numbers, no special cases - as far as I get the task...

Hi. I'm getting WA on test 13 and I can't find my error. Can somebody get me some tricky cases?. Thanks in advance...

7
1 2 3 4 5 6 22

answer is 44


2
1 3
answer is 2

Hope it will help someone <3

You need to create a dictionary (dict) with keys from '100' to '0' (keys in str format) and values ​​in the form of empty lists (list) - {'100': [], '99': [], ..., '0 ': []}.

After that, you need to read the commands IDs and their results in a loop, and then add the commands IDs to the dictionary with the key as the commands results - if you get the values ​​"11 2", then add the command ID 11 to the dictionary under the key 2 (command result) - [..., '2': [11], ...].

When we finish adding commands, we will have a sorted dictionary and all that remains is to print the values. In the loop we go through the dictionary and if the value (list) is not empty, then we display all the values ​​in the format "command_id dictionary_key".


Нужно создать словарь с ключами от '100' до '0' (ключи в формате str) и значениями в виде пустых списков (list) - {'100': [], '99': [], ..., '0': []}.

После этого нужно в цикле считывать ID команд и их результат, после чего добавлять ID команд в словарь с ключом в виде результата команды - если получили значения "11 2", значит добавляем ID команды 11 в словарь под ключом 2 (результат команды) - [..., '2': [11], ...].

Когда закончим добавление команд то у нас будет уже отсортированный словарь и останется только вывести значения. В цикле проходим по словарю и если значение (список) не пустой, то выводим все значения в формате "ID_команды ключ_словаря".

dp[i][j] - можно ли получить остаток j если длина равна i.
я получал всякие превышение памяти и времени, только потому что я сохранял предка. Но если не сохранять предка, а вычислять самому, то решение будет < 100 миллисекунд. Восстанавливал и находил минимальный ответ через рекурсию  почти как дфс.