World Cup group stage: Difference between revisions

{{task}}

 

 

 

 

 

=={{header|C}}==

{{trans|C++}}

#include <stdio.h>

#include <stdlib.h>

 

return 0;

{{out}}

<pre>POINTS 0 1 2 3 4 5 6 7 8 9

=={{header|C++}}==

{{trans|Go}}

#include <array>

#include <iomanip>

}

return 0;

{{out}}

<pre>POINTS 0 1 2 3 4 5 6 7 8 9

<!-- By Martin Freedman, 17/01/2018 -->

Unlike the Python solution, this does not use a library for combinations and cartesian products but provides 4 1-liner Linq methods.

using System.Collections.Generic;

using System.Linq;

}

}

Produces:

<pre>

=={{header|Common Lisp}}==

{{works with|SBCL|1.4.9}}

(let ((scoring (vector 0 1 3))

(histo (list (vector 0 0 0 0 0 0 0 0 0 0) (vector 0 0 0 0 0 0 0 0 0 0)

(dotimes (i (length el))

(format t "~3D " (aref el i)))

{{out}}

<pre>

This imports the module of the third D solution of the Combinations Task.

{{trans|Python}}

import std.stdio, std.range, std.array, std.algorithm, combinations3;

 

}

writefln("%(%s\n%)", histo[].retro);

{{out}}

<pre>[0, 0, 0, 1, 14, 148, 152, 306, 0, 108]

 

This alternative version is not fully idiomatic D, it shows what to currently do to tag the main function of the precedent version as @nogc.

 

immutable uint[2][6] combs = 4u.iota.array.combinations(2).array;

printf("\n");

}

{{out}}

<pre>0 0 0 1 14 148 152 306 0 108

=={{header|Elena}}==

{{trans|Java}}

import extensions;

}

{

var points := IntMatrix.allocate(4, 10);

var records := new int[]{0,0,0,0};

{

var r := results[i];

records := records.ascendant();

{

points[i][records[i]] := points[i][records[i]] + 1

});

}

{{out}}

<pre>

=={{header|Elixir}}==

{{trans|Erlang}}

def group_stage do

results = [[3,0],[1,1],[0,3]]

:io.format(format, Enum.to_list(0..9))

IO.puts String.duplicate(" ---", 10)

 

{{out}}

This solution take advantage of the expressiveness power of the list comprehensions expressions. Function ''combos'' is copied from [http://panduwana.wordpress.com/2010/04/21/combination-in-erlang/ panduwana blog].

 

-module(world_cup).

 

combinations([H|T],List2) ->

[ [{H,Item} | Comb] || Item <- List2, Comb <- combinations(T,List2)].

 

Output:

=={{header|Go}}==

{{trans|Kotlin}}

 

import (

fmt.Println()

}

 

{{out}}

There might be a more elegant way of expressing this.

 

outcome=: 3 0,1 1,:0 3

pairs=: (i.4) e."1(2 comb 4)

 

Here, standings represents all the possible outcomes:

 

Of course, not all of them are distinct:

 

With only 556 distinct outcomes, there must be some repeats. Looking at this more closely (gathering the outcomes in identical groups, counting how many members are in each group, and then considering the unique list of group sizes):

 

Some standings can be attained two different ways, some three different ways, some four different ways, and some six different ways. Let's look at the one with six different possibilities:

 

 

That's where every team gets 4 standing.

How about outcomes which can be achieved four different ways?

 

6 6 3 3

6 3 3 6

3 6 6 3

3 6 3 6

 

Ok, that's simple. So how about a histogram. Actually, it's not clear what a histogram should represent. There are four different teams, and possible standings range from 0 through 9, so we could show the outcomes for each team:

 

27 81 81 108 162 81 81 81 0 27

27 81 81 108 162 81 81 81 0 27

27 81 81 108 162 81 81 81 0 27

 

Each team has the same possible outcomes. So instead, let's order the results so that instead of seeing each team as a distinct entity we are seeing the first place, second place, third place and fourth place team (and where there's a tie, such as 4 4 4 4, we just arbitrarily say that one of the tied teams gets in each of the tied places...):

 

0 0 0 1 14 148 152 306 0 108

0 0 4 33 338 172 164 18 0 0

0 18 136 273 290 4 8 0 0 0

 

Here, the first row represents whichever team came in first in each outcome, the second row represents the second place team and so on.

{{works with|Java|1.5+}}

This example codes results as a 6-digit number in base 3. Each digit is a game. A 2 is a win for the team on the left, a 1 is a draw, and a 0 is a loss for the team on the left.

public class GroupStage{

System.out.println("Fourth place: " + Arrays.toString(points[0]));

}

{{out}}

<pre>First place: [0, 0, 0, 1, 14, 148, 152, 306, 0, 108]

=={{header|Julia}}==

{{trans|Java}}

games = ["12", "13", "14", "23", "24", "34"]

results = "000000"

 

worldcupstages()

<pre>

First place: [0, 0, 0, 1, 14, 148, 152, 306, 0, 108]

=={{header|Kotlin}}==

{{trans|Java}}

 

val games = arrayOf("12", "13", "14", "23", "24", "34")

println()

}

 

{{out}}

=={{header|Lua}}==

{{trans|C++}}

local m = {}

for i=1,a do

end

print()

{{out}}

<pre>POINTS 0 1 2 3 4 5 6 7 8 9

{{trans|Python}}

{{libheader|itertools}}

import itertools

 

 

for x in reversed(histo):

 

{{out}}

=={{header|Perl}}==

{{trans|Raku}}

 

@scoring = (0, 1, 3);

 

$fmt = ('%3d ') x 10 . "\n";

{{out}}

<pre> 0 0 0 1 14 148 152 306 0 108

In this case I used both, and modified both to fit their particular tasks (games and results).<br>

Some credit is due to the Kotlin entry for inspiring some of the innermost code.

{{out}}

<pre>

 

=={{header|Python}}==

 

scoring = [0, 1, 3]

 

for x in reversed(histo):

{{out}}

<pre>[0, 0, 0, 1, 14, 148, 152, 306, 0, 108]

 

=={{header|Racket}}==

;; Tim Brown 2014-09-15

(define (sort-standing stndg#)

4 "Sack the team!"))

 

 

{{out}}

{{Works with|rakudo|2016.12}}

{{trans|Python}}

my @histo = [0 xx 10] xx 4;

 

}

 

{{out}}

<pre> 0 0 0 1 14 148 152 306 0 108

===version 1, static game sets===

{{trans|Java}}

results = '000000' /*start with left teams all losing */

games = '12 13 14 23 24 34'

End

End

{{out}}

<pre>[0, 0, 0, 1, 14, 148, 152, 306, 0, 108]

:::* &nbsp; used lowercase spellings of REXX keywords for easier reading.

:::* &nbsp; removed some deadcode &nbsp; (code not needed &nbsp; or &nbsp; code not used).

:::* &nbsp; aligned the numbers in the output &nbsp; (used a consisted width/length).

:::* &nbsp; added whitespace within assignments and other REXX clauses.

:::* &nbsp; used an idiomatic method to show the place winners.

:::* &nbsp; added the capability to simulate a &nbsp; ''Cricket World Cup''.

parse arg teams win . /*obtain optional argument from the CL.*/

if teams=='' | teams=="," then teams= 4 /*Not specified? Then use the default.*/

end /*j*/; return

/*──────────────────────────────────────────────────────────────────────────────────────*/

Programming note: &nbsp; additional code was add to support a nice-looking grid for displaying the output.

 

 

=={{header|Ruby}}==

matches = teams.combination(2).to_a

outcomes = [:win, :draw, :loss]

puts fmt % [" ", *0..9]

puts fmt % ["-", *["---"]*10]

{{out}}

<pre> : 0 1 2 3 4 5 6 7 8 9

 

=={{header|Scala}}==

val games = Array("12", "13", "14", "23", "24", "34")

val points = Array.ofDim[Int](4, 10) //playing 3 games, points range from 0 to 9

println("Fourth place: " + points(0).mkString("[",", ","]"))

 

 

=={{header|Tcl}}==

{{trans|Java}}

{{works with|Tcl|8.6}}

proc groupStage {} {

foreach n {0 1 2 3} {

foreach nth {First Second Third Fourth} nums [groupStage] {

puts "$nth place:\t[join [lmap n $nums {format %3s $n}] {, }]"

{{out}}

<pre>

=={{header|Visual Basic .NET}}==

{{trans|C++}}

 

Module Module1

End Sub

 

{{out}}

<pre>POINTS 0 1 2 3 4 5 6 7 8 9

{{libheader|Wren-fmt}}

{{libheader|Wren-sort}}

 

var games = ["12", "13", "14", "23", "24", "34"]

points[3-i].each { |p| Fmt.write("$5d", p) }

System.print()

 

{{out}}

=={{header|Yabasic}}==

{{trans|Java}}

 

dim game$(6)

next

print

 

=={{header|zkl}}==

{{trans|D}}{{trans|Python}}

scoring:=T(0,1,3);

histo :=(0).pump(4,List().write,(0).pump(10,List().write,0).copy); //[4][10] of zeros

foreach h,v in (histo.zip(s.sort())){ h[v]+=1; }

}

{{out}}

<pre>