- Added solutions by Ulrich Rieke.

25 files changed, 1908 insertions, 1419 deletions

diff --git a/challenge-193/ulrich-rieke/cpp/ch-1.cpp b/challenge-193/ulrich-rieke/cpp/ch-1.cpp
new file mode 100644
index 0000000000..67e5eae34d
--- /dev/null
+++ b/challenge-193/ulrich-rieke/cpp/ch-1.cpp
@@ -0,0 +1,44 @@
+#include <iostream>
+#include <string>
+#include <algorithm>
+#include <cstdlib>
+#include <vector>
+
+std::string toBinaryString( int n , int len ) {
+  std::string binary ;
+  while ( n != 0 ) {
+      binary.append( std::to_string( n % 2 )) ;
+      n /= 2 ;
+  }
+  while ( binary.length( ) < len )
+      binary.append( "0" ) ;
+  std::reverse( binary.begin( ) , binary.end( ) ) ;
+  return binary ;
+}
+
+int main( int argc , char * argv[] ) {
+  if ( argc != 2 ) {
+      std::cerr << "usage : <programname> <number of ones>!\n" ;
+      return 1 ;
+  }
+  else {
+      int n = std::atoi( argv[ 1 ] ) ;
+      int sum = 0 ;
+      int multiplier = 1 ;
+      for ( int i = 0 ; i < n ; i++ ) {
+    sum += multiplier ;
+    multiplier *= 2 ;
+      }
+      std::vector<std::string> allBinaries ;
+      for ( int i = 0 ; i < sum + 1 ; i++ ) {
+    allBinaries.push_back( toBinaryString( i , n )) ;
+      }
+      for ( const auto & str : allBinaries ) {
+    std::cout << str ;
+    if ( str != allBinaries.back( ) )
+        std::cout << ", " ;
+      }
+      std::cout << std::endl ;
+      return 0 ;
+  }
+}
diff --git a/challenge-193/ulrich-rieke/cpp/ch-2.cpp b/challenge-193/ulrich-rieke/cpp/ch-2.cpp
new file mode 100644
index 0000000000..9390ad089a
--- /dev/null
+++ b/challenge-193/ulrich-rieke/cpp/ch-2.cpp
@@ -0,0 +1,85 @@
+#include <string>
+#include <iostream>
+#include <vector>
+#include <utility>
+
+//find the letter differences of a given string
+int findDifference( const std::string & st ) {
+  std::vector<int> differences ;
+  for ( auto it = st.begin( ) ; it != st.end( ) ; it++ ) {
+      differences.push_back( static_cast<int>( *it ) - 97 ) ;
+  }
+  std::vector<int> results ;
+  while ( results.size( ) != 1 ) {
+      int len = differences.size( ) ;
+      for ( int i = 0 ; i < len - 1 ; i++ ) {
+    results.push_back( differences[ i + 1 ] - differences[ i ] ) ;
+      }
+      if ( results.size( ) != 1 ) {
+    differences.clear( ) ;
+    for ( int i : results ) {
+        differences.push_back( i ) ;
+    }
+    results.clear( ) ;
+      }
+  }
+  return *results.begin( ) ;
+}
+
+std::vector<std::string> split( const std::string & startline , const std::string & sep ) {
+  std::vector<std::string> separated ;
+  std::string::size_type start { 0 } ;
+  std::string::size_type pos ;
+  do {
+      pos = startline.find_first_of( sep , start ) ;
+      separated.push_back( startline.substr(start , pos - start )) ;
+      start = pos + 1 ;
+  } while ( pos != std::string::npos ) ;
+  return separated ;
+}
+
+int main( ) {
+  std::cout << "Please enter some strings of equal length, separated by blanks!\n" ;
+  std::string line ;
+  std::getline( std::cin , line ) ;
+  std::vector<std::string> strings( split( line , " " )) ;
+  std::vector<int> differences ;
+  for ( const auto & s: strings ) {//there is a difference for every string
+      differences.push_back( findDifference( s ) ) ;
+  }
+  //we create 3 vectors, for differences above 0 , equal to 0 and under 0
+  //we pair the up with the index in the number string which comes first
+  //in the pairs. This allows us to immediately access "the odd string"
+  std::vector<std::pair<int , int>> aboveNils , nils , underNils ;
+  int count = 0 ;
+  for ( int i : differences ) {
+      if ( i < 0 )
+    underNils.push_back( std::make_pair( count , i ) ) ;
+      if ( i == 0 )
+    nils.push_back( std::make_pair( count , i ) ) ;
+      if ( i > 0 )
+    aboveNils.push_back( std::make_pair( count , i ) ) ;
+      count++ ;
+  }
+  std::string result ;
+  //in all subsequent size checks, if there is only one pair in the array
+  //the first int in that pair is the index of the odd string
+  if ( underNils.size( ) == 1 ) {
+      result = strings[(*underNils.begin( )).first] ;
+  }
+  else {
+      if ( nils.size( ) == 1 ) {
+    result = strings[(*nils.begin( ) ).first] ;
+      }
+      else {
+    if ( aboveNils.size( ) != 1 ) {
+        result = "Cannot find a clearly distinctive string!" ;
+    }
+    else {
+        result = strings[(*aboveNils.begin( ) ).first] ;
+    }
+      }
+  }
+  std::cout << result << std::endl ;
+  return 0 ;
+}
diff --git a/challenge-193/ulrich-rieke/haskell/ch-1.hs b/challenge-193/ulrich-rieke/haskell/ch-1.hs
new file mode 100644
index 0000000000..569fd64c3c
--- /dev/null
+++ b/challenge-193/ulrich-rieke/haskell/ch-1.hs
@@ -0,0 +1,18 @@
+module Challenge193
+  where
+
+toBinaryVec :: Int -> Int -> [Int]
+toBinaryVec num len = replicate ( len - length result ) 0 ++ result
+where
+  result :: [Int]
+  result = snd $ until ( (== 0) . fst ) step ( num , [] )
+  step :: (Int , [Int] ) -> ( Int , [Int] )
+  step ( d , li ) = ( div d 2 , mod d 2 : li )
+
+findLimit :: Int -> Int
+findLimit n = sum $ map (\p -> fst p * snd p ) $ zip ( iterate ( * 2 ) 1 )
+( replicate n 1 )
+
+solution :: Int -> [String]
+solution n = map (\vec -> foldl1 ( ++ ) $ map show vec ) $ map (\i ->
+toBinaryVec i n ) [0..findLimit n]
diff --git a/challenge-193/ulrich-rieke/haskell/ch-2.hs b/challenge-193/ulrich-rieke/haskell/ch-2.hs
new file mode 100644
index 0000000000..bf03738133
--- /dev/null
+++ b/challenge-193/ulrich-rieke/haskell/ch-2.hs
@@ -0,0 +1,44 @@
+module Challenge193_2
+  where
+import Data.List.Split( divvy )
+import Data.Char ( ord )
+
+developNumArray :: [Int] -> [Int]
+developNumArray list = concat $ until ( (== 1 ) . length ) step ( divvy 2 1 list )
+where
+  step :: [[Int]] -> [[Int]]
+  step allSublists = divvy 2 1 $ map (\subli -> last subli - head subli ) allSublists
+ 
+findDifference :: String -> Int
+findDifference s = last li - head li
+where
+  li :: [Int]
+  li = developNumArray $ map (\c -> ord c - 97 ) s
+
+separate :: [String] -> [[String]]
+separate strings = [firstList , secondList , thirdList]
+where
+  firstList :: [String]
+  firstList = filter (\s -> findDifference s < 0 ) strings
+  secondList :: [String]
+  secondList = filter( \s -> findDifference s == 0 ) strings
+  thirdList = filter (\s -> findDifference s > 0 ) strings
+
+keepAskingForInput :: IO [String]
+keepAskingForInput = do
+  putStrLn "Enter a line of strings, all of the same length, separated by blanks!"
+  input <- getLine
+  let theStrings = words input
+  if all (\s -> length s == ( length $ head theStrings )) theStrings
+    then return theStrings
+    else do
+    keepAskingForInput
+
+main :: IO ( )
+main = do
+  allStrings <- keepAskingForInput
+  let separatedLists = separate allStrings
+  if  all ( (/= 1 ) . length ) separatedLists
+  then putStrLn "No distinctive string can be found!"
+  else putStrLn $ head $ concat $ filter ((== 1 ) . length )
+    separatedLists
diff --git a/challenge-193/ulrich-rieke/perl/ch-1.pl b/challenge-193/ulrich-rieke/perl/ch-1.pl
new file mode 100644
index 0000000000..c706c00eea
--- /dev/null
+++ b/challenge-193/ulrich-rieke/perl/ch-1.pl
@@ -0,0 +1,20 @@
+#!/usr/bin/perl ;
+use strict ;
+use warnings ;
+use feature 'say' ;
+use Algorithm::Combinatorics qw ( variations_with_repetition ) ;
+
+my $n = $ARGV[0] ;
+my @seeder = ( 0 , 1 ) ;
+my @combis ;
+my $iter = variations_with_repetition( \@seeder , $n ) ;
+while ( my $p = $iter->next( )) {
+  push @combis, $p ;
+}
+for my $combi( @combis ) {
+  print join( '' , @$combi ) ;
+  unless ( $combi == $combis[-1] ) {
+      print ", " ;
+  }
+}
+say " " ;
diff --git a/challenge-193/ulrich-rieke/perl/ch-2.pl b/challenge-193/ulrich-rieke/perl/ch-2.pl
new file mode 100644
index 0000000000..a7933b3a02
--- /dev/null
+++ b/challenge-193/ulrich-rieke/perl/ch-2.pl
@@ -0,0 +1,69 @@
+#!/usr/bin/perl ;
+use strict ;
+use warnings ;
+use feature 'say' ;
+
+sub findDifference {
+  my $word = shift ;
+  my @positions = map { (ord $_) - 97 } split( // , $word ) ;
+  my @result ;
+  while ( scalar( @result ) != 1 ) {
+      my $len = scalar( @positions ) ;
+      for my $i ( 0..$len - 2 ) {
+    push @result , $positions[ $i + 1 ] - $positions[ $i ] ;
+      }
+#if the array of differences in @result contains more than 1 number,
+#we clear the positions array and transfer all elements of @result into
+#it until @result has only one element
+      if ( scalar( @result ) > 1 ) {
+    @positions = ( ) ;
+    for my $r ( @result ) {
+        push @positions , $r ;
+    }
+    @result = ( ) ;
+      }
+  }
+  return $result[0] ;
+}
+
+#find the index of a given number in an array
+sub findIndex {
+  my $array = shift ;
+  my $num = shift ;
+  my $pos = 0 ;
+  while ( $array->[$pos] != $num ) {
+      $pos++ ;
+  }
+  return $pos ;
+}
+
+say "Enter some strings of equal length, separated by a blank!" ;
+my $line = <STDIN> ;
+chomp $line ;
+my @strings = split ( /\s/ , $line ) ;
+my @differences = map { findDifference( $_ ) } @strings ;
+my $pos ;
+my $result ;
+my @underNil = grep { $_ < 0 } @differences ;
+if ( scalar( @underNil ) == 1 ) {
+  $pos = findIndex( \@differences, $underNil[0] ) ;
+  $result = $strings[ $pos ] ;
+}
+else {
+  my @nils = grep { $_ == 0 } @differences ;
+  if ( scalar( @nils ) == 1 ) {
+      $pos = findIndex( \@differences , $nils[0] ) ;
+      $result = $strings[ $pos ] ;
+  }
+  else {
+      my @overnil = grep { $_ > 0 } @differences ;
+      if ( scalar( @overnil ) != 1 ) {
+    $result = "There appears to be no distinctive string!" ;
+      }
+      else {
+    $pos = findIndex( \@differences, $overnil[0] ) ;
+    $result = $strings[ $pos ] ;
+      }
+  }
+}
+say $result ;
diff --git a/challenge-193/ulrich-rieke/raku/ch-1.raku b/challenge-193/ulrich-rieke/raku/ch-1.raku
new file mode 100644
index 0000000000..6f05c4df68
--- /dev/null
+++ b/challenge-193/ulrich-rieke/raku/ch-1.raku
@@ -0,0 +1,22 @@
+use v6 ;
+
+sub change( Str $binary , Int $len ) {
+  my $changed ;
+  if ( $binary.chars < $len ) {
+      $changed = ( '0' x $len - $binary.chars ) ~ $binary ;
+  }
+  else {
+      $changed = $binary ;
+  }
+  return $changed ;
+}
+
+sub MAIN( $n where $n > 0 ) {
+  my $limit = ('1' x $n).parse-base( 2 ) ;
+  my @combis ;
+  for (0..$limit) -> $num {
+      @combis.push( $num.base( 2 ) ) ;
+  }
+  my @changed = @combis.map( { &change( $_ , $n ) } ) ;
+  say @changed.join( ',' ) ;
+}
diff --git a/challenge-193/ulrich-rieke/raku/ch-2.raku b/challenge-193/ulrich-rieke/raku/ch-2.raku
new file mode 100644
index 0000000000..613b9cb726
--- /dev/null
+++ b/challenge-193/ulrich-rieke/raku/ch-2.raku
@@ -0,0 +1,54 @@
+use v6 ;
+#find the final difference in a string
+sub findDifference( Str $word --> Int ) {
+  my @posValues = $word.comb.map( { ord( $_ ) - 97  } ) ;
+  my @differences = @posValues.rotor( 2 => -1 ) ;
+  my @results ; #here we keep the differences
+  while ( @results.elems != 1 ) {
+      for @differences -> @positions {
+    @results.push( @positions[1] - @positions[0] ) ;
+      }
+      if ( @results.elems > 1 ) {
+    @differences = ( ) ;
+    for @results -> $num {
+        @differences.push( $num ) ;
+    }
+    @results = ( ) ;
+    @differences = @differences.rotor( 2 => -1 ) ;
+      }
+  }
+  return @results[ 0 ] ;
+}
+
+#We assume that one string stands out! As far as I can see it from
+#the task it may be the only string with a final difference value
+#of under 0 , 0 or over 0, but since I'm far from sure if that is
+#what you mean and whether it is always possible to uniquely identify
+#such a string, I provide a possible result saying precisely this
+say "Enter some strings of equal length, separated by blanks!" ;
+my $line = $*IN.get ;
+my @strings = $line.split( /\s/ ) ;
+my %stringDifferences ;
+for @strings -> $str {
+  %stringDifferences{ $str } = findDifference( $str ) ;
+}
+my @differenceNumbers = %stringDifferences.values( ) ;
+my @underNils = @differenceNumbers.grep( { $_ < 0 } ) ;
+my @nils = @differenceNumbers.grep( { $_ == 0 } ) ;
+my @overNils = @differenceNumbers.grep( { $_ > 0 } ) ;
+my $result ;
+if ( @underNils.elems == 1 ) {
+  $result = @strings.grep( { %stringDifferences{ $_ } < 0 } )[0] ;
+}
+elsif ( @nils.elems == 1 ) {
+  $result = @strings.grep( { %stringDifferences{ $_ } == 0 })[0] ;
+}
+else {
+  if ( @overNils.elems > 1 ) {
+      $result = "I cannot find the distinctive odd string!" ;
+  }
+  else {
+      $result = @strings.grep( { %stringDifferences{ $_ } > 0 })[0] ;
+  }
+}
+say $result ;
diff --git a/challenge-193/ulrich-rieke/rust/ch-1.rs b/challenge-193/ulrich-rieke/rust/ch-1.rs
new file mode 100644
index 0000000000..752e222c0d
--- /dev/null
+++ b/challenge-193/ulrich-rieke/rust/ch-1.rs
@@ -0,0 +1,47 @@
+use std::io ;
+
+fn find_limit( number : usize ) -> i32 {
+  let mut sum : i32 = 0 ;
+  let mut multiplier : i32 = 1 ;
+  for _ in 0..number {
+      sum += multiplier ;
+      multiplier *= 2 ;
+  }
+  sum
+}
+
+fn to_binary_string( mut num : i32 , length : usize ) -> String {
+  let mut binary_str : String = String::new( ) ;
+  while num != 0 {
+      if num % 2 == 1 {
+    binary_str.push( '1' ) ;
+      }
+      else {
+    binary_str.push( '0' ) ;
+      }
+      num /= 2 ;
+  }
+  let len : usize = binary_str.len( ) ;
+  for _ in len..length {
+      binary_str.push( '0' ) ;
+  }
+  let binary : &str = &binary_str[..] ;
+  let mut reversed : String = String::new( ) ;
+  binary.chars( ).rev( ).for_each( | c | reversed.push( c ) ) ;
+  reversed
+}
+ 
+fn main() {
+    println!("Enter an integer greater than 0!");
+    let mut inline : String = String::new( ) ;
+    io::stdin( ).read_line( &mut inline ).unwrap( ) ;
+    let entered : &str = &*inline ;
+    let n : usize = entered.trim( ).parse::<usize>().unwrap( ) ;
+    let limit : i32 = find_limit( n ) ;
+    let mut strings : Vec<String> = Vec::new( ) ;
+    for num in 0..=limit {
+      let bin_str = to_binary_string( num , n ) ;
+      strings.push( bin_str ) ;
+    }
+    println!("{:?}" , strings ) ;
+}
diff --git a/challenge-193/ulrich-rieke/rust/ch-2.rs b/challenge-193/ulrich-rieke/rust/ch-2.rs
new file mode 100644
index 0000000000..11c94426e8
--- /dev/null
+++ b/challenge-193/ulrich-rieke/rust/ch-2.rs
@@ -0,0 +1,67 @@
+use std::io ;
+use std::collections::HashMap ;
+
+fn find_string_difference( input : &str , lv : &HashMap<char, i32>) -> i32 {
+  let mut letters : Vec<char> = Vec::new( ) ;
+  for c in input.chars( ) {
+      letters.push( c ) ;
+  }
+  let len = letters.len( ) ;
+  let mut differences : Vec<i32> = Vec::new( ) ;
+  for i in 0..len - 1 {
+      differences.push( lv.get( &letters[ i + 1 ]).unwrap( ) -
+        lv.get( &letters[ i ]).unwrap( )) ;
+  }
+  let mut results : Vec<i32> = Vec::new( ) ;
+  while results.len( ) != 1 {
+      let l = differences.len( ) ;
+      for i in 0..l - 1 {
+    results.push( differences[ i + 1 ] - differences[ i ] ) ;
+      }
+      if results.len( ) > 1 {
+    differences.clear( ) ;
+    for i in 0..results.len( ) {
+        differences.push( results[ i ] ) ;
+    }
+    results.clear( ) ;
+      }
+  }
+  results[0]
+}
+
+fn main() {
+  let mut letter_values = HashMap::new( ) ;
+  letter_values.insert( 'a' , 0 ) ;
+  let mut pos : i32 = 1 ;
+  for c in 'b'..='z' {
+      letter_values.insert( c , pos ) ;
+      pos += 1 ;
+  }
+  let mut input : String = String::new( ) ;
+  println!("Enter some strings of same length separated by a blank!" ) ;
+  io::stdin( ).read_line( &mut input ).unwrap( ) ;
+  let entered_line : &str = &*input ;
+  let inputstrings : Vec<&str> = entered_line.split_whitespace( )
+      .map( | s | s.trim( ) ).collect( ) ;
+  let mut below_zero : Vec<&str> = Vec::new( ) ;
+  let mut zero : Vec<&str> = Vec::new( ) ;
+  let mut above_zero : Vec<&str> = Vec::new( ) ;
+  inputstrings.iter( ).filter( | s | find_string_difference( s ,
+        &letter_values ) < 0 ).for_each( | s | below_zero.push( s )) ;
+  inputstrings.iter( ).filter( | s | find_string_difference( s ,
+        &letter_values ) == 0 ).for_each( | s |
+        zero.push( s )) ;
+  inputstrings.iter( ).filter( | s | find_string_difference( s ,
+        &letter_values ) > 0 ).for_each( | s |
+        above_zero.push( s ) ) ;
+  let ordered : Vec<&Vec<&str>> = vec![&below_zero , &zero , &above_zero] ;
+  if ordered.iter( ).all( | &vector | vector.len( ) != 1 ) {
+      println!("No distinctive string can be found!" ) ;
+  }
+  else {
+      let pos: usize = ordered.iter( ).position( | &v | v.len( ) == 1 )
+    .unwrap( ) ;
+      let selected : Vec<&str> = ordered[ pos ].to_vec( ) ;
+      println!("{:?}" , selected[0] ) ;
+  }
+}
diff --git a/stats/pwc-current.json b/stats/pwc-current.json
index 0b198733fc..f8ef0ad87e 100644
--- a/stats/pwc-current.json
+++ b/stats/pwc-current.json
@@ -1,12 +1,35 @@
 {
+   "yAxis" : {
+      "title" : {
+         "text" : "Total Solutions"
+      }
+   },
+   "chart" : {
+      "type" : "column"
+   },
+   "title" : {
+      "text" : "The Weekly Challenge - 193"
+   },
+   "legend" : {
+      "enabled" : 0
+   },
+   "tooltip" : {
+      "followPointer" : 1,
+      "headerFormat" : "<span style='font-size:11px'>{series.name}</span><br/>",
+      "pointFormat" : "<span style='color:{point.color}'>{point.name}</span>: <b>{point.y:f}</b><br/>"
+   },
+   "subtitle" : {
+      "text" : "[Champions: 16] Last updated at 2022-11-30 18:03:21 GMT"
+   },
    "series" : [
       {
+         "colorByPoint" : 1,
          "name" : "The Weekly Challenge - 193",
          "data" : [
             {
                "name" : "Dario Mazzeo",
-               "drilldown" : "Dario Mazzeo",
-               "y" : 1
+               "y" : 1,
+               "drilldown" : "Dario Mazzeo"
             },
             {
                "name" : "E. Choroba",
@@ -14,54 +37,54 @@
                "y" : 2
             },
             {
-               "name" : "Feng Chang",
                "drilldown" : "Feng Chang",
-               "y" : 2
+               "y" : 2,
+               "name" : "Feng Chang"
             },
             {
-               "name" : "James Smith",
+               "y" : 3,
                "drilldown" : "James Smith",
-               "y" : 3
+               "name" : "James Smith"
             },
             {
-               "name" : "Laurent Rosenfeld",
+               "y" : 5,
                "drilldown" : "Laurent Rosenfeld",
-               "y" : 5
+               "name" : "Laurent Rosenfeld"
             },
             {
+               "drilldown" : "Luca Ferrari",
                "y" : 8,
-               "name" : "Luca Ferrari",
-               "drilldown" : "Luca Ferrari"
+               "name" : "Luca Ferrari"
             },
             {
                "drilldown" : "Mark Anderson",
-               "name" : "Mark Anderson",
-               "y" : 2
+               "y" : 2,
+               "name" : "Mark Anderson"
             },
             {
-               "y" : 2,
                "name" : "Niels van Dijke",
+               "y" : 2,
                "drilldown" : "Niels van Dijke"
             },
             {
-               "name" : "Olivier Delouya",
+               "y" : 1,
                "drilldown" : "Olivier Delouya",
-               "y" : 1
+               "name" : "Olivier Delouya"
             },
             {
-               "name" : "Peter Campbell Smith",
+               "y" : 3,
                "drilldown" : "Peter Campbell Smith",
-               "y" : 3
+               "name" : "Peter Campbell Smith"
             },
             {
-               "y" : 2,
                "name" : "Robert DiCicco",
-               "drilldown" : "Robert DiCicco"
+               "drilldown" : "Robert DiCicco",
+               "y" : 2
             },
             {
-               "y" : 4,
+               "name" : "Roger Bell_West",
                "drilldown" : "Roger Bell_West",
-               "name" : "Roger Bell_West"
+               "y" : 4
             },
             {
                "y" : 1,
@@ -70,70 +93,62 @@
             },
             {
                "drilldown" : "Stephen G. Lynn",
-               "name" : "Stephen G. Lynn",
-               "y" : 5
+               "y" : 5,
+               "name" : "Stephen G. Lynn"
             },
             {
+               "name" : "Thomas Kohler",
                "y" : 2,
-               "drilldown" : "Thomas Kohler",
-               "name" : "Thomas Kohler"
+               "drilldown" : "Thomas Kohler"
+            },
+            {
+               "y" : 4,
+               "drilldown" : "Ulrich Rieke",
+               "name" : "Ulrich Rieke"
             }
-         ],
-         "colorByPoint" : 1
+         ]
       }
    ],
-   "subtitle" : {
-      "text" : "[Champions: 15] Last updated at 2022-11-30 16:58:08 GMT"
-   },
-   "title" : {
-      "text" : "The Weekly Challenge - 193"
-   },
-   "xAxis" : {
-      "type" : "category"
-   },
-   "legend" : {
-      "enabled" : 0
-   },
    "plotOptions" : {
       "series" : {
-         "borderWidth" : 0,
          "dataLabels" : {
-            "format" : "{point.y}",
-            "enabled" : 1
-         }
+            "enabled" : 1,
+            "format" : "{point.y}"
+         },
+         "borderWidth" : 0
       }
    },
    "drilldown" : {
       "series" : [
          {
-            "id" : "Dario Mazzeo",
-            "name" : "Dario Mazzeo",
             "data" : [
                [
                   "Perl",
                   1
                ]
-            ]
+            ],
+            "id" : "Dario Mazzeo",
+            "name" : "Dario Mazzeo"
          },
          {
-            "name" : "E. Choroba",
             "data" : [
                [
                   "Perl",
                   2
                ]
             ],
-            "id" : "E. Choroba"
+            "id" : "E. Choroba",
+            "name" : "E. Choroba"
          },
          {
-            "name" : "Feng Chang",
+            "id" : "Feng Chang",
             "data" : [
                [
                   "Raku",
                   2
                ]
             ],
-            "id" : "Feng Chang"
+            "name" : "Feng Chang"
          },
          {
             "data" : [
@@ -146,12 +161,12 @@
                   1
                ]
             ],
-            "name" : "James Smith",
-            "id" : "James Smith"
+            "id" : "James Smith",
+            "name" : "James Smith"
          },
          {
-            "id" : "Laurent Rosenfeld",
             "name" : "Laurent Rosenfeld",
+            "id" : "Laurent Rosenfeld",
             "data" : [
                [
                   "Perl",
@@ -168,7 +183,6 @@
             ]
          },
          {
-            "name" : "Luca Ferrari",
             "data" : [
                [
                   "Raku",
@@ -179,27 +193,28 @@
                   6
                ]
             ],
-            "id" : "Luca Ferrari"
+            "id" : "Luca Ferrari",
+            "name" : "Luca Ferrari"
          },
          {
-            "id" : "Mark Anderson",
             "data" : [
                [
                   "Raku",
                   2
                ]
             ],
+            "id" : "Mark Anderson",
             "name" : "Mark Anderson"
          },
          {
-            "name" : "Niels van Dijke",
+            "id" : "Niels van Dijke",
             "data" : [
                [
                   "Perl",
                   2
                ]
             ],
-            "id" : "Niels van Dijke"
+            "name" : "Niels van Dijke"
          },
          {
             "name" : "Olivier Delouya",
@@ -212,6 +227,7 @@
             "id" : "Olivier Delouya"
          },
          {
+            "id" : "Peter Campbell Smith",
             "data" : [
                [
                   "Perl",
@@ -222,10 +238,10 @@
                   1
                ]
             ],
-            "name" : "Peter Campbell Smith",
-            "id" : "Peter Campbell Smith"
+            "name" : "Peter Campbell Smith"
          },
          {
+            "name" : "Robert DiCicco",
             "id" : "Robert DiCicco",
             "data" : [
                [
@@ -236,10 +252,11 @@
                   "Raku",
                   1
                ]
-            ],
-            "name" : "Robert DiCicco"
+            ]
          },
          {
+            "name" : "Roger Bell_West",
+            "id" : "Roger Bell_West",
             "data" : [
                [
                   "Perl",
@@ -249,19 +266,17 @@
                   "Raku",
                   2
                ]
-            ],
-            "name" : "Roger Bell_West",
-            "id" : "Roger Bell_West"
+            ]
          },
          {
-            "name" : "Simon Proctor",
+            "id" : "Simon Proctor",
             "data" : [
                [
                   "Raku",
                   1
                ]
             ],
-            "id" : "Simon Proctor"
+            "name" : "Simon Proctor"
          },
          {
             "id" : "Stephen G. Lynn",
@@ -288,22 +303,26 @@
                   2
                ]
             ],
-            "name" : "Thomas Kohler",
-            "id" : "Thomas Kohler"
+            "id" : "Thomas Kohler",
+            "name" : "Thomas Kohler"
+         },
+         {
+            "name" : "Ulrich Rieke",
+            "data" : [
+               [
+                  "Perl",
+                  2
+               ],
+               [
+                  "Raku",
+                  2
+               ]
+            ],
+            "id" : "Ulrich Rieke"
          }
       ]
    },
-   "yAxis" : {
-      "title" : {
-         "text" : "Total Solutions"
-      }
-   },
-   "chart" : {
-      "type" : "column"
-   },
-   "tooltip" : {
-      "pointFormat" : "<span style='color:{point.color}'>{point.name}</span>: <b>{point.y:f}</b><br/>",
-      "headerFormat" : "<span style='font-size:11px'>{series.name}</span><br/>",
-      "followPointer" : 1
+   "xAxis" : {
+      "type" : "category"
    }
 }
diff --git a/stats/pwc-language-breakdown-summary.json b/stats/pwc-language-breakdown-summary.json
index db29e8db38..7cd2c1a293 100644
--- a/stats/pwc-language-breakdown-summary.json
+++ b/stats/pwc-language-breakdown-summary.json
@@ -1,22 +1,18 @@
 {