From 3e186b69eb1cb354611a01b313f2972a49de7420 Mon Sep 17 00:00:00 2001 From: Anthony Cicchetti Date: Sat, 7 Mar 2020 17:29:24 -0500 Subject: [PATCH] Kotlin exercies --- kotlin/dominoes/.exercism/metadata.json | 1 + .../executionHistory/executionHistory.bin | Bin 0 -> 71473 bytes .../executionHistory/executionHistory.lock | Bin 0 -> 17 bytes .../.gradle/6.0.1/fileChanges/last-build.bin | Bin 0 -> 1 bytes .../6.0.1/fileContent/fileContent.lock | Bin 0 -> 17 bytes .../.gradle/6.0.1/fileHashes/fileHashes.bin | Bin 0 -> 19797 bytes .../.gradle/6.0.1/fileHashes/fileHashes.lock | Bin 0 -> 17 bytes kotlin/dominoes/.gradle/6.0.1/gc.properties | 0 .../buildOutputCleanup.lock | Bin 0 -> 17 bytes .../buildOutputCleanup/cache.properties | 2 + .../buildOutputCleanup/outputFiles.bin | Bin 0 -> 18803 bytes kotlin/dominoes/.gradle/vcs-1/gc.properties | 0 kotlin/dominoes/.idea/.gitignore | 8 + kotlin/dominoes/.idea/compiler.xml | 6 + kotlin/dominoes/.idea/jarRepositories.xml | 20 ++ kotlin/dominoes/.idea/misc.xml | 8 + kotlin/dominoes/.idea/vcs.xml | 6 + kotlin/dominoes/README.md | 42 ++++ kotlin/dominoes/build.gradle.kts | 23 +++ .../gradle/wrapper/gradle-wrapper.properties | 5 + kotlin/dominoes/gradlew | 188 ++++++++++++++++++ kotlin/dominoes/gradlew.bat | 100 ++++++++++ kotlin/dominoes/src/main/kotlin/Dominoes.kt | 44 ++++ .../dominoes/src/test/kotlin/DominoesTest.kt | 138 +++++++++++++ .../.exercism/metadata.json | 1 + .../executionHistory/executionHistory.bin | Bin 0 -> 72879 bytes .../executionHistory/executionHistory.lock | Bin 0 -> 17 bytes .../.gradle/6.0.1/fileChanges/last-build.bin | Bin 0 -> 1 bytes .../6.0.1/fileContent/fileContent.lock | Bin 0 -> 17 bytes .../.gradle/6.0.1/fileHashes/fileHashes.bin | Bin 0 -> 19647 bytes .../.gradle/6.0.1/fileHashes/fileHashes.lock | Bin 0 -> 17 bytes .../.gradle/6.0.1/gc.properties | 0 .../buildOutputCleanup.lock | Bin 0 -> 17 bytes .../buildOutputCleanup/cache.properties | 2 + .../buildOutputCleanup/outputFiles.bin | Bin 0 -> 18803 bytes .../.gradle/vcs-1/gc.properties | 0 kotlin/kindergarten-garden/.idea/.gitignore | 8 + kotlin/kindergarten-garden/.idea/compiler.xml | 6 + .../.idea/jarRepositories.xml | 20 ++ kotlin/kindergarten-garden/.idea/misc.xml | 8 + kotlin/kindergarten-garden/.idea/vcs.xml | 6 + kotlin/kindergarten-garden/README.md | 78 ++++++++ kotlin/kindergarten-garden/build.gradle.kts | 23 +++ .../gradle/wrapper/gradle-wrapper.properties | 5 + kotlin/kindergarten-garden/gradlew | 188 ++++++++++++++++++ kotlin/kindergarten-garden/gradlew.bat | 100 ++++++++++ .../src/main/kotlin/KindergartenGarden.kt | 100 ++++++++++ .../src/test/kotlin/KindergartenGardenTest.kt | 88 ++++++++ kotlin/yacht/.exercism/metadata.json | 1 + .../executionHistory/executionHistory.bin | Bin 0 -> 67584 bytes .../executionHistory/executionHistory.lock | Bin 0 -> 17 bytes .../.gradle/6.0.1/fileChanges/last-build.bin | Bin 0 -> 1 bytes .../6.0.1/fileContent/fileContent.lock | Bin 0 -> 17 bytes .../.gradle/6.0.1/fileHashes/fileHashes.bin | Bin 0 -> 19547 bytes .../.gradle/6.0.1/fileHashes/fileHashes.lock | Bin 0 -> 17 bytes kotlin/yacht/.gradle/6.0.1/gc.properties | 0 .../buildOutputCleanup.lock | Bin 0 -> 17 bytes .../buildOutputCleanup/cache.properties | 2 + .../buildOutputCleanup/outputFiles.bin | Bin 0 -> 18803 bytes kotlin/yacht/.gradle/vcs-1/gc.properties | 0 kotlin/yacht/.idea/.gitignore | 8 + kotlin/yacht/.idea/compiler.xml | 6 + kotlin/yacht/.idea/jarRepositories.xml | 20 ++ kotlin/yacht/.idea/misc.xml | 8 + kotlin/yacht/.idea/vcs.xml | 6 + kotlin/yacht/README.md | 67 +++++++ kotlin/yacht/build.gradle.kts | 23 +++ .../gradle/wrapper/gradle-wrapper.properties | 5 + kotlin/yacht/gradlew | 188 ++++++++++++++++++ kotlin/yacht/gradlew.bat | 100 ++++++++++ kotlin/yacht/src/main/kotlin/Yacht.kt | 34 ++++ kotlin/yacht/src/main/kotlin/YachtCategory.kt | 14 ++ kotlin/yacht/src/test/kotlin/YachtTest.kt | 93 +++++++++ 73 files changed, 1799 insertions(+) create mode 100644 kotlin/dominoes/.exercism/metadata.json create mode 100644 kotlin/dominoes/.gradle/6.0.1/executionHistory/executionHistory.bin create mode 100644 kotlin/dominoes/.gradle/6.0.1/executionHistory/executionHistory.lock create mode 100644 kotlin/dominoes/.gradle/6.0.1/fileChanges/last-build.bin create mode 100644 kotlin/dominoes/.gradle/6.0.1/fileContent/fileContent.lock create mode 100644 kotlin/dominoes/.gradle/6.0.1/fileHashes/fileHashes.bin create mode 100644 kotlin/dominoes/.gradle/6.0.1/fileHashes/fileHashes.lock create mode 100644 kotlin/dominoes/.gradle/6.0.1/gc.properties create mode 100644 kotlin/dominoes/.gradle/buildOutputCleanup/buildOutputCleanup.lock create mode 100644 kotlin/dominoes/.gradle/buildOutputCleanup/cache.properties create mode 100644 kotlin/dominoes/.gradle/buildOutputCleanup/outputFiles.bin create mode 100644 kotlin/dominoes/.gradle/vcs-1/gc.properties create mode 100644 kotlin/dominoes/.idea/.gitignore create mode 100644 kotlin/dominoes/.idea/compiler.xml create mode 100644 kotlin/dominoes/.idea/jarRepositories.xml create mode 100644 kotlin/dominoes/.idea/misc.xml create mode 100644 kotlin/dominoes/.idea/vcs.xml create mode 100644 kotlin/dominoes/README.md create mode 100644 kotlin/dominoes/build.gradle.kts create mode 100644 kotlin/dominoes/gradle/wrapper/gradle-wrapper.properties create mode 100644 kotlin/dominoes/gradlew create mode 100644 kotlin/dominoes/gradlew.bat create mode 100644 kotlin/dominoes/src/main/kotlin/Dominoes.kt create mode 100644 kotlin/dominoes/src/test/kotlin/DominoesTest.kt create mode 100644 kotlin/kindergarten-garden/.exercism/metadata.json create mode 100644 kotlin/kindergarten-garden/.gradle/6.0.1/executionHistory/executionHistory.bin create mode 100644 kotlin/kindergarten-garden/.gradle/6.0.1/executionHistory/executionHistory.lock create mode 100644 kotlin/kindergarten-garden/.gradle/6.0.1/fileChanges/last-build.bin create mode 100644 kotlin/kindergarten-garden/.gradle/6.0.1/fileContent/fileContent.lock create mode 100644 kotlin/kindergarten-garden/.gradle/6.0.1/fileHashes/fileHashes.bin create mode 100644 kotlin/kindergarten-garden/.gradle/6.0.1/fileHashes/fileHashes.lock create mode 100644 kotlin/kindergarten-garden/.gradle/6.0.1/gc.properties create mode 100644 kotlin/kindergarten-garden/.gradle/buildOutputCleanup/buildOutputCleanup.lock create mode 100644 kotlin/kindergarten-garden/.gradle/buildOutputCleanup/cache.properties create mode 100644 kotlin/kindergarten-garden/.gradle/buildOutputCleanup/outputFiles.bin create mode 100644 kotlin/kindergarten-garden/.gradle/vcs-1/gc.properties create mode 100644 kotlin/kindergarten-garden/.idea/.gitignore create mode 100644 kotlin/kindergarten-garden/.idea/compiler.xml create mode 100644 kotlin/kindergarten-garden/.idea/jarRepositories.xml create mode 100644 kotlin/kindergarten-garden/.idea/misc.xml create mode 100644 kotlin/kindergarten-garden/.idea/vcs.xml create mode 100644 kotlin/kindergarten-garden/README.md create mode 100644 kotlin/kindergarten-garden/build.gradle.kts create mode 100644 kotlin/kindergarten-garden/gradle/wrapper/gradle-wrapper.properties create mode 100644 kotlin/kindergarten-garden/gradlew create mode 100644 kotlin/kindergarten-garden/gradlew.bat create mode 100644 kotlin/kindergarten-garden/src/main/kotlin/KindergartenGarden.kt create mode 100644 kotlin/kindergarten-garden/src/test/kotlin/KindergartenGardenTest.kt create mode 100644 kotlin/yacht/.exercism/metadata.json create mode 100644 kotlin/yacht/.gradle/6.0.1/executionHistory/executionHistory.bin create mode 100644 kotlin/yacht/.gradle/6.0.1/executionHistory/executionHistory.lock create mode 100644 kotlin/yacht/.gradle/6.0.1/fileChanges/last-build.bin create mode 100644 kotlin/yacht/.gradle/6.0.1/fileContent/fileContent.lock create mode 100644 kotlin/yacht/.gradle/6.0.1/fileHashes/fileHashes.bin create mode 100644 kotlin/yacht/.gradle/6.0.1/fileHashes/fileHashes.lock create mode 100644 kotlin/yacht/.gradle/6.0.1/gc.properties create mode 100644 kotlin/yacht/.gradle/buildOutputCleanup/buildOutputCleanup.lock create mode 100644 kotlin/yacht/.gradle/buildOutputCleanup/cache.properties create mode 100644 kotlin/yacht/.gradle/buildOutputCleanup/outputFiles.bin create mode 100644 kotlin/yacht/.gradle/vcs-1/gc.properties create mode 100644 kotlin/yacht/.idea/.gitignore create mode 100644 kotlin/yacht/.idea/compiler.xml create mode 100644 kotlin/yacht/.idea/jarRepositories.xml create mode 100644 kotlin/yacht/.idea/misc.xml create mode 100644 kotlin/yacht/.idea/vcs.xml create mode 100644 kotlin/yacht/README.md create mode 100644 kotlin/yacht/build.gradle.kts create mode 100644 kotlin/yacht/gradle/wrapper/gradle-wrapper.properties create mode 100644 kotlin/yacht/gradlew create mode 100644 kotlin/yacht/gradlew.bat create mode 100644 kotlin/yacht/src/main/kotlin/Yacht.kt create mode 100644 kotlin/yacht/src/main/kotlin/YachtCategory.kt create mode 100644 kotlin/yacht/src/test/kotlin/YachtTest.kt diff --git a/kotlin/dominoes/.exercism/metadata.json b/kotlin/dominoes/.exercism/metadata.json new file mode 100644 index 0000000..7b85f75 --- /dev/null +++ b/kotlin/dominoes/.exercism/metadata.json @@ -0,0 +1 @@ +{"track":"kotlin","exercise":"dominoes","id":"54f263f9c337493685adef4809bba4f6","url":"https://exercism.io/my/solutions/54f263f9c337493685adef4809bba4f6","handle":"anthonycicc","is_requester":true,"auto_approve":false} \ No newline at end of file diff --git a/kotlin/dominoes/.gradle/6.0.1/executionHistory/executionHistory.bin b/kotlin/dominoes/.gradle/6.0.1/executionHistory/executionHistory.bin new file mode 100644 index 0000000000000000000000000000000000000000..2a37d5070af14e99176ee1f8220478072ebb3730 GIT binary patch literal 71473 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 UfE<8Q-B`U>A76zDu>b%7 literal 0 HcmV?d00001 diff --git a/kotlin/dominoes/.gradle/6.0.1/executionHistory/executionHistory.lock b/kotlin/dominoes/.gradle/6.0.1/executionHistory/executionHistory.lock new file mode 100644 index 0000000000000000000000000000000000000000..0ab975921ec66a01e8f7e5938e5c7331d89662b0 GIT binary patch literal 17 TcmZRsPS>>JcG*+T00AxlB4`5- literal 0 HcmV?d00001 diff --git a/kotlin/dominoes/.gradle/6.0.1/fileChanges/last-build.bin b/kotlin/dominoes/.gradle/6.0.1/fileChanges/last-build.bin new file mode 100644 index 0000000000000000000000000000000000000000..f76dd238ade08917e6712764a16a22005a50573d GIT binary patch literal 1 IcmZPo000310RR91 literal 0 HcmV?d00001 diff --git a/kotlin/dominoes/.gradle/6.0.1/fileContent/fileContent.lock b/kotlin/dominoes/.gradle/6.0.1/fileContent/fileContent.lock new file mode 100644 index 0000000000000000000000000000000000000000..de91596efca28a86d1f0e9d71c079a76ea488e4a GIT binary patch literal 17 TcmZRMkKek`kU%Zeo#sT#-YUmkJk`hCJ0+Ue$k4DxQCGN>a^H{nPvAJF;@~^A0f65y>6U^xK|tDzgS$| zSLi)GhxshwzjMNkM@@X?m@5eX`{||!Uw0)OK-^QG@c9n|MxH2(8xePRA$(P)D6n2y zJcXaLjd07>Sks=8ia0#JpKu#lzfjufCqrC3MYxM!qv&?x>P5_(33rRtTktdD24ikZ zxX(x8^!0C^{1rd{GU2`j{NA~!cs}Buk%aG?+SGCHE8Y)y{1L+a4_{Pm8I3PN+-ww3U?s7aAmnm#bq+wek}^-PG2dJ|nQRy}6dhn~8E zezRVno6sCmothSomHVgG^+pO)T2P`JzmsktVkZRQzH=L&?n)5zcNJ88E^Wt&-%t&s zE9`_=@=#KjGJM1=LKJfAS?RoP!rGdhaF#2i$0F)9UK5url4n(0abgtJ;Fz%!*%ime zZv;x4sfJO)u#KHC z%e#K2c}-E7Ij+PRV{qhl)_lYV|I;^^Z7GXeXk{FFU3bHB3h&W zeI3aSdTAc6fezEIf??>p5dzUt}rL=_6PE#rSil)x5ZTLti}dqIH5;f841ZCzuJb^Q{1G`_?Fqt z=ISQ69qdHR{<-;fC-rvW&Y$h=-gBnrP5){Ksaka7`A{9BhIQ_kxiayO&A}D2D8~@P zP;H`3R7a1e&JEFrhZu>zFm;4nlQG<=Umo3M!ds=AFgVOkEET%#U48D+`K5pjH>45{Rng__%yh2fMrFynxW+YVB-Jd_sE#qKKjXqIHCyvywqI(mwfbqv oUAKnOE9`_r&*Ev<&i?6doiDs75N@H)$Y@HQ)=xVTpaw_gK!fO$&!TRPcEy}ZV@T82MHxoI4X(*#bI-i zB7Z_TaN2|9YF!bngv6|QKhj2H1BhrN~Ihr?|P{3k^Vhph5!NxAbeuL)Zl}C$Gq*y zlm7=}4ZYqqwHsYyjOs4wlUofJ1vwLKx<5)^u+>B+_p)wv4@y4{zU|L1wj`U~c4vEF5qxgo$B@F(mPjgc8-dA{Ca(f^uFx5ZOd$^Rrd_({b%tT z`;n(i{hqM&0o7i%G<#dB`+@Y~j*;`_1b>e1L(=7{lx5w##~A?x5I_I{1Q0*~0R#|0 z009ILKmY**5I_I{1Q0*~0R#|0009ILKmY**5I_I{1Q0*~0R#|000C2=(74!)!xBBB YC;N|Lgg;(lzxg*Mc3-hi#jg1*9~+ + + + + + \ No newline at end of file diff --git a/kotlin/dominoes/.idea/jarRepositories.xml b/kotlin/dominoes/.idea/jarRepositories.xml new file mode 100644 index 0000000..efa4625 --- /dev/null +++ b/kotlin/dominoes/.idea/jarRepositories.xml @@ -0,0 +1,20 @@ + + + + + + + + + + + \ No newline at end of file diff --git a/kotlin/dominoes/.idea/misc.xml b/kotlin/dominoes/.idea/misc.xml new file mode 100644 index 0000000..b9d0e72 --- /dev/null +++ b/kotlin/dominoes/.idea/misc.xml @@ -0,0 +1,8 @@ + + + + + + + + \ No newline at end of file diff --git a/kotlin/dominoes/.idea/vcs.xml b/kotlin/dominoes/.idea/vcs.xml new file mode 100644 index 0000000..b2bdec2 --- /dev/null +++ b/kotlin/dominoes/.idea/vcs.xml @@ -0,0 +1,6 @@ + + + + + + \ No newline at end of file diff --git a/kotlin/dominoes/README.md b/kotlin/dominoes/README.md new file mode 100644 index 0000000..697142a --- /dev/null +++ b/kotlin/dominoes/README.md @@ -0,0 +1,42 @@ +# Dominoes + +Make a chain of dominoes. + +Compute a way to order a given set of dominoes in such a way that they form a +correct domino chain (the dots on one half of a stone match the dots on the +neighbouring half of an adjacent stone) and that dots on the halves of the +stones which don't have a neighbour (the first and last stone) match each other. + +For example given the stones `[2|1]`, `[2|3]` and `[1|3]` you should compute something +like `[1|2] [2|3] [3|1]` or `[3|2] [2|1] [1|3]` or `[1|3] [3|2] [2|1]` etc, where the first and last numbers are the same. + +For stones `[1|2]`, `[4|1]` and `[2|3]` the resulting chain is not valid: `[4|1] [1|2] [2|3]`'s first and last numbers are not the same. 4 != 3 + +Some test cases may use duplicate stones in a chain solution, assume that multiple Domino sets are being used. + +## Setup + +Go through the setup instructions for Kotlin to install the necessary +dependencies: + +[https://exercism.io/tracks/kotlin/installation](https://exercism.io/tracks/kotlin/installation) + +## Making the test suite pass + +Execute the tests with: + +```bash +$ ./gradlew test +``` + +> Use `gradlew.bat` if you're on Windows + +In the test suites all tests but the first have been skipped. + +Once you get a test passing, you can enable the next one by removing the +`@Ignore` annotation. + +## Submitting Incomplete Solutions + +It's possible to submit an incomplete solution so you can see how others have +completed the exercise. diff --git a/kotlin/dominoes/build.gradle.kts b/kotlin/dominoes/build.gradle.kts new file mode 100644 index 0000000..1793ac4 --- /dev/null +++ b/kotlin/dominoes/build.gradle.kts @@ -0,0 +1,23 @@ +import org.gradle.api.tasks.testing.logging.TestExceptionFormat + +plugins { + kotlin("jvm") version "1.3.60" +} + +repositories { + jcenter() +} + +dependencies { + compile(kotlin("stdlib")) + + testImplementation("junit:junit:4.12") + testImplementation(kotlin("test-junit")) +} + +tasks.withType { + testLogging { + exceptionFormat = TestExceptionFormat.FULL + events("passed", "failed", "skipped") + } +} diff --git a/kotlin/dominoes/gradle/wrapper/gradle-wrapper.properties b/kotlin/dominoes/gradle/wrapper/gradle-wrapper.properties new file mode 100644 index 0000000..9492014 --- /dev/null +++ b/kotlin/dominoes/gradle/wrapper/gradle-wrapper.properties @@ -0,0 +1,5 @@ +distributionBase=GRADLE_USER_HOME +distributionPath=wrapper/dists +distributionUrl=https\://services.gradle.org/distributions/gradle-6.0.1-bin.zip +zipStoreBase=GRADLE_USER_HOME +zipStorePath=wrapper/dists diff --git a/kotlin/dominoes/gradlew b/kotlin/dominoes/gradlew new file mode 100644 index 0000000..83f2acf --- /dev/null +++ b/kotlin/dominoes/gradlew @@ -0,0 +1,188 @@ +#!/usr/bin/env sh + +# +# Copyright 2015 the original author or authors. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# https://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# + +############################################################################## +## +## Gradle start up script for UN*X +## +############################################################################## + +# Attempt to set APP_HOME +# Resolve links: $0 may be a link +PRG="$0" +# Need this for relative symlinks. +while [ -h "$PRG" ] ; do + ls=`ls -ld "$PRG"` + link=`expr "$ls" : '.*-> \(.*\)$'` + if expr "$link" : '/.*' > /dev/null; then + PRG="$link" + else + PRG=`dirname "$PRG"`"/$link" + fi +done +SAVED="`pwd`" +cd "`dirname \"$PRG\"`/" >/dev/null +APP_HOME="`pwd -P`" +cd "$SAVED" >/dev/null + +APP_NAME="Gradle" +APP_BASE_NAME=`basename "$0"` + +# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script. +DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"' + +# Use the maximum available, or set MAX_FD != -1 to use that value. +MAX_FD="maximum" + +warn () { + echo "$*" +} + +die () { + echo + echo "$*" + echo + exit 1 +} + +# OS specific support (must be 'true' or 'false'). +cygwin=false +msys=false +darwin=false +nonstop=false +case "`uname`" in + CYGWIN* ) + cygwin=true + ;; + Darwin* ) + darwin=true + ;; + MINGW* ) + msys=true + ;; + NONSTOP* ) + nonstop=true + ;; +esac + +CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar + +# Determine the Java command to use to start the JVM. +if [ -n "$JAVA_HOME" ] ; then + if [ -x "$JAVA_HOME/jre/sh/java" ] ; then + # IBM's JDK on AIX uses strange locations for the executables + JAVACMD="$JAVA_HOME/jre/sh/java" + else + JAVACMD="$JAVA_HOME/bin/java" + fi + if [ ! -x "$JAVACMD" ] ; then + die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME + +Please set the JAVA_HOME variable in your environment to match the +location of your Java installation." + fi +else + JAVACMD="java" + which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. + +Please set the JAVA_HOME variable in your environment to match the +location of your Java installation." +fi + +# Increase the maximum file descriptors if we can. +if [ "$cygwin" = "false" -a "$darwin" = "false" -a "$nonstop" = "false" ] ; then + MAX_FD_LIMIT=`ulimit -H -n` + if [ $? -eq 0 ] ; then + if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then + MAX_FD="$MAX_FD_LIMIT" + fi + ulimit -n $MAX_FD + if [ $? -ne 0 ] ; then + warn "Could not set maximum file descriptor limit: $MAX_FD" + fi + else + warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT" + fi +fi + +# For Darwin, add options to specify how the application appears in the dock +if $darwin; then + GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\"" +fi + +# For Cygwin or MSYS, switch paths to Windows format before running java +if [ "$cygwin" = "true" -o "$msys" = "true" ] ; then + APP_HOME=`cygpath --path --mixed "$APP_HOME"` + CLASSPATH=`cygpath --path --mixed "$CLASSPATH"` + JAVACMD=`cygpath --unix "$JAVACMD"` + + # We build the pattern for arguments to be converted via cygpath + ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null` + SEP="" + for dir in $ROOTDIRSRAW ; do + ROOTDIRS="$ROOTDIRS$SEP$dir" + SEP="|" + done + OURCYGPATTERN="(^($ROOTDIRS))" + # Add a user-defined pattern to the cygpath arguments + if [ "$GRADLE_CYGPATTERN" != "" ] ; then + OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)" + fi + # Now convert the arguments - kludge to limit ourselves to /bin/sh + i=0 + for arg in "$@" ; do + CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -` + CHECK2=`echo "$arg"|egrep -c "^-"` ### Determine if an option + + if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then ### Added a condition + eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"` + else + eval `echo args$i`="\"$arg\"" + fi + i=$((i+1)) + done + case $i in + (0) set -- ;; + (1) set -- "$args0" ;; + (2) set -- "$args0" "$args1" ;; + (3) set -- "$args0" "$args1" "$args2" ;; + (4) set -- "$args0" "$args1" "$args2" "$args3" ;; + (5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;; + (6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;; + (7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;; + (8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;; + (9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;; + esac +fi + +# Escape application args +save () { + for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done + echo " " +} +APP_ARGS=$(save "$@") + +# Collect all arguments for the java command, following the shell quoting and substitution rules +eval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS "\"-Dorg.gradle.appname=$APP_BASE_NAME\"" -classpath "\"$CLASSPATH\"" org.gradle.wrapper.GradleWrapperMain "$APP_ARGS" + +# by default we should be in the correct project dir, but when run from Finder on Mac, the cwd is wrong +if [ "$(uname)" = "Darwin" ] && [ "$HOME" = "$PWD" ]; then + cd "$(dirname "$0")" +fi + +exec "$JAVACMD" "$@" diff --git a/kotlin/dominoes/gradlew.bat b/kotlin/dominoes/gradlew.bat new file mode 100644 index 0000000..9618d8d --- /dev/null +++ b/kotlin/dominoes/gradlew.bat @@ -0,0 +1,100 @@ +@rem +@rem Copyright 2015 the original author or authors. +@rem +@rem Licensed under the Apache License, Version 2.0 (the "License"); +@rem you may not use this file except in compliance with the License. +@rem You may obtain a copy of the License at +@rem +@rem https://www.apache.org/licenses/LICENSE-2.0 +@rem +@rem Unless required by applicable law or agreed to in writing, software +@rem distributed under the License is distributed on an "AS IS" BASIS, +@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +@rem See the License for the specific language governing permissions and +@rem limitations under the License. +@rem + +@if "%DEBUG%" == "" @echo off +@rem ########################################################################## +@rem +@rem Gradle startup script for Windows +@rem +@rem ########################################################################## + +@rem Set local scope for the variables with windows NT shell +if "%OS%"=="Windows_NT" setlocal + +set DIRNAME=%~dp0 +if "%DIRNAME%" == "" set DIRNAME=. +set APP_BASE_NAME=%~n0 +set APP_HOME=%DIRNAME% + +@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script. +set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m" + +@rem Find java.exe +if defined JAVA_HOME goto findJavaFromJavaHome + +set JAVA_EXE=java.exe +%JAVA_EXE% -version >NUL 2>&1 +if "%ERRORLEVEL%" == "0" goto init + +echo. +echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. +echo. +echo Please set the JAVA_HOME variable in your environment to match the +echo location of your Java installation. + +goto fail + +:findJavaFromJavaHome +set JAVA_HOME=%JAVA_HOME:"=% +set JAVA_EXE=%JAVA_HOME%/bin/java.exe + +if exist "%JAVA_EXE%" goto init + +echo. +echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME% +echo. +echo Please set the JAVA_HOME variable in your environment to match the +echo location of your Java installation. + +goto fail + +:init +@rem Get command-line arguments, handling Windows variants + +if not "%OS%" == "Windows_NT" goto win9xME_args + +:win9xME_args +@rem Slurp the command line arguments. +set CMD_LINE_ARGS= +set _SKIP=2 + +:win9xME_args_slurp +if "x%~1" == "x" goto execute + +set CMD_LINE_ARGS=%* + +:execute +@rem Setup the command line + +set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar + +@rem Execute Gradle +"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %CMD_LINE_ARGS% + +:end +@rem End local scope for the variables with windows NT shell +if "%ERRORLEVEL%"=="0" goto mainEnd + +:fail +rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of +rem the _cmd.exe /c_ return code! +if not "" == "%GRADLE_EXIT_CONSOLE%" exit 1 +exit /b 1 + +:mainEnd +if "%OS%"=="Windows_NT" endlocal + +:omega diff --git a/kotlin/dominoes/src/main/kotlin/Dominoes.kt b/kotlin/dominoes/src/main/kotlin/Dominoes.kt new file mode 100644 index 0000000..6046bf0 --- /dev/null +++ b/kotlin/dominoes/src/main/kotlin/Dominoes.kt @@ -0,0 +1,44 @@ +class ChainNotFoundException(msg: String = "Doesn't matter") : RuntimeException(msg) + +data class Domino(val left: Int, val right: Int) { + fun reversed() = Domino(right, left) + fun contains(dots: Int): Boolean = left == dots || right == dots +} + +object Dominoes { + fun formChain(vararg domino: Domino): List = formChain(domino.toList()) + + fun formChain(inputDominoes: List): List { + if (inputDominoes.isEmpty()) return emptyList() + inputDominoes.forEachIndexed { index, domino -> + val remaining = inputDominoes.filterIndexed { i, _ -> i != index } + val chain = chainFrom(listOf(domino), remaining) ?: chainFrom(listOf(domino.reversed()), remaining) + return chain ?: throw ChainNotFoundException() + } + throw ChainNotFoundException() + } + + private fun chainFrom(chain: List, remaining: List): List? { + if (remaining.isEmpty() && chain.first().left == chain.last().right) { + return chain + } else { + val tail = chain.last().right + remaining.forEachIndexed { index, domino -> + if (domino.contains(tail)) { + val d = if (domino.left == tail) { + domino + } else { + domino.reversed() + } + val rest = remaining.filterIndexed { i, _ -> i != index } + val result = chainFrom(chain + d, rest) + if (result != null) { + return result + } + } + } + } + return null + } + +} diff --git a/kotlin/dominoes/src/test/kotlin/DominoesTest.kt b/kotlin/dominoes/src/test/kotlin/DominoesTest.kt new file mode 100644 index 0000000..97b6fc7 --- /dev/null +++ b/kotlin/dominoes/src/test/kotlin/DominoesTest.kt @@ -0,0 +1,138 @@ +import org.junit.Rule +import org.junit.rules.ExpectedException +import kotlin.test.Test +import kotlin.test.assertEquals + +class DominoesTest { + + @Test + fun `empty input = empty output`() = Dominoes.formChain().should { haveSize(0) } + + @Test + fun `singleton input = singleton output`() { + val input = listOf(Domino(1, 1)) + Dominoes.formChain(input).should { beValidDominoes(input) } + } + + @Test(ChainNotFoundException::class) + fun `singleton can't be chained`() { + Dominoes.formChain(Domino(1, 2)) + } + + @Test + fun `three elements`() { + val input = listOf(Domino(1, 2), Domino(3, 1), Domino(2, 3)) + Dominoes.formChain(input).should { beValidDominoes(input) } + } + + @Test + fun `can reverse dominoes`() { + val input = listOf(Domino(1, 2), Domino(1, 3), Domino(2, 3)) + Dominoes.formChain(input).should { beValidDominoes(input) } + } + + @Test(expected = ChainNotFoundException::class) + fun `can't be chained`() { + Dominoes.formChain(Domino(1, 2), Domino(4, 1), Domino(2, 3)) + } + + @Test(expected = ChainNotFoundException::class) + fun `disconnected - simple`() { + Dominoes.formChain(Domino(1, 1), Domino(2, 2)) + } + + @Test(expected = ChainNotFoundException::class) + fun `disconnected - double loop`() { + Dominoes.formChain(Domino(1, 2), Domino(2, 1), Domino(3, 4), Domino(4, 3)) + } + + @Test(expected = ChainNotFoundException::class) + fun `disconnected - single isolated`() { + Dominoes.formChain(Domino(1, 2), Domino(2, 3), Domino(3, 1), Domino(4, 4)) + } + + @Test + fun `need backtrack`() { + val input = listOf( + Domino(1, 2), + Domino(2, 3), + Domino(3, 1), + Domino(2, 4), + Domino(4, 2)) + Dominoes.formChain(input).should { beValidDominoes(input) } + } + + @Test + fun `separate loops`() { + val input = listOf( + Domino(1, 2), + Domino(2, 3), + Domino(3, 1), + Domino(1, 1), + Domino(2, 2), + Domino(3, 3)) + Dominoes.formChain(input).should { beValidDominoes(input) } + } + + @Test + fun `nine elements`() { + val input = listOf( + Domino(1, 2), + Domino(5, 3), + Domino(3, 1), + Domino(1, 2), + Domino(2, 4), + Domino(1, 6), + Domino(2, 3), + Domino(3, 4), + Domino(5, 6)) + Dominoes.formChain(input).should { beValidDominoes(input) } + } + + private fun List.should(what: DominoListAsserter.() -> Unit) = what(DominoListAsserter(this)) + + private class DominoListAsserter(private val outputDominoes: List) { + + fun haveSize(n: Int) = assertEquals(n, outputDominoes.size) + + fun beValidDominoes(inputDominoes: List) { + haveSameDominoesAs(inputDominoes) + haveMatchingEnds() + haveConsecutiveDominoes() + } + + private fun haveSameDominoesAs(inputDominoes: List) { + val errorMessage = "The number of dominoes in the input list (${inputDominoes.size}) needs to match the number of dominoes in the output chain (${outputDominoes.size})" + assertEquals(inputDominoes.size, outputDominoes.size, errorMessage) + inputDominoes.forEach { domino -> + val inputFrequency: Int = dominoFrequency(inputDominoes, domino) + val outputFrequency: Int = dominoFrequency(outputDominoes, domino) + val frequencyErrorMessage = "The frequency of domino (${domino.left}, ${domino.right}) in the input is ($inputFrequency), but ($outputFrequency) in the output." + assertEquals(inputFrequency, outputFrequency, frequencyErrorMessage) + } + } + + private fun haveMatchingEnds() { + val leftValueOfFirstDomino = outputDominoes.first().left + val rightValueOfLastDomino = outputDominoes.last().right + val errorMessage = "The left value of the first domino ($leftValueOfFirstDomino) needs to match the right value of the last domino ($rightValueOfLastDomino)." + assertEquals(leftValueOfFirstDomino, rightValueOfLastDomino, errorMessage) + } + + private fun haveConsecutiveDominoes() { + (0 until outputDominoes.size - 1).forEach { i -> + val rightValueOfIthDomino = outputDominoes[i].right + val leftValueOfNextDomino = outputDominoes[i + 1].left + val errorMessage = "The right value of domino number $i ($rightValueOfIthDomino) needs to match the left value of domino number ${i + 1} ($leftValueOfNextDomino)." + assertEquals(outputDominoes[i].right, outputDominoes[i + 1].left, errorMessage) + } + } + + private fun dominoFrequency(list: List, d: Domino) = + list.count { + (it.left == d.left && it.right == d.right) || (it.left == d.right && it.right == d.left) + } + + } + +} diff --git a/kotlin/kindergarten-garden/.exercism/metadata.json b/kotlin/kindergarten-garden/.exercism/metadata.json new file mode 100644 index 0000000..75a37e0 --- /dev/null +++ b/kotlin/kindergarten-garden/.exercism/metadata.json @@ -0,0 +1 @@ +{"track":"kotlin","exercise":"kindergarten-garden","id":"8968cc6a00f84cf883cb56be6827b8cf","url":"https://exercism.io/my/solutions/8968cc6a00f84cf883cb56be6827b8cf","handle":"anthonycicc","is_requester":true,"auto_approve":false} \ No newline at end of file diff --git a/kotlin/kindergarten-garden/.gradle/6.0.1/executionHistory/executionHistory.bin b/kotlin/kindergarten-garden/.gradle/6.0.1/executionHistory/executionHistory.bin new file mode 100644 index 0000000000000000000000000000000000000000..65e399c054fc6818d8abfb20432f95e0e91ba9de GIT binary patch literal 72879 zcmeHQ349bq)=$r%%O{A9tc$y=D=HqiWSE|N#0zq0P)N*y*9i7eJ?Ui9Gjw-Ig4Ze{ zH{pmNpvD6f#rr~BR9sh(MZA7^;DLC6tO|G`?kf7d>SLJ6OgNI6$hgIiWHQ~=Rj>Z_ z>g@M_uP`s~X!;lPU!L)gGCr2?$jf8A@b~fNb@D+FAP5iy2m%BFf&f8)AV3fx2oMAa z0t5kq06~BtKoB4Z5CjMU1Ob9Tjw4V7@*if@;pl-j{KpXud3nyB@P~cgU$*`v&EI*o zar>%u*877~t14UHV7EPBTt9D!b-k=?L8Ql&Po6QZf6?E%ZhgY_ON@KuH$i|PKoB4Z z5CjMU1Ob8oL4Y7Y5FiK;1PB5I0fGQQfFM8+AP5iy2m%BFf&f8)AV3fx2oMAa0t5kq z06~BtKoB4Z5CjMU1Ob8oL4Y7Y5FiK;1PB7zK){`s=NS(_SK^(>gRbulS| zMi(MJs<0Xo=;qUA58M{M?XtPI|8-{Lpr&i7OlH>OE+{5iuSqgeD>S9QA=qd`u+gzd zeOQw1lM0K9hg4lqd6OtbG^8M5h!U=^L$an0XJfrCwa;Y*LDHnC%tnT>W7*+Rp+16C z`vkc@60x_ik;p}?B1>{u9ikQ~N>owpH;QaTMfN#xFWO*Kyo}{**)U4JH6mIOtyg$d z43I#Eno^ITH2hFGQtKmHInwGCxw0u1e{L!plSU#%1!+tHnpssv3KmZV$&h_w1ch0? z$$k@GjriKKYF0%BQQ4?KT(X7w%?eH8Yn$3hGJ}uS)kS4PK&!UX;3956jDuB`J9sD> zMCY}rQUJn_h$?k#L>k9pnRJm1q-G{I1vI^Vl7K`OYH6P*AU?u^I^ar_)@!kPt&G*G z%?jQoNGi)kP@$2!f>)#%G-$ZYXgw3_8D=WIHkP<^&5IQpD+{b57|&XQ&k*YCVug}| zu;fh^ocLm?9BC>ZGlH!{=GDpgY8g^Q^ZRrpitt!Pld7RQE5GTeF@_WgYYrPR6HY;m zn!=ukA~7q~WKlr~G)%RRzwC1RgzAJ_&63PV>IGC@FKdvE^~79Bu7-TI;eeF{I*Q6z zMTO-7)TlR} zP^?7j3PD{!Ma}9?mr+BBEW*$t^YK=lB}Z{@84~ZkR&F!k25z7syjBl-WJcp6Vg!1FIetG3`Kyl)dgo+cSgeC0!?RKpWF6&Vs`V|-b~8!rdTx6R2NlZ)e>JJg=H2- z+c+FEVoFr+Y`XLoZZqL(SV5`^VCZ9;3HN-s4xPUQA>{XZ@GQqFk_y9__22>pu|gq& zp<2R&BNAXxhLM5a(~)N@C>B*TWBfB_1T*ug#vOh9F)y{KtPFF~I6M}>cvB4-$BUY% z>O*9_WaBH$DA5SCV39mlQlc^*rA*9c8VM>th%-9dQl!2E8<-6ytHJA*$34k>#jnOf6=`ZpF{wHXJTNJIdjq^)T*hVC87`DY1bxufo4Opd0}mKx z^G=8Rc-pVT6Q6Z)60{x{g>{9QXomT{%+OGy)o>zxbzmf#22+ZHj46pq9m?}=-!tN+ zUmT?y23u5p)nZ^S87*iZ&$#Cr*Yye&HNvoo1yOt2?c-}C>8bB2NekI&=be2mBI1VP*!kHi2kx}0Lr6M*G~#~a{0E~k+E zbiVPlqlQ)N^z#2cS$)Fn>junTJ7CFq+5^S5FS8_J6z%8b1UwwpTkVe~8`F z-$RVs0WdQ`(J6?C3A#kigPcA$@(V1_3NTcQ0gel@E}!4U1{0sm$4?p%7q6`DmGA2L z>D$6E@xiliUS>PkwSuO8JoQax@U7c=?~slg>fZ2uPU!^w^(TXRz5B*7PaHEPeA|aR z4t?lg(+FC*f565qQ~B5X(%&r@dSjpNiw(UtHcAypOFIVTJp`#>UxVj;V`PgDIBC;& z|Dm%T!Q6yfeGnIq2h@C2$00$$^NQ7--3-HXBFFH~AkU%zg09T+LBWYc0WmJtA7t2| z$hbXw$ttN+&!R`KdP!jiogMDIy7Y-tF1KyUa9v;*g4dgt{9d2HGXm@60{)=e#Uf`Q z=wTSIn-4O6PGEvTj~}jayd}T+c#_O#+`GE|uz@G8|Ni<57yVb4MY-E9*oJ$hs>n^{zwc+%S z)_i;OtckICS5B~fm*E-+EP@k^G#Zb5$j38o(dqKK*?`L(3?Qcvbh_YrAn5n_-A^%87+vZN!!`i(&1Qb(4ni3t0JT=e+PKV3M z1Q-{?gj|e|cOk~ZIsH!2?e=*5LBQS_4ER|%oA5Zj9$xVJ+@kd~h`i@%V``iIc+uFK z&gAZVpmphG;}8F3GFd$&t^u;MddS^@o%U{Nc}ckGnU6<2bIBJ^-g^AI2mP>4hoePD zoVI=UdsNG7?xxY_G#uoEddkWz$A)zJ*o*rQ-Pr4@_2XW=Z_=7eKf5O<2Xy*ByZRSg z*z=5%@pIl8ytvP4U+2bfPDihfmK{CyqDQ3XuDS6)?>v4IS@y>deljqWr!4zt8gGx{ z%lQ9$*`DFU0_#Nw-hH>Xb`J_}-o-gxEbrlYjt_D{PV|am5EeJ0%NKNc5f94%XV6;7 z7|Ss@{79E+(yC_Oo#p-hd&#B;n|Cbo_IcAc)AnZe>nFhpWSZp~4<|w#?+@}po`XF~ z(8ah}s1_{vg93*FZWca7Z+v~9rjBhgPO9jiecI~sW2%1I{%Mbsudh1Hk@;0nydmKY zhqaEzCp<2{n{l~4Tp-{QJRYyt!}_?OAOtwK&%-*|fH%m*H(h%w1(_ttf0yT}KB4Zy zFL&QsJ$}r1uWb9K)5}lexGJsAz=GPU0zz&d&pJiF$IbgVub<~Y-@F`by@GI%h1{&m z$+^5-puK#OYH{Y1Bf{O!SU|PDcjfwT`Qex4;0EmL4B_5r0@et9)OvZ1|HK=1e8T7s zxPu}q`dnVo!vy_slm#zm5a)v}Fzj2L48y{3zg;sNM*X)n*U`Tlc2GtUqYKY!u3Udg?5TIlR+b()af&bF3&d>BbM%OB>c85$`2p<_Zq&~|%%6K-4$gA) zsFs!mo11JW4j$s#aXLLv%eDPz?#*yC_tn<}X44H6E&fwytkg02lt^)ag170JTh+y)hr+t zY$kNO3NWGTv92RE<-qVl2A(O|RA%%0Hlxy|X_5Y55+-Z?3nFk(uQ>D? z+3Cm63JzFSv+LoN_m&^O^|b0|s9!^jZ@Q@J=PF<{Vb$CLaCS1Zh^)FTTaL zLVEe+f(wLqKKkDNQDK)=JyDD=yGGruI$v<~rCUE+PxpQ3o6Xm}#(AEgy0rZ5S+8t` z2Ik0eyoujG^Qgd=7v6BnQ5#>j-Mj6TiBuO$ko{pq1KU--%KaIujT=fF<#%7Uxa7sT z1OI*G{K{Y#3}z`(Y{_;@Ta|tE-9rXc&fRcb`Q}Zr=7p#IKy^{cZ)LWE!;3114s{6lu+O}DHx4S7Zz#)fwKoT+ozzll$+J%9V1eXid1&}r1KCQF7_Y4qtYHa@|6 zUN~mg3(TO>9ba~bnB|^Hz(qRqkMPqQ|Ll{Cl;_MOeTZ<82p5TPkq8%waFGZXiExp0 zPAlOeS)4(_MIu}zWOB%}&qX@2s}6PcafW$!>M3)Y!_Vw*)Qtnzy`MTRZdcZX=ei2l z!~;4zopMgtKCX!mc9pP+M{0ID!NcaJDqYuH9r+aqk(_5bCEP>G)t`$sX?^~uk%c| z0?8*lTQX!uX1-9%2S&G+UsDfsam#RzK|w#59*Qp3?E@1%&L?_ZK`-m_^M1rQogNXm zF^uSsb9naTkYut~*rWGnKYzT#R`t}TFU}d>`kL+CEJ$w2%rRi^DRN#9I1LdQ!7q5d zNbm>!JmS5A)9(RmI39?oOj4~Asj|YQA1!LywqxDnKUZ;8-ZyvWpn>6!Z4VvygN|%8 zyz$%PU|b6?>joZ|Q}6{uVDlo@8$f(WechK;Z5oe=x{^ont`6TwY+#!+%g+ zH{kJpQE&-v0eLu< z4RAgmVgfAZ@*qDG^oefZbNQ31VVF-QiOwy*V#mPOM-8d@H~r1PZw3t|mYdlpZ@tz* z?Wkt!zzc(_g{(g;b6$7I<6>Q2fp@!@pvMJ7bp)fC&*}8R_{->4yc}5cI$3A(qq-*O z9snL|ny{p1(Zf5BKjoiWFJIKK$<}ji+fibFOjnXkF|d~g-I9fV^zl_qn>OC!Zaw+u zb!!Jtdo#0k87U|JFLhjYz*qN50bUuvf+R)o9GO*V_p4vNePQjNK7PIKAJlik2abby zPNfgqQ2X~4*F~QB-5)*|@4Kq7XRetu{+jbCz4`m`C4YOX$B478o%qHT?~R5<^q)LNNm-R^pNw3OOMW~Th`s_<{shMP7{|NZM`sO z|HV-5Z`6rP4;<8G|2=sh6f+%h>9Kcr>xqq&;C?8Bj;n}E4|6}-bxx~@OOIrw&+zP) z;^;8P=C+g*i%z@rz;;RIj+wH3&=Cs->=+~=moyF}DxnPBt;hUB226Zs(9j_(ieKG4 z==PRtsRgO#jb`GGyY@(sgN>w%U8Bi08XJo>ddz5z-J0|6$7eWUMGwvh@dV8Pjko}C4C|$$myyd9-F_xK4n3W%!@+otOuI0hMn2UxA>D z4l`67j-XVCA2y##5b}e2hIhYx#`@Mpn|}E7&MiOxbW>vP4kY7n7lLhe(p4Nbs#{)O zpXn`0mm%5@`0$~Ub5QFc{*NqB^TGNUhb%0phPZb;h*u=@Q9W?e^ail&jy9(l^}VQjDDeEyaKw&3jWv7L`|&l#Uq9xF>;QTO1d$$Fw@O@jS%FDj>XB z-n2SNj(?dHwe;oTHd!Wvr<*Q2hE;*hyQwR5Td)?GSvgE33Lx@XII2hpK#JcptDAUl zk`apyRCe`#wxp@O7|2S9gj%jgc~ke&j<=XaSbA$d;i%T?BE9ooZCk978u#3|D&ca@ zMKaPOtX9A+h@NT1xioUyOYuwgQoI9v9YK(|COtyp5+kdAVXLHmTvI>X5dBU$9joyv z{Z7Rq4_LIf49&ht-LbbsIKCo;%7o1B*;_IQ^a>$%aNM-+OWWv&@fZfFT*tq^5oQmk zol;m*UQ|$7T7Jpx?PRX2)5RG4Rc*nKL!PXF)`*2Q5FRwj+zaOS@1x`--0wHC+Z*nd z!~@!EOe=w7gd!h~g{vcM59BsU=qRSG_^nQ3pO}pvV-KC}u zOeUo~k@`$H(;CG2PPhFH9XPVapiel{CIR=r5KQ4dAM~8*ll+SxTsHI%x2vCh`~1hN zm;6i-&h*{`_2TUd;Y`znGaVwFX?Ss(#04Ro>2SOD&RI36w9~m5F8iQkd)es}&h!zP z;!NXtBZYdL*%xRj?*KBwnNBNsrcg;s$j%%pdiFJv zD>z}2NAXTX_bX$W^LElZ3t^IX!ZQnDl7|e}*!yq2r!Vi5L(*l$D+^(gcdcpCLASO@ zVUpYDaS$a(X(~r5yf#+jZ{fPV(Q&&KU3BNUs4QgKA$up|K&m}CL&m!y z2S{zFcaE7ec=>r3U3pxqbL@}Jt5;FkE%2kv!=6wbha@!G>7}0xZXWZ-#Z#LWO>LNc z?(XZU>=(K*3)M0;%xI>*vh&z0OJBe3jvXTwbHD#(9+l-1v!TlLn$4q5zxhW^N;Wb}+>iyK{trV5f?AB*eHY*qxMP()1ud*R)d)Ab= z7439&zv4gjJK>VQ%~=Ov@PJ;FW*Asx?KBgI85M z-FMce-mMK=PrUrTtEye24!MHLc9HL9yh;hRd5e2eoVs@62P^FNNUtAucn>OzrM;ce zieT@fjk+n3ou1JgDtc<>_Rn`ezjE4!X!HA2wu*W+qgAMZ9+2rAI~1wWSmvaT@Sz$t zWL$OBfa*6t_Q=wc&R9HS@&udf*w$MLsO%N?W=4UIv3xBXMgVtq^6iAdLmJR6X+x%s zX1;mBRQ3VF@PGBIK7skV;c|P?y? z)xNFA;8@ZO)_G_r4)szN^c0oJ+`j0z@}@`@sw}Fg%uh8es01V&jd)>z?)6>t{Dx7d zZkzDlg5^(td>z%5#b;roMs|Proo$+Jal-yA`x`N``_m7H_hP1!+EtCy3z#wW6AirI z%;>N}Pj9?HUH3}sq;4ZFJMOp>n}_8APlCauiRl3;dau`A zU9I`R)iflAf8Flr9P5FQCJ1SQkR}Le0@(>^qFu@pAx#j{1Tf}QlWVOXnNox_5vl@8 zq8b7MA`(Ie?#n-s-E46&(k;)DgV1y?gbg80VEPduO@PznG^g`v;>FqN$Il85SXQ&^ z;g$E6AHVgq>Sw6-V~i!TEwUdWiv*hM+`zMUhDTz&I1*@1Lvn{02}wcYNT4}*#i4{* zrGsc%+!zvQE-D<5Pc;2xM<)ndW`QKo90@c>0?o0CohGCSLYi=~!9-te`Hb7)G(syD zudMEs@9O#K+rlvM!Lx5(W;^H%8wqIw$tFt_-cy)?=J14dk_!6U=*jcDq}Q{Q9;-@2{$4(Yg|?hW6Q@OzmIW=q2F{VE}g zaxcooLASObqzOfcuP)j(k07Lp{q`}l9~fe$MwTfIcDiO)-HIj0OnGPEz}4TDG%kqc zBx&Nh9aT*a?^t}%u;$U*hTmd)g^(t&<4}XjVbZV6b^C9JH1W?Np5Mh5P!}#a?)1M* zx7~d=Ax)&VxvFNH!9Yk8wV17t_9#D%1vb!3LUD>lwwMfdy5Q*rM@%X3uUHb;I{w8= zj^qewq9fJ`Y1)sFCibiX)4*fV8@iM`k6^$)$~DxG?BVY-Y03|x!1~nImh98;D_g5xU@`t>1;xpNJBWtE`yy==J(+T zGgYlkg2A30^lx+b*NHa|DVWhMgSs_t>UE9OGIG_5fk%$J3nEQ0%&)f4V=HYB6{yz|n0lfeK literal 0 HcmV?d00001 diff --git a/kotlin/kindergarten-garden/.gradle/6.0.1/executionHistory/executionHistory.lock b/kotlin/kindergarten-garden/.gradle/6.0.1/executionHistory/executionHistory.lock new file mode 100644 index 0000000000000000000000000000000000000000..be6a7c53df79a720e0d6aa3f4e6bd2d219b1e812 GIT binary patch literal 17 UcmZSn=sk0)U+Jk^3=p6I06YZ*^#A|> literal 0 HcmV?d00001 diff --git a/kotlin/kindergarten-garden/.gradle/6.0.1/fileChanges/last-build.bin b/kotlin/kindergarten-garden/.gradle/6.0.1/fileChanges/last-build.bin new file mode 100644 index 0000000000000000000000000000000000000000..f76dd238ade08917e6712764a16a22005a50573d GIT binary patch literal 1 IcmZPo000310RR91 literal 0 HcmV?d00001 diff --git a/kotlin/kindergarten-garden/.gradle/6.0.1/fileContent/fileContent.lock b/kotlin/kindergarten-garden/.gradle/6.0.1/fileContent/fileContent.lock new file mode 100644 index 0000000000000000000000000000000000000000..c7aff751afebf77bc38e19335e4f5b3d2fe2c71d GIT binary patch literal 17 TcmZP;akw?}!+P$I3{U_7G@%4$ literal 0 HcmV?d00001 diff --git a/kotlin/kindergarten-garden/.gradle/6.0.1/fileHashes/fileHashes.bin b/kotlin/kindergarten-garden/.gradle/6.0.1/fileHashes/fileHashes.bin new file mode 100644 index 0000000000000000000000000000000000000000..2e4c6bcfed82c6540be262b82b2a6695338cb607 GIT binary patch literal 19647 zcmeI3drVVT9Dr{N4WqDuNK+QZ7~2?W?SR!Pu!OwnRwNtl{x8J?r zJ?DN+|LScjMTG?~(t~<1cn>yV3kpC1C;$bZ02F`%Pyh-*0Vn_kpa2wr0#E=7KmjNK z1)u;F_`ej$MHj-w7ZWC8yEcMKDJnh?ZSbp%g+01vV;bI_Sx0_9`1IPE(5D?~wU}ol z6MlSiiGBKrZV$~b5#F?HXjhT*z&e_n2=70p8c9{D66o{$5dKqVy~AX-RbVcc68^Jx zr8-8Imx#GyE8&;ppV}Z14_GkII((nM@q3N1edcTW_&CCEww(#jeQfCn=9vqG|E0;* zuv$6En9Kd|^MggI$0m{TUt3P%TMUPyQfH(xNiFU*8_ z<{;s+F2%*80S8~eJfnp0R14QuR5x^%K7I$`Yj5zjO&3peVy>trJl8*TV^z0aNOLFQ zNq8STLjfoN1)u;FfC5ke3P1rU00p1`6o3Ly017|>C;$bZ02F`%Pyh-*0Vn_k zpa2wr0#E=7KmjNK1)u;FfC5ke3P1rU00p4He^p>Pnpl7yQLaaDHorK{JaoN!+4Jk_ zyBluVDT<}*bk3f}s|$49K_BaBeDz9_z+B)weXdm*H6`4M?m2fE_sX#0D`OgB0YAEa zd|GpN@ZQYsvOC+nj8~aP$3)WKvpoH5^okpEoWAwFUWV&`3|^~JH?XbR3(v{2ULU*a z@VS~w8+*}_X!xS{-bPl~rm0&a!TeLV?R#t*Nr$K5cY$S&OHMT0Z;YcxHBap*19=a+=3Nqc}A*;GmTrKU&*zjIt zWBl9y82V97w5s`_?`gyJ;?=6{y3|m7QC;~?Q)THV=?kc;%Lt|atwFJvMuD@?+VVuj zm`Kz=C*N(<(Z+f_2YWTs_%>PMr!%s0S|VS3@-Vx(nKtsU5irLz_#aD3RiS#O@u%o^LCcQ(bEb$Mvvgwl ncb;=RB4HXmHs#`~Sny<;er|3>~A0|eLs05O&XIsgCw literal 0 HcmV?d00001 diff --git a/kotlin/kindergarten-garden/.gradle/6.0.1/gc.properties b/kotlin/kindergarten-garden/.gradle/6.0.1/gc.properties new file mode 100644 index 0000000..e69de29 diff --git a/kotlin/kindergarten-garden/.gradle/buildOutputCleanup/buildOutputCleanup.lock b/kotlin/kindergarten-garden/.gradle/buildOutputCleanup/buildOutputCleanup.lock new file mode 100644 index 0000000000000000000000000000000000000000..062803bb353a41e16d2f1e4a258ba430770328e3 GIT binary patch literal 17 UcmZSHbguIEBgf0$3=p6O07E?mUjP6A literal 0 HcmV?d00001 diff --git a/kotlin/kindergarten-garden/.gradle/buildOutputCleanup/cache.properties b/kotlin/kindergarten-garden/.gradle/buildOutputCleanup/cache.properties new file mode 100644 index 0000000..0f0afed --- /dev/null +++ b/kotlin/kindergarten-garden/.gradle/buildOutputCleanup/cache.properties @@ -0,0 +1,2 @@ +#Sat Mar 07 16:24:19 EST 2020 +gradle.version=6.0.1 diff --git a/kotlin/kindergarten-garden/.gradle/buildOutputCleanup/outputFiles.bin b/kotlin/kindergarten-garden/.gradle/buildOutputCleanup/outputFiles.bin new file mode 100644 index 0000000000000000000000000000000000000000..8be67409a9c16b6a717cce1736f0f379378170c1 GIT binary patch literal 18803 zcmeI%Pbh<79Ki7x#b)w1_1b|FE$pz`fdir_TgjiLw4@XV*klZSgi`derfKtQ zPm=t9FmClejjR{ko4syP`sA5!e_mhks`(1(yN<5n!sXR0H6N0G9de$Q+B#*vL;6i? zc};Wpaa+w-OSgCv&l83RE>wS(ZnIxzF3$A?R6mfOsz2D@CbsOVk4w*QAFSW;-;Ao> zCB0~QW&Wgl_SWp49O+I^W1C|;cTV*N>F#Hndm;DuUHwi_dhecPY2)c7PxUM50nJ}E z6~3=jeN%d{w&&>1HDkC(mZwB|e_!&N~%ir@~LTY>YdC9?g$`&00IagfB*sr zAb + + + + + \ No newline at end of file diff --git a/kotlin/kindergarten-garden/.idea/jarRepositories.xml b/kotlin/kindergarten-garden/.idea/jarRepositories.xml new file mode 100644 index 0000000..efa4625 --- /dev/null +++ b/kotlin/kindergarten-garden/.idea/jarRepositories.xml @@ -0,0 +1,20 @@ + + + + + + + + + + + \ No newline at end of file diff --git a/kotlin/kindergarten-garden/.idea/misc.xml b/kotlin/kindergarten-garden/.idea/misc.xml new file mode 100644 index 0000000..b9d0e72 --- /dev/null +++ b/kotlin/kindergarten-garden/.idea/misc.xml @@ -0,0 +1,8 @@ + + + + + + + + \ No newline at end of file diff --git a/kotlin/kindergarten-garden/.idea/vcs.xml b/kotlin/kindergarten-garden/.idea/vcs.xml new file mode 100644 index 0000000..b2bdec2 --- /dev/null +++ b/kotlin/kindergarten-garden/.idea/vcs.xml @@ -0,0 +1,6 @@ + + + + + + \ No newline at end of file diff --git a/kotlin/kindergarten-garden/README.md b/kotlin/kindergarten-garden/README.md new file mode 100644 index 0000000..33b79a5 --- /dev/null +++ b/kotlin/kindergarten-garden/README.md @@ -0,0 +1,78 @@ +# Kindergarten Garden + +Given a diagram, determine which plants each child in the kindergarten class is +responsible for. + +The kindergarten class is learning about growing plants. The teacher +thought it would be a good idea to give them actual seeds, plant them in +actual dirt, and grow actual plants. + +They've chosen to grow grass, clover, radishes, and violets. + +To this end, the children have put little cups along the window sills, and +planted one type of plant in each cup, choosing randomly from the available +types of seeds. + +```text +[window][window][window] +........................ # each dot represents a cup +........................ +``` + +There are 12 children in the class: + +- Alice, Bob, Charlie, David, +- Eve, Fred, Ginny, Harriet, +- Ileana, Joseph, Kincaid, and Larry. + +Each child gets 4 cups, two on each row. Their teacher assigns cups to +the children alphabetically by their names. + +The following diagram represents Alice's plants: + +```text +[window][window][window] +VR...................... +RG...................... +``` + +In the first row, nearest the windows, she has a violet and a radish. In the +second row she has a radish and some grass. + +Your program will be given the plants from left-to-right starting with +the row nearest the windows. From this, it should be able to determine +which plants belong to each student. + +For example, if it's told that the garden looks like so: + +```text +[window][window][window] +VRCGVVRVCGGCCGVRGCVCGCGV +VRCCCGCRRGVCGCRVVCVGCGCV +``` + +Then if asked for Alice's plants, it should provide: + +- Violets, radishes, violets, radishes + +While asking for Bob's plants would yield: + +- Clover, grass, clover, clover + +# Running the tests + +You can run all the tests for an exercise by entering + +```sh +$ ./gradlew test +``` + +in your terminal. + +## Source + +Random musings during airplane trip. [http://jumpstartlab.com](http://jumpstartlab.com) + +## Submitting Incomplete Solutions + +It's possible to submit an incomplete solution so you can see how others have completed the exercise. diff --git a/kotlin/kindergarten-garden/build.gradle.kts b/kotlin/kindergarten-garden/build.gradle.kts new file mode 100644 index 0000000..1793ac4 --- /dev/null +++ b/kotlin/kindergarten-garden/build.gradle.kts @@ -0,0 +1,23 @@ +import org.gradle.api.tasks.testing.logging.TestExceptionFormat + +plugins { + kotlin("jvm") version "1.3.60" +} + +repositories { + jcenter() +} + +dependencies { + compile(kotlin("stdlib")) + + testImplementation("junit:junit:4.12") + testImplementation(kotlin("test-junit")) +} + +tasks.withType { + testLogging { + exceptionFormat = TestExceptionFormat.FULL + events("passed", "failed", "skipped") + } +} diff --git a/kotlin/kindergarten-garden/gradle/wrapper/gradle-wrapper.properties b/kotlin/kindergarten-garden/gradle/wrapper/gradle-wrapper.properties new file mode 100644 index 0000000..9492014 --- /dev/null +++ b/kotlin/kindergarten-garden/gradle/wrapper/gradle-wrapper.properties @@ -0,0 +1,5 @@ +distributionBase=GRADLE_USER_HOME +distributionPath=wrapper/dists +distributionUrl=https\://services.gradle.org/distributions/gradle-6.0.1-bin.zip +zipStoreBase=GRADLE_USER_HOME +zipStorePath=wrapper/dists diff --git a/kotlin/kindergarten-garden/gradlew b/kotlin/kindergarten-garden/gradlew new file mode 100644 index 0000000..83f2acf --- /dev/null +++ b/kotlin/kindergarten-garden/gradlew @@ -0,0 +1,188 @@ +#!/usr/bin/env sh + +# +# Copyright 2015 the original author or authors. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# https://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# + +############################################################################## +## +## Gradle start up script for UN*X +## +############################################################################## + +# Attempt to set APP_HOME +# Resolve links: $0 may be a link +PRG="$0" +# Need this for relative symlinks. +while [ -h "$PRG" ] ; do + ls=`ls -ld "$PRG"` + link=`expr "$ls" : '.*-> \(.*\)$'` + if expr "$link" : '/.*' > /dev/null; then + PRG="$link" + else + PRG=`dirname "$PRG"`"/$link" + fi +done +SAVED="`pwd`" +cd "`dirname \"$PRG\"`/" >/dev/null +APP_HOME="`pwd -P`" +cd "$SAVED" >/dev/null + +APP_NAME="Gradle" +APP_BASE_NAME=`basename "$0"` + +# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script. +DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"' + +# Use the maximum available, or set MAX_FD != -1 to use that value. +MAX_FD="maximum" + +warn () { + echo "$*" +} + +die () { + echo + echo "$*" + echo + exit 1 +} + +# OS specific support (must be 'true' or 'false'). +cygwin=false +msys=false +darwin=false +nonstop=false +case "`uname`" in + CYGWIN* ) + cygwin=true + ;; + Darwin* ) + darwin=true + ;; + MINGW* ) + msys=true + ;; + NONSTOP* ) + nonstop=true + ;; +esac + +CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar + +# Determine the Java command to use to start the JVM. +if [ -n "$JAVA_HOME" ] ; then + if [ -x "$JAVA_HOME/jre/sh/java" ] ; then + # IBM's JDK on AIX uses strange locations for the executables + JAVACMD="$JAVA_HOME/jre/sh/java" + else + JAVACMD="$JAVA_HOME/bin/java" + fi + if [ ! -x "$JAVACMD" ] ; then + die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME + +Please set the JAVA_HOME variable in your environment to match the +location of your Java installation." + fi +else + JAVACMD="java" + which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. + +Please set the JAVA_HOME variable in your environment to match the +location of your Java installation." +fi + +# Increase the maximum file descriptors if we can. +if [ "$cygwin" = "false" -a "$darwin" = "false" -a "$nonstop" = "false" ] ; then + MAX_FD_LIMIT=`ulimit -H -n` + if [ $? -eq 0 ] ; then + if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then + MAX_FD="$MAX_FD_LIMIT" + fi + ulimit -n $MAX_FD + if [ $? -ne 0 ] ; then + warn "Could not set maximum file descriptor limit: $MAX_FD" + fi + else + warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT" + fi +fi + +# For Darwin, add options to specify how the application appears in the dock +if $darwin; then + GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\"" +fi + +# For Cygwin or MSYS, switch paths to Windows format before running java +if [ "$cygwin" = "true" -o "$msys" = "true" ] ; then + APP_HOME=`cygpath --path --mixed "$APP_HOME"` + CLASSPATH=`cygpath --path --mixed "$CLASSPATH"` + JAVACMD=`cygpath --unix "$JAVACMD"` + + # We build the pattern for arguments to be converted via cygpath + ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null` + SEP="" + for dir in $ROOTDIRSRAW ; do + ROOTDIRS="$ROOTDIRS$SEP$dir" + SEP="|" + done + OURCYGPATTERN="(^($ROOTDIRS))" + # Add a user-defined pattern to the cygpath arguments + if [ "$GRADLE_CYGPATTERN" != "" ] ; then + OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)" + fi + # Now convert the arguments - kludge to limit ourselves to /bin/sh + i=0 + for arg in "$@" ; do + CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -` + CHECK2=`echo "$arg"|egrep -c "^-"` ### Determine if an option + + if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then ### Added a condition + eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"` + else + eval `echo args$i`="\"$arg\"" + fi + i=$((i+1)) + done + case $i in + (0) set -- ;; + (1) set -- "$args0" ;; + (2) set -- "$args0" "$args1" ;; + (3) set -- "$args0" "$args1" "$args2" ;; + (4) set -- "$args0" "$args1" "$args2" "$args3" ;; + (5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;; + (6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;; + (7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;; + (8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;; + (9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;; + esac +fi + +# Escape application args +save () { + for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done + echo " " +} +APP_ARGS=$(save "$@") + +# Collect all arguments for the java command, following the shell quoting and substitution rules +eval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS "\"-Dorg.gradle.appname=$APP_BASE_NAME\"" -classpath "\"$CLASSPATH\"" org.gradle.wrapper.GradleWrapperMain "$APP_ARGS" + +# by default we should be in the correct project dir, but when run from Finder on Mac, the cwd is wrong +if [ "$(uname)" = "Darwin" ] && [ "$HOME" = "$PWD" ]; then + cd "$(dirname "$0")" +fi + +exec "$JAVACMD" "$@" diff --git a/kotlin/kindergarten-garden/gradlew.bat b/kotlin/kindergarten-garden/gradlew.bat new file mode 100644 index 0000000..9618d8d --- /dev/null +++ b/kotlin/kindergarten-garden/gradlew.bat @@ -0,0 +1,100 @@ +@rem +@rem Copyright 2015 the original author or authors. +@rem +@rem Licensed under the Apache License, Version 2.0 (the "License"); +@rem you may not use this file except in compliance with the License. +@rem You may obtain a copy of the License at +@rem +@rem https://www.apache.org/licenses/LICENSE-2.0 +@rem +@rem Unless required by applicable law or agreed to in writing, software +@rem distributed under the License is distributed on an "AS IS" BASIS, +@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +@rem See the License for the specific language governing permissions and +@rem limitations under the License. +@rem + +@if "%DEBUG%" == "" @echo off +@rem ########################################################################## +@rem +@rem Gradle startup script for Windows +@rem +@rem ########################################################################## + +@rem Set local scope for the variables with windows NT shell +if "%OS%"=="Windows_NT" setlocal + +set DIRNAME=%~dp0 +if "%DIRNAME%" == "" set DIRNAME=. +set APP_BASE_NAME=%~n0 +set APP_HOME=%DIRNAME% + +@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script. +set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m" + +@rem Find java.exe +if defined JAVA_HOME goto findJavaFromJavaHome + +set JAVA_EXE=java.exe +%JAVA_EXE% -version >NUL 2>&1 +if "%ERRORLEVEL%" == "0" goto init + +echo. +echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. +echo. +echo Please set the JAVA_HOME variable in your environment to match the +echo location of your Java installation. + +goto fail + +:findJavaFromJavaHome +set JAVA_HOME=%JAVA_HOME:"=% +set JAVA_EXE=%JAVA_HOME%/bin/java.exe + +if exist "%JAVA_EXE%" goto init + +echo. +echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME% +echo. +echo Please set the JAVA_HOME variable in your environment to match the +echo location of your Java installation. + +goto fail + +:init +@rem Get command-line arguments, handling Windows variants + +if not "%OS%" == "Windows_NT" goto win9xME_args + +:win9xME_args +@rem Slurp the command line arguments. +set CMD_LINE_ARGS= +set _SKIP=2 + +:win9xME_args_slurp +if "x%~1" == "x" goto execute + +set CMD_LINE_ARGS=%* + +:execute +@rem Setup the command line + +set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar + +@rem Execute Gradle +"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %CMD_LINE_ARGS% + +:end +@rem End local scope for the variables with windows NT shell +if "%ERRORLEVEL%"=="0" goto mainEnd + +:fail +rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of +rem the _cmd.exe /c_ return code! +if not "" == "%GRADLE_EXIT_CONSOLE%" exit 1 +exit /b 1 + +:mainEnd +if "%OS%"=="Windows_NT" endlocal + +:omega diff --git a/kotlin/kindergarten-garden/src/main/kotlin/KindergartenGarden.kt b/kotlin/kindergarten-garden/src/main/kotlin/KindergartenGarden.kt new file mode 100644 index 0000000..90f2437 --- /dev/null +++ b/kotlin/kindergarten-garden/src/main/kotlin/KindergartenGarden.kt @@ -0,0 +1,100 @@ +class KindergartenGarden(private val diagram: String) { + private enum class Student(i: Int) { + Alice(0), + Bob(1), + Charlie(2), + David(3), + Eve(4), + Fred(5), + Ginny(6), + Harriet(7), + Ileana(8), + Joseph(9), + Kincaid(10), + Larry(12) + } + + private enum class Plant(s: String) { + Violet("V") { + override fun toString(): String = "violets" + }, + Grass("G") { + override fun toString(): String = "grass" + }, + Clover("C") { + override fun toString(): String = "clover" + }, + Radish("R") { + override fun toString(): String = "radishes" + } + } + + private val studentToPlants: Map> + init { + val k = mutableMapOf>() + val rows = diagram.split("\n").map { row -> row.map { it.toString().toPlant() } } + for (group in 0 until (rows[0].size / 2)){ + val plants = mutableListOf() + with(plants) { + add(rows[0][2 * group]) + add(rows[0][(2 * group) + 1]) + add(rows[1][2 * group]) + add(rows[1][(2 * group) + 1]) + } + k[group.toStudent()] = plants + } + studentToPlants = k + } + + private fun String.toPlant(): Plant { + return when (this) { + "V" -> Plant.Violet + "G" -> Plant.Grass + "C" -> Plant.Clover + "R" -> Plant.Radish + else -> throw IllegalArgumentException("Bad Plant Type. Must be one of V, G, C, R") + } + } + private fun String.toStudent(): KindergartenGarden.Student { + return when(this) { + "Alice" -> Student.Alice + "Bob" -> Student.Bob + "Charlie" -> Student.Charlie + "David" -> Student.David + "Eve" -> Student.Eve + "Fred" -> Student.Fred + "Ginny" -> Student.Ginny + "Harriett" -> Student.Harriet + "Ileana" -> Student.Ileana + "Joseph" -> Student.Joseph + "Kincaid" -> Student.Kincaid + "Larry" -> Student.Larry + else -> throw IllegalArgumentException("Bad student name $this") + } + } + + private fun Int.toStudent(): KindergartenGarden.Student { + return when (this) { + 0 -> Student.Alice + 1 -> Student.Bob + 2 -> Student.Charlie + 3 -> Student.David + 4 -> Student.Eve + 5 -> Student.Fred + 6 -> Student.Ginny + 7 -> Student.Harriet + 8 -> Student.Ileana + 9 -> Student.Joseph + 10 -> Student.Kincaid + 11 -> Student.Larry + else -> throw IllegalArgumentException("Bad student number $this") + } + fun getPlantsOfStudent(student: String): List { + TODO("Implement the function to complete the task") + } +} + + fun getPlantsOfStudent(student: String): List { + return studentToPlants[student.toStudent()]?.map { it.toString() } ?: emptyList() + } +} diff --git a/kotlin/kindergarten-garden/src/test/kotlin/KindergartenGardenTest.kt b/kotlin/kindergarten-garden/src/test/kotlin/KindergartenGardenTest.kt new file mode 100644 index 0000000..299a8fb --- /dev/null +++ b/kotlin/kindergarten-garden/src/test/kotlin/KindergartenGardenTest.kt @@ -0,0 +1,88 @@ +import kotlin.test.Test +import kotlin.test.Ignore +import kotlin.test.assertEquals + +class KindergartenGardenTest { + + @Test + fun `single student`() { + val student = "Alice" + val diagram = "RC\nGG" + val expected = listOf("radishes", "clover", "grass", "grass") + + assertEquals(expected, KindergartenGarden(diagram).getPlantsOfStudent(student)) + } + + @Test + fun `single student2`() { + val student = "Alice" + val diagram = "VC\nRC" + val expected = listOf("violets", "clover", "radishes", "clover") + + assertEquals(expected, KindergartenGarden(diagram).getPlantsOfStudent(student)) + } + + @Test + fun `two students`() { + val student = "Bob" + val diagram = "VVCG\nVVRC" + val expected = listOf("clover", "grass", "radishes", "clover") + + assertEquals(expected, KindergartenGarden(diagram).getPlantsOfStudent(student)) + } + + @Test + fun `one garden second student`() { + val student = "Bob" + val diagram = "VVCCGG\nVVCCGG" + val expected = listOf("clover", "clover", "clover", "clover") + + assertEquals(expected, KindergartenGarden(diagram).getPlantsOfStudent(student)) + } + + @Test + fun `one garden third student`() { + val student = "Charlie" + val diagram = "VVCCGG\nVVCCGG" + val expected = listOf("grass", "grass", "grass", "grass") + + assertEquals(expected, KindergartenGarden(diagram).getPlantsOfStudent(student)) + } + + @Test + fun `full garden first student`() { + val student = "Alice" + val diagram = "VRCGVVRVCGGCCGVRGCVCGCGV\nVRCCCGCRRGVCGCRVVCVGCGCV" + val expected = listOf("violets", "radishes", "violets", "radishes") + + assertEquals(expected, KindergartenGarden(diagram).getPlantsOfStudent(student)) + } + + @Test + fun `full garden second student`() { + val student = "Bob" + val diagram = "VRCGVVRVCGGCCGVRGCVCGCGV\nVRCCCGCRRGVCGCRVVCVGCGCV" + val expected = listOf("clover", "grass", "clover", "clover") + + assertEquals(expected, KindergartenGarden(diagram).getPlantsOfStudent(student)) + } + + @Test + fun `full garden second to last student`() { + val student = "Kincaid" + val diagram = "VRCGVVRVCGGCCGVRGCVCGCGV\nVRCCCGCRRGVCGCRVVCVGCGCV" + val expected = listOf("grass", "clover", "clover", "grass") + + assertEquals(expected, KindergartenGarden(diagram).getPlantsOfStudent(student)) + } + + @Test + fun `full garden last student`() { + val student = "Larry" + val diagram = "VRCGVVRVCGGCCGVRGCVCGCGV\nVRCCCGCRRGVCGCRVVCVGCGCV" + val expected = listOf("grass", "violets", "clover", "violets") + + assertEquals(expected, KindergartenGarden(diagram).getPlantsOfStudent(student)) + } + +} diff --git a/kotlin/yacht/.exercism/metadata.json b/kotlin/yacht/.exercism/metadata.json new file mode 100644 index 0000000..ff498c9 --- /dev/null +++ b/kotlin/yacht/.exercism/metadata.json @@ -0,0 +1 @@ +{"track":"kotlin","exercise":"yacht","id":"54cf6a94c14545848b8113a4eab84156","url":"https://exercism.io/my/solutions/54cf6a94c14545848b8113a4eab84156","handle":"anthonycicc","is_requester":true,"auto_approve":false} \ No newline at end of file diff --git a/kotlin/yacht/.gradle/6.0.1/executionHistory/executionHistory.bin b/kotlin/yacht/.gradle/6.0.1/executionHistory/executionHistory.bin new file mode 100644 index 0000000000000000000000000000000000000000..852a2bcdc4a0e72206f90c65b073b6872a182a87 GIT binary patch literal 67584 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 literal 0 HcmV?d00001 diff --git a/kotlin/yacht/.gradle/6.0.1/executionHistory/executionHistory.lock b/kotlin/yacht/.gradle/6.0.1/executionHistory/executionHistory.lock new file mode 100644 index 0000000000000000000000000000000000000000..9c3d78386d14d98e652bc2364661fb5e22551d94 GIT binary patch literal 17 UcmZR+mwMIw3;Vfp1_;mw06L=tz5oCK literal 0 HcmV?d00001 diff --git a/kotlin/yacht/.gradle/6.0.1/fileChanges/last-build.bin b/kotlin/yacht/.gradle/6.0.1/fileChanges/last-build.bin new file mode 100644 index 0000000000000000000000000000000000000000..f76dd238ade08917e6712764a16a22005a50573d GIT binary patch literal 1 IcmZPo000310RR91 literal 0 HcmV?d00001 diff --git a/kotlin/yacht/.gradle/6.0.1/fileContent/fileContent.lock b/kotlin/yacht/.gradle/6.0.1/fileContent/fileContent.lock new file mode 100644 index 0000000000000000000000000000000000000000..332e44d838ad00ec8f2a8cc7ed4edb785f719689 GIT binary patch literal 17 ScmZS9D!U~wkTWTr0SW*n1OpNP literal 0 HcmV?d00001 diff --git a/kotlin/yacht/.gradle/6.0.1/fileHashes/fileHashes.bin b/kotlin/yacht/.gradle/6.0.1/fileHashes/fileHashes.bin new file mode 100644 index 0000000000000000000000000000000000000000..d6c0ae0a511f6d61b04d1f746938f80bf75c91bf GIT binary patch literal 19547 zcmeI%`%hD690u^yi)ahh5?Y{&A~KYsp>Q_5fe|AMy|`#p91CJ5B7+zOywG?-k*ta$ zg5vNpyKcxWRGq|8$5eEgV$Wz{(+hAo19CY^FHT& z&!;~&fuaJXZ`eV-AM*FNa0db)00JNY0w4eaAOHd&00JNY0w4eaAOHd&00JNY0wD0A z2qd8o5#x^uoX2Nwrsydu$_L%Z4YSwGJancj5kJLrnT(^rDS(0}u>DQ|2)>bxeBl(kTsUZ4kfs@SzB)2d2-Sy-P z-WB%!u_Paw`B@*|VEdPy|JA$v{9V7t7yb9+T&E(rw5qvrxXyl>o$n&Ke|%Wn(zUCv z<6OOr3o4U&Z+f<-6RmiH=_EP_grOkbFtjK}T)(PtS3#F_B!YZ#Rmap^Z4# z^^<&M$-2ogeG|jjyqx4)<`{WZC3b(DYhy^B-C}XI8;51={NG8gZ$36VB}n@W=jtw! z?^fEgB&z{WZBl=}H`o-FH(dHh3;y!T7~B{;do;}5v8A~k z$;G>?iuETGU4^(&`-*MwxN9WmA6QXk75WwYWoxPIT!4%iUDEJM=QjA;ho&^Imdn#K zZK7YqWfg2=0Iwkza~lCC9{HN|_R!S&eVO!z315yi6b-?+Ax`2pI@2r}#chWl-VoGg zwTmZvvyBn+a literal 0 HcmV?d00001 diff --git a/kotlin/yacht/.gradle/6.0.1/gc.properties b/kotlin/yacht/.gradle/6.0.1/gc.properties new file mode 100644 index 0000000..e69de29 diff --git a/kotlin/yacht/.gradle/buildOutputCleanup/buildOutputCleanup.lock b/kotlin/yacht/.gradle/buildOutputCleanup/buildOutputCleanup.lock new file mode 100644 index 0000000000000000000000000000000000000000..11544ecd318b474dbe6bc1756bee058023e191c8 GIT binary patch literal 17 UcmZR+k>c3fzfxyD0|e*;05i-4KmY&$ literal 0 HcmV?d00001 diff --git a/kotlin/yacht/.gradle/buildOutputCleanup/cache.properties b/kotlin/yacht/.gradle/buildOutputCleanup/cache.properties new file mode 100644 index 0000000..f809af4 --- /dev/null +++ b/kotlin/yacht/.gradle/buildOutputCleanup/cache.properties @@ -0,0 +1,2 @@ +#Sat Mar 07 16:55:00 EST 2020 +gradle.version=6.0.1 diff --git a/kotlin/yacht/.gradle/buildOutputCleanup/outputFiles.bin b/kotlin/yacht/.gradle/buildOutputCleanup/outputFiles.bin new file mode 100644 index 0000000000000000000000000000000000000000..86636a28be2a4eeafe82eb90030e8a52bf57bc92 GIT binary patch literal 18803 zcmeI&ODF_!9Ki9}O&*KImRfsQ%F2PFl$%!^P#)!(q$DRw$+juU!NDFpuA)#LDVsbl z4oFE!DM#C$Y;mG!h2$|~{=cNXI7;7t&FsJL%>JAIXOBBon&wRXP(%A3>EBak2q1s} z0tg_000IagfB*srAbB*mv`g-QA(Z7!iUGO_Qu zGcQ*MJD~`$?_u zlWxt4T^RQaJgeR$J?1#LY`YB>sdX}>+bXj{c6Vq+-S3y4=(=(Q*89DxUr4t*?_DqR zM=sUpq!;fEN6P&Eu + + + + + \ No newline at end of file diff --git a/kotlin/yacht/.idea/jarRepositories.xml b/kotlin/yacht/.idea/jarRepositories.xml new file mode 100644 index 0000000..efa4625 --- /dev/null +++ b/kotlin/yacht/.idea/jarRepositories.xml @@ -0,0 +1,20 @@ + + + + + + + + + + + \ No newline at end of file diff --git a/kotlin/yacht/.idea/misc.xml b/kotlin/yacht/.idea/misc.xml new file mode 100644 index 0000000..b9d0e72 --- /dev/null +++ b/kotlin/yacht/.idea/misc.xml @@ -0,0 +1,8 @@ + + + + + + + + \ No newline at end of file diff --git a/kotlin/yacht/.idea/vcs.xml b/kotlin/yacht/.idea/vcs.xml new file mode 100644 index 0000000..b2bdec2 --- /dev/null +++ b/kotlin/yacht/.idea/vcs.xml @@ -0,0 +1,6 @@ + + + + + + \ No newline at end of file diff --git a/kotlin/yacht/README.md b/kotlin/yacht/README.md new file mode 100644 index 0000000..e4797a4 --- /dev/null +++ b/kotlin/yacht/README.md @@ -0,0 +1,67 @@ +# Score a single throw of dice in *Yacht* + +The dice game [Yacht](https://en.wikipedia.org/wiki/Yacht_(dice_game)) is from +the same family as Poker Dice, Generala and particularly Yahtzee, of which it +is a precursor. In the game, five dice are rolled and the result can be entered +in any of twelve categories. The score of a throw of the dice depends on +category chosen. + +## Scores in Yacht + +| Category | Score | Description | Example | +| -------- | ----- | ----------- | ------- | +| Ones | 1 × number of ones | Any combination | 1 1 1 4 5 scores 3 | +| Twos | 2 × number of twos | Any combination | 2 2 3 4 5 scores 4 | +| Threes | 3 × number of threes | Any combination | 3 3 3 3 3 scores 15 | +| Fours | 4 × number of fours | Any combination | 1 2 3 3 5 scores 0 | +| Fives | 5 × number of fives| Any combination | 5 1 5 2 5 scores 15 | +| Sixes | 6 × number of sixes | Any combination | 2 3 4 5 6 scores 6 | +| Full House | Total of the dice | Three of one number and two of another | 3 3 3 5 5 scores 19 | +| Four of a Kind | Total of the four dice | At least four dice showing the same face | 4 4 4 4 6 scores 16 | +| Little Straight | 30 points | 1-2-3-4-5 | 1 2 3 4 5 scores 30 | +| Big Straight | 30 points | 2-3-4-5-6 | 2 3 4 5 6 scores 30 | +| Choice | Sum of the dice | Any combination | 2 3 3 4 6 scores 18 | +| Yacht | 50 points | All five dice showing the same face | 4 4 4 4 4 scores 50 | + +If the dice do not satisfy the requirements of a category, the score is zero. +If, for example, *Four Of A Kind* is entered in the *Yacht* category, zero +points are scored. A *Yacht* scores zero if entered in the *Full House* category. + +## Task + +Given a list of values for five dice and a category, your solution should return +the score of the dice for that category. If the dice do not satisfy the requirements +of the category your solution should return 0. You can assume that five values +will always be presented, and the value of each will be between one and six +inclusively. You should not assume that the dice are ordered. + +## Setup + +Go through the setup instructions for Kotlin to install the necessary +dependencies: + +[https://exercism.io/tracks/kotlin/installation](https://exercism.io/tracks/kotlin/installation) + +## Making the test suite pass + +Execute the tests with: + +```bash +$ ./gradlew test +``` + +> Use `gradlew.bat` if you're on Windows + +In the test suites all tests but the first have been skipped. + +Once you get a test passing, you can enable the next one by removing the +`@Ignore` annotation. + +## Source + +James Kilfiger, using wikipedia [https://en.wikipedia.org/wiki/Yacht_(dice_game)](https://en.wikipedia.org/wiki/Yacht_(dice_game)) + +## Submitting Incomplete Solutions + +It's possible to submit an incomplete solution so you can see how others have +completed the exercise. diff --git a/kotlin/yacht/build.gradle.kts b/kotlin/yacht/build.gradle.kts new file mode 100644 index 0000000..1793ac4 --- /dev/null +++ b/kotlin/yacht/build.gradle.kts @@ -0,0 +1,23 @@ +import org.gradle.api.tasks.testing.logging.TestExceptionFormat + +plugins { + kotlin("jvm") version "1.3.60" +} + +repositories { + jcenter() +} + +dependencies { + compile(kotlin("stdlib")) + + testImplementation("junit:junit:4.12") + testImplementation(kotlin("test-junit")) +} + +tasks.withType { + testLogging { + exceptionFormat = TestExceptionFormat.FULL + events("passed", "failed", "skipped") + } +} diff --git a/kotlin/yacht/gradle/wrapper/gradle-wrapper.properties b/kotlin/yacht/gradle/wrapper/gradle-wrapper.properties new file mode 100644 index 0000000..9492014 --- /dev/null +++ b/kotlin/yacht/gradle/wrapper/gradle-wrapper.properties @@ -0,0 +1,5 @@ +distributionBase=GRADLE_USER_HOME +distributionPath=wrapper/dists +distributionUrl=https\://services.gradle.org/distributions/gradle-6.0.1-bin.zip +zipStoreBase=GRADLE_USER_HOME +zipStorePath=wrapper/dists diff --git a/kotlin/yacht/gradlew b/kotlin/yacht/gradlew new file mode 100644 index 0000000..83f2acf --- /dev/null +++ b/kotlin/yacht/gradlew @@ -0,0 +1,188 @@ +#!/usr/bin/env sh + +# +# Copyright 2015 the original author or authors. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# https://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# + +############################################################################## +## +## Gradle start up script for UN*X +## +############################################################################## + +# Attempt to set APP_HOME +# Resolve links: $0 may be a link +PRG="$0" +# Need this for relative symlinks. +while [ -h "$PRG" ] ; do + ls=`ls -ld "$PRG"` + link=`expr "$ls" : '.*-> \(.*\)$'` + if expr "$link" : '/.*' > /dev/null; then + PRG="$link" + else + PRG=`dirname "$PRG"`"/$link" + fi +done +SAVED="`pwd`" +cd "`dirname \"$PRG\"`/" >/dev/null +APP_HOME="`pwd -P`" +cd "$SAVED" >/dev/null + +APP_NAME="Gradle" +APP_BASE_NAME=`basename "$0"` + +# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script. +DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"' + +# Use the maximum available, or set MAX_FD != -1 to use that value. +MAX_FD="maximum" + +warn () { + echo "$*" +} + +die () { + echo + echo "$*" + echo + exit 1 +} + +# OS specific support (must be 'true' or 'false'). +cygwin=false +msys=false +darwin=false +nonstop=false +case "`uname`" in + CYGWIN* ) + cygwin=true + ;; + Darwin* ) + darwin=true + ;; + MINGW* ) + msys=true + ;; + NONSTOP* ) + nonstop=true + ;; +esac + +CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar + +# Determine the Java command to use to start the JVM. +if [ -n "$JAVA_HOME" ] ; then + if [ -x "$JAVA_HOME/jre/sh/java" ] ; then + # IBM's JDK on AIX uses strange locations for the executables + JAVACMD="$JAVA_HOME/jre/sh/java" + else + JAVACMD="$JAVA_HOME/bin/java" + fi + if [ ! -x "$JAVACMD" ] ; then + die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME + +Please set the JAVA_HOME variable in your environment to match the +location of your Java installation." + fi +else + JAVACMD="java" + which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. + +Please set the JAVA_HOME variable in your environment to match the +location of your Java installation." +fi + +# Increase the maximum file descriptors if we can. +if [ "$cygwin" = "false" -a "$darwin" = "false" -a "$nonstop" = "false" ] ; then + MAX_FD_LIMIT=`ulimit -H -n` + if [ $? -eq 0 ] ; then + if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then + MAX_FD="$MAX_FD_LIMIT" + fi + ulimit -n $MAX_FD + if [ $? -ne 0 ] ; then + warn "Could not set maximum file descriptor limit: $MAX_FD" + fi + else + warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT" + fi +fi + +# For Darwin, add options to specify how the application appears in the dock +if $darwin; then + GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\"" +fi + +# For Cygwin or MSYS, switch paths to Windows format before running java +if [ "$cygwin" = "true" -o "$msys" = "true" ] ; then + APP_HOME=`cygpath --path --mixed "$APP_HOME"` + CLASSPATH=`cygpath --path --mixed "$CLASSPATH"` + JAVACMD=`cygpath --unix "$JAVACMD"` + + # We build the pattern for arguments to be converted via cygpath + ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null` + SEP="" + for dir in $ROOTDIRSRAW ; do + ROOTDIRS="$ROOTDIRS$SEP$dir" + SEP="|" + done + OURCYGPATTERN="(^($ROOTDIRS))" + # Add a user-defined pattern to the cygpath arguments + if [ "$GRADLE_CYGPATTERN" != "" ] ; then + OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)" + fi + # Now convert the arguments - kludge to limit ourselves to /bin/sh + i=0 + for arg in "$@" ; do + CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -` + CHECK2=`echo "$arg"|egrep -c "^-"` ### Determine if an option + + if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then ### Added a condition + eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"` + else + eval `echo args$i`="\"$arg\"" + fi + i=$((i+1)) + done + case $i in + (0) set -- ;; + (1) set -- "$args0" ;; + (2) set -- "$args0" "$args1" ;; + (3) set -- "$args0" "$args1" "$args2" ;; + (4) set -- "$args0" "$args1" "$args2" "$args3" ;; + (5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;; + (6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;; + (7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;; + (8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;; + (9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;; + esac +fi + +# Escape application args +save () { + for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done + echo " " +} +APP_ARGS=$(save "$@") + +# Collect all arguments for the java command, following the shell quoting and substitution rules +eval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS "\"-Dorg.gradle.appname=$APP_BASE_NAME\"" -classpath "\"$CLASSPATH\"" org.gradle.wrapper.GradleWrapperMain "$APP_ARGS" + +# by default we should be in the correct project dir, but when run from Finder on Mac, the cwd is wrong +if [ "$(uname)" = "Darwin" ] && [ "$HOME" = "$PWD" ]; then + cd "$(dirname "$0")" +fi + +exec "$JAVACMD" "$@" diff --git a/kotlin/yacht/gradlew.bat b/kotlin/yacht/gradlew.bat new file mode 100644 index 0000000..9618d8d --- /dev/null +++ b/kotlin/yacht/gradlew.bat @@ -0,0 +1,100 @@ +@rem +@rem Copyright 2015 the original author or authors. +@rem +@rem Licensed under the Apache License, Version 2.0 (the "License"); +@rem you may not use this file except in compliance with the License. +@rem You may obtain a copy of the License at +@rem +@rem https://www.apache.org/licenses/LICENSE-2.0 +@rem +@rem Unless required by applicable law or agreed to in writing, software +@rem distributed under the License is distributed on an "AS IS" BASIS, +@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +@rem See the License for the specific language governing permissions and +@rem limitations under the License. +@rem + +@if "%DEBUG%" == "" @echo off +@rem ########################################################################## +@rem +@rem Gradle startup script for Windows +@rem +@rem ########################################################################## + +@rem Set local scope for the variables with windows NT shell +if "%OS%"=="Windows_NT" setlocal + +set DIRNAME=%~dp0 +if "%DIRNAME%" == "" set DIRNAME=. +set APP_BASE_NAME=%~n0 +set APP_HOME=%DIRNAME% + +@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script. +set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m" + +@rem Find java.exe +if defined JAVA_HOME goto findJavaFromJavaHome + +set JAVA_EXE=java.exe +%JAVA_EXE% -version >NUL 2>&1 +if "%ERRORLEVEL%" == "0" goto init + +echo. +echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. +echo. +echo Please set the JAVA_HOME variable in your environment to match the +echo location of your Java installation. + +goto fail + +:findJavaFromJavaHome +set JAVA_HOME=%JAVA_HOME:"=% +set JAVA_EXE=%JAVA_HOME%/bin/java.exe + +if exist "%JAVA_EXE%" goto init + +echo. +echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME% +echo. +echo Please set the JAVA_HOME variable in your environment to match the +echo location of your Java installation. + +goto fail + +:init +@rem Get command-line arguments, handling Windows variants + +if not "%OS%" == "Windows_NT" goto win9xME_args + +:win9xME_args +@rem Slurp the command line arguments. +set CMD_LINE_ARGS= +set _SKIP=2 + +:win9xME_args_slurp +if "x%~1" == "x" goto execute + +set CMD_LINE_ARGS=%* + +:execute +@rem Setup the command line + +set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar + +@rem Execute Gradle +"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %CMD_LINE_ARGS% + +:end +@rem End local scope for the variables with windows NT shell +if "%ERRORLEVEL%"=="0" goto mainEnd + +:fail +rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of +rem the _cmd.exe /c_ return code! +if not "" == "%GRADLE_EXIT_CONSOLE%" exit 1 +exit /b 1 + +:mainEnd +if "%OS%"=="Windows_NT" endlocal + +:omega diff --git a/kotlin/yacht/src/main/kotlin/Yacht.kt b/kotlin/yacht/src/main/kotlin/Yacht.kt new file mode 100644 index 0000000..938ec7a --- /dev/null +++ b/kotlin/yacht/src/main/kotlin/Yacht.kt @@ -0,0 +1,34 @@ +object Yacht { + + fun solve(category: YachtCategory, vararg dices: Int): Int { + return when (category) { + YachtCategory.YACHT -> (if (dices.all { it == dices[0] }) 50 else 0) + YachtCategory.ONES -> 1 * dices.filter { it == 1 }.size + YachtCategory.TWOS -> 2 * dices.filter { it == 2 }.size + YachtCategory.THREES -> 3 * dices.filter { it == 3 }.size + YachtCategory.FOURS -> 4 * dices.filter { it == 4 }.size + YachtCategory.FIVES -> 5 * dices.filter { it == 5 }.size + YachtCategory.SIXES -> 6 * dices.filter { it == 6 }.size + YachtCategory.FULL_HOUSE -> calcFullHouse(dices.toList()) + YachtCategory.FOUR_OF_A_KIND -> dices.toList() + .groupingBy { it }.eachCount() + .filter { (_, frequency) -> frequency >= 4 }.map { (value, frequency) -> value * frequency.coerceAtMost(4) }.getOrNull(0) ?: 0 + YachtCategory.LITTLE_STRAIGHT -> if (listOf(1,2,3,4,5) == dices.sorted()) 30 else 0 + YachtCategory.BIG_STRAIGHT -> if (listOf(2,3,4,5,6) == dices.sorted()) 30 else 0 + YachtCategory.CHOICE -> dices.sum() + } + } + + private fun calcFullHouse(dice: List): Int { + val frequency = dice.groupingBy { it }.eachCount() + val needsCalc = with(frequency) { + Pair(any { (_, frequency) -> frequency == 3}, + any { (_, frequency) -> frequency == 2}) + } + return if (needsCalc.first && needsCalc.second) { + dice.sum() + } else 0 + } +} + + diff --git a/kotlin/yacht/src/main/kotlin/YachtCategory.kt b/kotlin/yacht/src/main/kotlin/YachtCategory.kt new file mode 100644 index 0000000..5d650ea --- /dev/null +++ b/kotlin/yacht/src/main/kotlin/YachtCategory.kt @@ -0,0 +1,14 @@ +enum class YachtCategory { + YACHT, + ONES, + TWOS, + THREES, + FOURS, + FIVES, + SIXES, + FULL_HOUSE, + FOUR_OF_A_KIND, + LITTLE_STRAIGHT, + BIG_STRAIGHT, + CHOICE +} diff --git a/kotlin/yacht/src/test/kotlin/YachtTest.kt b/kotlin/yacht/src/test/kotlin/YachtTest.kt new file mode 100644 index 0000000..bc77c04 --- /dev/null +++ b/kotlin/yacht/src/test/kotlin/YachtTest.kt @@ -0,0 +1,93 @@ +import org.junit.Rule +import org.junit.rules.ExpectedException +import kotlin.test.Test +import kotlin.test.assertEquals +import YachtCategory.* + +class YachtTest { + + @Test + fun yacht() = assertEquals(50, Yacht.solve(YACHT, 5, 5, 5, 5, 5)) + + @Test + fun `not yacht`() = assertEquals(0, Yacht.solve(YACHT, 1, 3, 3, 2, 5)) + + @Test + fun ones() = assertEquals(3, Yacht.solve(ONES, 1, 1, 1, 3, 5)) + + @Test + fun `ones out of order`() = assertEquals(3, Yacht.solve(ONES, 3, 1, 1, 5, 1)) + + @Test + fun `no ones`() = assertEquals(0, Yacht.solve(ONES, 4, 3, 6, 5, 5)) + + @Test + fun twos() = assertEquals(2, Yacht.solve(TWOS, 2, 3, 4, 5, 6)) + + @Test + fun fours() = assertEquals(8, Yacht.solve(FOURS, 1, 4, 1, 4, 1)) + + @Test + fun `yacht counted as threes`() = assertEquals(15, Yacht.solve(THREES, 3, 3, 3, 3, 3)) + + @Test + fun `yacht of threes counted as fives`() = assertEquals(0, Yacht.solve(FIVES, 3, 3, 3, 3, 3)) + + @Test + fun sixes() = assertEquals(6, Yacht.solve(SIXES, 2, 3, 4, 5, 6)) + + @Test + fun `full house two small three big`() = assertEquals(16, Yacht.solve(FULL_HOUSE, 2, 2, 4, 4, 4)) + + @Test + fun `full house three small two big`() = assertEquals(19, Yacht.solve(FULL_HOUSE, 5, 3, 3, 5, 3)) + + @Test + fun `two pair is not a full house`() = assertEquals(0, Yacht.solve(FULL_HOUSE, 2, 2, 4, 4, 5)) + + @Test + fun `four of a kind is not a full house`() = assertEquals(0, Yacht.solve(FULL_HOUSE, 1, 4, 4, 4, 4)) + + @Test + fun `yacht is not a full house`() = assertEquals(0, Yacht.solve(FULL_HOUSE, 2, 2, 2, 2, 2)) + + @Test + fun `four of a kind`() = assertEquals(24, Yacht.solve(FOUR_OF_A_KIND, 6, 6, 4, 6, 6)) + + @Test + fun `yacht can be scored as four of a kind`() = assertEquals(12, Yacht.solve(FOUR_OF_A_KIND, 3, 3, 3, 3, 3)) + + @Test + fun `full house is not four of a kind`() = assertEquals(0, Yacht.solve(FOUR_OF_A_KIND, 3, 3, 3, 5, 5)) + + @Test + fun `little straight`() = assertEquals(30, Yacht.solve(LITTLE_STRAIGHT, 3, 5, 4, 1, 2)) + + @Test + fun `little straight as big straight`() = assertEquals(0, Yacht.solve(BIG_STRAIGHT, 1, 2, 3, 4, 5)) + + @Test + fun `four in order but not a little straight`() = assertEquals(0, Yacht.solve(LITTLE_STRAIGHT, 1, 1, 2, 3, 4)) + + @Test + fun `no pairs but not a little straight`() = assertEquals(0, Yacht.solve(LITTLE_STRAIGHT, 1, 2, 3, 4, 6)) + + @Test + fun `minimum is 1 maximum is 5 but not a little straight`() = assertEquals(0, Yacht.solve(LITTLE_STRAIGHT, 1, 1, 3, 4, 5)) + + @Test + fun `big straight`() = assertEquals(30, Yacht.solve(BIG_STRAIGHT, 4, 6, 2, 5, 3)) + + @Test + fun `big straight as little straight`() = assertEquals(0, Yacht.solve(LITTLE_STRAIGHT, 6, 5, 4, 3, 2)) + + @Test + fun `no pairs but not a big straight`() = assertEquals(0, Yacht.solve(BIG_STRAIGHT, 6, 5, 4, 3, 1)) + + @Test + fun choice() = assertEquals(23, Yacht.solve(CHOICE, 3, 3, 5, 6, 6)) + + @Test + fun `yacht as choice`() = assertEquals(10, Yacht.solve(CHOICE, 2, 2, 2, 2, 2)) + +}