diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..12f59b6 --- /dev/null +++ b/.gitignore @@ -0,0 +1,206 @@ +# Download this file using PowerShell v3 under Windows with the following comand: +# Invoke-WebRequest https://gist.githubusercontent.com/kmorcinek/2710267/raw/ -OutFile .gitignore +# or wget: +# wget --no-check-certificate http://gist.githubusercontent.com/kmorcinek/2710267/raw/.gitignore + +# User-specific files +*.suo +*.user +*.sln.docstates + +# Build results + +[Dd]ebug/ +[Rr]elease/ +x64/ +build/ +[Bb]in/ +[Oo]bj/ + +# NuGet Packages +*.nupkg +# The packages folder can be ignored because of Package Restore +**/packages/* +# except build/, which is used as an MSBuild target. +!**/packages/build/ +# Uncomment if necessary however generally it will be regenerated when needed +#!**/packages/repositories.config + +# MSTest test Results +[Tt]est[Rr]esult*/ +[Bb]uild[Ll]og.* + +*_i.c +*_p.c +*.ilk +*.meta +*.obj +*.pch +*.pdb +*.pgc +*.pgd +*.rsp +*.sbr +*.tlb +*.tli +*.tlh +*.tmp +*.tmp_proj +*.log +*.vspscc +*.vssscc +.builds +*.pidb +*.log +*.scc + +# OS generated files # +.DS_Store* +Icon? + +# Visual C++ cache files +ipch/ +*.aps +*.ncb +*.opensdf +*.sdf +*.cachefile + +# Visual Studio profiler +*.psess +*.vsp +*.vspx + +# Guidance Automation Toolkit +*.gpState + +# ReSharper is a .NET coding add-in +_ReSharper*/ +*.[Rr]e[Ss]harper + +# TeamCity is a build add-in +_TeamCity* + +# DotCover is a Code Coverage Tool +*.dotCover + +# NCrunch +*.ncrunch* +.*crunch*.local.xml + +# Installshield output folder +[Ee]xpress/ + +# DocProject is a documentation generator add-in +DocProject/buildhelp/ +DocProject/Help/*.HxT +DocProject/Help/*.HxC +DocProject/Help/*.hhc +DocProject/Help/*.hhk +DocProject/Help/*.hhp +DocProject/Help/Html2 +DocProject/Help/html + +# Click-Once directory +publish/ + +# Publish Web Output +*.Publish.xml + +# Windows Azure Build Output +csx +*.build.csdef + +# Windows Store app package directory +AppPackages/ + +# Others +*.Cache +ClientBin/ +# [Ss]tyle[Cc]op.* +~$* +*~ +*.dbmdl +*.[Pp]ublish.xml +*.pfx +*.publishsettings +modulesbin/ +tempbin/ + +# EPiServer Site file (VPP) +AppData/ + +# RIA/Silverlight projects +Generated_Code/ + +# Backup & report files from converting an old project file to a newer +# Visual Studio version. Backup files are not needed, because we have git ;-) +_UpgradeReport_Files/ +Backup*/ +UpgradeLog*.XML +UpgradeLog*.htm + +# vim +*.txt~ +*.swp +*.swo + +# svn +.svn + +# Remainings from resolvings conflicts in Source Control +*.orig + +# SQL Server files +**/App_Data/*.mdf +**/App_Data/*.ldf +**/App_Data/*.sdf + + +#LightSwitch generated files +GeneratedArtifacts/ +_Pvt_Extensions/ +ModelManifest.xml + +# ========================= +# Windows detritus +# ========================= + +# Windows image file caches +Thumbs.db +ehthumbs.db + +# Folder config file +Desktop.ini + +# Recycle Bin used on file shares +$RECYCLE.BIN/ + +# Mac desktop service store files +.DS_Store + +# SASS Compiler cache +.sass-cache + +# Visual Studio 2014 CTP +**/*.sln.ide + +# Visual Studio temp something +.vs/ + +# VS 2015+ +*.vc.vc.opendb +*.vc.db + +# Rider +.idea/ + +**/node_modules/* + +# Added by Jskonst +# .vscode/ +Properties/ + +##### +# End of core ignore list, below put you custom 'per project' settings (patterns or path) +##### \ No newline at end of file diff --git a/.vscode/settings.json b/.vscode/settings.json new file mode 100644 index 0000000..bf78e73 --- /dev/null +++ b/.vscode/settings.json @@ -0,0 +1,10 @@ +{ + "files.exclude": { + "**/.git": true, + "**/.svn": true, + "**/CVS": true, + "**/.DS_Store": true, + "CourseApp": true, + "CourseApp.test":true, + } +} \ No newline at end of file diff --git a/CourseApp.Tests/CourseApp.Tests.csproj b/CourseApp.Tests/CourseApp.Tests.csproj new file mode 100644 index 0000000..ae46394 --- /dev/null +++ b/CourseApp.Tests/CourseApp.Tests.csproj @@ -0,0 +1,30 @@ + + + + netcoreapp2.1 + True + 1573,1591,1701;1702;1705 + false + + + + + + + + + + + + + + + ../_stylecop/stylecop.ruleset + true + + + + + + + diff --git a/CourseApp.Tests/DemoTest.cs b/CourseApp.Tests/DemoTest.cs new file mode 100644 index 0000000..71e4289 --- /dev/null +++ b/CourseApp.Tests/DemoTest.cs @@ -0,0 +1,14 @@ +using System; +using Xunit; +using CourseApp; + +namespace CourseApp.Tests +{ + public class DemoTest + { + [Fact] + public void Test1() + { + } + } +} diff --git a/CourseApp.Tests/Module1/AplusBTest.cs b/CourseApp.Tests/Module1/AplusBTest.cs new file mode 100644 index 0000000..6242786 --- /dev/null +++ b/CourseApp.Tests/Module1/AplusBTest.cs @@ -0,0 +1,41 @@ +using System; +using System.IO; +using Xunit; +using CourseApp.Module1; + +namespace CourseApp.Tests.Module1 +{ + [Collection("Sequential")] + public class AplusBTest : IDisposable + { + public void Dispose() + { + var standardOut = new StreamWriter(Console.OpenStandardOutput()); + standardOut.AutoFlush = true; + var standardIn = new StreamReader(Console.OpenStandardInput()); + Console.SetOut(standardOut); + Console.SetIn(standardIn); + } + + [Theory] + [InlineData("10 12", "22")] + [InlineData("1 1", "2")] + [InlineData("10000 10000", "20000")] + public void Test1(string input, string expected) + { + var stringWriter = new StringWriter(); + Console.SetOut(stringWriter); + + var stringReader = new StringReader(input); + Console.SetIn(stringReader); + + // act + AplusB.Calculate(); + + // assert + var output = stringWriter.ToString().Split(Environment.NewLine, StringSplitOptions.RemoveEmptyEntries); + Assert.Equal($"{expected}", output[0]); + var standardOutput = new StreamWriter(Console.OpenStandardOutput()); + } + } +} diff --git a/CourseApp.Tests/Module2/BubbleSortTest.cs b/CourseApp.Tests/Module2/BubbleSortTest.cs new file mode 100644 index 0000000..7ebaa95 --- /dev/null +++ b/CourseApp.Tests/Module2/BubbleSortTest.cs @@ -0,0 +1,51 @@ +namespace CourseApp.Tests.Module2 +{ + using System; + using System.Collections.Generic; + using System.IO; + using CourseApp.Module2; + using Xunit; + + [Collection("Sequential")] + public class BubbleSortTest : IDisposable + { + private const string Inp1 = @"4 +4 3 2 1"; + + private const string Out1 = @"3 4 2 1 +3 2 4 1 +3 2 1 4 +2 3 1 4 +2 1 3 4 +1 2 3 4"; + + public void Dispose() + { + var standardOut = new StreamWriter(Console.OpenStandardOutput()); + standardOut.AutoFlush = true; + var standardIn = new StreamReader(Console.OpenStandardInput()); + Console.SetOut(standardOut); + Console.SetIn(standardIn); + } + + [Theory] + [InlineData(Inp1, Out1)] + public void Test1(string input, string expected) + { + var stringWriter = new StringWriter(); + Console.SetOut(stringWriter); + + var stringReader = new StringReader(input); + Console.SetIn(stringReader); + + // act + BubleSort.Sort(); + + // assert + var output = stringWriter.ToString().Split(Environment.NewLine, StringSplitOptions.RemoveEmptyEntries); + var result = string.Join(Environment.NewLine, output); + + Assert.Equal($"{expected}", result); + } + } +} diff --git a/CourseApp.Tests/Module3/FindStringTest.cs b/CourseApp.Tests/Module3/FindStringTest.cs new file mode 100644 index 0000000..089768c --- /dev/null +++ b/CourseApp.Tests/Module3/FindStringTest.cs @@ -0,0 +1,41 @@ +using System; +using System.IO; +using System.Security.Cryptography.X509Certificates; +using Xunit; +using CourseApp.Module3; + +namespace CourseApp.Tests.Module3 +{ + [Collection("Sequential")] + public class FindStringTest : IDisposable + { + public void Dispose() + { + var standardOut = new StreamWriter(Console.OpenStandardOutput()); + standardOut.AutoFlush = true; + var standardIn = new StreamReader(Console.OpenStandardInput()); + Console.SetOut(standardOut); + Console.SetIn(standardIn); + } + + [Theory] + [InlineData("ababbababa\naba", "0 5 7")] + [InlineData("bcbbbabaacbbccabbabbacabaababacbbcaacababbaaacccaccbcabaaabbabaaacaaabbbcacbbbaccabbcacabbabaabacbbbccacacbcbabcacacccccbabcaaccabacbacbcbbacaccabbacabcaccabaccaaabacaacbacabcabcaababbcbcbbbacbabaacbaccccbaacbabaacbcabcbacaccbccbcaaababaabacbacccbcabaabcccaabcaccabacaacbbccbbacabcaaabbabbcccabbcbaabbbccabacaaaacacbbccbbcaaaabbbbaaccccbbacccbcbacacbacbbcabaabccbbbacacbbcabcacabccbacacbababccbbbbbccccbababbcacaccababcbaaabbbbbbacbcbaaccbcbabcaaaabbbbaccaacaacbbbcaacacaabbcbbabbbacababaabaaacbbbabbcbbbbbaccabbbcbaaabbcccbaacaaacbbbbacbccacabcbccbccaccbcccabacbbaacccbbabaaccbbbaaaabcaabacbacacacabccccbbcbabccbaabcccaaacabbcaaabbcaaacaabcbbaabbccbbabccacaacbabbcbbaccabccccaaaacccacbbccbcbaaacaaabbababcbbbcbcbbcbcbccacaabacbbaacccacacaaccbaaabccaabcabbacbbacaacacbbcaaabcabbbacaaaaabccaabbaacbcccbbbacabcaaacacbbbbacabcabcbcbaabababbcabaabcaabaabbcbbabbcabbccacaabcaacaaabacccbaaabccbabbccbbbacbbcacbbccbbccbacbccbbaaaacbaacbcabbcaaacacbacbbccbbacbaaaacbbaabcabcccabcbcabccaacaaabccabcbcccacbacabcabcabcccbbaabbabaabcbcaabbbcabababaaaacabcbbaacaaabcbaabcacabbcbcbbcabcbcccbcabcbaaaccbbbbcaabbbcaaaabbaacbcbabaaabccbbacbcaaabbccccbcbacaccaaaaacccabccbbbbacabcabaaabaaaacccccabababcacabcccaabacbcaabbccbbbaabcbacbbbccbccbbbbaabcbacacbcbbbababacababbaaaabacaccbbcaabbbbacacbccaaacbcacbaaccabaacbbcacabcbccbaabbbaaacaabbcaacaaabacbbbbbbbbbaaacaacbacbbcaacccabbacacbacbbbbaabccbcbbbbcbcaacccbcbcabaabcbcbbcaabcabbbcacbabbaacaaccbbcbabaacbbcbbabacbcacbbaabaacabcccbcaccccbcccbacabbcabacbbaacbcccaaaaaabcbcbcabcacacacccabaccacabbabcbbaaaaccacabbcbbbcbccacbaabbcacbcabcaabccaccbaabcccbbcbbbbcccabbaccbaaabbcaaaaccbccaababaabbbcbccaaccccacabacbbaaabbbbcbcacbaccabbcbbcaabaaccbbcaabbaacaacbaabcbccbccabccbacbcbaccbccccbbbbcaaabacacacbaccaaaaccaaccabacacaababcaaccababccacbcccbbbbbcbcaaaccaabaabacccbcbbaaccccbacbbacacccaccccacaaabbcbaabaaccabbbbcbccaaaacccbabbaabbcccacccbabaaaccccaccbbaccbaaaccbcbcbbbbaacaabacacbbcabcaaccbbaacaccbabcaccaabbababaacbccbaaccbcbaabcbacbbbaabbabbccabcaabacbccaaccbabcacbbccaccababcbbacacbcbaccbcbabcaabbcbbababbbabbbccbcbcbbbabccaacabbabaaaabbbbbacbbcabcabccbcbcbcaabbbbcabcbbbcacbbcabbbacbabaaccbbacacbacaaaaacaacaacbabbbcacabcbbcaaaaabbcccbbcbbbcacabaaabacbbbccbbcbccccabbbabbbabcccaccaaabcacacaccbcaaaacababcaacaaabbbcaccacbaaccacccbabcbbabacabbbbcccbacaacacabaaaaacbbcabbaacaaccababbcacbbbccaaabcccacaabaaaccbcbabccbbbcccbbbaccaaacaabccacaabbccbacaabababaaaccbccbcaaaaabababcbbacbaaaabaaacbbcbbaaccbbbbaaacabcaaccabbcaccbcccbacaabacabbaccbacbaabcbcaaabbbcbcabbacaccabaabbbabcacbabccabaabbcbcacbbbbcbbbcaaabbbabaaccbbacabaaacbbabaaaccacacabcccccbbcbbbbbccabcbaaccccbbbaccababbbacbccccccbacacabcacbbbacbbacbccccbaabbbcacbacacbccbcabbbcacacacabaacaaaabccbcaacaababcbbaabccbccbabccbaabbcbbbaabcbababbcacbbcbbbbabcbabbcbcccababbaaaccabccbaaacbaccbbcbaaacccbbaaacaabcbbcbbcccbcbacacbcbbaabbaaacbbcababbaccabbbbbcaccbbbcccaaabbaabcccbbaaaacbcbabcaaccaacaaccaaabcbccbbbcabccbacbbccaabbaaccaccbcbbaaccbcabcacaacbacabbccaabbaacabcacabbcaacbbcaaaaaaacbaabbbacccaccbcbccccbbcbbcccacaaabbcacacbaabbbcaccacccbbcaacababcabbaabacbcaaccbccaabbabccbbccbacabbacbabaabbaabcccbbcbbaabbbcaccccaaacbcbbaaccaccbbabcabaababaaccccacabbbcacccaccabcbccbacaaababaacbbabaacccbbcacbcababacbccbccaacabccabacccbbcbacaacaccbabbaaaacbbaacacbabbccbaacacbaabaababbbaabbcbcacbccacbbbabacaccbccacbccacbbbcbbcaccaccbacabcabababbcccaaaababcaaacbccbbacccacabacbacccbababbbbbaccabacbbbcccbacbcbcccbaaaacbcbbbbaaccbcbababbcbabbacabaabbbaacbaacccccacbbaccbccbbbccbcaaaccbaabbcbabcacbbbaabacbbabcabbbbaabcaccabbcabbaccccccbcbccbacbccaabcbccaaabccbbaaacbbbbbbbaaaaaccccabacbbcabaacccabbcbcbccbbacaaccbacbbabcbbacbbbabcbcacaccbaaccbbcccabcbcccbacaabccaacacccabcabcaaccaabbbcaacbabbcbbbccacabbbabaaacaaacbaacabbbccaacacaaacacccabacbbaacacaccccacaabcbbaaaccaacaccccabbccabbabcabacabcaabccbcbaababccabccabacccccabbcacabccbbbacbbcacbaccacaaaabcccbbbcbaacbcabcbbbaacccbcbcacbcbababcabcabbcbcccbcbcccbababbcbbaccaabbbbabacaaccbccaababacbabcabaccacbcaabbbaabcacabbbacbcccacbccccaacbcbaaabcaaacabacbcaccbacbabacbaaacaabaabaccbcbbbbbcacbbbccbbccaaabbcababaabacbabcbcccccbbbbccbbbaacbaabbbaaabccabccbbbabcaaaaacbabbbcbcabbcabcccbbaccaaaaabbaaaacaacabbccabcabcbcbcaabaaacccabbacccbacccaaaacacccaaccbbabcaccaabbbccacabcbbaaacbbbbccbaacccbbbbcabaaabacbcaccabbaaccbabaabcabcbbcbcacaccbccbccaccbaccbacccbccabbbacaabccaabcbbcbccabbcccabbcbaccacbbbbcbbaabbbbabaabbbccabaccacaccabbccbcbcbabcaaaccaccabaccccbaaabbabccaabaaababaaacaabaacbcabacbcbabccbcbbbbaccccaccbacbbcacccaababcbbbcbbccaacacbbbaacabbcbbbbabbabcbbbbbbbcccbbbcbabaacacbccacbbbacabbbaacbccbaacbbccbbaaccbbcaabcccbbbbbcaacaccaccccaababcccaccabaaaccabccaccacaacacbbccbaaababaaabaabccaabaaccaabaccbbababababbcaaabcaacccccbabbcabbabccccaaaabacbacccbbabbbaacccbbcaaabbcbcaccaacbcccaaacbacabccaccbcaccacbabbbbbbbbbaabccccbcbccabacaaaacbabcccbbbacccacbbcbbbbacbccbaabcaababaccbaccabaacbacbacaacbaabaaaccbaaaaacaaabbacaccccccbcbbcaccccacccbccbccaccbaacaaabaccaccabaabbcaccbbacccababacbbacaaabbccaccbbbcbbaaabaccaabcbabababcbabcacaacbaaaabccccabccccacabacaaabbbabbcacccbbccccbbbaabbccbcccccbcaccbccaaaccaacbacbbacaacacbaabcbbaccbcccaacabbaaaaaaabcbcccacabcbcaabcaaaabaabcbaacccccabcacaccabbccacabbbaabccabbaaccbaabcacaaacbabbcacabccacbaaabcbaacacccabbbbbcaabcaccacbbaacbaacacbccbccccbacbccacabbbcccbababbacbcaccbcabbcaaccbbabbbaacaabbacbacbaabcccbcbbbbaacbbaccaaaaabaccaacccaacaaabbccacababcabaabcacbcbbcabbaabcbbabaacaabccccbbbccbbcbcabcaacbabbbcabbaaabbbbaccaaaaaacacccbbbcaabaabcacaccabacacccbbcaaccaabcccbbbbbbacaaaaacbcacbbacbccbaccbbcbbcbbcbbaabbaaababcabcccabcccbacacccbbbbccbbcaacbacbcbbbbccbbbabbacabcaaacbcabaccbaaaccbbbbbaacccaabacbabbaacacacaacbcbacbabbbbcabcbaccbbbbcbcaaacbbcabbbccbbbcabacbbacaaabcaacacacaaaccabababacbccbacbcbbbcbbcbbaacccbcccbbcacaabbabaabbccbccccbccacaaabaaaccabaccaaacbcacccaccabbaacbbbbabaccaabbbccccbbabcccbabcabaaabaaabbacbaaaacabcaaccacaaaccbcbababbccaacabbcbaacbcbcabaaccccbbbabbbbbaabbccbaababbabcbbbbbbbcaabbacccccbcaaacbcaacbbbbccacacbabcabacbccacbaacacbacaabaccbcacabcbcbbacbccbbbaaaacbccccbbcbaacbaababacbbbccbbccbcccbaccacbabcbabaabcccbbcabccbacacbaabbbaacaccaabcccacbcbbaccaababccbacccccabbbbbcbbbcbaccbbabbaccbbbbccbacbbcabbcbaccababcbcababcabbcbcbabcbbaaaabcbbbbcbacaaabccbcbaacccabacbbcbbcbcaaaacbcccbcbabbabbbcccbbccaccbccbabbaacabacbacacababbcbbbacabbabcacaacbbaccabaccccabbaacacabcbcccbaaabcacbabaabaabbaccbcabccabacbbbbcbabbcbbacabbccaacccbbcccbabccbccccbacaacccbcbbbabcaccacbccccbbaaacacabcaaccaacaaabcbcbacbcabcbabaccacbbaccbabcacccbacccabbcbcbcccabccbbaabbabccccbabacaccacbcacabcacabbcbbbbabcbcbcbbbcabcaccbbaaaaabbbbccccaaabbcbbabccbabaccbacbbcabbaacccbbcbacccbcbbcbaaabbccccabbbbabcacbaacaaacbbaabcbaacbbcababccacbbcacbacabbbbbaccabcacccbabacabccaccbcabbabccacbcabbaabcbcccbacacbbbccccbcacbbbacabbabbbabaacbabcacabaaccacbabcccbababcbcccbcbbbabacabbcbaccbcbbaaaacabbccaacbcbcabbacccabaacacccbbbacbaaaaabcabbcbbccbcccabaaabccaabaabcbcbbabbccaaccacbbaaabbbbbabacbaccbcbbbccacbabbacbbbbbbacabbbbbaabacbcbabbaaacabccbbacbcbbaaacbbaabcbacbabbcbaccaccaabbaabbbcbbcacbbbbacbaabbaaaacbaaaabaababacaaacbbbbbbccacaaacbbbacbcbcaaacaababbaccbaaaacccacbacbaaaabbcaccbcabbccbbcaaccbbbbbcccaccaccbcbacaaaaaabacccbcabaabaacaaacabaababccabacbbababaaccccbaacaccbcabacaabbccbcbbaabbcaaacaccbacbbabaccacabcbbbccaacbbaabaaacbcccaabacaccaaacccabbbccacccbcacabacccabccaaababbaccbabaabacbbccbccbccabbbbaabbbcaaaacaccbcbabaaaabcaacbacababcbababccbcbaabcbbaaccacbacbaacbabcacbaaacacaccbaccaabcbaabcbabaacbacccbccaaaacbaaaaabccbccccacbbbaccacbabaacbbacbbbccabcccbcbbbaabccccbaacaabbcabcbbbbbbbaaaacabccccbcbababbaacbccaccbbabacbcabbbbabbacacbbaaaaabbacbbacccbbaacbccbbccaabbbccccaccbaaccacbbaaababacabbcbcbabaaacbcabcaacbaabbaababbcaccaccaababbcccacaaaaaaabbabcababcabccaccababcaaacacbcabaccacbcbccacbcbcccbbacabbbbbcbbacaababacabacccaaccbabaaabbccbbaababbccbacabcaccacbaabbbbbcbaabcbcbcbaabcccbabbcbaccacbcbbcbccabbacbcacbcbbccccabcbcbaccccbcbacaababccbcbcccbccabccababacbabbacaaacaabcccbcaabcbbcabbacbbcbbcbcaccaccbcbaabbacbacbabbbacccaacabcaacbbcababacacaccbccabcccbcbcbaabbaaababcaabbabcabaabbaababcaacbaaabbbaaaacababbaccacaabbcbccbbccacbbabaabcbbbcbabcbabaaaacabbbbbbacababcccccbcbaaccbbacbbbbbbacacaabbababcbccaacccacccaaccccababccaaaacaacabbcbcabcccabaababcccaaaccabbbaccbcabcbccabccbbaaabbcabcacaabcacbcaacccbbbbbabaccbbccbabbcbcbacbcaccbbcbccabbcbcbcacbcababbcaabaabaaaccbcbbccaacacaccbaabbccbbacbacaaccaabaabcaabbaabcabbbbbabccabcabcabccbbaabcbaabcaabbbbccaacbababbabccabaccccaaaacabbabccbabccbbbaabbccacbbaaaacacbacabaaabbacbcabbbabaabbabcbbacbcacbbcbacacabbacbbbbbaccbbabbaacabaacabcabcabcbaccbbcbcbabcaaacacacccaacbbbcbbcabbacbacbaabbcabcaaacccabcbcbbbcabbaaabbcbaaabcccccbccbcaaabbbbabbcccaaabaaabbbaabccacccbbcaaabaccaaaaabbababcbbacccccccbabbcbcacccbcccccabcababbabccababbabbaabacbbcbbbbbababcaaccbababccbaacbcaccbcccbaabcabcabbacbaaaacaccbccbcacabaaccbccbbacccacbabaabbcaaaaaaabaacccaccbbaababbaabcaaabcbbcccbcabcbabbaabbabbabaaccaabacbacbccbbaccaccaaaaccacbbbabbabbcbbbcaccccaabacabbbbcabcbabcbcccaabcaccabcbbababcccaccbcaaaabbbaacbacbcbaaabbbbaabbcabccccaabbabccccaacbaabcaabaaacbbccbabbcbaaccabbcbbbbabbbcababcbacbbaaaabaabacbbccaabcbbacaacabbacacbcbaaabbabacbacbbaacccaacbababbcaccaacaabaccaabcbabbbaaacabaaaabbbcbbbcccaababbcabaaccbaacbacbccbccbacbbabacabacbbbaaaaaccccacbbacaacabccbcccbacabbabbbaaacbabbacbabaccccccbaaaaccbbbcbaccabcbbcacbcbbbccbbbaabcbcbaababbcbcccacaababbbbbabccbababcacabcacbacbcbaabbabcccabaccbaccbccbababbcaacbcaabacaabbcbcbaccabbccbcabaaaaccbccbcccccccabaabcbcbccccacaccabbbacccababababcccaccaccccccaccbbaaaacbcccccaccbcacbcccbbacbaabcbabcacbcabcbccbabacbbcabcbabcabcbbabacccccabbbacabbacccbababbcbacbabaacccbabbcbaaabbccaabcabaababccacccbaacbcabbababccaaabbccaccaacacacbacbccaaaaccacacbaacccaaababcbbccbaccaacbbcabcbabbbcbacabcbccbcbbbaacaabbbcabcccacbbbabacccbbacaaacbccbcaccbbbbcbbbcbbcaabbcabcccacacbbcbccbcbbcabcbaaabbcbabaacbaabbcacbbcbabcacccbcbcaccabaacccaaaacaabcaabbccbbbccbcaccbbbabcbaababbabbaacababcccbbaabaccaaaaacacbbabbacaabbbbbabbcbbcaabccabcabbbbcbaabbbcabacabcbaabcccbccacccccbccabbbcabbabbcbaccbcbbbcbacbabbcbaaaaaccbacbcbabbacaabcacbcacbabaabcabbbbbbcccccabcbaabbccabcbacaccbbbbacabbcacaccccabcacbcbcababcaabbbbccbccacabbccaabccbaacbbababaaaaaaababacccbabccacbaabbabaacbbaccaccbbaabacccabbccaacaababccbaacacabaccacbbbaccccacbbccbccaababaabaababbbbacaacccbbcccccaabbcbcbbaaacacacbbbabccabcacacaccabbaacbbabaabbcccbccaaabbabbaacacbccccaacccccaccccacabacbabacaaccacacccacaccaaabacbcccacacbbbccbcbbbccbccaacacababbaaccbcccbbcaacabcccccaccabacaaccacbababbcbcaacabaacbbcaaaabbacbabaccbbcbaaabbcaaccabacbbcbaacbaacccbbbcabcbaacbccbbbbbbbbaacabaaacacabccaaacbaacbbbbcabcacaacacbabaaccbccacaabaacbaaaaabcbacabbcbcbcaaacaaaccaaaacaacbcbbcbcccaaccaabcabcbaaacbacbbbacaaaacbcbaaacbbcacbbaaaabccabcabccccbcabcabcaacbcababacbcabbcbabaabccbcbababcbabccbaaacacaaaaacccbcaccbbacccbbbbbabbbbbabccabbabcacccbcbcbabbabbababbabbcbcacacacbacbbabacccbcbaaabababaabcaaacacccabcabcacaacaccbbaaaaaacaacabbabacbbcccabcababaacbbabaaccbcbcbacacbccbcbcaccacbbbbccbaccaacaababcacbbbccbcccaaccaccacacabbbbbbcacbbbcccaaaaaaacbcbbccbabbbbbabbabaaabcacbaaabcccbbabbbacacacabacbcbacaaaaccaaaabcabaacbcaaccbacaccaabcaaaabaacccbcbaccacccacaababacacbcbcbabbabccbccaabacaacbccbaacbccbbccabccbbaaccbcbacabaaacacababbbaabbabbabbabccabaababccabbcaacbcababababccaabccbcaacbbcbaacccbabaaaaabccabaaaababbaccbbcbbaccbbaccbcbbcbccacbcbcaccbccacaaaababccbacbcabcaaabbbbabcbccccbcbaaacbabcaabbcbcbacaacbcbbcbabcabcabacbccabaccbcccbbbbabaccbcaabbcaaaacccccbabcacccaccbaabbabbabbabcbcbacacabacaababaacbaccbbccccabaacbabacbbabcbbccbbaaaacaacccabbabbabaaaaabcaaabbbccbcaaacbababcacccbaaaaabcacbcbabcbacaaccababacaabbabbaabacccaaabcccabccccbbcbcaacaaaccacabaaccbcaabcbbccaabbbbacbcbcacaaaaccabcbbccbbbbbacbbcabbbabaabccbbacbbabbbccabacbbaacacaacababaabbccbbcbbaccacbcbabbcbbcbbbaacacabacaaaacccabcbbbccbcbbbbbcbbcacbbbbcbbcabcbbcbcbaacccababbccbcbbacccaabaccaabcbbbbacbbbaacaaccabcabacbbbbbbabbccbaaaaabbbcbccaabcaabaaacababbbcbbbaacabcbcbabaccbaaacacbabbaabaccabcaaccacacabaacbcbbbbbaaaaaaccbcbaaacabbaacacbababbabbccbacbaaacbbababcabacabbacbacbaabbbccaacbaacbaaccbcbaabbcbbbcbcaccacbccccbcaaabaaabcacbbccccbcabbccbccacabaabccabbcbbaaacababbabbbaccaabcccbbbbbbaabbcccabcbbbabccbcabaaaacbbabcbbccaacabcacbabbacccababacccbbcaaaacabccabcaaaacbcacababbccacccbcbcbbbbbabaaababcccaaccccccccbbbcacbcccababbabcaabbabbbaabacbbaaacccbaccbcbcaaaaaccbbccccbbbaaccabcabbbaacbcccacccaccacccbcbbcabaacaacccbacabcbaacabcbabccabccbbbaccabbcaacbaababcabbbacbbcabcaaaaacaccbcccaabbcccaaabccbcbabaaacccbaabbbbbbcbaaabbbcaabccaaaaaaababcacbabaaaaabcabaacabcaccacbcbcabaaccbabacbabaababcbcccbaababcbcbaabbcaabbcbccacbabccbbbcbbbbbcbcbccacbabacabacacacbcccbbcccaccbcbaacbcabcbabbacbcacabaacacccbaaaccbbbbcabbabbaaaaabcbbbccbcaccaaacbcaabaabacbbaacbaabccabaabababacbabcccbbbccccabcbcccccbcacaabbbaaccbbcabacccabcaaabccbabaaacbbaaabbbaacccccbbabcbababccaabbbbbaccabbacacaabaacbacaacbabbaabcacabcbaaacabaaccccbacccbcabaabcccaccaacbcbcbaacabbaababbbcbcaccbcccaacabbccabcbccabaacaabcbbcabcbcbbbbbbabbcbbacbacacccccaabaccaabbaabcaccbccaaacbaabbaccaacbbccbcaaacccaccbbcbaaccbbcbcaabcaacbacbbabcaaaccaccacaacaacaacbabbcbacbbcbababcccacabcacccbacbbaaaacbacaaabcbcbabcccccacbbcbcbcaaacbccaabaaccbbbcabcccccabaacacaaabbbcacbbcaccccbaacbbbbccbabcbccccabcccbacabaababbabbcbaabbaabaabacbaccccabbbbbcaaabbacaacbcaaacacccbaaacacbbcccbbccbcbcaabbbbbcbaacbcaabbbaababccbbabababcabcbcabaababbbbbcbaacccbabbaabbaabbacaaabccacacaabaaabaccabbacbaabcbbcbaabbccbcccbaaabbcbcaaaabbcccbaccacabbcccbabbabcaaabcbacbccaabbbacacbbabbbacabababcabcaacbbcbcbaababacacccbbbccbcbccbacaaabbccaabbcacbacccccccbaabacbbbbbabcaaabbabacacbaabbbbcccacbbbcaaabbabacaabaacbcbabcaaaccabbbcbcaccbbbabcbbabcabbccbacbaabbaccbcaacabcbbaababbbacbbcabaacbaacacaaacbbccccacbabbbcaabaacabbaccbabcbaacccbbbaaabaacaaabbbbcccbbbbbbcabccaabcaaaccbaaaaaacccbaccabbabbbabcccbbcccbabccabcbbccabbacbbaaccbbacbbaacaaaccbacbaababccaabbcbbbacabcccababcbbbaabcbbabacbcccaabcbaabcbbaccbbabccbbcbbccaababacacccbbabbacabbabaaccbbacbcbcbbcccbcacccbaacccbbbbaccabccaccbccbbbcbbabbbcbabbbbcaaaccbacacbaabcbcbcccbcaccccacacccccaccbaabbbaccbbababcaccbcaaacbbabccbabaacabccbabccacaabcaccccbbbbabbaacabcbacccbcacbbaabacaababbcabacbccaccbcbaccbbcbcbabccaabcbbabbabaaccbbaccaaaaccbbcbabacccccacbcaababacbababbbcbababbbabcbbacbccccacaabbcabcccbbaacbcbacacabbbbcccbcabbaabbbbabacbbcabbbbccaaccbbbbcabcaaabaabbbccbbccbacccbabccbaaaaacaaabaaabbababccbbbabcccbccccaaaaaaccabcaabacbbaacaacbbbabbaabbaaaccbbcaaaaababcabaabccbabbccabaaccbacbbbcbbacbacbabbaccaaaaccccaaaccbcbabbbcbbccbbaaababacaababababbccacbaccbcacbccbacacabcaacbcccccbabababcabaacbcabbbbbaabbbacabbbbbcaabcaababbccccbbbacacaacccbcaaccabcbbaacbbbccccbabcbbcbabbcabcbacabacabaccbbababccababaaccaabccbcbaccbbacabccbacbcacbbaaabaaaabcabcbbacaccbabbaccccbabaabaccbbcaabaacacaabbcaccccacacacbcbabbcbabbcaaccabcabcaacbccbcbaccacaacaabbacbcccabbbbbcaccacbbaaaaacaaaacacbabbaaabbbcabbaacacaacbccbacccccaaaabcccaccaaacaaacabcbaabbcbaababbabcbcbacabbcbccabcbccccbabaccccbcbcccacaaacbbabaaaacbcabcbbccabbcbabcbbbaacbaabccbccacccbaabaabbcaaaccccbcabcbccccaaacbaaabbcbbaabcaccccbbabaacccaabacabcbcaaabbbbbabccbcbccababaccbcabbccacabcaacaababbaababcbacaccaaabacccbababbccacbcbaaacccaaabcaccaacaaaacbccbcbccbbcacaacabbcaaaaabbaccbacbbccbaabbbcbbbabcbbacbaabbcaaaccbaaabcaacacbabbbbaaabcbcaccbaabbbcccccbbbcccbcbcbbaccacbabcacbacacbaccaccbcbbcbbcacccacccabbccbbccbbaaabcabbbbbaccbabaacccabcccaccbcacbabccbbbbbbccbbbacaacbbbbcbbbcbacbcacbacbacbabbabcbccbccabbbababccaaacbacababacacbabcbbccbcbccacacaaaabcbcacacacbcccbccccbcbbbabbbabcaccbbaaabaacaccacbcbabbabbbbcccacbbbabcbbabbbaacbcbaccabccaaaacccaaccbccccaaaababbcabbccccabccababbbabcabcbbccccaabaccaaaccabaccabacacbbababcaabacbcabbccaccbcbcbaaacacacccacccbaccccccbacbcabbaaaaabcabbacbaaaabbcaacbcaacbaaccbacacabbcccbbcaabbcbaaccabbcabcabccacccccbbccaccacabbaccacbbcaacbabcaacbcccbccacbabcaccbcbccaaccaccbcababbaaaccbabbcbccababbccbaacbaaccccbbabbaaacaccaaccaacccacbaaaccacbaaabbabababaabbaaabaaaabaabbcbbbcbabccbcbbcbbcbbbabbbccaaaabcbbaccaacaaaabbcabcbcaaaccacbbaabaccabbacbaabcabbbcaaccccaacbabaaaaccccccaabaaabbbabccbacccacabcccababaaaacbcabbacaaabcbacbccbbbbabccbbbcbabbababbbcbbbbabaabcaacabbbaaabacbabbccbcbcaccaacbccbbbbcbbcaaccabbbbcbccbbbccaaacaccbacbaccabcbcababbacbaaabaacbccbaaacccccccccbacaabbbcbcaabaacbbccbaaaabaaabcbbbbbbcabcaabcacabbabaccbaacbbacaaaacbabcaacbbbabcccbcaccaccabccccacbbaabbcbabcbacbbabbaacbcaaaaabbcbcbbbcaccaacbcbbcabbccbbbaacaabcbcbcacbacbaacbbbabcbbbbbababbbaacabbbcacabaaaccbbbaacaacacbacbbabbbaccabaacbabaacbacacbabcabbcacabacbbbbaccccbabbcabbcaacabcbccbbcabbcabbcaccccacbcaaaabbbabbcbaaaabbbbabbcaaaccbbaaaaaccbaccbacccabbcbcccabbaaacbabcaccabbccbbcacaabcbcacacaccccbccaaaccbabcaabbbbaaabacabcababccaccaaaaabccabcbbacabcbbbbcbcbbaabcaabbaccaacaacbabbabbbcacbcacbbacbacacacbbabccaacacccacbaabaaaacaababcbacccccccaabaccaaaaaabacababaabbaaaabacaabccbbcacbbaaaccacabcbccbbcbbbaaabbccbcbbcabccbaabbbcbbbbccbabacabaabacaccbcabcabacababbbaabcabcabcbcbbccbcbaabbcbbbbaabbcbccbaabababcccacbaaacaccccbaaaacbcaccbbabaaabbacaaccababacaaacbabaacbcbbabbaababbbcbabaaccbaaccacbcaccbbcbbbbbcbbaababccbaacababbacaccbcbaabacbcbbbaaccababbcbaccabcabbaccaccbababcbcaaaaacaaabbccaacbccabbcabbaacbaacabccabcaabaccbaccbcbcbacabbbacbcbccbcbbbaaccbbacaccbbbcaabbcabbccaaccbacaaacbbabccbcabaaccbccacccacacbcbabacbbcabbcbbacccccacacbbabaaacaaacacabaacbaacbcaccaabaabababccabbbbabccbbacbbbabaacabbabccccaaabcaabacaccbcabccabccabbbbbabbbccbccabcccbacbcbcbbaccacacccaacaaacabaccccababbbbbbbacccbabcccabbbcacabbaccbbcaccaaccccaccbaacccbbcbaccbabcbacababacbaccbccacacccaaabcbaacabacbbcaabbbaaabccbabbaaacbacaccabbcccbbbbaacbbbcbbbacbbcacccbbbaababcbaaaaabbabcaabbbaaabbaaabbbabbacacccbbccbcbcacbcbbcaabcabccbcaaccbcaaacbacbcbabbbcbbcccaabbacbaabcaacabaabbbaccbaabcababcbbacacbbaababacbbcbbaccbbccbaaabbaccabaaaaaccbcbaccaacaaccbccbbabbcaaabbaccbabbccccbbcbcbaacbbcbababacbabcccaccacbccabaaccacabcbcaacccaccacabbbabcbcbbbbacccbcbbbcabaaccaabaaaacaccbccacbcacabaabbcaaccbacacabaacbbbbcbabcabbaaaacaacbabaabbbabaaccbcaaacabcabccacbbbcbcabcabbccaacbacaabbccbcbcbbcacccabcbccbbbaccacbaabbbcacccabccbbacacaacbcacabcabccabbbbbabaacbaabacabaabccaaaacccbacccccacaccabbcbcbaccaababbaaacabcbbcbbbcbbaabbaaacbcbbaabcbbaccbbabcbcbcabcccbaaacaaccbaccaaacccbbcabbabcbcaabcabbabaaaccaacabaabbcbbbbbaaacaabacaaabbcacbcabbccccbcbbcbcbbcaabaaacaaacaacbababbaabaaacaabcbbabcbcbacbabcabbcbbaaabcbcccccaacaacabacbcacaccccabacbbaabbcccaccbbbccaccbccabccacbcaabaaaacbccabcbabaaccaabcaacbbbacbcbaaabcbabcaaaccbcaacaaacbaabaaaccabcabcbcacbbcaabccccbbbacbbaaaaacabcbacccbcaaaabbbcbbcbcbabccabcccaacccbacccaacccabacbccbbacccabbabacbacbbcacbaaaabbcbbaabbbacbcbbcbabbbbacbccabbcbbccbabbccbcccabccbacababccacbcbccaaaabcaacacbabbcbccbcbbcabbbbbbabbacbcbcbccabbccbaccaaabbbabcbaacbccabcaaabbabaccbaaabbbabcacccbacbbbcabbbcbbabcaabcbbcaacccbacccaabbcbabccacbbccacbacbabcaabbbcaaabbccbaacacbcaaaaaaaccabcabcccbaacabbcacccbbcacaaaccacabacbbaabacaaacccaaaabaaccaacbaaaacacaccabcbbbaacbbbcbcacaabaccaaaccaccacacaaabaabbbacabbaaacabcbabccaaaaccbacaccaccacbccababcbcbaaccbabcaacbccccaacaaabbccbabccaacccccbcbbcabaccbaacbcbcbcbacababaabcbaaccabbcacbaabaacaabababbbaccbacbaccacccbcbcbcabcbbbbbbacbbaabcaccbaacbbcccaababaacbccaaccaabcabaaabbaacbaccaacaabbacabbacccccccacbacaacabaabcabcbcacccbbbbcbacbcaaabacbaabccbbabbcbbccacaaabbbaccabaaababccbccabccbcacababcbbcbccbccabbacabccaabaaaacaaabbbbcaaaaccbcaabbbabaccbaaccaacbaaaabbcbccbabaaacababccbcbcbabaacbcbaccbbcbacbbbbaacbbabbcabaaaccbbbcababbbaaabababcbaccccacccccbbbbacaaaacaaacaabcbacbacbababbccbbabcbacbbbacbcbaccaaababcaaaccbbabcabbbacaccaaabcaabbabbabaccbccbbacbbcacbbccbbcaaababcacccaacaaaccbcbacbaccabcaccabccccaccbcabcbcacbbccbbcbccabcbaabccbabbbbabaacacacaabcccbaccabcbaccacabacacabccccaaaaaabcccabaabccaacbbccacabbbbcaababccbbacacbccbbaaacbbabcbacbaaabbbabbaacaaabbbbaaaacababbbbcacbbcacaabbcabbaabcbbacccbccbaaaacabababaccbaacabcbaabcbcacbbbcbabaacaaacccabbaabcbbccacacbbcabcabbcccaaaacccabbbaccacbcacabbaccccccabaccccbabbacaaaacababaaacabbcbbbcbcbabbaccbbcbbaaabccbbabccabcbbbbaabcaaaaccbcbcccbcacaccaabcaabbaccccacbaabaaaaaaacacabaccbccaacbabcacbbabcccbaaacccbacacbaccbcabcbbaaacbcbccbbbbbbcbaacbccaaabacbcacaccabcbcbacaacabbaccaccaccababcaccbcababcbabaaaaabbbbbbcabbcacaccbaccbabbbbacbcaacaccacbcbcacbcacbaabaccabbaacabcbacbcbabcbbccccabcbabaccbbbcaacbcbccbaabcbccbcbcccccacababbbaccbcabcabcccaccbbabccabacccabbbccacccacacbaaaacbbaabcbcbabcbbbcbabbacbcbccbcbbbabbbacccacbaccbbcbbbacbbaaaccbabbcbccbccbccaccabaaaaacbbbcaacbcacabababbcaabbcbbbacaccacbacbcacaabbabaacbccababaabbbacaaabcabbaacbcaacabbaccbabbbcbbcccbabbbbbabbcbacacaaccabaaaaccbcbbbbcbbacaacbcbacbbcaabbacacaccabbacbbacbbbaacbbbabccabbcbccbcacacbaabbacbbbbcaaabccbbaabbbcabaabbcbbabcbaaacccabccbabacbbcacacccbaccaabccabbabccbabcbbbbaccabacbaccbcbbaaababbcbcabbaaacccabcbcabccacabbccbccabbabbcabcbbcbabcabcbaccacabbcbbbbbcabcacabacbcacacbbbbaaabaccbaacccbbbcccabbaacacccaaccccaacccbaabbbacacacabcbcbacccabbbaacccbaaacacbccccaabbcabaccaabaacaacccbcaacbcabbbbccacbbabacaaccacabbcbabcabbaaaabaacbaabcaabccccacabbccbccababcccbccbabcbbaabaaaccacaaaaaccacccccbbaacbbabbbacacbbccabbaabaacccaabcccbcbaaaacccabbbabbaabcbccabcbbacaabacbabcabbaababcbbbbcaacbaabcbbbcbabcaacacbcacaacbcbacbabbabcabbaccacabbbabccacbccabbcbbccaccbabbbcbcacbcbaaacabcacbcaaaccbbbaaaabaaabbccbbbbcaccccabbbcababbabcbbabbbbcacccacccbabccabcabbcaabcbbaaaacbcabacacabbbcbbcacababcbbaaccbcbcbacaccbbccabccbcaccacbbaccbccaaabcaaacaabaacacccbaaccacbbabbaacbbbcbbcbaabaabcaacbabbcbcaccaccabaacbcacacabaabbbcbcbbbaaabcccbaacbaaababcaaabbbccbcbbbcccbbcabcccacaababcbcbbcbaacccabccccccbaacaaccaacbcccccaccbacabcbabccbbcbbbabccbbcbabacccabacabaabababccbabbbcaaabbbbcbbacbaacbcabbacbaccbcaabbcabcccaaaaaccacaacabaaabacbbaccccbcaabcccbbaabaaaaccccacabaccbbaaabcccabacbbcabcaaabcbcaacbabacccccbbcbacbaccacabaaacabaaaccaaccbbaaaaccbcccbcbbbaababcbabbacbacccbcaacaacccacbcbcbbbcccccaccbabcabbbaabcbbaccbabbbcbcababbcabcbacbcbbabbcbbccbabaaccbbabacbbbbcbabbabbccaacbcbbaaccbabbcbcbbccaaaccbaacbccabbbcacacacbbbbacbcacbaaababccaacabbcbccbbbbaabaabbccbbbbbbbaaabcbbbccaababbabbcaabcbbccbabcbaaabcaacbbbbbabccabbaaacbccbbcbcacccabbaabbccccabcaacbacacccbbccaabcbcbcccaabacbcabaccaabbbcbcaabaccbbacacbaccabacccbcaaacccabacbcabcbbccabccccbababcbaaabbaaccacacccabcaaccbbcccccabbcacaccccacccacbbcaabbbbcbbabbacacbcbaabbccccccabcbbcbccccbbbccbacbabaaacccacaaccbaacbaaccccacacaccababcbabbacccaccbbbcbccbccbccbbbabaccacacbbabaccababbcbcbbccaabacbcbaccbcbabbcbaacabbaacabbbbcacbccbabcccbabaaacbaaaccbbbabaacaaccaccbbcbcacacabcbaabbaccaaabbcccccbcacabcaacccacababcabcbccccbabbacaaacccccacbbcccbbababbcbbacaccccbbccbcacabacccbbbcaacccaaacabbabcaccbcccabcbabaabbcbaacbbabacbcaabbaaabbbbbaccaaacaaababccbabbcbaabbcbcccaaaabbaaababbcacccbcbbacaacbabbbaacbccaaabcbbbacbbcbcccccaccacbcacacbabaacbabbbaabbbbbabcbbbacaaabbacaaacabbbabaccbcccabcaacacbccbacacabaacacababbcbbabbbbbcaccbaabbbcbbbababbccbbcaaaccbacabaababaacccaccbcacbacaaabcccabbacccaacbacabcccbaaacbbbccccaaacabbcbbaccbaaabacaccacbbbbccbaacababccbabbacbbbccbccccaaaaaaabcbaaacabcbabccbabbababacbccbcbcbaaaababacccbcbbbcacaabccbbbababaaabcbcabbbbcbcbbcacbcabbaacaccbbbcbaccbcbcbaaacbaaabcbaaabbcbcbaacbacabbcabaaaacbabcaaaabaabbaabbaccacbacabcaaaabbccaabbbcbaccabaaaabcaaaabbacbbbcbaccaacccaaacabbabcbbcbaaaccbabbbabcabbcacbbcabbaaaacccabcccbbcbccababccabbbcaaaaababcbcbbcacbccacbbaccbbcaabcabccbacbcccbbcbcabcbacccacbbcaaaacbccccbabbcbbabaccbbcacacabbcbaccccbbcababcaccaccaabcacaaaacbcbbaabaaccacbbacabcacbcbccbbbcbaacacbcacbcbbabaabbaabccacbcabaaababccccbaccaaccaccabbbcbbbbabacacacbccbbcbbabbbbaacacbaccaacacbbbabccbcbbbcbbcbcbabbacbbcaaabcabababacbcccbcbccaaccbbaccbabcbbbaccabbbbcbcbacaabcaacbbacaabbbaacccacacbccbcaabaaabbbacaaabaccbbacbccaacaabccbcaaacbccbaacaccbcccaccaacbabbcbaaaaccbcaacbbaccbcaacbbcbacabaccabcbaacaabcbcbbcbacaaacaaaaabbbaaccbabcabcbbabbacacccbbbcbbabbcbcababccabbaabaabbccbcaaabaabcabbaabbbccabacbbbbcbabaacccbabcbbcbaabcaacccbcaccbbbabbacaabcabbabbaacbacbbcaaaacbacccbbcaabcbbbcbcabbbbcabacaababccaaccccababacccacaacccaacabbcccaccabcbabacbaccaabbabaaaacccaccccabaaabcbbbbcccbaccbcccbcccaaaababbbcaaacabcacacbcacbabcccccbabccacabababaaaacbacbccabacabbaaabacaaabcabbbbcaacbccaccccacbcababbcaccbacabcbbabbababccbbccccccbcbbcbcaaacaccaccacbcbbaabaabbbaacaccbcbcaccbbccacababbcbabcbbcbbcbccabccbabbaccbcabbaccaccaabcaccccccacacbbaccabaccbbbcbbbabbbacaababacaacbaccbcbcccbbaaccbcbccabccccaacabbbbabcaaacaaccbcbcaabbbbbccbccababcabbbbbbcbabbabbbccbccabaaccbacacbacccccbaccccbccaabcccbccabbabbacbcacabbccbccbaaabbcbbabbcaabcababacccbaacaccabbcaccbcaaabbcbbcabcbcabcacabaaccbacaaaaacbccacccccccacccaccabbbacccacbbabcbcabbcaccbbaabbababacababababbbcbabbcbcacaababaabaacbacacacacccaabcaccbcbbbccccacacaaacaccaccbaccbacacbbabcbcaaabcacccabccacabccabaabccabacbccaabaabaaaacbcabcaccacbbabcbcaccbbbccbabcacbccabcacccbababcacabcabacabcbcbabcabbacababababcacccbacccabaaacabbcabbaccbbbacccbabcccccbbbcacaccaaccaababcabbcacabcbcbcaababccbbcbaaaacbbccaabbbccaccbbcbcbcbacbaccbcaaacacbbccacccbbbccacaaaaccabaacaacbaacaaabaabcbcbbabaaaccaccbaaaabbabbabbbbabaabbbccaabcaccbbabbcbbbcabaccbaacacacbbbcbaccabacbaaabbbcaabacccccacabbbbbabababaccaacbaababccaababbaaccaccbbccbbbbaccbccbcbbbbbaabbbbaccbccacaccccaacacabbbaababbcbccbacbbaabaaabaacccbbcbbcaccababcbcbcbcbabcacbaabbcabaabbbabbabaaaccabcaccbcbcccbacbccbccccabaccbbabababbabbaabacabacbbcccbabcccacccccbacbacabbbbcbaacbbaaacacacbbccbccbbabbbccacacabcbbccaacbbbacaccbcccbbcbacbcbabacbccaabccbabcbbbbcbaaccccaccacbaabccbabbabbaabbccbcbccbbbccbaaabcbcbbaabccbacbbbbcccacbbabbaaabbbcbbccabbaaabccbabccbbbacccacccacccbbccaaaccabaaaabbccabbabcbbbccccaaacbbbaacbbbbacbbbcbbabbcabccaacaaacbaacbcaccaacaaabacbaacbcacaaabbbbbaabbcaacbbabcacbaababcbcbbbbacaabbabcacaccbccbbacacccaacbccaacaaacaaaabbbababaaacbacccccaacbcacabaaccbacbcaccbbccccaabaaaabbacaccbbcbbcbbaaaaabaccccaaccbccaccbccabccbacbaaaccccbcbbbaabcbaabbcbacaaccccbccbbbbacacabccbcbacaacbcaaccaabacabbabcaaacccccacbbccbabcabaccababbbaacbcbccbccacbcccacbacbabacabcbacbcabcacbcbccbcbbbbbabaaababbccababcbccbabbaaabbcababcaabaaacccaaccabacccbcccbcabcabcaccaaabcabbaccabacbccbaabcbbacccabbbabaaaccaaacbcbccbababbbacaacaaabcacaababbcaabbacbabbbacacbaabbccbababbcaabcbababccccbabcbbbcbcbacbcbcabaccbccccbaaabbaacabcbbacaccbaaabcbaaacbcaabaaccabbcabbbabaacbcccbcabbcacccababcbbbbcabcbacaacabbacbbabcaabacbbbabbccaaaaacbabbbbcbcccbaacaaabacbacbabbbccabcbabbabbaccbbacacbacbccacbaabbcbccbbbaabbcacccbabbbabbbcaacababccaccacbbcaaaabbbccbbcbcaccabbaacccbacbcacabbcbbbacbaaccccaaaccaacbcbacbbccacbbcacccacbabaaabbbcaabccaacbbcbccbbaabacaccacaacaaaaaabbbcccbbcbbbbcabababbcbccbcbbbbcaabbccbcaaaccbbccabcaaacacbcbcaabbbbabacbaabbcacbbacccabaacaacaabbabacaaccccbccbccbbaaaaabcaacbccbcccaaabacacbbacaacccbcbcaaaccabbbabcbcaacbaccacbbbaccbacbacbcbcabccccccaaabbaacabccaaababbbbaabbbbaabcacccacabbcbcacbbbaabccbaabacccacaaccaccbabccbcbababbcaaccaaaaabbbacccbbbaaabcabbbcabaccccabbbabaabaaccbaaabcbbbcaaaccbcabbaaaaccccbcbbcbacbbbabbcbaabcccccaaacabbcaacbcccbacbbaaabcbcabbacabbcbabbcaacaccbaabccaaacbaaaabcbbbbabcccbbbbbcabccaabbbaababaccbbbbbbcbcbacaaaabcccccbaccbbbbacacbabcabcababcccccbaccccbbcababcbabaacbaabcababcbcbcbaabaacaccccabcbaacbabcbbabcbcabcaaacccacaaabccbcbacbcbbccbbacaccbbcccaccaaaacbcbcaabcbbcbccbacbcacabacccabcaababcabbabcbbbbcbcbcabcabbcabbbcccabaaaababababaacbbabcbcbaaaabccaacabcccbbaacbccababcbaabbbababbbabbbcbaacacbabacaaabbbcbabcacacccbbbccacaabcacccacbabbacbacbbaacaaababbcabaabbcccacbccaaaacbccbabcbacbbabbbabbbacaabccbcbbccccbacbaccaaaacaaccaccabaabcbbbbccbcbccbcacbcacbccbccbcbacccacbbcbaacacccaabbbabcaabbbabcacbbcabbcbbaabbacaccaaabcbbaaccbccccbbcbaaaaaacabcacbcbccaabcacbcaaaacaabacacccbcbbbcaabbcbbcababcacbacacaaabcccbbbcabccaccaabcbbbccaccacacacbccaaaabcbcbbbccabcabbcbbccbbbcaccccabbaabacabbbcbaacccbbcbcaaabbabcccacabbbabcaaaaacacbbcaacccccacacbcbbcbbabccabaacbabccbbbcaabbccabcbaccbbaacbbabaabcbbbabccccbaabbcbcacacbccbccaabbcccbcbabcabcabcababbcccbacbccacabbccccabacbcaaaabacbacbcbaccbaaaabcbcbbbbcbbbaacbacbacaacccbabacccccbcbbabbcbcabcccbacaabaaabcccabcaccbcaababcccbabbabccbcccbacbaacaacacacaacbcabbabbcbaaaaabcbccabccaabcbaccaaaccbacacabacbaaabccbcabcbaabbaccbaabcbccabcacaaacbcbbabccbcaccabcacbacbbacaccccbccbccccbbabccbcacaacabaabaccabcbbccacbcbcaacbaccccaacbaacaccaacaaababaabcbcabaccbbaaabbaabaccbccbbbcbcbbbcbccccabacbcbabbbbcbbbabbacbccaccccaacccaccccaabccacbcbbcccaaaabababbcaacbbaababbcaacbbaacaabcbbbaaaacbcabcabbcaaccaacbcccbcabcaaababbcbbbcbbbcacacbabacccbacabacbcbccaabcabaabcaacbcbabcbcababbbabbbbabcacabccaacaacabcccbbabbcaabcbacabbabcabaacccbbccbcabbbaccacbbabcaaabbbcbabcaabcbcababcbbabaaaabacaaabbbacccbbbbcabacacaacbccaccaabbabacbcaacbbacabaacaacaaabcacacbbbbccbabbcbccbcaccbabcbaacacbcbcacabbbaabccccaaccbccbaaaabccbbabcababacabbccbcabcbcccabbcaababccbbabcabcbcacbabacccbbaabccbcababcbaacabacaccbbbbbcbcbaacbccacccccbccbbaccabccbcbacccabcbaababaaabbcbcacabaaaababacccacbcccbaccacbabcacacccabaaaacbbaccbabbbbbbbcaccccbbaabcccbbaaabaabbcbabbcabaabbabbabbcbcacaaaaababcabcccacbbccbbacbbabacbbccbbcbaabbabbcbaacaaacbababbaacabaabbbbacccaabaabccabcabababbaababaccabccaccaccabaaababacbbbaaccbbcccaaacabbabccbcbcaaaccccabcbabbaaaaacabacacaacbbcbabacaabccbcbcaaabacbbcbabcccaacacaccccaabcacbbcaaaabbacaabcbaaaacaacccbccbcabcaacabcabcaaaaabbaaaabbabaabacbcaaaabbacbaaccbbcbbcccbbaabccacabacccccbbbbabbbbbcaccbcacaaabbacaaaacccccbccbaacacabccacbabaabbcbcabcbaacacbcbccbbaccaacaabaacabccccbbcbacbcaabbbbbbcbbbcaacaaccabbccbcbabbacaacaaccbacbbcbbcbbbccaaababcacabbabaacbcbaacbacbaacaaaaabccacbbbbaaaaccacaacbcacccacabcccbaabbaccbbbbbbbcacbaacbcacbabcaaaacbbcbabbbabcccabbbaaaaacccccacacccbbbcbacbbbaabaccbcaaabccccbcaacbaacccaababccccbbbcabcbbbaaabbcbcabcaaaaabcaaacbcbaccbcbaabcaabbacbaacbbacaaacccbbcacacacbbcbacacccbcccabcabbcabbabcccbbacbacababaccabababbcbaaaabbcaaaaacbaaacacaaaaccabacabbaaaabbbaacccbbacccbacbacabcabcaaacaaaacaaccbbaabbbcabbcbcacbaccacacabbcabcacbcbccccacbaacaccbccbbcabcbabaaabaabcbaccaababbcaacbaabcabbbcbcaaaacbaccacaccaccacbaa\nbcbbbabaacbbccabbabbacabaababacbbcaacababbaaacccaccbcabaaabbabaaacaaabbbcacbbbaccabbcacabbabaabacbbbccacacbcbabcacacccccbabcaaccabacbacbcbbacaccabbacabcaccabaccaaabacaacbacabcabcaababbcbcbbbacbabaacbaccccbaacbabaacbcabcbacaccbccbcaaababaabacbacccbcabaabcccaabcaccabacaacbbccbbacabcaaabbabbcccabbcbaabbbccabacaaaacacbbccbbcaaaabbbbaaccccbbacccbcbacacbacbbcabaabccbbbacacbbcabcacabccbacacbababccbbbbbccccbababbcacaccababcbaaabbbbbbacbcbaaccbcbabcaaaabbbbaccaacaacbbbcaacacaabbcbbabbbacababaabaaacbbbabbcbbbbbaccabbbcbaaabbcccbaacaaacbbbbacbccacabcbccbccaccbcccabacbbaacccbbabaaccbbbaaaabcaabacbacacacabccccbbcbabccbaabcccaaacabbcaaabbcaaacaabcbbaabbccbbabccacaacbabbcbbaccabccccaaaacccacbbccbcbaaacaaabbababcbbbcbcbbcbcbccacaabacbbaacccacacaaccbaaabccaabcabbacbbacaacacbbcaaabcabbbacaaaaabccaabbaacbcccbbbacabcaaacacbbbbacabcabcbcbaabababbcabaabcaabaabbcbbabbcabbccacaabcaacaaabacccbaaabccbabbccbbbacbbcacbbccbbccbacbccbbaaaacbaacbcabbcaaacacbacbbccbbacbaaaacbbaabcabcccabcbcabccaacaaabccabcbcccacbacabcabcabcccbbaabbabaabcbcaabbbcabababaaaacabcbbaacaaabcbaabcacabbcbcbbcabcbcccbcabcbaaaccbbbbcaabbbcaaaabbaacbcbabaaabccbbacbcaaabbccccbcbacaccaaaaacccabccbbbbacabcabaaabaaaacccccabababcacabcccaabacbcaabbccbbbaabcbacbbbccbccbbbbaabcbacacbcbbbababacababbaaaabacaccbbcaabbbbacacbccaaacbcacbaaccabaacbbcacabcbccbaabbbaaacaabbcaacaaabacbbbbbbbbbaaacaacbacbbcaacccabbacacbacbbbbaabccbcbbbbcbcaacccbcbcabaabcbcbbcaabcabbbcacbabbaacaaccbbcbabaacbbcbbabacbcacbbaabaacabcccbcaccccbcccbacabbcabacbbaacbcccaaaaaabcbcbcabcacacacccabaccacabbabcbbaaaaccacabbcbbbcbccacbaabbcacbcabcaabccaccbaabcccbbcbbbbcccabbaccbaaabbcaaaaccbccaababaabbbcbccaaccccacabacbbaaabbbbcbcacbaccabbcbbcaabaaccbbcaabbaacaacbaabcbccbccabccbacbcbaccbccccbbbbcaaabacacacbaccaaaaccaaccabacacaababcaaccababccacbcccbbbbbcbcaaaccaabaabacccbcbbaaccccbacbbacacccaccccacaaabbcbaabaaccabbbbcbccaaaacccbabbaabbcccacccbabaaaccccaccbbaccbaaaccbcbcbbbbaacaabacacbbcabcaaccbbaacaccbabcaccaabbababaacbccbaaccbcbaabcbacbbbaabbabbccabcaabacbccaaccbabcacbbccaccababcbbacacbcbaccbcbabcaabbcbbababbbabbbccbcbcbbbabccaacabbabaaaabbbbbacbbcabcabccbcbcbcaabbbbcabcbbbcacbbcabbbacbabaaccbbacacbacaaaaacaacaacbabbbcacabcbbcaaaaabbcccbbcbbbcacabaaabacbbbccbbcbccccabbbabbbabcccaccaaabcacacaccbcaaaacababcaacaaabbbcaccacbaaccacccbabcbbabacabbbbcccbacaacacabaaaaacbbcabbaacaaccababbcacbbbccaaabcccacaabaaaccbcbabccbbbcccbbbaccaaacaabccacaabbccbacaabababaaaccbccbcaaaaabababcbbacbaaaabaaacbbcbbaaccbbbbaaacabcaaccabbcaccbcccbacaabacabbaccbacbaabcbcaaabbbcbcabbacaccabaabbbabcacbabccabaabbcbcacbbbbcbbbcaaabbbabaaccbbacabaaacbbabaaaccacacabcccccbbcbbbbbccabcbaaccccbbbaccababbbacbccccccbacacabcacbbbacbbacbccccbaabbbcacbacacbccbcabbbcacacacabaacaaaabccbcaacaababcbbaabccbccbabccbaabbcbbbaabcbababbcacbbcbbbbabcbabbcbcccababbaaaccabccbaaacbaccbbcbaaacccbbaaacaabcbbcbbcccbcbacacbcbbaabbaaacbbcababbaccabbbbbcaccbbbcccaaabbaabcccbbaaaacbcbabcaaccaacaaccaaabcbccbbbcabccbacbbccaabbaaccaccbcbbaaccbcabcacaacbacabbccaabbaacabcacabbcaacbbcaaaaaaacbaabbbacccaccbcbccccbbcbbcccacaaabbcacacbaabbbcaccacccbbcaacababcabbaabacbcaaccbccaabbabccbbccbacabbacbabaabbaabcccbbcbbaabbbcaccccaaacbcbbaaccaccbbabcabaababaaccccacabbbcacccaccabcbccbacaaababaacbbabaacccbbcacbcababacbccbccaacabccabacccbbcbacaacaccbabbaaaacbbaacacbabbccbaacacbaabaababbbaabbcbcacbccacbbbabacaccbccacbccacbbbcbbcaccaccbacabcabababbcccaaaababcaaacbccbbacccacabacbacccbababbbbbaccabacbbbcccbacbcbcccbaaaacbcbbbbaaccbcbababbcbabbacabaabbbaacbaacccccacbbaccbccbbbccbcaaaccbaabbcbabcacbbbaabacbbabcabbbbaabcaccabbcabbaccccccbcbccbacbccaabcbccaaabccbbaaacbbbbbbbaaaaaccccabacbbcabaacccabbcbcbccbbacaaccbacbbabcbbacbbbabcbcacaccbaaccbbcccabcbcccbacaabccaacacccabcabcaaccaabbbcaacbabbcbbbccacabbbabaaacaaacbaacabbbccaacacaaacacccabacbbaacacaccccacaabcbbaaaccaacaccccabbccabbabcabacabcaabccbcbaababccabccabacccccabbcacabccbbbacbbcacbaccacaaaabcccbbbcbaacbcabcbbbaacccbcbcacbcbababcabcabbcbcccbcbcccbababbcbbaccaabbbbabacaaccbccaababacbabcabaccacbcaabbbaabcacabbbacbcccacbccccaacbcbaaabcaaacabacbcaccbacbabacbaaacaabaabaccbcbbbbbcacbbbccbbccaaabbcababaabacbabcbcccccbbbbccbbbaacbaabbbaaabccabccbbbabcaaaaacbabbbcbcabbcabcccbbaccaaaaabbaaaacaacabbccabcabcbcbcaabaaacccabbacccbacccaaaacacccaaccbbabcaccaabbbccacabcbbaaacbbbbccbaacccbbbbcabaaabacbcaccabbaaccbabaabcabcbbcbcacaccbccbccaccbaccbacccbccabbbacaabccaabcbbcbccabbcccabbcbaccacbbbbcbbaabbbbabaabbbccabaccacaccabbccbcbcbabcaaaccaccabaccccbaaabbabccaabaaababaaacaabaacbcabacbcbabccbcbbbbaccccaccbacbbcacccaababcbbbcbbccaacacbbbaacabbcbbbbabbabcbbbbbbbcccbbbcbabaacacbccacbbbacabbbaacbccbaacbbccbbaaccbbcaabcccbbbbbcaacaccaccccaababcccaccabaaaccabccaccacaacacbbccbaaababaaabaabccaabaaccaabaccbbababababbcaaabcaacccccbabbcabbabccccaaaabacbacccbbabbbaacccbbcaaabbcbcaccaacbcccaaacbacabccaccbcaccacbabbbbbbbbbaabccccbcbccabacaaaacbabcccbbbacccacbbcbbbbacbccbaabcaababaccbaccabaacbacbacaacbaabaaaccbaaaaacaaabbacaccccccbcbbcaccccacccbccbccaccbaacaaabaccaccabaabbcaccbbacccababacbbacaaabbccaccbbbcbbaaabaccaabcbabababcbabcacaacbaaaabccccabccccacabacaaabbbabbcacccbbccccbbbaabbccbcccccbcaccbccaaaccaacbacbbacaacacbaabcbbaccbcccaacabbaaaaaaabcbcccacabcbcaabcaaaabaabcbaacccccabcacaccabbccacabbbaabccabbaaccbaabcacaaacbabbcacabccacbaaabcbaacacccabbbbbcaabcaccacbbaacbaacacbccbccccbacbccacabbbcccbababbacbcaccbcabbcaaccbbabbbaacaabbacbacbaabcccbcbbbbaacbbaccaaaaabaccaacccaacaaabbccacababcabaabcacbcbbcabbaabcbbabaacaabccccbbbccbbcbcabcaacbabbbcabbaaabbbbaccaaaaaacacccbbbcaabaabcacaccabacacccbbcaaccaabcccbbbbbbacaaaaacbcacbbacbccbaccbbcbbcbbcbbaabbaaababcabcccabcccbacacccbbbbccbbcaacbacbcbbbbccbbbabbacabcaaacbcabaccbaaaccbbbbbaacccaabacbabbaacacacaacbcbacbabbbbcabcbaccbbbbcbcaaacbbcabbbccbbbcabacbbacaaabcaacacacaaaccabababacbccbacbcbbbcbbcbbaacccbcccbbcacaabbabaabbccbccccbccacaaabaaaccabaccaaacbcacccaccabbaacbbbbabaccaabbbccccbbabcccbabcabaaabaaabbacbaaaacabcaaccacaaaccbcbababbccaacabbcbaacbcbcabaaccccbbbabbbbbaabbccbaababbabcbbbbbbbcaabbacccccbcaaacbcaacbbbbccacacbabcabacbccacbaacacbacaabaccbcacabcbcbbacbccbbbaaaacbccccbbcbaacbaababacbbbccbbccbcccbaccacbabcbabaabcccbbcabccbacacbaabbbaacaccaabcccacbcbbaccaababccbacccccabbbbbcbbbcbaccbbabbaccbbbbccbacbbcabbcbaccababcbcababcabbcbcbabcbbaaaabcbbbbcbacaaabccbcbaacccabacbbcbbcbcaaaacbcccbcbabbabbbcccbbccaccbccbabbaacabacbacacababbcbbbacabbabcacaacbbaccabaccccabbaacacabcbcccbaaabcacbabaabaabbaccbcabccabacbbbbcbabbcbbacabbccaacccbbcccbabccbccccbacaacccbcbbbabcaccacbccccbbaaacacabcaaccaacaaabcbcbacbcabcbabaccacbbaccbabcacccbacccabbcbcbcccabccbbaabbabccccbabacaccacbcacabcacabbcbbbbabcbcbcbbbcabcaccbbaaaaabbbbccccaaabbcbbabccbabaccbacbbcabbaacccbbcbacccbcbbcbaaabbccccabbbbabcacbaacaaacbbaabcbaacbbcababccacbbcacbacabbbbbaccabcacccbabacabccaccbcabbabccacbcabbaabcbcccbacacbbbccccbcacbbbacabbabbbabaacbabcacabaaccacbabcccbababcbcccbcbbbabacabbcbaccbcbbaaaacabbccaacbcbcabbacccabaacacccbbbacbaaaaabcabbcbbccbcccabaaabccaabaabcbcbbabbccaaccacbbaaabbbbbabacbaccbcbbbccacbabbacbbbbbbacabbbbbaabacbcbabbaaacabccbbacbcbbaaacbbaabcbacbabbcbaccaccaabbaabbbcbbcacbbbbacbaabbaaaacbaaaabaababacaaacbbbbbbccacaaacbbbacbcbcaaacaababbaccbaaaacccacbacbaaaabbcaccbcabbccbbcaaccbbbbbcccaccaccbcbacaaaaaabacccbcabaabaacaaacabaababccabacbbababaaccccbaacaccbcabacaabbccbcbbaabbcaaacaccbacbbabaccacabcbbbccaacbbaabaaacbcccaabacaccaaacccabbbccacccbcacabacccabccaaababbaccbabaabacbbccbccbccabbbbaabbbcaaaacaccbcbabaaaabcaacbacababcbababccbcbaabcbbaaccacbacbaacbabcacbaaacacaccbaccaabcbaabcbabaacbacccbccaaaacbaaaaabccbccccacbbbaccacbabaacbbacbbbccabcccbcbbbaabccccbaacaabbcabcbbbbbbbaaaacabccccbcbababbaacbccaccbbabacbcabbbbabbacacbbaaaaabbacbbacccbbaacbccbbccaabbbccccaccbaaccacbbaaababacabbcbcbabaaacbcabcaacbaabbaababbcaccaccaababbcccacaaaaaaabbabcababcabccaccababcaaacacbcabaccacbcbccacbcbcccbbacabbbbbcbbacaababacabacccaaccbabaaabbccbbaababbccbacabcaccacbaabbbbbcbaabcbcbcbaabcccbabbcbaccacbcbbcbccabbacbcacbcbbccccabcbcbaccccbcbacaababccbcbcccbccabccababacbabbacaaacaabcccbcaabcbbcabbacbbcbbcbcaccaccbcbaabbacbacbabbbacccaacabcaacbbcababacacaccbccabcccbcbcbaabbaaababcaabbabcabaabbaababcaacbaaabbbaaaacababbaccacaabbcbccbbccacbbabaabcbbbcbabcbabaaaacabbbbbbacababcccccbcbaaccbbacbbbbbbacacaabbababcbccaacccacccaaccccababccaaaacaacabbcbcabcccabaababcccaaaccabbbaccbcabcbccabccbbaaabbcabcacaabcacbcaacccbbbbbabaccbbccbabbcbcbacbcaccbbcbccabbcbcbcacbcababbcaabaabaaaccbcbbccaacacaccbaabbccbbacbacaaccaabaabcaabbaabcabbbbbabccabcabcabccbbaabcbaabcaabbbbccaacbababbabccabaccccaaaacabbabccbabccbbbaabbccacbbaaaacacbacabaaabbacbcabbbabaabbabcbbacbcacbbcbacacabbacbbbbbaccbbabbaacabaacabcabcabcbaccbbcbcbabcaaacacacccaacbbbcbbcabbacbacbaabbcabcaaacccabcbcbbbcabbaaabbcbaaabcccccbccbcaaabbbbabbcccaaabaaabbbaabccacccbbcaaabaccaaaaabbababcbbacccccccbabbcbcacccbcccccabcababbabccababbabbaabacbbcbbbbbababcaaccbababccbaacbcaccbcccbaabcabcabbacbaaaacaccbccbcacabaaccbccbbacccacbabaabbcaaaaaaabaacccaccbbaababbaabcaaabcbbcccbcabcbabbaabbabbabaaccaabacbacbccbbaccaccaaaaccacbbbabbabbcbbbcaccccaabacabbbbcabcbabcbcccaabcaccabcbbababcccaccbcaaaabbbaacbacbcbaaabbbbaabbcabccccaabbabccccaacbaabcaabaaacbbccbabbcbaaccabbcbbbbabbbcababcbacbbaaaabaabacbbccaabcbbacaacabbacacbcbaaabbabacbacbbaacccaacbababbcaccaacaabaccaabcbabbbaaacabaaaabbbcbbbcccaababbcabaaccbaacbacbccbccbacbbabacabacbbbaaaaaccccacbbacaacabccbcccbacabbabbbaaacbabbacbabaccccccbaaaaccbbbcbaccabcbbcacbcbbbccbbbaabcbcbaababbcbcccacaababbbbbabccbababcacabcacbacbcbaabbabcccabaccbaccbccbababbcaacbcaabacaabbcbcbaccabbccbcabaaaaccbccbcccccccabaabcbcbccccacaccabbbacccababababcccaccaccccccaccbbaaaacbcccccaccbcacbcccbbacbaabcbabcacbcabcbccbabacbbcabcbabcabcbbabacccccabbbacabbacccbababbcbacbabaacccbabbcbaaabbccaabcabaababccacccbaacbcabbababccaaabbccaccaacacacbacbccaaaaccacacbaacccaaababcbbccbaccaacbbcabcbabbbcbacabcbccbcbbbaacaabbbcabcccacbbbabacccbbacaaacbccbcaccbbbbcbbbcbbcaabbcabcccacacbbcbccbcbbcabcbaaabbcbabaacbaabbcacbbcbabcacccbcbcaccabaacccaaaacaabcaabbccbbbccbcaccbbbabcbaababbabbaacababcccbbaabaccaaaaacacbbabbacaabbbbbabbcbbcaabccabcabbbbcbaabbbcabacabcbaabcccbccacccccbccabbbcabbabbcbaccbcbbbcbacbabbcbaaaaaccbacbcbabbacaabcacbcacbabaabcabbbbbbcccccabcbaabbccabcbacaccbbbbacabbcacaccccabcacbcbcababcaabbbbccbccacabbccaabccbaacbbababaaaaaaababacccbabccacbaabbabaacbbaccaccbbaabacccabbccaacaababccbaacacabaccacbbbaccccacbbccbccaababaabaababbbbacaacccbbcccccaabbcbcbbaaacacacbbbabccabcacacaccabbaacbbabaabbcccbccaaabbabbaacacbccccaacccccaccccacabacbabacaaccacacccacaccaaabacbcccacacbbbccbcbbbccbccaacacababbaaccbcccbbcaacabcccccaccabacaaccacbababbcbcaacabaacbbcaaaabbacbabaccbbcbaaabbcaaccabacbbcbaacbaacccbbbcabcbaacbccbbbbbbbbaacabaaacacabccaaacbaacbbbbcabcacaacacbabaaccbccacaabaacbaaaaabcbacabbcbcbcaaacaaaccaaaacaacbcbbcbcccaaccaabcabcbaaacbacbbbacaaaacbcbaaacbbcacbbaaaabccabcabccccbcabcabcaacbcababacbcabbcbabaabccbcbababcbabccbaaacacaaaaacccbcaccbbacccbbbbbabbbbbabccabbabcacccbcbcbabbabbababbabbcbcacacacbacbbabacccbcbaaabababaabcaaacacccabcabcacaacaccbbaaaaaacaacabbabacbbcccabcababaacbbabaaccbcbcbacacbccbcbcaccacbbbbccbaccaacaababcacbbbccbcccaaccaccacacabbbbbbcacbbbcccaaaaaaacbcbbccbabbbbbabbabaaabcacbaaabcccbbabbbacacacabacbcbacaaaaccaaaabcabaacbcaaccbacaccaabcaaaabaacccbcbaccacccacaababacacbcbcbabbabccbccaabacaacbccbaacbccbbccabccbbaaccbcbacabaaacacababbbaabbabbabbabccabaababccabbcaacbcababababccaabccbcaacbbcbaacccbabaaaaabccabaaaababbaccbbcbbaccbbaccbcbbcbccacbcbcaccbccacaaaababccbacbcabcaaabbbbabcbccccbcbaaacbabcaabbcbcbacaacbcbbcbabcabcabacbccabaccbcccbbbbabaccbcaabbcaaaacccccbabcacccaccbaabbabbabbabcbcbacacabacaababaacbaccbbccccabaacbabacbbabcbbccbbaaaacaacccabbabbabaaaaabcaaabbbccbcaaacbababcacccbaaaaabcacbcbabcbacaaccababacaabbabbaabacccaaabcccabccccbbcbcaacaaaccacabaaccbcaabcbbccaabbbbacbcbcacaaaaccabcbbccbbbbbacbbcabbbabaabccbbacbbabbbccabacbbaacacaacababaabbccbbcbbaccacbcbabbcbbcbbbaacacabacaaaacccabcbbbccbcbbbbbcbbcacbbbbcbbcabcbbcbcbaacccababbccbcbbacccaabaccaabcbbbbacbbbaacaaccabcabacbbbbbbabbccbaaaaabbbcbccaabcaabaaacababbbcbbbaacabcbcbabaccbaaacacbabbaabaccabcaaccacacabaacbcbbbbbaaaaaaccbcbaaacabbaacacbababbabbccbacbaaacbbababcabacabbacbacbaabbbccaacbaacbaaccbcbaabbcbbbcbcaccacbccccbcaaabaaabcacbbccccbcabbccbccacabaabccabbcbbaaacababbabbbaccaabcccbbbbbbaabbcccabcbbbabccbcabaaaacbbabcbbccaacabcacbabbacccababacccbbcaaaacabccabcaaaacbcacababbccacccbcbcbbbbbabaaababcccaaccccccccbbbcacbcccababbabcaabbabbbaabacbbaaacccbaccbcbcaaaaaccbbccccbbbaaccabcabbbaacbcccacccaccacccbcbbcabaacaacccbacabcbaacabcbabccabccbbbaccabbcaacbaababcabbbacbbcabcaaaaacaccbcccaabbcccaaabccbcbabaaacccbaabbbbbbcbaaabbbcaabccaaaaaaababcacbabaaaaabcabaacabcaccacbcbcabaaccbabacbabaababcbcccbaababcbcbaabbcaabbcbccacbabccbbbcbbbbbcbcbccacbabacabacacacbcccbbcccaccbcbaacbcabcbabbacbcacabaacacccbaaaccbbbbcabbabbaaaaabcbbbccbcaccaaacbcaabaabacbbaacbaabccabaabababacbabcccbbbccccabcbcccccbcacaabbbaaccbbcabacccabcaaabccbabaaacbbaaabbbaacccccbbabcbababccaabbbbbaccabbacacaabaacbacaacbabbaabcacabcbaaacabaaccccbacccbcabaabcccaccaacbcbcbaacabbaababbbcbcaccbcccaacabbccabcbccabaacaabcbbcabcbcbbbbbbabbcbbacbacacccccaabaccaabbaabcaccbccaaacbaabbaccaacbbccbcaaacccaccbbcbaaccbbcbcaabcaacbacbbabcaaaccaccacaacaacaacbabbcbacbbcbababcccacabcacccbacbbaaaacbacaaabcbcbabcccccacbbcbcbcaaacbccaabaaccbbbcabcccccabaacacaaabbbcacbbcaccccbaacbbbbccbabcbccccabcccbacabaababbabbcbaabbaabaabacbaccccabbbbbcaaabbacaacbcaaacacccbaaacacbbcccbbccbcbcaabbbbbcbaacbcaabbbaababccbbabababcabcbcabaababbbbbcbaacccbabbaabbaabbacaaabccacacaabaaabaccabbacbaabcbbcbaabbccbcccbaaabbcbcaaaabbcccbaccacabbcccbabbabcaaabcbacbccaabbbacacbbabbbacabababcabcaacbbcbcbaababacacccbbbccbcbccbacaaabbccaabbcacbacccccccbaabacbbbbbabcaaabbabacacbaabbbbcccacbbbcaaabbabacaabaacbcbabcaaaccabbbcbcaccbbbabcbbabcabbccbacbaabbaccbcaacabcbbaababbbacbbcabaacbaacacaaacbbccccacbabbbcaabaacabbaccbabcbaacccbbbaaabaacaaabbbbcccbbbbbbcabccaabcaaaccbaaaaaacccbaccabbabbbabcccbbcccbabccabcbbccabbacbbaaccbbacbbaacaaaccbacbaababccaabbcbbbacabcccababcbbbaabcbbabacbcccaabcbaabcbbaccbbabccbbcbbccaababacacccbbabbacabbabaaccbbacbcbcbbcccbcacccbaacccbbbbaccabccaccbccbbbcbbabbbcbabbbbcaaaccbacacbaabcbcbcccbcaccccacacccccaccbaabbbaccbbababcaccbcaaacbbabccbabaacabccbabccacaabcaccccbbbbabbaacabcbacccbcacbbaabacaababbcabacbccaccbcbaccbbcbcbabccaabcbbabbabaaccbbaccaaaaccbbcbabacccccacbcaababacbababbbcbababbbabcbbacbccccacaabbcabcccbbaacbcbacacabbbbcccbcabbaabbbbabacbbcabbbbccaaccbbbbcabcaaabaabbbccbbccbacccbabccbaaaaacaaabaaabbababccbbbabcccbccccaaaaaaccabcaabacbbaacaacbbbabbaabbaaaccbbcaaaaababcabaabccbabbccabaaccbacbbbcbbacbacbabbaccaaaaccccaaaccbcbabbbcbbccbbaaababacaababababbccacbaccbcacbccbacacabcaacbcccccbabababcabaacbcabbbbbaabbbacabbbbbcaabcaababbccccbbbacacaacccbcaaccabcbbaacbbbccccbabcbbcbabbcabcbacabacabaccbbababccababaaccaabccbcbaccbbacabccbacbcacbbaaabaaaabcabcbbacaccbabbaccccbabaabaccbbcaabaacacaabbcaccccacacacbcbabbcbabbcaaccabcabcaacbccbcbaccacaacaabbacbcccabbbbbcaccacbbaaaaacaaaacacbabbaaabbbcabbaacacaacbccbacccccaaaabcccaccaaacaaacabcbaabbcbaababbabcbcbacabbcbccabcbccccbabaccccbcbcccacaaacbbabaaaacbcabcbbccabbcbabcbbbaacbaabccbccacccbaabaabbcaaaccccbcabcbccccaaacbaaabbcbbaabcaccccbbabaacccaabacabcbcaaabbbbbabccbcbccababaccbcabbccacabcaacaababbaababcbacaccaaabacccbababbccacbcbaaacccaaabcaccaacaaaacbccbcbccbbcacaacabbcaaaaabbaccbacbbccbaabbbcbbbabcbbacbaabbcaaaccbaaabcaacacbabbbbaaabcbcaccbaabbbcccccbbbcccbcbcbbaccacbabcacbacacbaccaccbcbbcbbcacccacccabbccbbccbbaaabcabbbbbaccbabaacccabcccaccbcacbabccbbbbbbccbbbacaacbbbbcbbbcbacbcacbacbacbabbabcbccbccabbbababccaaacbacababacacbabcbbccbcbccacacaaaabcbcacacacbcccbccccbcbbbabbbabcaccbbaaabaacaccacbcbabbabbbbcccacbbbabcbbabbbaacbcbaccabccaaaacccaaccbccccaaaababbcabbccccabccababbbabcabcbbccccaabaccaaaccabaccabacacbbababcaabacbcabbccaccbcbcbaaacacacccacccbaccccccbacbcabbaaaaabcabbacbaaaabbcaacbcaacbaaccbacacabbcccbbcaabbcbaaccabbcabcabccacccccbbccaccacabbaccacbbcaacbabcaacbcccbccacbabcaccbcbccaaccaccbcababbaaaccbabbcbccababbccbaacbaaccccbbabbaaacaccaaccaacccacbaaaccacbaaabbabababaabbaaabaaaabaabbcbbbcbabccbcbbcbbcbbbabbbccaaaabcbbaccaacaaaabbcabcbcaaaccacbbaabaccabbacbaabcabbbcaaccccaacbabaaaaccccccaabaaabbbabccbacccacabcccababaaaacbcabbacaaabcbacbccbbbbabccbbbcbabbababbbcbbbbabaabcaacabbbaaabacbabbccbcbcaccaacbccbbbbcbbcaaccabbbbcbccbbbccaaacaccbacbaccabcbcababbacbaaabaacbccbaaacccccccccbacaabbbcbcaabaacbbccbaaaabaaabcbbbbbbcabcaabcacabbabaccbaacbbacaaaacbabcaacbbbabcccbcaccaccabccccacbbaabbcbabcbacbbabbaacbcaaaaabbcbcbbbcaccaacbcbbcabbccbbbaacaabcbcbcacbacbaacbbbabcbbbbbababbbaacabbbcacabaaaccbbbaacaacacbacbbabbbaccabaacbabaacbacacbabcabbcacabacbbbbaccccbabbcabbcaacabcbccbbcabbcabbcaccccacbcaaaabbbabbcbaaaabbbbabbcaaaccbbaaaaaccbaccbacccabbcbcccabbaaacbabcaccabbccbbcacaabcbcacacaccccbccaaaccbabcaabbbbaaabacabcababccaccaaaaabccabcbbacabcbbbbcbcbbaabcaabbaccaacaacbabbabbbcacbcacbbacbacacacbbabccaacacccacbaabaaaacaababcbacccccccaabaccaaaaaabacababaabbaaaabacaabccbbcacbbaaaccacabcbccbbcbbbaaabbccbcbbcabccbaabbbcbbbbccbabacabaabacaccbcabcabacababbbaabcabcabcbcbbccbcbaabbcbbbbaabbcbccbaabababcccacbaaacaccccbaaaacbcaccbbabaaabbacaaccababacaaacbabaacbcbbabbaababbbcbabaaccbaaccacbcaccbbcbbbbbcbbaababccbaacababbacaccbcbaabacbcbbbaaccababbcbaccabcabbaccaccbababcbcaaaaacaaabbccaacbccabbcabbaacbaacabccabcaabaccbaccbcbcbacabbbacbcbccbcbbbaaccbbacaccbbbcaabbcabbccaaccbacaaacbbabccbcabaaccbccacccacacbcbabacbbcabbcbbacccccacacbbabaaacaaacacabaacbaacbcaccaabaabababccabbbbabccbbacbbbabaacabbabccccaaabcaabacaccbcabccabccabbbbbabbbccbccabcccbacbcbcbbaccacacccaacaaacabaccccababbbbbbbacccbabcccabbbcacabbaccbbcaccaaccccaccbaacccbbcbaccbabcbacababacbaccbccacacccaaabcbaacabacbbcaabbbaaabccbabbaaacbacaccabbcccbbbbaacbbbcbbbacbbcacccbbbaababcbaaaaabbabcaabbbaaabbaaabbbabbacacccbbccbcbcacbcbbcaabcabccbcaaccbcaaacbacbcbabbbcbbcccaabbacbaabcaacabaabbbaccbaabcababcbbacacbbaababacbbcbbaccbbccbaaabbaccabaaaaaccbcbaccaacaaccbccbbabbcaaabbaccbabbccccbbcbcbaacbbcbababacbabcccaccacbccabaaccacabcbcaacccaccacabbbabcbcbbbbacccbcbbbcabaaccaabaaaacaccbccacbcacabaabbcaaccbacacabaacbbbbcbabcabbaaaacaacbabaabbbabaaccbcaaacabcabccacbbbcbcabcabbccaacbacaabbccbcbcbbcacccabcbccbbbaccacbaabbbcacccabccbbacacaacbcacabcabccabbbbbabaacbaabacabaabccaaaacccbacccccacaccabbcbcbaccaababbaaacabcbbcbbbcbbaabbaaacbcbbaabcbbaccbbabcbcbcabcccbaaacaaccbaccaaacccbbcabbabcbcaabcabbabaaaccaacabaabbcbbbbbaaacaabacaaabbcacbcabbccccbcbbcbcbbcaabaaacaaacaacbababbaabaaacaabcbbabcbcbacbabcabbcbbaaabcbcccccaacaacabacbcacaccccabacbbaabbcccaccbbbccaccbccabccacbcaabaaaacbccabcbabaaccaabcaacbbbacbcbaaabcbabcaaaccbcaacaaacbaabaaaccabcabcbcacbbcaabccccbbbacbbaaaaacabcbacccbcaaaabbbcbbcbcbabccabcccaacccbacccaacccabacbccbbacccabbabacbacbbcacbaaaabbcbbaabbbacbcbbcbabbbbacbccabbcbbccbabbccbcccabccbacababccacbcbccaaaabcaacacbabbcbccbcbbcabbbbbbabbacbcbcbccabbccbaccaaabbbabcbaacbccabcaaabbabaccbaaabbbabcacccbacbbbcabbbcbbabcaabcbbcaacccbacccaabbcbabccacbbccacbacbabcaabbbcaaabbccbaacacbcaaaaaaaccabcabcccbaacabbcacccbbcacaaaccacabacbbaabacaaacccaaaabaaccaacbaaaacacaccabcbbbaacbbbcbcacaabaccaaaccaccacacaaabaabbbacabbaaacabcbabccaaaaccbacaccaccacbccababcbcbaaccbabcaacbccccaacaaabbccbabccaacccccbcbbcabaccbaacbcbcbcbacababaabcbaaccabbcacbaabaacaabababbbaccbacbaccacccbcbcbcabcbbbbbbacbbaabcaccbaacbbcccaababaacbccaaccaabcabaaabbaacbaccaacaabbacabbacccccccacbacaacabaabcabcbcacccbbbbcbacbcaaabacbaabccbbabbcbbccacaaabbbaccabaaababccbccabccbcacababcbbcbccbccabbacabccaabaaaacaaabbbbcaaaaccbcaabbbabaccbaaccaacbaaaabbcbccbabaaacababccbcbcbabaacbcbaccbbcbacbbbbaacbbabbcabaaaccbbbcababbbaaabababcbaccccacccccbbbbacaaaacaaacaabcbacbacbababbccbbabcbacbbbacbcbaccaaababcaaaccbbabcabbbacaccaaabcaabbabbabaccbccbbacbbcacbbccbbcaaababcacccaacaaaccbcbacbaccabcaccabccccaccbcabcbcacbbccbbcbccabcbaabccbabbbbabaacacacaabcccbaccabcbaccacabacacabccccaaaaaabcccabaabccaacbbccacabbbbcaababccbbacacbccbbaaacbbabcbacbaaabbbabbaacaaabbbbaaaacababbbbcacbbcacaabbcabbaabcbbacccbccbaaaacabababaccbaacabcbaabcbcacbbbcbabaacaaacccabbaabcbbccacacbbcabcabbcccaaaacccabbbaccacbcacabbaccccccabaccccbabbacaaaacababaaacabbcbbbcbcbabbaccbbcbbaaabccbbabccabcbbbbaabcaaaaccbcbcccbcacaccaabcaabbaccccacbaabaaaaaaacacabaccbccaacbabcacbbabcccbaaacccbacacbaccbcabcbbaaacbcbccbbbbbbcbaacbccaaabacbcacaccabcbcbacaacabbaccaccaccababcaccbcababcbabaaaaabbbbbbcabbcacaccbaccbabbbbacbcaacaccacbcbcacbcacbaabaccabbaacabcbacbcbabcbbccccabcbabaccbbbcaacbcbccbaabcbccbcbcccccacababbbaccbcabcabcccaccbbabccabacccabbbccacccacacbaaaacbbaabcbcbabcbbbcbabbacbcbccbcbbbabbbacccacbaccbbcbbbacbbaaaccbabbcbccbccbccaccabaaaaacbbbcaacbcacabababbcaabbcbbbacaccacbacbcacaabbabaacbccababaabbbacaaabcabbaacbcaacabbaccbabbbcbbcccbabbbbbabbcbacacaaccabaaaaccbcbbbbcbbacaacbcbacbbcaabbacacaccabbacbbacbbbaacbbbabccabbcbccbcacacbaabbacbbbbcaaabccbbaabbbcabaabbcbbabcbaaacccabccbabacbbcacacccbaccaabccabbabccbabcbbbbaccabacbaccbcbbaaababbcbcabbaaacccabcbcabccacabbccbccabbabbcabcbbcbabcabcbaccacabbcbbbbbcabcacabacbcacacbbbbaaabaccbaacccbbbcccabbaacacccaaccccaacccbaabbbacacacabcbcbacccabbbaacccbaaacacbccccaabbcabaccaabaacaacccbcaacbcabbbbccacbbabacaaccacabbcbabcabbaaaabaacbaabcaabccccacabbccbccababcccbccbabcbbaabaaaccacaaaaaccacccccbbaacbbabbbacacbbccabbaabaacccaabcccbcbaaaacccabbbabbaabcbccabcbbacaabacbabcabbaababcbbbbcaacbaabcbbbcbabcaacacbcacaacbcbacbabbabcabbaccacabbbabccacbccabbcbbccaccbabbbcbcacbcbaaacabcacbcaaaccbbbaaaabaaabbccbbbbcaccccabbbcababbabcbbabbbbcacccacccbabccabcabbcaabcbbaaaacbcabacacabbbcbbcacababcbbaaccbcbcbacaccbbccabccbcaccacbbaccbccaaabcaaacaabaacacccbaaccacbbabbaacbbbcbbcbaabaabcaacbabbcbcaccaccabaacbcacacabaabbbcbcbbbaaabcccbaacbaaababcaaabbbccbcbbbcccbbcabcccacaababcbcbbcbaacccabccccccbaacaaccaacbcccccaccbacabcbabccbbcbbbabccbbcbabacccabacabaabababccbabbbcaaabbbbcbbacbaacbcabbacbaccbcaabbcabcccaaaaaccacaacabaaabacbbaccccbcaabcccbbaabaaaaccccacabaccbbaaabcccabacbbcabcaaabcbcaacbabacccccbbcbacbaccacabaaacabaaaccaaccbbaaaaccbcccbcbbbaababcbabbacbacccbcaacaacccacbcbcbbbcccccaccbabcabbbaabcbbaccbabbbcbcababbcabcbacbcbbabbcbbccbabaaccbbabacbbbbcbabbabbccaacbcbbaaccbabbcbcbbccaaaccbaacbccabbbcacacacbbbbacbcacbaaababccaacabbcbccbbbbaabaabbccbbbbbbbaaabcbbbccaababbabbcaabcbbccbabcbaaabcaacbbbbbabccabbaaacbccbbcbcacccabbaabbccccabcaacbacacccbbccaabcbcbcccaabacbcabaccaabbbcbcaabaccbbacacbaccabacccbcaaacccabacbcabcbbccabccccbababcbaaabbaaccacacccabcaaccbbcccccabbcacaccccacccacbbcaabbbbcbbabbacacbcbaabbccccccabcbbcbccccbbbccbacbabaaacccacaaccbaacbaaccccacacaccababcbabbacccaccbbbcbccbccbccbbbabaccacacbbabaccababbcbcbbccaabacbcbaccbcbabbcbaacabbaacabbbbcacbccbabcccbabaaacbaaaccbbbabaacaaccaccbbcbcacacabcbaabbaccaaabbcccccbcacabcaacccacababcabcbccccbabbacaaacccccacbbcccbbababbcbbacaccccbbccbcacabacccbbbcaacccaaacabbabcaccbcccabcbabaabbcbaacbbabacbcaabbaaabbbbbaccaaacaaababccbabbcbaabbcbcccaaaabbaaababbcacccbcbbacaacbabbbaacbccaaabcbbbacbbcbcccccaccacbcacacbabaacbabbbaabbbbbabcbbbacaaabbacaaacabbbabaccbcccabcaacacbccbacacabaacacababbcbbabbbbbcaccbaabbbcbbbababbccbbcaaaccbacabaababaacccaccbcacbacaaabcccabbacccaacbacabcccbaaacbbbccccaaacabbcbbaccbaaabacaccacbbbbccbaacababccbabbacbbbccbccccaaaaaaabcbaaacabcbabccbabbababacbccbcbcbaaaababacccbcbbbcacaabccbbbababaaabcbcabbbbcbcbbcacbcabbaacaccbbbcbaccbcbcbaaacbaaabcbaaabbcbcbaacbacabbcabaaaacbabcaaaabaabbaabbaccacbacabcaaaabbccaabbbcbaccabaaaabcaaaabbacbbbcbaccaacccaaacabbabcbbcbaaaccbabbbabcabbcacbbcabbaaaacccabcccbbcbccababccabbbcaaaaababcbcbbcacbccacbbaccbbcaabcabccbacbcccbbcbcabcbacccacbbcaaaacbccccbabbcbbabaccbbcacacabbcbaccccbbcababcaccaccaabcacaaaacbcbbaabaaccacbbacabcacbcbccbbbcbaacacbcacbcbbabaabbaabccacbcabaaababccccbaccaaccaccabbbcbbbbabacacacbccbbcbbabbbbaacacbaccaacacbbbabccbcbbbcbbcbcbabbacbbcaaabcabababacbcccbcbccaaccbbaccbabcbbbaccabbbbcbcbacaabcaacbbacaabbbaacccacacbccbcaabaaabbbacaaabaccbbacbccaacaabccbcaaacbccbaacaccbcccaccaacbabbcbaaaaccbcaacbbaccbcaacbbcbacabaccabcbaacaabcbcbbcbacaaacaaaaabbbaaccbabcabcbbabbacacccbbbcbbabbcbcababccabbaabaabbccbcaaabaabcabbaabbbccabacbbbbcbabaacccbabcbbcbaabcaacccbcaccbbbabbacaabcabbabbaacbacbbcaaaacbacccbbcaabcbbbcbcabbbbcabacaababccaaccccababacccacaacccaacabbcccaccabcbabacbaccaabbabaaaacccaccccabaaabcbbbbcccbaccbcccbcccaaaababbbcaaacabcacacbcacbabcccccbabccacabababaaaacbacbccabacabbaaabacaaabcabbbbcaacbccaccccacbcababbcaccbacabcbbabbababccbbccccccbcbbcbcaaacaccaccacbcbbaabaabbbaacaccbcbcaccbbccacababbcbabcbbcbbcbccabccbabbaccbcabbaccaccaabcaccccccacacbbaccabaccbbbcbbbabbbacaababacaacbaccbcbcccbbaaccbcbccabccccaacabbbbabcaaacaaccbcbcaabbbbbccbccababcabbbbbbcbabbabbbccbccabaaccbacacbacccccbaccccbccaabcccbccabbabbacbcacabbccbccbaaabbcbbabbcaabcababacccbaacaccabbcaccbcaaabbcbbcabcbcabcacabaaccbacaaaaacbccacccccccacccaccabbbacccacbbabcbcabbcaccbbaabbababacababababbbcbabbcbcacaababaabaacbacacacacccaabcaccbcbbbccccacacaaacaccaccbaccbacacbbabcbcaaabcacccabccacabccabaabccabacbccaabaabaaaacbcabcaccacbbabcbcaccbbbccbabcacbccabcacccbababcacabcabacabcbcbabcabbacababababcacccbacccabaaacabbcabbaccbbbacccbabcccccbbbcacaccaaccaababcabbcacabcbcbcaababccbbcbaaaacbbccaabbbccaccbbcbcbcbacbaccbcaaacacbbccacccbbbccacaaaaccabaacaacbaacaaabaabcbcbbabaaaccaccbaaaabbabbabbbbabaabbbccaabcaccbbabbcbbbcabaccbaacacacbbbcbaccabacbaaabbbcaabacccccacabbbbbabababaccaacbaababccaababbaaccaccbbccbbbbaccbccbcbbbbbaabbbbaccbccacaccccaacacabbbaababbcbccbacbbaabaaabaacccbbcbbcaccababcbcbcbcbabcacbaabbcabaabbbabbabaaaccabcaccbcbcccbacbccbccccabaccbbabababbabbaabacabacbbcccbabcccacccccbacbacabbbbcbaacbbaaacacacbbccbccbbabbbccacacabcbbccaacbbbacaccbcccbbcbacbcbabacbccaabccbabcbbbbcbaaccccaccacbaabccbabbabbaabbccbcbccbbbccbaaabcbcbbaabccbacbbbbcccacbbabbaaabbbcbbccabbaaabccbabccbbbacccacccacccbbccaaaccabaaaabbccabbabcbbbccccaaacbbbaacbbbbacbbbcbbabbcabccaacaaacbaacbcaccaacaaabacbaacbcacaaabbbbbaabbcaacbbabcacbaababcbcbbbbacaabbabcacaccbccbbacacccaacbccaacaaacaaaabbbababaaacbacccccaacbcacabaaccbacbcaccbbccccaabaaaabbacaccbbcbbcbbaaaaabaccccaaccbccaccbccabccbacbaaaccccbcbbbaabcbaabbcbacaaccccbccbbbbacacabccbcbacaacbcaaccaabacabbabcaaacccccacbbccbabcabaccababbbaacbcbccbccacbcccacbacbabacabcbacbcabcacbcbccbcbbbbbabaaababbccababcbccbabbaaabbcababcaabaaacccaaccabacccbcccbcabcabcaccaaabcabbaccabacbccbaabcbbacccabbbabaaaccaaacbcbccbababbbacaacaaabcacaababbcaabbacbabbbacacbaabbccbababbcaabcbababccccbabcbbbcbcbacbcbcabaccbccccbaaabbaacabcbbacaccbaaabcbaaacbcaabaaccabbcabbbabaacbcccbcabbcacccababcbbbbcabcbacaacabbacbbabcaabacbbbabbccaaaaacbabbbbcbcccbaacaaabacbacbabbbccabcbabbabbaccbbacacbacbccacbaabbcbccbbbaabbcacccbabbbabbbcaacababccaccacbbcaaaabbbccbbcbcaccabbaacccbacbcacabbcbbbacbaaccccaaaccaacbcbacbbccacbbcacccacbabaaabbbcaabccaacbbcbccbbaabacaccacaacaaaaaabbbcccbbcbbbbcabababbcbccbcbbbbcaabbccbcaaaccbbccabcaaacacbcbcaabbbbabacbaabbcacbbacccabaacaacaabbabacaaccccbccbccbbaaaaabcaacbccbcccaaabacacbbacaacccbcbcaaaccabbbabcbcaacbaccacbbbaccbacbacbcbcabccccccaaabbaacabccaaababbbbaabbbbaabcacccacabbcbcacbbbaabccbaabacccacaaccaccbabccbcbababbcaaccaaaaabbbacccbbbaaabcabbbcabaccccabbbabaabaaccbaaabcbbbcaaaccbcabbaaaaccccbcbbcbacbbbabbcbaabcccccaaacabbcaacbcccbacbbaaabcbcabbacabbcbabbcaacaccbaabccaaacbaaaabcbbbbabcccbbbbbcabccaabbbaababaccbbbbbbcbcbacaaaabcccccbaccbbbbacacbabcabcababcccccbaccccbbcababcbabaacbaabcababcbcbcbaabaacaccccabcbaacbabcbbabcbcabcaaacccacaaabccbcbacbcbbccbbacaccbbcccaccaaaacbcbcaabcbbcbccbacbcacabacccabcaababcabbabcbbbbcbcbcabcabbcabbbcccabaaaababababaacbbabcbcbaaaabccaacabcccbbaacbccababcbaabbbababbbabbbcbaacacbabacaaabbbcbabcacacccbbbccacaabcacccacbabbacbacbbaacaaababbcabaabbcccacbccaaaacbccbabcbacbbabbbabbbacaabccbcbbccccbacbaccaaaacaaccaccabaabcbbbbccbcbccbcacbcacbccbccbcbacccacbbcbaacacccaabbbabcaabbbabcacbbcabbcbbaabbacaccaaabcbbaaccbccccbbcbaaaaaacabcacbcbccaabcacbcaaaacaabacacccbcbbbcaabbcbbcababcacbacacaaabcccbbbcabccaccaabcbbbccaccacacacbccaaaabcbcbbbccabcabbcbbccbbbcaccccabbaabacabbbcbaacccbbcbcaaabbabcccacabbbabcaaaaacacbbcaacccccacacbcbbcbbabccabaacbabccbbbcaabbccabcbaccbbaacbbabaabcbbbabccccbaabbcbcacacbccbccaabbcccbcbabcabcabcababbcccbacbccacabbccccabacbcaaaabacbacbcbaccbaaaabcbcbbbbcbbbaacbacbacaacccbabacccccbcbbabbcbcabcccbacaabaaabcccabcaccbcaababcccbabbabccbcccbacbaacaacacacaacbcabbabbcbaaaaabcbccabccaabcbaccaaaccbacacabacbaaabccbcabcbaabbaccbaabcbccabcacaaacbcbbabccbcaccabcacbacbbacaccccbccbccccbbabccbcacaacabaabaccabcbbccacbcbcaacbaccccaacbaacaccaacaaababaabcbcabaccbbaaabbaabaccbccbbbcbcbbbcbccccabacbcbabbbbcbbbabbacbccaccccaacccaccccaabccacbcbbcccaaaabababbcaacbbaababbcaacbbaacaabcbbbaaaacbcabcabbcaaccaacbcccbcabcaaababbcbbbcbbbcacacbabacccbacabacbcbccaabcabaabcaacbcbabcbcababbbabbbbabcacabccaacaacabcccbbabbcaabcbacabbabcabaacccbbccbcabbbaccacbbabcaaabbbcbabcaabcbcababcbbabaaaabacaaabbbacccbbbbcabacacaacbccaccaabbabacbcaacbbacabaacaacaaabcacacbbbbccbabbcbccbcaccbabcbaacacbcbcacabbbaabccccaaccbccbaaaabccbbabcababacabbccbcabcbcccabbcaababccbbabcabcbcacbabacccbbaabccbcababcbaacabacaccbbbbbcbcbaacbccacccccbccbbaccabccbcbacccabcbaababaaabbcbcacabaaaababacccacbcccbaccacbabcacacccabaaaacbbaccbabbbbbbbcaccccbbaabcccbbaaabaabbcbabbcabaabbabbabbcbcacaaaaababcabcccacbbccbbacbbabacbbccbbcbaabbabbcbaacaaacbababbaacabaabbbbacccaabaabccabcabababbaababaccabccaccaccabaaababacbbbaaccbbcccaaacabbabccbcbcaaaccccabcbabbaaaaacabacacaacbbcbabacaabccbcbcaaabacbbcbabcccaacacaccccaabcacbbcaaaabbacaabcbaaaacaacccbccbcabcaacabcabcaaaaabbaaaabbabaabacbcaaaabbacbaaccbbcbbcccbbaabccacabacccccbbbbabbbbbcaccbcacaaabbacaaaacccccbccbaacacabccacbabaabbcbcabcbaacacbcbccbbaccaacaabaacabccccbbcbacbcaabbbbbbcbbbcaacaaccabbccbcbabbacaacaaccbacbbcbbcbbbccaaababcacabbabaacbcbaacbacbaacaaaaabccacbbbbaaaaccacaacbcacccacabcccbaabbaccbbbbbbbcacbaacbcacbabcaaaacbbcbabbbabcccabbbaaaaacccccacacccbbbcbacbbbaabaccbcaaabccccbcaacbaacccaababccccbbbcabcbbbaaabbcbcabcaaaaabcaaacbcbaccbcbaabcaabbacbaacbbacaaacccbbcacacacbbcbacacccbcccabcabbcabbabcccbbacbacababaccabababbcbaaaabbcaaaaacbaaacacaaaaccabacabbaaaabbbaacccbbacccbacbacabcabcaaacaaaacaaccbbaabbbcabbcbcacbaccacacabbcabcacbcbccccacbaacaccbccbbcabcbabaaabaabcbaccaababbcaacbaabcabbbcbcaaaacbaccacaccaccacbaa\nbbcccab", "287\r\n1585\r\n3612\r\n4294\r\n10800\r\n12025\r\n20604\r\n26894\r\n")] + public void Test1(string input, string expected) + { + var stringWriter = new StringWriter(); + Console.SetOut(stringWriter); + + var stringReader = new StringReader(input); + Console.SetIn(stringReader); + + // act + FindString.FindStr(); + + // assert + var output = stringWriter.ToString().Split(Environment.NewLine, StringSplitOptions.RemoveEmptyEntries); + Assert.Equal($"{expected}", output[0]); + var standardOutput = new StreamWriter(Console.OpenStandardOutput()); + } + } +} diff --git a/CourseApp.Tests/Module3/ZFuncTest1.cs b/CourseApp.Tests/Module3/ZFuncTest1.cs new file mode 100644 index 0000000..02f26c0 --- /dev/null +++ b/CourseApp.Tests/Module3/ZFuncTest1.cs @@ -0,0 +1,41 @@ +using System; +using System.IO; +using Xunit; +using CourseApp.Module3; + +namespace CourseApp.Tests.Module3 +{ + [Collection("Sequential")] + public class ZFuncTest1 : IDisposable + { + public void Dispose() + { + var standardOut = new StreamWriter(Console.OpenStandardOutput()); + standardOut.AutoFlush = true; + var standardIn = new StreamReader(Console.OpenStandardInput()); + Console.SetOut(standardOut); + Console.SetIn(standardIn); + } + + [Theory] + [InlineData( + "zbzbzbzbzbzbzbzbzbzbzbzbzbzbzbzbzbzbzbzbzbzbzbzbzbzbzbzbzbzbzbzbzbzbzbzbzbzbzbzbzbzbzbzbzbzbzbzbzbzbzbzbzbzbzbzbzz", + 113)] + [InlineData("zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz", 1)] + + public void Test1(string input, int expected) + { + var stringWriter = new StringWriter(); + Console.SetOut(stringWriter); + + var stringReader = new StringReader(input); + Console.SetIn(stringReader); + + ZFuncTest.Pain(); + + var output = stringWriter.ToString().Split(Environment.NewLine, StringSplitOptions.RemoveEmptyEntries); + Assert.Equal($"{expected}", output[0]); + var standardOutput = new StreamWriter(Console.OpenStandardOutput()); + } + } +} \ No newline at end of file diff --git a/CourseApp.Tests/Module4/PspTest.cs b/CourseApp.Tests/Module4/PspTest.cs new file mode 100644 index 0000000..47a5f05 --- /dev/null +++ b/CourseApp.Tests/Module4/PspTest.cs @@ -0,0 +1,39 @@ +using System; +using System.IO; +using Xunit; + +namespace CourseApp.Tests.Module3 +{ + [Collection("Sequential")] + public class PspTest : IDisposable + { + public void Dispose() + { + var standardOut = new StreamWriter(Console.OpenStandardOutput()); + standardOut.AutoFlush = true; + var standardIn = new StreamReader(Console.OpenStandardInput()); + Console.SetOut(standardOut); + Console.SetIn(standardIn); + } + + [Theory] + [InlineData("())(()", "2")] + [InlineData("))(((", "5")] + public void Test1(string input, string expected) + { + var stringWriter = new StringWriter(); + Console.SetOut(stringWriter); + + var stringReader = new StringReader(input); + Console.SetIn(stringReader); + + // act + PSP.Psp(); + + // assert + var output = stringWriter.ToString().Split(Environment.NewLine, StringSplitOptions.RemoveEmptyEntries); + Assert.Equal($"{expected}", output[0]); + var standardOutput = new StreamWriter(Console.OpenStandardOutput()); + } + } +} diff --git a/CourseApp.Tests/Module4/SortTest.cs b/CourseApp.Tests/Module4/SortTest.cs new file mode 100644 index 0000000..b691277 --- /dev/null +++ b/CourseApp.Tests/Module4/SortTest.cs @@ -0,0 +1,41 @@ +namespace CourseApp.Tests.Module4 +{ + using System; + using System.IO; + using CourseApp.Module4; + using Xunit; + + [Collection("Sequential")] + public class SortTest : IDisposable + { + public void Dispose() + { + var standardOut = new StreamWriter(Console.OpenStandardOutput()); + standardOut.AutoFlush = true; + var standardIn = new StreamReader(Console.OpenStandardInput()); + Console.SetOut(standardOut); + Console.SetIn(standardIn); + } + + [Theory] + [InlineData("3\n3 2 1", "YES")] + [InlineData("4\n4 1 3 2", "YES")] + [InlineData("3\n2 3 1", "NO")] + public void Test1(string input, string expected) + { + var stringWriter = new StringWriter(); + Console.SetOut(stringWriter); + + var stringReader = new StringReader(input); + Console.SetIn(stringReader); + + // act + Sort.Pain(); + + // assert + var output = stringWriter.ToString().Split(Environment.NewLine, StringSplitOptions.RemoveEmptyEntries); + Assert.Equal($"{expected}", output[0]); + var standardOutput = new StreamWriter(Console.OpenStandardOutput()); + } + } +} diff --git a/CourseApp.sln b/CourseApp.sln new file mode 100644 index 0000000..4c8426c --- /dev/null +++ b/CourseApp.sln @@ -0,0 +1,31 @@ + +Microsoft Visual Studio Solution File, Format Version 12.00 +# Visual Studio Version 17 +VisualStudioVersion = 17.0.32014.148 +MinimumVisualStudioVersion = 10.0.40219.1 +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "CourseApp", "CourseApp\CourseApp.csproj", "{D1856C82-5A61-4A61-A2CE-BDAF53530918}" +EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "CourseApp.Tests", "CourseApp.Tests\CourseApp.Tests.csproj", "{34D7AE24-58E8-48D5-A59E-F18CC60525F1}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|Any CPU = Debug|Any CPU + Release|Any CPU = Release|Any CPU + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {D1856C82-5A61-4A61-A2CE-BDAF53530918}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {D1856C82-5A61-4A61-A2CE-BDAF53530918}.Debug|Any CPU.Build.0 = Debug|Any CPU + {D1856C82-5A61-4A61-A2CE-BDAF53530918}.Release|Any CPU.ActiveCfg = Release|Any CPU + {D1856C82-5A61-4A61-A2CE-BDAF53530918}.Release|Any CPU.Build.0 = Release|Any CPU + {34D7AE24-58E8-48D5-A59E-F18CC60525F1}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {34D7AE24-58E8-48D5-A59E-F18CC60525F1}.Debug|Any CPU.Build.0 = Debug|Any CPU + {34D7AE24-58E8-48D5-A59E-F18CC60525F1}.Release|Any CPU.ActiveCfg = Release|Any CPU + {34D7AE24-58E8-48D5-A59E-F18CC60525F1}.Release|Any CPU.Build.0 = Release|Any CPU + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection + GlobalSection(ExtensibilityGlobals) = postSolution + SolutionGuid = {064E603C-674E-4DB9-A061-4B08C0ACD98C} + EndGlobalSection +EndGlobal diff --git a/CourseApp/.vscode/launch.json b/CourseApp/.vscode/launch.json new file mode 100644 index 0000000..208ea3a --- /dev/null +++ b/CourseApp/.vscode/launch.json @@ -0,0 +1,25 @@ +{ + // Use IntelliSense to learn about possible attributes. + // Hover to view descriptions of existing attributes. + // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387 + "version": "0.2.0", + "configurations": [ + { + "name": ".NET Core Launch (console)", + "type": "coreclr", + "request": "launch", + "preLaunchTask": "build", + "program": "${workspaceFolder}/bin/Debug/netcoreapp2.1/CourseApp.dll", + "args": [], + "cwd": "${workspaceFolder}", + "console": "internalConsole", + "stopAtEntry": false + }, + { + "name": ".NET Core Attach", + "type": "coreclr", + "request": "attach", + "processId": "${command:pickProcess}" + } + ] +} \ No newline at end of file diff --git a/CourseApp/.vscode/tasks.json b/CourseApp/.vscode/tasks.json new file mode 100644 index 0000000..f8c71cd --- /dev/null +++ b/CourseApp/.vscode/tasks.json @@ -0,0 +1,42 @@ +{ + "version": "2.0.0", + "tasks": [ + { + "label": "build", + "command": "dotnet", + "type": "process", + "args": [ + "build", + "${workspaceFolder}/CourseApp.csproj", + "/property:GenerateFullPaths=true", + "/consoleloggerparameters:NoSummary" + ], + "problemMatcher": "$msCompile" + }, + { + "label": "publish", + "command": "dotnet", + "type": "process", + "args": [ + "publish", + "${workspaceFolder}/CourseApp.csproj", + "/property:GenerateFullPaths=true", + "/consoleloggerparameters:NoSummary" + ], + "problemMatcher": "$msCompile" + }, + { + "label": "watch", + "command": "dotnet", + "type": "process", + "args": [ + "watch", + "run", + "${workspaceFolder}/CourseApp.csproj", + "/property:GenerateFullPaths=true", + "/consoleloggerparameters:NoSummary" + ], + "problemMatcher": "$msCompile" + } + ] +} \ No newline at end of file diff --git a/CourseApp/CourseApp.csproj b/CourseApp/CourseApp.csproj new file mode 100644 index 0000000..9551450 --- /dev/null +++ b/CourseApp/CourseApp.csproj @@ -0,0 +1,23 @@ + + + + Exe + netcoreapp2.1 + True + 1573,1591,1701;1702;1705; + + + + + + + + ../_stylecop/stylecop.ruleset + true + + + + + + + diff --git a/CourseApp/MergesortTest.cs b/CourseApp/MergesortTest.cs new file mode 100644 index 0000000..d0cd401 --- /dev/null +++ b/CourseApp/MergesortTest.cs @@ -0,0 +1,62 @@ +using System; +using System.Collections.Generic; +using System.Text; + +namespace CourseApp +{ + public class MergesortTest + { + public static int[] Merge(int[] arr1, int[] arr2) + { + int i = 0, j = 0, k = 0; + var resultArray = new int[arr1.Length + arr2.Length]; + while (k < resultArray.Length) + { + if ((j == arr2.Length) || (i < arr1.Length && arr1[i] <= arr2[j])) + { + resultArray[k] = arr1[i]; + i++; + } + else + { + resultArray[k] = arr2[j]; + j++; + } + + k++; + } + + foreach (int elem in resultArray) + { + Console.WriteLine(elem); + } + + return resultArray; + } + + public static int[] MergeSort(int[] resultArray) + { + if (resultArray.Length == 1) + { + return resultArray; + } + + var mid = resultArray.Length / 2; + var left = new int[mid]; + for (int i = 0; i < mid; i++) + { + left[i] = resultArray[i]; + } + + var rigth = new int[resultArray.Length - mid]; + for (int i = 0; i < rigth.Length; i++) + { + rigth[i] = resultArray[i + mid]; + } + + left = MergeSort(left); + rigth = MergeSort(rigth); + return Merge(left, rigth); + } + } +} diff --git a/CourseApp/Module1/AplusB.cs b/CourseApp/Module1/AplusB.cs new file mode 100644 index 0000000..9a15b45 --- /dev/null +++ b/CourseApp/Module1/AplusB.cs @@ -0,0 +1,16 @@ +using System; + +namespace CourseApp.Module1 +{ + public class AplusB + { + public static void Calculate() + { + string s = Console.ReadLine(); + string[] values = s.Split(' '); + int a = int.Parse(values[0]); + int b = int.Parse(values[1]); + Console.WriteLine($"{a + b}"); + } + } +} diff --git a/CourseApp/Module2/BorderOut.cs b/CourseApp/Module2/BorderOut.cs new file mode 100644 index 0000000..2cc9bb9 --- /dev/null +++ b/CourseApp/Module2/BorderOut.cs @@ -0,0 +1,50 @@ +using System; + +namespace CourseApp.Module2 +{ + public class BorderOut + { + public static int[] Merge(int[] arr1, int[] arr2) + { + var res = new int[arr1.Length + arr2.Length]; + int k = 0, i = 0, j = 0; + while (k < res.Length) + { + if ((j == arr2.Length) || (i < arr1.Length && arr1[i] <= arr2[j])) + { + res[k] = arr1[i]; + i++; + } + else + { + res[k] = arr2[j]; + j++; + } + + k++; + } + + return res; + } + + public static int[] MergeSort(int[] arr) + { + if (arr.Length == 1) + { + return arr; + } + + var mid = arr.Length / 2; + var left = new int[mid]; + var right = new int[arr.Length - mid]; + + Array.Copy(arr, 0, left, 0, left.Length); + Array.Copy(arr, left.Length, right, 0, right.Length); + + left = MergeSort(left); + right = MergeSort(right); + + return Merge(left, right); + } + } +} \ No newline at end of file diff --git a/CourseApp/Module2/BubleSort.cs b/CourseApp/Module2/BubleSort.cs new file mode 100644 index 0000000..f3b705a --- /dev/null +++ b/CourseApp/Module2/BubleSort.cs @@ -0,0 +1,41 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; + +namespace CourseApp.Module2 +{ + public class BubleSort + { + public static void Sort() + { + var k = 0; + var massLen = Convert.ToInt32(Console.ReadLine()); + var mass = Console.ReadLine().Split(" "); + foreach (string i in mass) + { + for (int index = 0; index < massLen - 1; index++) + { + if (Convert.ToInt32(mass[index]) > Convert.ToInt32(mass[index + 1])) + { + var temp = mass[index]; + mass[index] = mass[index + 1]; + mass[index + 1] = temp; + foreach (string elem in mass) + { + Console.Write(elem + " "); + k++; + } + + Console.WriteLine(); + } + } + } + + if (k == 0) + { + Console.WriteLine(0); + } + } + } +} diff --git a/CourseApp/Module2/Inversion.cs b/CourseApp/Module2/Inversion.cs new file mode 100644 index 0000000..9cc92b6 --- /dev/null +++ b/CourseApp/Module2/Inversion.cs @@ -0,0 +1,82 @@ +using System; + +namespace CourseApp.Module2 +{ + public class Inversion + { + private static long inversionCount = 0; + + public static void Main1() + { + int v = int.Parse(Console.ReadLine()); + if (v > 1) + { + string temp = Console.ReadLine(); + string[] values = temp.Split(' '); + int[] array = new int[v]; + for (int i = 0; i < values.Length; i++) + { + array[i] = int.Parse(values[i]); + } + + int[] result = Sort(array, 0, v); + Console.WriteLine(inversionCount); + } + else + { + Console.WriteLine(0); + } + } + + public static int[] Sort(int[] array, int firstInd, int lastInd) + { + if (lastInd - firstInd == 1) + { + int[] res = new int[1]; + res[0] = array[firstInd]; + return res; + } + + int w = (firstInd + lastInd) / 2; + + int[] left = Sort(array, firstInd, w); + int[] right = Sort(array, w, lastInd); + + return Merge(left, right); + } + + public static int[] Merge(int[] left, int[] right) + { + int i = 0; + int j = 0; + int[] result = new int[left.Length + right.Length]; + + for (int n = 0; n < result.Length; n++) + { + if (i == left.Length) + { + result[n] = right[j]; + j++; + } + else if (j == right.Length) + { + result[n] = left[i]; + i++; + } + else if (left[i] <= right[j]) + { + result[n] = left[i]; + i++; + } + else + { + result[n] = right[j]; + j++; + inversionCount += left.Length - i; + } + } + + return result; + } + } +} \ No newline at end of file diff --git a/CourseApp/Module2/MergeBorderOutput.cs b/CourseApp/Module2/MergeBorderOutput.cs new file mode 100644 index 0000000..2f6d7b8 --- /dev/null +++ b/CourseApp/Module2/MergeBorderOutput.cs @@ -0,0 +1,83 @@ +using System; + +namespace CourseApp.Module2 +{ + public class MergeBorderOutput + { + public static void Gain() // Main() method + { + MergeSortMethod(); + } + + public static void MergeSortMethod() + { + int[] arr = InputParse(); + + int[] sortedArr = ArrSort(ref arr, 0, arr.Length); + + Console.WriteLine("{0}", string.Join(" ", sortedArr)); + } + + private static int[] Merge(ref int[] left, ref int[] right) + { + int i = 0; + int j = 0; + int[] add = new int[left.Length + right.Length]; + for (int k = 0; k < add.Length; k++) + { + if (i == left.Length) + { + add[k] = right[j]; + j++; + } + else if (j == right.Length || left[i] <= right[j]) + { + add[k] = left[i]; + i++; + } + else + { + add[k] = right[j]; + j++; + } + } + + return add; + } + + private static int[] ArrSort(ref int[] arr, int begin, int end) + { + if (end - begin == 1) + { + int[] res = new int[1]; + res[0] = arr[begin]; + return res; + } + + int mid = (begin + end) / 2; + + int[] left = ArrSort(ref arr, begin, mid); + int[] right = ArrSort(ref arr, mid, end); + + int[] sort = Merge(ref left, ref right); + + Console.WriteLine("{0} {1} {2} {3}", begin + 1, end, sort[0], sort[sort.Length - 1]); + + return Merge(ref left, ref right); + } + + private static int[] InputParse() + { + int n = int.Parse(Console.ReadLine()); + int[] arr = new int[n]; + string s = Console.ReadLine(); + string[] sValues = s.Split(' '); + for (int i = 0; i < n; i++) + { + arr[i] = int.Parse(sValues[i]); + } + + return arr; + } + } +} \ No newline at end of file diff --git a/CourseApp/Module2/MergeSort.cs b/CourseApp/Module2/MergeSort.cs new file mode 100644 index 0000000..094037f --- /dev/null +++ b/CourseApp/Module2/MergeSort.cs @@ -0,0 +1,62 @@ +using System; + +namespace CourseApp +{ + public class MergeSort + { + public static int[] Merge(int[] arr1, int[] arr2) + { + int i = 0, j = 0, k = 0; + var resultArray = new int[arr1.Length + arr2.Length]; + while (k < resultArray.Length) + { + if ((j == arr2.Length) || (i < arr1.Length && arr1[i] <= arr2[j])) + { + resultArray[k] = arr1[i]; + i++; + } + else + { + resultArray[k] = arr2[j]; + j++; + } + + k++; + } + + return resultArray; + } + + public static int[] Sort(int[] array) + { + if (array.Length == 1) + { + return array; + } + + var mid = array.Length / 2; + var left = new int[mid]; + var right = new int[array.Length - mid]; + + Array.Copy(array, 0, left, 0, left.Length); + Array.Copy(array, left.Length, right, 0, right.Length); + + left = Sort(left); + right = Sort(right); + + return Merge(left, right); + } + + public static int[] ParseConsole() + { + var str = Console.ReadLine().Split(" "); + var mass = new int[str.Length]; + for (int i = 0; i < mass.Length; i++) + { + mass[i] = Convert.ToInt32(str[i]); + } + + return mass; + } + } +} diff --git a/CourseApp/Module2/NumberOfDifferent.cs b/CourseApp/Module2/NumberOfDifferent.cs new file mode 100644 index 0000000..3e57abd --- /dev/null +++ b/CourseApp/Module2/NumberOfDifferent.cs @@ -0,0 +1,28 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; + +namespace CourseApp.Module2 +{ + public class NumberOfDifferent + { + public static int[] Parse() + { + var len = Convert.ToInt32(Console.ReadLine()); + var mass = new int[len]; + var str = Console.ReadLine().Split(' '); + for (int i = 0; i < len; i++) + { + mass[i] = Convert.ToInt32(str[i]); + } + + return mass; + } + + public static void CountDiffrent(int[] mass) + { + Console.WriteLine(mass.ToList().Distinct().Count()); + } + } +} diff --git a/CourseApp/Module2/Pairs.cs b/CourseApp/Module2/Pairs.cs new file mode 100644 index 0000000..ce95c7c --- /dev/null +++ b/CourseApp/Module2/Pairs.cs @@ -0,0 +1,54 @@ +using System; +using System.Collections.Generic; + +public class Pairs +{ + public int Index { get; set; } + + public int Cost { get; set; } + + public static void PairSort() + { + var list = new List(); + int count = Convert.ToInt32(Console.ReadLine()); + int i = 0; + while (i < count) + { + var str1 = Console.ReadLine(); + var index = Convert.ToInt32(str1.Split(" ")[0]); + var cost = Convert.ToInt32(str1.Split(" ")[1]); + var pair = new Pairs(); + pair.Index = index; + pair.Cost = cost; + list.Add(pair); + i++; + } + + for (int k = 0; k < count - 1; k++) + { + for (int j = 0; j < count - 1; j++) + { + if (list[j].Cost < list[j + 1].Cost) + { + (list[j], list[j + 1]) = (list[j + 1], list[j]); + } + } + } + + for (int k = 0; k < count - 1; k++) + { + for (int j = 0; j < count - 1; j++) + { + if ((list[j].Cost == list[j + 1].Cost) && (list[j].Index > list[j + 1].Index)) + { + (list[j], list[j + 1]) = (list[j + 1], list[j]); + } + } + } + + foreach (var ind in list) + { + Console.WriteLine($"{ind.Index} {ind.Cost}"); + } + } +} \ No newline at end of file diff --git a/CourseApp/Module2/QuickSort.cs b/CourseApp/Module2/QuickSort.cs new file mode 100644 index 0000000..a40201f --- /dev/null +++ b/CourseApp/Module2/QuickSort.cs @@ -0,0 +1,44 @@ +using System; +using System.Collections.Generic; +using System.Globalization; +using System.Text; + +namespace CourseApp.Module2 +{ + public class QuickSort + { + // private int[] numbers = { 4, -1, 3421, 1234, -32, 12 }; - массив, чтобы скопировать его в Main() при вызове данной функции + public static int FindPivot(int[] numbers, int minIndex, int maxIndex) // поиск опроного члена (по умолчанию беру опорным элементом последнйи элемент массива) + { + int pivot = minIndex - 1; + for (int i = minIndex; i < maxIndex; i++) + { + if (numbers[i] < numbers[maxIndex]) + { + pivot++; + (numbers[pivot], numbers[i]) = (numbers[i], numbers[pivot]); + } + } + + pivot++; + (numbers[pivot], numbers[maxIndex]) = (numbers[maxIndex], numbers[pivot]); + + return pivot; + } + + public static int[] Sort(int[] numbers, int minIndex, int maxIndex) // сама сортировка (рекурсивно для подмассивов) + { + if (minIndex >= maxIndex) + { + return numbers; // если длина подмассива == 1 => выйти из цикла + } + + int pivot = FindPivot(numbers, minIndex, maxIndex); + + Sort(numbers, minIndex, pivot - 1); + Sort(numbers, pivot + 1, maxIndex); + + return numbers; + } + } +} diff --git a/CourseApp/Module2/RadixSort.cs b/CourseApp/Module2/RadixSort.cs new file mode 100644 index 0000000..17fe0b6 --- /dev/null +++ b/CourseApp/Module2/RadixSort.cs @@ -0,0 +1,77 @@ +using System; +using System.Collections.Generic; +using System.Linq; + +namespace CourseApp.Module2 +{ + public class RadixSort + { + public static void RadSort(string[] arr_string) + { + var phase = 1; + var rank = arr_string[0].Length; + + Console.WriteLine("Initial array:"); + Console.WriteLine("{0}", string.Join(", ", arr_string)); + + foreach (var i in Enumerable.Range(0, Convert.ToInt32(Math.Ceiling(Convert.ToDouble(-1 - (rank - 1)) / -1))).Select(x_1 => rank - 1 + (x_1 * -1))) + { + Console.WriteLine("**********"); + Console.WriteLine("Phase {0}", phase); + ulong n; + List[] arrayList = new List[10]; + for (n = 0; n < 10; n++) + { + arrayList[n] = new List(); + } + + for (int j = 0; j < arr_string.Length; j++) + { + int k = int.Parse(arr_string[j].Substring(rank - phase, 1)); + arrayList[k].Add(arr_string[j]); + } + + for (n = 0; n < 10; n++) + { + if (arrayList[n].Count == 0) + { + Console.WriteLine("Bucket " + n + ": empty"); + } + else + { + Console.WriteLine("Bucket " + n + ": {0}", string.Join(", ", arrayList[n])); + } + } + + int l = 0; + + for (n = 0; n < 10; n++) + { + for (int j = 0; j < arrayList[n].Count; j++) + { + arr_string[l] = arrayList[n][j]; + l++; + } + } + + phase++; + } + + Console.WriteLine("**********"); + Console.WriteLine("Sorted array:"); + Console.Write("{0}", string.Join(", ", arr_string)); + } + + public static void Begin() + { + var m = ulong.Parse(Console.ReadLine()); + var arr_string = new string[m]; + for (ulong i = 0; i < m; i++) + { + arr_string[i] = Console.ReadLine(); + } + + RadSort(arr_string); + } + } +} \ No newline at end of file diff --git a/CourseApp/Module3/CycleOfStr.cs b/CourseApp/Module3/CycleOfStr.cs new file mode 100644 index 0000000..f949504 --- /dev/null +++ b/CourseApp/Module3/CycleOfStr.cs @@ -0,0 +1,48 @@ +using System; +using System.Globalization; + +namespace CourseApp.Module3 +{ + public class CycleOfStr + { + public static int GetHash(string s, int n) + { + int res = 0, p = 2803, x = 31; + for (int i = 0; i < n; i++) + { + res = ((res * x) + s[i]) % p; + } + + return res; + } + + public static int RabinKarp(string s, string t) + { + int ht = GetHash(t, t.Length); + int hs = GetHash(s, s.Length); + int p = 2803, x = 27; + + for (int i = 0; i < s.Length; i++) + { + if (ht == hs) + { + return i; + } + + ht = ((ht * x) - (t[i] * ht) + t[i]) % p; + ht = (ht + p) % p; + } + + return -1; + } + + public static void Pain() // Main method + { + var s = Console.ReadLine(); + var t = Console.ReadLine(); + + var res = RabinKarp(s, t); + Console.WriteLine(res); + } + } +} \ No newline at end of file diff --git a/CourseApp/Module3/CyclingString.cs b/CourseApp/Module3/CyclingString.cs new file mode 100644 index 0000000..99f23cd --- /dev/null +++ b/CourseApp/Module3/CyclingString.cs @@ -0,0 +1,45 @@ +using System; + +namespace CourseApp.Module3 +{ + public class CyclingString + { + public static int[] Prefix_function(string str) // Z-function finder + { + int[] res = new int[str.Length]; + res[0] = 0; + + for (int i = 0; i < str.Length - 1; i++) + { + int j = res[i]; + + while (j > 0 && str[i + 1] != str[j]) + { + j = res[j - 1]; + } + + if (str[i + 1] == str[j]) + { + res[i + 1] = j + 1; + } + else + { + res[i + 1] = 0; + } + } + + return res; + } + + public static void Pain() + { + string str = Console.ReadLine(); + + int[] prefixs = Prefix_function(str); + + int result = str.Length - prefixs[str.Length - 1]; + + Console.WriteLine(result); + } + } +} \ No newline at end of file diff --git a/CourseApp/Module3/FindString.cs b/CourseApp/Module3/FindString.cs new file mode 100644 index 0000000..914e765 --- /dev/null +++ b/CourseApp/Module3/FindString.cs @@ -0,0 +1,57 @@ +using System; + +namespace CourseApp.Module3 +{ + public class FindString + { + public static long Get_hash(string str, int b, int q, int t) + { + long res = 0; + for (int i = 0; i < b; i++) + { + res = ((res * t) + str[i]) % q; + } + + return res; + } + + public static void Rabin_karp(string e, string k, int o, int v) + { + long ht = Get_hash(k, k.Length, o, v); + + long hs = Get_hash(e, k.Length, o, v); + + long xt = 1; + + for (int i = 0; i < k.Length; i++) + { + xt = (xt * v) % o; + } + + for (int i = 0; i <= e.Length - k.Length; i++) + { + if (ht == hs) + { + Console.Write("{0} ", i); + } + + if (i + k.Length < e.Length) + { + hs = ((hs * v) - (e[i] * xt) + e[i + k.Length]) % o; + hs = (hs + o) % o; + } + } + } + + public static void FindStr() + { + string str = Console.ReadLine(); + string subStr = Console.ReadLine(); + + int o = 67953405; + int v = 26; + + Rabin_karp(str, subStr, o, v); + } + } +} \ No newline at end of file diff --git a/CourseApp/Module3/Prefix.cs b/CourseApp/Module3/Prefix.cs new file mode 100644 index 0000000..7a5484f --- /dev/null +++ b/CourseApp/Module3/Prefix.cs @@ -0,0 +1,52 @@ +using System; +using System.Collections.Generic; +using System.Globalization; +using System.Reflection.PortableExecutable; +using System.Text; + +namespace CourseApp.Module3 +{ + public class Prefix + { + public static int[] Period(string str) + { + var length = str.Length; + var result = new int[length]; + for (int i = 0; i < length - 1; i++) + { + var j = result[i]; + while ((j > 0) && (str[i + 1] != str[j])) + { + j = result[i - 1]; + } + + if (str[i + 1] == str[j]) + { + result[i + 1] = j + 1; + } + else + { + result[i + 1] = 0; + } + } + + return result; + } + + public static void Pain() + { + var str = Console.ReadLine(); + var pref = Period(str); + var res = str.Length - pref[str.Length - 1]; + + if (str.Length % res == 0) + { + Console.WriteLine(str.Length / res); + } + else + { + Console.WriteLine(1); + } + } + } +} diff --git a/CourseApp/Module3/Shiftstring.cs b/CourseApp/Module3/Shiftstring.cs new file mode 100644 index 0000000..4bee3de --- /dev/null +++ b/CourseApp/Module3/Shiftstring.cs @@ -0,0 +1,74 @@ +using System; +using System.Linq; + +namespace CourseApp.Module3 +{ + public class ShiftString + { + public static int Rabin_Karp(string str, string subStr) + { + if (str == subStr) + { + return 0; // случай, когда строки изначально совпали + } + + subStr = string.Concat(Enumerable.Repeat(subStr, 2)); // умножаем подстроку (паттерн) на 2 (как в Python) + + long w = 13; + long b = 1; + long t = 100000000; + + long first_hash = 0; + long second_hash = 0; + long xt = 1; + + foreach (char i in str.Reverse()) + { + first_hash = (first_hash + (i * b)) % t; // высчитываем хэш 1 строки + b = (b * w) % t; + } + + b = 1; + + for (int i = str.Length - 1; i >= 0; i--) + { + second_hash = (second_hash + (subStr[i] * b)) % t; // высчитываем хэш 2 строки + b = (b * w) % t; + } + + for (int i = 0; i < str.Length - 1; i++) + { + xt = (xt * w) % t; + } + + for (int i = 1; i < subStr.Length - str.Length + 1; i++) + { + if (first_hash == second_hash) + { + return i - 1; // находим циклическое + } + + second_hash = w * (second_hash - (subStr[i - 1] * xt)); // второй хэш + second_hash += subStr[i + str.Length - 1]; + second_hash = second_hash % t; // избавляемся от переполнения + + if ((second_hash < 0 && t > 0) || (second_hash > 0 && t < 0)) + { + second_hash += t; + } + } + + return -1; // ничего не нашли((( + } + + public static void EnterValues() + { + string r = Console.ReadLine(); + string q = Console.ReadLine(); + + int result = Rabin_Karp(r, q); + + Console.WriteLine(result); + } + } +} \ No newline at end of file diff --git a/CourseApp/Module3/ZFuncTest.cs b/CourseApp/Module3/ZFuncTest.cs new file mode 100644 index 0000000..8c61e05 --- /dev/null +++ b/CourseApp/Module3/ZFuncTest.cs @@ -0,0 +1,41 @@ +using System; + +namespace CourseApp.Module3 +{ + public class ZFuncTest + { + public static int[] ZFunc(string str) + { + var res = new int[str.Length]; + res[0] = 0; + + for (int i = 0; i < str.Length - 1; i++) + { + int j = res[i]; + while (j > 0 && str[i + 1] != str[j]) + { + j = res[j - 1]; + } + + if (str[i + 1] == str[j]) + { + res[i + 1] = j + 1; + } + else + { + res[i + 1] = 0; + } + } + + return res; + } + + public static void Pain() + { + var str = Console.ReadLine(); + int[] pref = ZFunc(str); + int res = str.Length - pref[str.Length - 1]; + Console.WriteLine(res); + } + } +} \ No newline at end of file diff --git a/CourseApp/Module4/BalsCount.cs b/CourseApp/Module4/BalsCount.cs new file mode 100644 index 0000000..3ff70f6 --- /dev/null +++ b/CourseApp/Module4/BalsCount.cs @@ -0,0 +1,45 @@ +using System; +using System.Collections.Generic; + +namespace CourseApp.Module4 +{ + public class BalsCount + { + public static void Count() + { + var nums = Console.ReadLine(); + var myStack = new Stack(); + var resStack = new Stack(); + var count = 1; + var res = 0; + + for (int i = 2; i < nums.Length; i += 2) + { + myStack.Push(Convert.ToInt16(nums[i])); + } + + var length = myStack.Count; + + while (myStack.Count > 0) + { + resStack.Push(myStack.Peek()); + if (resStack.Pop() == myStack.Pop()) + { + count++; + if (count == 3) + { + res++; + resStack.Clear(); + } + } + else + { + resStack.Clear(); + count = 1; + } + } + + Console.WriteLine(res * 3); + } + } +} diff --git a/CourseApp/Module4/PSP.cs b/CourseApp/Module4/PSP.cs new file mode 100644 index 0000000..b3b705c --- /dev/null +++ b/CourseApp/Module4/PSP.cs @@ -0,0 +1,35 @@ +using System; +using System.Collections.Generic; + +namespace CourseApp +{ + public class PSP + { + public static void Psp() + { + var str = Console.ReadLine(); + var stack = new Stack(); + + foreach (char symbol in str) + { + if (symbol == '(') + { + stack.Push(symbol); + } + else if (symbol == ')') + { + if (stack.Count > 0 && stack.Peek() == '(') + { + stack.Pop(); + } + else + { + stack.Push(symbol); + } + } + } + + Console.WriteLine(stack.Count); + } + } +} \ No newline at end of file diff --git a/CourseApp/Module4/Sort.cs b/CourseApp/Module4/Sort.cs new file mode 100644 index 0000000..556fb40 --- /dev/null +++ b/CourseApp/Module4/Sort.cs @@ -0,0 +1,48 @@ +using System; +using System.Collections.Generic; +using System.Linq; + +namespace CourseApp.Module4 +{ + public class Sort + { + public static void Pain() + { + var count = Convert.ToInt16(Console.ReadLine()); + var mass = Console.ReadLine().Split(" "); + + var a = Pup(count, mass); + + var str = a ? "YES" : "NO"; + + Console.WriteLine(str); + } + + public static bool Pup(int count, string[] mass) + { + var res = false; + var stack = new Stack(); + var ind = 0; + var start = 1; + + while (count >= ind + 1) + { + stack.Push(Convert.ToInt16(mass[ind])); + ind++; + + while (stack.Count != 0 && stack.Peek() == start) + { + stack.Pop(); + start++; + } + } + + if (stack.Count == 0) + { + res = true; + } + + return res; + } + } +} \ No newline at end of file diff --git a/CourseApp/Module5/Tree.cs b/CourseApp/Module5/Tree.cs new file mode 100644 index 0000000..7e27f36 --- /dev/null +++ b/CourseApp/Module5/Tree.cs @@ -0,0 +1,30 @@ +namespace CourseApp.Module5 +{ + public class Tree + { + public Tree(int value) + { + this.Value = value; + this.Left = null; + this.Right = null; + } + + public Tree Left { get; set; } + + public Tree Right { get; set; } + + public int Value { get; set; } + + public int GetVal(int value) + { + return this.Value; + } + + public void SetVal(int val) + { + this.Value = val; + } + + public Tree GetLeft(Tree elem) => elem.Left == null ? null : elem.Left; + } +} \ No newline at end of file diff --git a/CourseApp/Program.cs b/CourseApp/Program.cs new file mode 100644 index 0000000..ef15117 --- /dev/null +++ b/CourseApp/Program.cs @@ -0,0 +1,18 @@ +using System; +using System.Collections.Generic; +using System.Globalization; +using System.Linq; +using CourseApp.Module2; +using CourseApp.Module3; +using CourseApp.Module4; + +namespace CourseApp +{ + public class Program + { + public static void Main() + { + Sort.Pain(); + } + } +} \ No newline at end of file diff --git a/_stylecop/stylecop.json b/_stylecop/stylecop.json new file mode 100644 index 0000000..4a96e8f --- /dev/null +++ b/_stylecop/stylecop.json @@ -0,0 +1,12 @@ +{ + "$schema": "https://raw.githubusercontent.com/DotNetAnalyzers/StyleCopAnalyzers/master/StyleCop.Analyzers/StyleCop.Analyzers/Settings/stylecop.schema.json", + "settings": { + "documentationRules": { + "documentExposedElements": false, + "documentInterfaces": false, + "companyName": "Test Company", + "copyrightText": "This source code is Copyright © {companyName} and MAY NOT be copied, reproduced,\npublished, distributed or transmitted to or stored in any manner without prior\nwritten consent from {companyName} (www.yourcompany.com).", + "xmlHeader":false + } + } +} \ No newline at end of file diff --git a/_stylecop/stylecop.ruleset b/_stylecop/stylecop.ruleset new file mode 100644 index 0000000..13ae1f9 --- /dev/null +++ b/_stylecop/stylecop.ruleset @@ -0,0 +1,15 @@ + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/courseworkspace.code-workspace b/courseworkspace.code-workspace new file mode 100644 index 0000000..0c34b36 --- /dev/null +++ b/courseworkspace.code-workspace @@ -0,0 +1,15 @@ +{ + "folders": [ + { + "path": "CourseApp" + }, + { + "path": "CourseApp.Tests" + }, + { + "name": "Configs (Root)", + "path": "." + } + ], + "settings": {} +} \ No newline at end of file diff --git a/golang/.golangci.yml b/golang/.golangci.yml deleted file mode 100644 index e6ddb63..0000000 --- a/golang/.golangci.yml +++ /dev/null @@ -1,111 +0,0 @@ -run: - tests: false - skip-files: - - \.pb\.go$ - - \.pb\.validate\.go$ - - \.pb\.gw\.go$ - -linters-settings: - dupl: - threshold: 500 - # commented linter rules should be uncommented when corresponding linter will be enabled - # funlen: - # lines: 160 - # statements: 60 - gci: - local-prefixes: github.com/golangci/golangci-lint - # revive: - # min-confidence: 0 - # gomnd: - # checks: - # - argument - # - case - # - condition - # - return - lll: - line-length: 160 - -linters: - # please, do not use `enable-all`: it's deprecated and will be removed soon. - # inverted configuration with `enable-all` and `disable` is not scalable during updates of golangci-lint - # Disabled linters should be enabled later - disable-all: true - enable: - - asciicheck - - bidichk - - bodyclose - - containedctx - # - deadcode - - decorder - - depguard - - dogsled - - dupl - - durationcheck - # - errcheck - - errchkjson - # - errname - - errorlint - - execinquery - - exportloopref - # - forbidigo - - forcetypeassert - # - funlen - - gocognit - - goconst - # - gocritic - - gocyclo - # - gofmt - # - gofumpt - - goheader - # - goimports - # - gomnd - - gomodguard - - goprintffuncname - - gosec - - gosimple - - govet - - grouper - # - ifshort - - importas - - ineffassign - - lll - # - maintidx - - makezero - # - misspell - - nakedret - - nestif - - nilerr - - nilnil - - noctx - # - nolintlint - - nosprintfhostport - - paralleltest - # - prealloc - # - predeclared - - promlinter - # - revive - - rowserrcheck - - sqlclosecheck - # - structcheck - # - stylecheck - # - tagliatelle - - tenv - - testpackage - - tparallel - - typecheck - - unconvert - - unparam - - unused - # - varcheck - - wastedassign - - whitespace - -issues: - # Excluding configuration per-path, per-linter, per-text and per-source - exclude-rules: - - path: _test\.go - linters: - - gomnd - - text: "File is not `goimports`-ed with -local github.com/golangci/golangci-lint" - linters: - - goimports diff --git a/golang/.vscode/launch.json b/golang/.vscode/launch.json deleted file mode 100644 index 9b0666d..0000000 --- a/golang/.vscode/launch.json +++ /dev/null @@ -1,25 +0,0 @@ -{ - // Use IntelliSense to learn about possible attributes. - // Hover to view descriptions of existing attributes. - // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387 - "version": "0.2.0", - "configurations": [ - { - "name": "Launch test function", - "type": "go", - "request": "launch", - "mode": "test", - "program": "${file}", - }, - { - "name": "Launch Package", - "type": "go", - "request": "launch", - "mode": "auto", - "program": "${fileDirname}", - "console": "integratedTerminal", - "args": ["sample"], - "showLog": true - } - ] -} \ No newline at end of file diff --git a/golang/.vscode/settings.json b/golang/.vscode/settings.json deleted file mode 100644 index 6e380ce..0000000 --- a/golang/.vscode/settings.json +++ /dev/null @@ -1,4 +0,0 @@ -{ - "go.lintTool": "golangci-lint", - "go.lintFlags": ["--fast"] -} diff --git a/golang/README.md b/golang/README.md deleted file mode 100644 index 24dd698..0000000 --- a/golang/README.md +++ /dev/null @@ -1,34 +0,0 @@ -# Работа с проектом - -`vscode` при старте предложит установить рекомендованныек расширения - с ним лучше согласиться. - - -## Настройка окружения - -### Golang - -Установите `golang` для соответствующей операционной системы. - -Запустите выкачивание зависимостей - -```shell -go mod tidy -``` - -Для локальной проверки линтером следует установить линтер. Устанавливать следует из git bash терминала в случае `windows` - -```shell -# binary will be $(go env GOPATH)/bin/golangci-lint -curl -sSfL https://raw.githubusercontent.com/golangci/golangci-lint/master/install.sh | sh -s -- -b $(go env GOPATH)/bin v1.50.1 -``` - -Для запуска линтера следует выполнить следующую команду -```shell -$(go env GOPATH)/bin/golangci-lint run -vvv --out-format tab --print-resources-usage --timeout=180s --config=.golangci.yml -``` - -### Запуск тестов - -```shell -go test -count=1 -p 1 -v ./... -``` \ No newline at end of file diff --git a/golang/algorithm.code-workspace b/golang/algorithm.code-workspace deleted file mode 100644 index ec166d2..0000000 --- a/golang/algorithm.code-workspace +++ /dev/null @@ -1,18 +0,0 @@ -{ - "folders": [ - { - "path": "." - }, - ], - "settings": { - "files.exclude": { - "**/.git": true, - }, - }, - "extensions": { - "recommendations": [ - "golang.go", - "eamodio.gitlens" - ] - } -} diff --git a/golang/go.mod b/golang/go.mod deleted file mode 100644 index be4ab0b..0000000 --- a/golang/go.mod +++ /dev/null @@ -1,5 +0,0 @@ -module isuct.ru/informatics2022 - -go 1.16 - -require github.com/stretchr/testify v1.8.1 // indirect diff --git a/golang/go.sum b/golang/go.sum deleted file mode 100644 index d9320db..0000000 --- a/golang/go.sum +++ /dev/null @@ -1,17 +0,0 @@ -github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= -github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= -github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= -github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= -github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= -github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= -github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw= -github.com/stretchr/objx v0.5.0 h1:1zr/of2m5FGMsad5YfcqgdqdWrIhu+EBEJRhR1U7z/c= -github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo= -github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= -github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU= -github.com/stretchr/testify v1.8.1 h1:w7B6lhMri9wdJUVmEZPGGhZzrYTPvgJArz7wNPgYKsk= -github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4= -gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= -gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= -gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= -gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= diff --git a/golang/internal/module1/summ.go b/golang/internal/module1/summ.go deleted file mode 100644 index 79b914a..0000000 --- a/golang/internal/module1/summ.go +++ /dev/null @@ -1,25 +0,0 @@ -package module1 - -import ( - "bufio" - "fmt" - "os" - "strconv" - "strings" -) - -func Summ() { - reader := bufio.NewReader(os.Stdin) - line, err := reader.ReadString('\n') - if err != nil { - panic(err) - } - line = strings.TrimSuffix(line, "\n") - line = strings.TrimSuffix(line, "\r") - arr := strings.Split(line, " ") - - a, _ := strconv.Atoi(arr[0]) - b, _ := strconv.Atoi(arr[1]) - summ := a + b - fmt.Println(summ) -} diff --git a/golang/main.go b/golang/main.go deleted file mode 100644 index 8d32ddc..0000000 --- a/golang/main.go +++ /dev/null @@ -1,12 +0,0 @@ -package main - -import ( - "fmt" - - "isuct.ru/informatics2022/internal/module1" -) - -func main() { - fmt.Println("Hello world") - module1.Summ() -} diff --git a/golang/tests/helpers/helper.go b/golang/tests/helpers/helper.go deleted file mode 100644 index b31cfff..0000000 --- a/golang/tests/helpers/helper.go +++ /dev/null @@ -1,21 +0,0 @@ -package helpers - -import ( - "os" - "testing" -) - -func Replacer(input string, t *testing.T) (*os.File, *os.File) { - inp := []byte(input) - - r, w, err := os.Pipe() - if err != nil { - t.Fatal(err) - } - - _, err = w.Write(inp) - if err != nil { - t.Fatal(err) - } - return r, w -} diff --git a/golang/tests/module1/summ_test.go b/golang/tests/module1/summ_test.go deleted file mode 100644 index 06d1810..0000000 --- a/golang/tests/module1/summ_test.go +++ /dev/null @@ -1,48 +0,0 @@ -package module1_test - -import ( - "io" - "os" - "testing" - - "github.com/stretchr/testify/assert" - "isuct.ru/informatics2022/internal/module1" - "isuct.ru/informatics2022/tests/helpers" -) - -func TestSumm(t *testing.T) { - assert := assert.New(t) - - defer func(v *os.File) { os.Stdin = v }(os.Stdin) - defer func(v *os.File) { os.Stdout = v }(os.Stdout) - t.Run("Case: 10 12", func(t *testing.T) { - r, w := helpers.Replacer("10 12\n", t) - os.Stdin = r - os.Stdout = w - - module1.Summ() - w.Close() - out, _ := io.ReadAll(r) - assert.Equal("22\n", string(out)) - }) - t.Run("Case: 1 1", func(t *testing.T) { - r, w := helpers.Replacer("1 1\n", t) - os.Stdin = r - os.Stdout = w - - module1.Summ() - w.Close() - out, _ := io.ReadAll(r) - assert.Equal("2\n", string(out)) - }) - t.Run("Case: 10000 10000", func(t *testing.T) { - r, w := helpers.Replacer("10000 10000\n", t) - os.Stdin = r - os.Stdout = w - - module1.Summ() - w.Close() - out, _ := io.ReadAll(r) - assert.Equal("20000\n", string(out)) - }) -} diff --git a/python/.flake8 b/python/.flake8 deleted file mode 100644 index 4b473c6..0000000 --- a/python/.flake8 +++ /dev/null @@ -1,3 +0,0 @@ -[flake8] -ignore = E722 -max-line-length = 128 diff --git a/python/.gitignore b/python/.gitignore deleted file mode 100644 index c792544..0000000 --- a/python/.gitignore +++ /dev/null @@ -1,206 +0,0 @@ -# Prerequisites -*.d - -# Object files -*.o -*.ko -*.obj -*.elf - -# Linker output -*.ilk -*.map -*.exp - -# Precompiled Headers -*.gch -*.pch - -# Libraries -*.lib -*.a -*.la -*.lo - -# Shared objects (inc. Windows DLLs) -*.dll -*.so -*.so.* -*.dylib - -# Executables -*.exe -*.out -*.app -*.i*86 -*.x86_64 -*.hex - -# Debug files -*.dSYM/ -*.su -*.idb -*.pdb - -# Kernel Module Compile Results -*.mod* -*.cmd -.tmp_versions/ -modules.order -Module.symvers -Mkfile.old -dkms.conf -*.out - -# Byte-compiled / optimized / DLL files -__pycache__/ -*.py[cod] -*$py.class - -# C extensions -*.so - -# Distribution / packaging -.Python -build/ -develop-eggs/ -dist/ -downloads/ -eggs/ -.eggs/ -lib/ -lib64/ -parts/ -sdist/ -var/ -wheels/ -share/python-wheels/ -*.egg-info/ -.installed.cfg -*.egg -MANIFEST - -# PyInstaller -# Usually these files are written by a python script from a template -# before PyInstaller builds the exe, so as to inject date/other infos into it. -*.manifest -*.spec - -# Installer logs -pip-log.txt -pip-delete-this-directory.txt - -# Unit test / coverage reports -htmlcov/ -.tox/ -.nox/ -.coverage -.coverage.* -.cache -nosetests.xml -coverage.xml -*.cover -*.py,cover -.hypothesis/ -.pytest_cache/ -cover/ - -# Translations -*.mo -*.pot - -# Django stuff: -*.log -local_settings.py -db.sqlite3 -db.sqlite3-journal - -# Flask stuff: -instance/ -.webassets-cache - -# Scrapy stuff: -.scrapy - -# Sphinx documentation -docs/_build/ - -# PyBuilder -.pybuilder/ -target/ - -# Jupyter Notebook -.ipynb_checkpoints - -# IPython -profile_default/ -ipython_config.py - -# pyenv -# For a library or package, you might want to ignore these files since the code is -# intended to run in multiple environments; otherwise, check them in: -# .python-version - -# pipenv -# According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control. -# However, in case of collaboration, if having platform-specific dependencies or dependencies -# having no cross-platform support, pipenv may install dependencies that don't work, or not -# install all needed dependencies. -#Pipfile.lock - -# poetry -# Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control. -# This is especially recommended for binary packages to ensure reproducibility, and is more -# commonly ignored for libraries. -# https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control -#poetry.lock - -# PEP 582; used by e.g. github.com/David-OConnor/pyflow -__pypackages__/ - -# Celery stuff -celerybeat-schedule -celerybeat.pid - -# SageMath parsed files -*.sage.py - -# Environments -.env -.venv -env/ -venv/ -ENV/ -env.bak/ -venv.bak/ - -# Spyder project settings -.spyderproject -.spyproject - -# Rope project settings -.ropeproject - -# mkdocs documentation -/site - -# mypy -.mypy_cache/ -.dmypy.json -dmypy.json - -# Pyre type checker -.pyre/ - -# pytype static type analyzer -.pytype/ - -# Cython debug symbols -cython_debug/ - -# PyCharm -# JetBrains specific template is maintainted in a separate JetBrains.gitignore that can -# be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore -# and can be added to the global gitignore or merged into this file. For a more nuclear -# option (not recommended) you can uncomment the following to ignore the entire idea folder. -#.idea/ \ No newline at end of file diff --git a/python/.vscode/launch.json b/python/.vscode/launch.json deleted file mode 100644 index 0a5c809..0000000 --- a/python/.vscode/launch.json +++ /dev/null @@ -1,15 +0,0 @@ -{ - // Use IntelliSense to learn about possible attributes. - // Hover to view descriptions of existing attributes. - // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387 - "version": "0.2.0", - "configurations": [ - { - "name": "Python: Текущий файл", - "type": "python", - "request": "launch", - "program": "${file}", - "console": "integratedTerminal" - } - ] -} diff --git a/python/.vscode/settings.json b/python/.vscode/settings.json deleted file mode 100644 index 2597cbc..0000000 --- a/python/.vscode/settings.json +++ /dev/null @@ -1,7 +0,0 @@ -{ - "python.linting.pylintEnabled": false, - "python.linting.mypyEnabled": false, - "python.linting.enabled": true, - "python.linting.lintOnSave": true, - "python.linting.flake8Enabled": true, -} diff --git a/python/Pipfile b/python/Pipfile deleted file mode 100644 index 0f6a6f3..0000000 --- a/python/Pipfile +++ /dev/null @@ -1,19 +0,0 @@ -[[source]] -url = "https://pypi.org/simple" -verify_ssl = true -name = "pypi" - -[packages] - -[dev-packages] -mypy = "*" -flake8 = "*" - -[requires] -python_version = "3.9" - -[scripts] -start = "python ./src/main.py" -test = "python -m unittest" -lint = "flake8 ./" -lintMyPy = "mypy ./" diff --git a/python/Pipfile.lock b/python/Pipfile.lock deleted file mode 100644 index f3145ef..0000000 --- a/python/Pipfile.lock +++ /dev/null @@ -1,106 +0,0 @@ -{ - "_meta": { - "hash": { - "sha256": "4894b22932cc8c76e138c68198ce54cb057a7f4b391476c15e3e05d193ceb7f7" - }, - "pipfile-spec": 6, - "requires": { - "python_version": "3.9" - }, - "sources": [ - { - "name": "pypi", - "url": "https://pypi.org/simple", - "verify_ssl": true - } - ] - }, - "default": {}, - "develop": { - "flake8": { - "hashes": [ - "sha256:6fbe320aad8d6b95cec8b8e47bc933004678dc63095be98528b7bdd2a9f510db", - "sha256:7a1cf6b73744f5806ab95e526f6f0d8c01c66d7bbe349562d22dfca20610b248" - ], - "index": "pypi", - "version": "==5.0.4" - }, - "mccabe": { - "hashes": [ - "sha256:348e0240c33b60bbdf4e523192ef919f28cb2c3d7d5c7794f74009290f236325", - "sha256:6c2d30ab6be0e4a46919781807b4f0d834ebdd6c6e3dca0bda5a15f863427b6e" - ], - "markers": "python_version >= '3.6'", - "version": "==0.7.0" - }, - "mypy": { - "hashes": [ - "sha256:1021c241e8b6e1ca5a47e4d52601274ac078a89845cfde66c6d5f769819ffa1d", - "sha256:14d53cdd4cf93765aa747a7399f0961a365bcddf7855d9cef6306fa41de01c24", - "sha256:175f292f649a3af7082fe36620369ffc4661a71005aa9f8297ea473df5772046", - "sha256:26ae64555d480ad4b32a267d10cab7aec92ff44de35a7cd95b2b7cb8e64ebe3e", - "sha256:41fd1cf9bc0e1c19b9af13a6580ccb66c381a5ee2cf63ee5ebab747a4badeba3", - "sha256:5085e6f442003fa915aeb0a46d4da58128da69325d8213b4b35cc7054090aed5", - "sha256:58f27ebafe726a8e5ccb58d896451dd9a662a511a3188ff6a8a6a919142ecc20", - "sha256:6389af3e204975d6658de4fb8ac16f58c14e1bacc6142fee86d1b5b26aa52bda", - "sha256:724d36be56444f569c20a629d1d4ee0cb0ad666078d59bb84f8f887952511ca1", - "sha256:75838c649290d83a2b83a88288c1eb60fe7a05b36d46cbea9d22efc790002146", - "sha256:7b35ce03a289480d6544aac85fa3674f493f323d80ea7226410ed065cd46f206", - "sha256:85f7a343542dc8b1ed0a888cdd34dca56462654ef23aa673907305b260b3d746", - "sha256:86ebe67adf4d021b28c3f547da6aa2cce660b57f0432617af2cca932d4d378a6", - "sha256:8ee8c2472e96beb1045e9081de8e92f295b89ac10c4109afdf3a23ad6e644f3e", - "sha256:91781eff1f3f2607519c8b0e8518aad8498af1419e8442d5d0afb108059881fc", - "sha256:a692a8e7d07abe5f4b2dd32d731812a0175626a90a223d4b58f10f458747dd8a", - "sha256:a705a93670c8b74769496280d2fe6cd59961506c64f329bb179970ff1d24f9f8", - "sha256:c6e564f035d25c99fd2b863e13049744d96bd1947e3d3d2f16f5828864506763", - "sha256:cebca7fd333f90b61b3ef7f217ff75ce2e287482206ef4a8b18f32b49927b1a2", - "sha256:d6af646bd46f10d53834a8e8983e130e47d8ab2d4b7a97363e35b24e1d588947", - "sha256:e7aeaa763c7ab86d5b66ff27f68493d672e44c8099af636d433a7f3fa5596d40", - "sha256:eaa97b9ddd1dd9901a22a879491dbb951b5dec75c3b90032e2baa7336777363b", - "sha256:eb7a068e503be3543c4bd329c994103874fa543c1727ba5288393c21d912d795", - "sha256:f793e3dd95e166b66d50e7b63e69e58e88643d80a3dcc3bcd81368e0478b089c" - ], - "index": "pypi", - "version": "==0.982" - }, - "mypy-extensions": { - "hashes": [ - "sha256:090fedd75945a69ae91ce1303b5824f428daf5a028d2f6ab8a299250a846f15d", - "sha256:2d82818f5bb3e369420cb3c4060a7970edba416647068eb4c5343488a6c604a8" - ], - "version": "==0.4.3" - }, - "pycodestyle": { - "hashes": [ - "sha256:2c9607871d58c76354b697b42f5d57e1ada7d261c261efac224b664affdc5785", - "sha256:d1735fc58b418fd7c5f658d28d943854f8a849b01a5d0a1e6f3f3fdd0166804b" - ], - "markers": "python_version >= '3.6'", - "version": "==2.9.1" - }, - "pyflakes": { - "hashes": [ - "sha256:4579f67d887f804e67edb544428f264b7b24f435b263c4614f384135cea553d2", - "sha256:491feb020dca48ccc562a8c0cbe8df07ee13078df59813b83959cbdada312ea3" - ], - "markers": "python_version >= '3.6'", - "version": "==2.5.0" - }, - "tomli": { - "hashes": [ - "sha256:939de3e7a6161af0c887ef91b7d41a53e7c5a1ca976325f429cb46ea9bc30ecc", - "sha256:de526c12914f0c550d15924c62d72abc48d6fe7364aa87328337a31007fe8a4f" - ], - "markers": "python_version < '3.11'", - "version": "==2.0.1" - }, - "typing-extensions": { - "hashes": [ - "sha256:1511434bb92bf8dd198c12b1cc812e800d4181cfcb867674e0f8279cc93087aa", - "sha256:16fa4864408f655d35ec496218b85f79b3437c829e93320c7c9215ccfd92489e" - ], - "markers": "python_version >= '3.7'", - "version": "==4.4.0" - } - } -} diff --git a/python/README.md b/python/README.md deleted file mode 100644 index a394814..0000000 --- a/python/README.md +++ /dev/null @@ -1,54 +0,0 @@ -# Работа с проектом - -`vscode` при старте предложит установить рекомендованныек расширения - с ним лучше согласиться. - - -## Настройка окружения - -### Python - -Установите `python` для соответствующей операционной системы. - -**ВАЖНО** - -При установке в windows - укажите галочку - добавить python в переменную окружения `PATH` - -### Pipenv - -Мы используем виртуальное окружение `pipenv`, для его установки используйте следующую команду: - -```shell -pip install pipenv -``` -Установку требуется сделать только 1 раз, активацию - каждый раз когда вы перезапускаете терминал. - - -Для активации виртуального окружения следует выполнить следующую команду, при этом выполнять ее нужно в каталоге текущего проекта `python` (рядом с текущим `README.md` файлом и содержит `Pipfile`) - -``` -pipenv shell -``` - -После этого необходимо установить зависимости, указанные в `pipenv` файле - - - -После установки pipenv при использовании `vscode` следует выбрать версию интерпретатора, привязанный к проекту. Для этого можно выполнить следующую последовательность действий. Настраивать требуется только 1 раз при настройке виртуального окружения. - -- Нажать комбинацию клавиш `ctrl-shift-p` -- Начать писать `Reload window` -- Начать писать `Python select interpreter` -- Выбрать на уровне рабочей области -- Найти свое окружение, скорее всего в его имени в скобках будет указано `(python-"НАБОР_СИМВОЛОВ")` - -Ваше рабочее окружение настроено и можете его иcпользовать. - -### Доступные команды - -Команды проверок, запускаемые в `github actions` можно также запустить локально выполнением одной из следующих команд - -```shell -pipenv run test -pipenv run lint -pipenv run lintMyPy -``` \ No newline at end of file diff --git a/python/algorithm.code-workspace b/python/algorithm.code-workspace deleted file mode 100644 index 9c3d46e..0000000 --- a/python/algorithm.code-workspace +++ /dev/null @@ -1,19 +0,0 @@ -{ - "folders": [ - { - "path": "." - }, - ], - "settings": { - "files.exclude": { - "**/.git": true, - }, - "editor.tabSize": 4, - }, - "extensions": { - "recommendations": [ - "ms-python.python", - "eamodio.gitlens" - ] - } -} diff --git a/python/requirements.txt b/python/requirements.txt deleted file mode 100644 index 35e3f5c..0000000 Binary files a/python/requirements.txt and /dev/null differ diff --git a/python/src/__init__.py b/python/src/__init__.py deleted file mode 100644 index e69de29..0000000 diff --git a/python/src/main.py b/python/src/main.py deleted file mode 100644 index e37a77c..0000000 --- a/python/src/main.py +++ /dev/null @@ -1,7 +0,0 @@ -def summ(a: int, b: int) -> int: - return a + b - - -if __name__ == "__main__": - print("Hello world") - print(summ(3, 4)) diff --git a/python/src/module1/hello.py b/python/src/module1/hello.py deleted file mode 100644 index bdb9c05..0000000 --- a/python/src/module1/hello.py +++ /dev/null @@ -1,22 +0,0 @@ -""" ->>> import io, sys ->>> sys.stdin = io.StringIO(chr(10).join(['Vasya'])) ->>> hello() -Hello, Vasya! ->>> sys.stdin = io.StringIO(chr(10).join(['Petya'])) ->>> hello() -Hello, Petya! ->>> sys.stdin = io.StringIO(chr(10).join(['Olya'])) ->>> hello() -Hello, Olya! -""" - - -def hello(): - name = input() - print(f'Hello, {name}!') - - -if __name__ == "__main__": - import doctest - doctest.testmod(verbose=True) diff --git a/python/src/module1/summ.py b/python/src/module1/summ.py deleted file mode 100644 index cd5e905..0000000 --- a/python/src/module1/summ.py +++ /dev/null @@ -1,22 +0,0 @@ -""" ->>> import io, sys ->>> sys.stdin = io.StringIO(chr(10).join(['10 12'])) # input ->>> summ() -22 ->>> sys.stdin = io.StringIO(chr(10).join(['1 1'])) # input ->>> summ() -2 ->>> sys.stdin = io.StringIO(chr(10).join(['10000 10000'])) # input ->>> summ() -20000 -""" - - -def summ(): - a, b = map(int, input().split(' ')) - print(a + b) - - -if __name__ == "__main__": - import doctest - doctest.testmod(verbose=True) diff --git a/python/src/module2/bubble_sort.py b/python/src/module2/bubble_sort.py deleted file mode 100644 index ac28b7e..0000000 --- a/python/src/module2/bubble_sort.py +++ /dev/null @@ -1,36 +0,0 @@ -""" ->>> import io, sys ->>> sys.stdin = io.StringIO(chr(10).join(['4','4 3 2 1'])) ->>> bubble_sort() -3 4 2 1 -3 2 4 1 -3 2 1 4 -2 3 1 4 -2 1 3 4 -1 2 3 4 -""" - - -def bubble_sort(): - n = input() - inp_string = input() - str_lst = inp_string.split(" ") - res = [] - for item in str_lst: - res.append(int(item)) - - n = len(res) - num_swap = 0 - for i in range(0, n - 1): - for j in range(0, n - 1 - i): - if res[j] > res[j + 1]: - res[j], res[j + 1] = res[j + 1], res[j] - num_swap += 1 - print(" ".join(map(str, res))) - if num_swap == 0: - print("0") - - -if __name__ == "__main__": - import doctest - doctest.testmod(verbose=True) diff --git a/python/tests/__init__.py b/python/tests/__init__.py deleted file mode 100644 index e69de29..0000000 diff --git a/python/tests/test_main.py b/python/tests/test_main.py deleted file mode 100644 index 0280a2e..0000000 --- a/python/tests/test_main.py +++ /dev/null @@ -1,37 +0,0 @@ -import unittest -from src import main - - -class SummTests(unittest.TestCase): - - def test_positive(self): - res = main.summ(2, 3) - self.assertEqual(5, res) - - def test_zero(self): - res = main.summ(0, 0) - self.assertEqual(0, res) - - def test_one_negative(self): - res = main.summ(-2, 3) - self.assertEqual(1, res) - - def test_both_negative(self): - res = main.summ(-2, -4) - self.assertEqual(-6, res) - - def test_one_negative_zero_res(self): - res = main.summ(-2, 2) - self.assertEqual(0, res) - - def test_one_negative_and_text(self): - try: - main.summ(-2, "2") - except: - self.assertTrue(True) - return - self.fail() - - -if __name__ == '__main__': - unittest.main()