- Added solutions by Ali Moradi.

- Added solutions by Richard Park.
- Added solutions by David Ferrone.
- Added solutions by E. Choroba.
- Added solutions by Robbie Hatley.
- Added solutions by Peter Campbell Smith.
- Added solutions by Niels van Dijke.
- Added solutions by Kjetil Skotheim.
- Added solutions by Ulrich Rieke.

12 files changed, 354 insertions, 0 deletions

diff --git a/challenge-336/perlboy1967/perl/ch1.pl b/challenge-336/perlboy1967/perl/ch-1.pl
index 1a6c36ec02..1a6c36ec02 100755
--- a/challenge-336/perlboy1967/perl/ch1.pl
+++ b/challenge-336/perlboy1967/perl/ch-1.pl
diff --git a/challenge-336/perlboy1967/perl/ch2.pl b/challenge-336/perlboy1967/perl/ch-2.pl
index d2af12fb92..d2af12fb92 100755
--- a/challenge-336/perlboy1967/perl/ch2.pl
+++ b/challenge-336/perlboy1967/perl/ch-2.pl
diff --git a/challenge-336/ulrich-rieke/cpp/ch-1.cpp b/challenge-336/ulrich-rieke/cpp/ch-1.cpp
new file mode 100755
index 0000000000..4dcf324053
--- /dev/null
+++ b/challenge-336/ulrich-rieke/cpp/ch-1.cpp
@@ -0,0 +1,46 @@
+#include <iostream>

+#include <string> 

+#include <sstream>

+#include <vector>

+#include <utility>

+#include <algorithm>

+#include <set>

+

+std::vector<std::string> split( const std::string & text , char delimiter ) {

+   std::vector<std::string> tokens ;

+   std::istringstream istr { text } ;

+   std::string word ;

+   while ( std::getline( istr , word , delimiter ) ) 

+      tokens.push_back( word ) ;

+   return tokens ;

+}

+

+int main( ) {

+   std::cout << "Enter some numbers separated by whitespace!\n" ;

+   std::string line ;

+   std::getline( std::cin , line ) ;

+   auto tokens { split( line, ' ' ) } ;

+   std::string numbers ;

+   for ( auto s : tokens ) 

+      numbers.push_back( std::stoi( s ) ) ;

+   std::set<int> uniques { numbers.begin( ) , numbers.end( ) } ;

+   std::vector<std::pair<int , int>> frequencies ;

+   for ( auto it = uniques.begin( ) ; it != uniques.end( ) ; ++it ) {

+      frequencies.push_back( std::make_pair( *it , std::count( numbers.begin( ) , 

+		  numbers.end( ) , *it ))) ;

+   }

+   bool result = false ;

+   if ( frequencies.size( ) == 1 ) {

+      result = frequencies[0].second > 1 ;

+   }

+   else {

+      std::sort( frequencies.begin( ) , frequencies.end( ) , []( const auto & 

+	       aPair , const auto & bPair ) { return aPair.second < bPair.second ; }

+	    ) ;

+      int mini = frequencies[0].second ;

+      result = mini > 1 && std::all_of( frequencies.begin( ) + 1 , frequencies.end( ),

+	    [mini]( const auto & p ) { return p.second % mini == 0 ; } ) ;

+   }

+   std::cout << std::boolalpha << result << '\n' ;

+   return 0 ;

+}

diff --git a/challenge-336/ulrich-rieke/cpp/ch-2.cpp b/challenge-336/ulrich-rieke/cpp/ch-2.cpp
new file mode 100755
index 0000000000..5304fa2916
--- /dev/null
+++ b/challenge-336/ulrich-rieke/cpp/ch-2.cpp
@@ -0,0 +1,50 @@
+#include <vector>

+#include <string>

+#include <sstream>

+#include <regex>

+#include <iostream>

+#include <numeric>

+#include <algorithm>

+

+std::vector<std::string> split( const std::string & text , char delimiter ) {

+   std::vector<std::string> tokens ;

+   std::istringstream istr { text } ;

+   std::string word ;

+   while ( std::getline( istr , word , delimiter ) ) 

+      tokens.push_back( word ) ;

+   return tokens ;

+}

+

+int main( ) {

+   std::cout << "Enter some numbers and D , C or + separated by whitespace!\n" ;

+   std::string line ;

+   std::getline( std::cin , line ) ;

+   auto tokens { split( line , ' ' ) } ;

+   std::vector<int> numbers ;

+   std::string numpattern {"(\\-)*\\d+"} ;

+   std::regex nu { numpattern } ;

+   auto until = std::find_if( tokens.begin( ) , tokens.end( ) , [nu]( const auto w )

+	 { return ! std::regex_match( w.begin( ) , w.end( ) , nu ) ; } ) ;

+   for ( auto it = tokens.begin( ) ; it != until ; ++it ) 

+      numbers.push_back( std::stoi( *it ) ) ;

+   for ( auto it = until ; it != tokens.end( ) ; ++it ) {

+      if ( ! std::regex_match( *it , nu ) ) { // no number ! 

+	 if ( *it == "C" ) {

+	    numbers.pop_back( ) ;

+	 }

+	 if ( *it == "D" ) {

+	    int last = numbers.back( ) ;

+	    numbers.push_back( last * 2 ) ;

+	 }

+	 if ( *it == "+" ) {

+	    int l = numbers.size( ) ;

+	    numbers.push_back( numbers[l - 2] + numbers[l - 1] ) ;

+	 }

+      }

+      else { // it's a number !

+	 numbers.push_back( std::stoi( *it ) ) ;

+      }

+   }

+   std::cout << std::accumulate( numbers.begin( ) , numbers.end( ) , 0 ) << '\n' ;

+   return 0 ;

+}

diff --git a/challenge-336/ulrich-rieke/haskell/ch-1.hs b/challenge-336/ulrich-rieke/haskell/ch-1.hs
new file mode 100755
index 0000000000..c31c224de3
--- /dev/null
+++ b/challenge-336/ulrich-rieke/haskell/ch-1.hs
@@ -0,0 +1,22 @@
+module Challenge336

+   where

+import Data.List( group , findIndices, sortOn ) 

+import qualified Data.Set as S

+

+makePairs :: [Int] -> [(Int , Int)]   

+makePairs list = map (\i -> ( i , length $ findIndices ( == i ) list )) $ S.toList

+ $ S.fromList list

+

+checkCondition :: [(Int , Int)] -> Bool

+checkCondition frequencies =

+   let sorted = sortOn snd frequencies

+       mini = snd $ head sorted

+       l    = length sorted

+   in if l == 1 then mini > 1 else (all (\p -> snd p `mod` mini == 0 ) $ drop 1  

+    sorted) && ( mini > 1 )

+

+main :: IO ( ) 

+main = do

+   putStrLn "Enter some integers separated by blanks!" 

+   numberline <- getLine

+   print $ checkCondition $ makePairs $ map read $ words numberline

diff --git a/challenge-336/ulrich-rieke/haskell/ch-2.hs b/challenge-336/ulrich-rieke/haskell/ch-2.hs
new file mode 100755
index 0000000000..ab57272255
--- /dev/null
+++ b/challenge-336/ulrich-rieke/haskell/ch-2.hs
@@ -0,0 +1,31 @@
+module Challenge336_2

+   where

+import Data.List ( (!!) ) 

+import Data.Char ( isDigit ) 

+

+convert :: String -> Int

+convert str = if head str == '-' then (read ( drop 1 str )) * (-1) else read str

+

+addNumber :: [Int] -> String -> [Int]

+addNumber list str 

+   |str == "C" = take ( l - 1 ) list

+   |str == "D" = list ++ [ (last list) * 2 ]

+   |str == "+" =  list ++ [ (list !! ( l - 2 )) + list !! ( l - 1 ) ]

+   |otherwise = list ++ [ convert str ]

+    where

+     l :: Int

+     l = length list

+

+solution :: String -> Int

+solution input = 

+   let theWords = words input 

+       (firstPart , secondPart ) = span (\s -> isDigit ( head s ) || head s == 

+	     '-' ) theWords

+       startnumbers = map convert firstPart

+   in sum $ foldl addNumber startnumbers secondPart   

+

+main :: IO ( ) 

+main = do

+   putStrLn "Enter some integers , C , D or + separated by blanks!" 

+   inputline <- getLine

+   print $ solution inputline

diff --git a/challenge-336/ulrich-rieke/perl/ch-1.pl b/challenge-336/ulrich-rieke/perl/ch-1.pl
new file mode 100755
index 0000000000..dcb6ce2a75
--- /dev/null
+++ b/challenge-336/ulrich-rieke/perl/ch-1.pl
@@ -0,0 +1,35 @@
+#!/usr/bin/perl ;

+use strict ;

+use warnings ; 

+use feature 'say' ;

+use List::Util qw ( all ) ;

+

+say "Enter some integers separated by blanks!" ;

+my $line = <STDIN> ;

+chomp $line ;

+my @numbers = split( /\s+/ , $line ) ;

+my %frequencies ;

+my @pairs ;

+map { $frequencies{$_}++ } @numbers ;

+for my $k ( keys %frequencies ) {

+   push( @pairs , [$k , $frequencies{$k} ] ) ;

+}

+my $result = 0 ;

+if ( scalar( @pairs ) == 1 ) {

+   if ( $pairs[0]->[1] > 1 ) {

+      $result = 1 ;

+   }

+}

+else {

+   my @sorted = sort { $a->[1] <=> $b->[1] } @pairs ;

+   my $mini = $sorted[0]->[1] ;

+   if ( $mini > 1 && all { $_->[1] % $mini == 0 } @sorted[1..$#sorted] ) {

+      $result = 1 ;

+   }

+}

+if ( $result == 0 ) {

+   say "false" ;

+}

+else {

+   say "true" ;

+}

diff --git a/challenge-336/ulrich-rieke/perl/ch-2.pl b/challenge-336/ulrich-rieke/perl/ch-2.pl
new file mode 100755
index 0000000000..7242f311da
--- /dev/null
+++ b/challenge-336/ulrich-rieke/perl/ch-2.pl
@@ -0,0 +1,35 @@
+#!/usr/bin/perl ;

+use strict ;

+use warnings ;

+use feature 'say' ;

+use List::Util qw ( sum ) ;

+

+say "Enter some numbers and the letters C , D or + separated by spaces!" ;

+my $line = <STDIN> ;

+chomp $line ;

+my @parts = split( /\s+/ , $line ) ;

+my @numbers ;

+my $len = scalar( @parts ) ;

+my $pos = 0 ;

+while ( $pos < $len && $parts[$pos] =~ /\d+/ ) {

+   push( @numbers , $parts[$pos] ) ;

+   $pos++ ;

+}

+for my $p ($pos..$len - 1) {

+   if ( $parts[$p] =~ /C|D|\+/ ) {

+      if ( $parts[$p] eq 'C' ) {

+	 pop( @numbers ) ;

+      }

+      if ( $parts[$p] eq 'D' ) {

+	 push( @numbers , $numbers[-1] * 2 ) ;

+      }

+      if ( $parts[$p] eq '+' ) {

+	 my $l = scalar( @numbers ) ;

+	 push( @numbers , $numbers[$l - 2 ] + $numbers[$l - 1] ) ;

+      }

+   }

+   else { #it must be a number !

+      push( @numbers , $parts[$p] ) ;

+   }

+}

+say sum( @numbers ) ;

diff --git a/challenge-336/ulrich-rieke/raku/ch-1.raku b/challenge-336/ulrich-rieke/raku/ch-1.raku
new file mode 100755
index 0000000000..3512ffbc1f
--- /dev/null
+++ b/challenge-336/ulrich-rieke/raku/ch-1.raku
@@ -0,0 +1,26 @@
+use v6 ;

+

+say "Enter some integers separated by blanks!" ;

+my $line = $*IN.get ;

+my @numbers = $line.words.map( {.Int } ) ;

+my %frequencies ;

+for @numbers -> $k {

+   %frequencies{$k}++ ;

+}

+my $result ;

+if %frequencies.keys.elems == 1 {

+   my $num = %frequencies.keys[0] ;

+   $result = $num > 1 ;

+}

+else {

+   my @pairs ;

+   for %frequencies.keys -> $k {

+      @pairs.push( [$k , %frequencies{$k}] ) ;

+   }

+   my @sorted = @pairs.sort( {$^a[1] <=> $^b[1] } ) ;

+   my $mini = @sorted[0][1] ;

+   $result = $mini > 1 && @sorted[1..@sorted.elems - 1].grep( {$_[1] %% $mini} )

+      .elems == @sorted.elems - 1 ;

+}

+say $result ;

+

diff --git a/challenge-336/ulrich-rieke/raku/ch-2.raku b/challenge-336/ulrich-rieke/raku/ch-2.raku
new file mode 100755
index 0000000000..2d2eff22b5
--- /dev/null
+++ b/challenge-336/ulrich-rieke/raku/ch-2.raku
@@ -0,0 +1,30 @@
+use v6 ;

+

+say "Enter some integers and the character + , C or D separated by whitespace!" ;

+my $line = $*IN.get ;

+my @parts = $line.words ;

+my @numbers ;

+my $len = @parts.elems ;

+my $pos = 0 ;

+while ( $pos < $len  && @parts[$pos] ~~ /\d+/ ) {

+   @numbers.push( +(@parts[$pos]) ) ;

+   $pos++ ;

+}

+for ($pos..$len - 1 ) -> $i {

+   if ( @parts[ $i ] ~~ /'C' | 'D' | '+' / ) {

+      if ( @parts[ $i ] eq 'C' ) {

+	 @numbers.pop( ) ;

+      }

+      if ( @parts[ $i ] eq 'D' ) {

+	 @numbers.push( @numbers[*-1] * 2 ) ;

+      }

+      if ( @parts[ $i ] eq '+' ) {

+	 my $l = @numbers.elems ;

+	 @numbers.push( @numbers[$l - 2 ] + @numbers[ $l - 1 ] ) ;

+      }

+   }

+   else { #we must be at a number 

+      @numbers.push( +@parts[$i] ) ;

+   }

+}

+say [+] @numbers ;

diff --git a/challenge-336/ulrich-rieke/rust/ch-1.rs b/challenge-336/ulrich-rieke/rust/ch-1.rs
new file mode 100755
index 0000000000..902a91f315
--- /dev/null
+++ b/challenge-336/ulrich-rieke/rust/ch-1.rs
@@ -0,0 +1,30 @@
+use std::io ;
+use std::collections::HashSet ;
+
+fn main() {
+    println!("Enter some integers separated by blanks!");
+    let mut inline : String = String::new( ) ;
+    io::stdin( ).read_line( &mut inline ).unwrap( ) ;
+    let numbers : Vec<i32> = inline.trim( ).split_whitespace( ).map( |s| 
+	  s.parse::<i32>( ).unwrap( )).collect( ) ;
+    let mut uniques : HashSet<i32> = HashSet::new( ) ;
+    for n in &numbers {
+       uniques.insert(*n ) ;
+    }
+    let mut numfrequencies : Vec<(i32, usize)> = Vec::new( ) ;
+    for n in &uniques {
+       numfrequencies.push( (*n , numbers.iter( ).filter( |&d| *d == *n ).count( )) ) ;
+    }
+    let result : bool  ;
+    if uniques.len( ) == 1 {
+       result = numbers.len( ) > 1 ;
+    }
+    else {
+       let freq_slice = &mut numfrequencies[..] ;
+       freq_slice.sort_by( |a , b| a.1.cmp( &b.1 ) ) ;
+       let mini : usize = freq_slice[0].1 ;
+       result = mini > 1 && freq_slice.into_iter( ).skip( 1 ).map( |p| p.1 )
+	  .all( |n| n % mini == 0 ) ;
+    }
+    println!("{}" , result ) ;
+}
diff --git a/challenge-336/ulrich-rieke/rust/ch-2.rs b/challenge-336/ulrich-rieke/rust/ch-2.rs
new file mode 100755
index 0000000000..53db5bfeb8
--- /dev/null
+++ b/challenge-336/ulrich-rieke/rust/ch-2.rs
@@ -0,0 +1,49 @@
+use std::io ;
+
+fn main() {
+    println!("Enter some integers or letters D , C or + separated by blanks!");
+    let mut inline : String = String::new( ) ;
+    io::stdin( ).read_line( &mut inline ).unwrap( ) ;
+    let entrystrings : Vec<&str> = inline.trim( ).split_whitespace( ).collect( );
+    let mut numbers : Vec<i32> = Vec::new( ) ;
+    if let Some( pos ) = entrystrings.iter( ).position( |s| ! s.parse::<i32>( ).
+	  is_ok( ) ) {
+       if pos < entrystrings.len( ) {
+	  entrystrings.iter( ).take( pos ).map( |s| s.parse::<i32>( ).unwrap( )).
+	     for_each( |n| numbers.push( n ) ) ;
+	  let len : usize = entrystrings.len( ) ;
+	  for p in pos..len {
+	     let value : &str = entrystrings[p] ;
+	     if value == "C" {
+		numbers.remove( numbers.len( ) - 1 ) ;
+	     }
+	     if value == "D" {
+		let l = numbers.len( ) ;
+		numbers.push( numbers[l - 1] * 2 ) ;
+	     }
+	     if value == "+" {
+		let l = numbers.len( ) ;
+		numbers.push( numbers[l - 2] + numbers[l - 1] ) ;
+	     }
+	     if value.chars( ).count( ) >= 2 {
+		let num : i32 = value.parse::<i32>( ).unwrap( ) ;
+		numbers.push( num ) ;
+	     }
+	     if value.chars( ).count( ) == 1 && value.chars( ).nth( 0 ).unwrap( ).
+		is_ascii_digit( ) {
+		   let num : i32 = value.parse::<i32>( ).unwrap( ) ;
+		   numbers.push( num ) ;
+	     }
+	  }
+       }
+       else {
+       }
+       println!("{}" , numbers.into_iter( ).sum::<i32>( ) ) ;
+    }
+    else {
+       for s in entrystrings {
+	  numbers.push( s.parse::<i32>( ).unwrap( )) ;
+       }
+       println!("{}" , numbers.into_iter( ).sum::<i32>( ) ) ;
+    }
+}