Het Grote Tweakers Programmeervuur

[Verwijderd]

Memorice schreef op zaterdag 12 december 2009 @ 01:12:
[...]


Een Neural Network is gewoon een machine learning techniek voor bijvoorbeeld classification. Om eerlijk te zijn zie ik niet echt in hoe je dit in een geschikte opdracht om kunt vormen, met name omdat er ook alternatieve mogelijkheden zijn. Het enige wat ik zou kunnen bedenken is een bredere 'opdracht', waarin het gebruik van Neural Networks een mogelijke aanpak kan zijn. Zo zou je bijvoorbeeld een dataset kunnen nemen, vervolgens dit opsplitsen in een train en test gedeelte, het train gedeelte beschikbaar maken en er dan een classification task van maken, maar ik beschouw dit toch niet echt meer als een opdracht die in de context van dit topic past. Wanneer hier anders over gedacht wordt, dan kan ik best een dataset leveren...

Je doelt dus dat dit een opdracht zou kunnen zijn voor een contest ipv "een gewone programmeer opdracht".. Nee, dit is niet de topic om daarvoor te gebruiken.

Dan ga ik kijken naar de mogelijkheden bij een andere opdracht.

[writser]

Nog even terugkomend op rummikub: vorige week o.i.d. kwam ik in een situatie die ik nog nooit had meegemaakt. Ik had onderstaande stenen op mijn bordje staan (en deels er onder liggen) en toen was de zak met stenen leeg. Ik kon dus helemaal niks meer. Vervelend potje was dat .



Daarop voortbordurend vroeg ik me af: zijn alle potjes rummikub uit te spelen? Of bestaan er deadlocks, situaties waarin de zak met stenen leeg is en niemand nog iets kan. In theorie kan een potje vastlopen als iedereen de volgende stenen op zijn bordje heeft staan:

11 33 55 77 99 1111 1313 ene kleur
22 44 66 88 1010 1212 andere kleur

De zak is dan leeg en niemand kan nog winnen. Maar zijn er ook situaties waarin bijvoorbeeld 3 spelers al wel de initiele 30 punten hebben opgelegd maar het potje toch in een deadlock eindigt? Ik heb het nog nooit meegemaakt in elk geval.

[Verwijderd]

Wie zal het zeggen? Maar het wel iets om over na te denken om dit uit te zoeken dmv een programmaatje die de potten uitspelen deze casus uitzoekt.

[EdwinG]

writser schreef op zaterdag 12 december 2009 @ 15:59:
Nog even terugkomend op rummikub: vorige week o.i.d. kwam ik in een situatie die ik nog nooit had meegemaakt. Ik had onderstaande stenen op mijn bordje staan (en deels er onder liggen) en toen was de zak met stenen leeg. Ik kon dus helemaal niks meer. Vervelend potje was dat .

[afbeelding]

Hier kun je gewoon nog iets uitleggen hoor:
Zwart 7, Joker, Zwart 9, Zwart 10 is de beste optie, maar
Oranje 11, Joker, Oranje 13 is ook best te doen.

[Memorice]

Verwijderd schreef op zaterdag 12 december 2009 @ 09:33:
[...]
Je doelt dus dat dit een opdracht zou kunnen zijn voor een contest ipv "een gewone programmeer opdracht".. Nee, dit is niet de topic om daarvoor te gebruiken.

Dan ga ik kijken naar de mogelijkheden bij een andere opdracht.

Ik denk idd dat het eerder in een contest past ja, al zou het misschien nog eerder richting wetenschappelijk onderzoek gaan...

[writser]

EdwinG schreef op zaterdag 12 december 2009 @ 17:50:
[...]


Hier kun je gewoon nog iets uitleggen hoor:
Zwart 7, Joker, Zwart 9, Zwart 10 is de beste optie, maar
Oranje 11, Joker, Oranje 13 is ook best te doen.

Oh, en je dacht dat ik al die rijtjes over het hoofd had gezien? Wij spelen altijd met de regel dat je een joker niet mag gebruiken om mee uit te komen. Weet niet of dat officieel is though.

[Verwijderd]

Om gek van te worden

Ik heb hier een bestand..
Hiervan wil ik naast je code weten hoeveel keren de reeks 123 voor komt in het eerder genoemde bestand.
De reeksen moet echter horizontaal, verticaal en diagonaal ingelezen worden wat het in totaal 8 kanten moet zijn.


VB:

code:

113
223
333

In de bovenstaande tekst staat er driemaal de reeks '123'

Toevoeging: Dat het bestand in 8 richtingen gelezen moeten worden betekend dus dat de reeks op allerlei manieren dus ook in tegenovergestelde richtingen kan voor komen. Hou dus daar rekening mee.

[ Voor 31% gewijzigd door Verwijderd op 13-12-2009 17:09 ]

[Onbekend]

spoiler:

2860 2864 keer

(Ik heb niet nageteld of het klopte. )

[ Voor 7% gewijzigd door Onbekend op 13-12-2009 18:05 ]

[Silentuz]

spoiler:

2840, 100x100 array

niet gelijk aan Onbekend though.

hier is mijn code:

Java:

import java.util.*;

public class Count123 {
    //even vals gespeeld voor het aantal regels/lijnen.
    int[][] field = new int[100][100];

    public Count123() {
        // Inlezen bestand in 2d array.
        Scanner scan = new Scanner(System.in);
        int line = 0;
        while(scan.hasNextLine()){
            String nextLine = scan.nextLine();
            char[] arr = nextLine.toCharArray();
            for(int x = 0; x < arr.length; x++) {
                field[x][line] = Integer.parseInt(arr[x]+"");
            }
            line++;
        }
    }
    
    public int solve(){
        int result = 0;
        for(int y = 0; y < field[0].length; y++){
            for(int x = 0; x < field.length; x++) {
                if(field[x][y] == 1) {
                    result += check(x,y);
                }
            }
        }
        return result;
    }
    
    public int check(int x, int y) {
        int result = 0;
        result += (y+2 < field[x].length    && field[x][y+1] == 2 && field[x][y+2] == 3) ? 1 : 0;
        result += (y-2 > 0                  && field[x][y-1] == 2 && field[x][y-2] == 3) ? 1 : 0;
        result += (x+2 < field.length       && field[x+1][y] == 2 && field[x+2][y] == 3) ? 1 : 0;
        result += (x-2 > 0                  && field[x-1][y] == 2 && field[x-2][y] == 3) ? 1 : 0;
        result += (x+2 < field.length       && y+2 < field[x].length    && field[x+1][y+1] == 2 && field[x+2][y+2] == 3) ? 1 : 0;
        result += (x-2 > 0                  && y-2 > 0                  && field[x-1][y-1] == 2 && field[x-2][y-2] == 3) ? 1 : 0;
        result += (x+2 < field.length       && y-2 > 0                  && field[x+1][y-1] == 2 && field[x+2][y-2] == 3) ? 1 : 0;
        result += (x-2 > 0                  && y+2 < field[x].length    && field[x-1][y+1] == 2 && field[x-2][y+2] == 3) ? 1 : 0;
        return result;
    }
    
    public static void main(String[] args){
        System.out.println(new Count123().solve());
    }
}

[ Voor 3% gewijzigd door Silentuz op 13-12-2009 02:35 ]

[Onbekend]

Silentuz schreef op zondag 13 december 2009 @ 01:09:

spoiler:

2840, 100x100 array

niet gelijk aan Onbekend though.

hier is mijn code:

Moeten de vergelijkingen "y-2 > 0" niet "y-2 >= 0" zijn ?
Jouw array loopt namelijk van 0 t/m lengte - 1.

[xos]

Resultaat:

spoiler:

2864

Ik heb de gelegenheid aangepakt om eens wat te spelen met openmp.

C++:

#include <omp.h>
#include <cstdio>
#include <iostream>

static const size_t N_ROWS = 100;
static const size_t N_COLS = 100;
static const size_t NEWLINE_SIZE = 1; /* 0x0A */

template<size_t R, size_t C>
union Input
{
   char raw[R*C];
   char data[R][C];
};

int main(int argc, char* argv[], char* env[])
{
   static int h_offset[] = {-1, -1, -1, 0, 0, 1, 1, 1};
   static int v_offset[] = {-1, 0, 1, -1, 1, -1, 0, 1};
   int found = 0;
   int chunk = N_ROWS;
   Input<N_ROWS, N_COLS+NEWLINE_SIZE> i; 

   FILE* fp = fopen("aap.txt", "r");

   if (!fp)
   {
      std::cerr << "Unable to open aap.txt" << std::endl;
      return EXIT_FAILURE;
   }

   fread(i.raw, N_COLS+NEWLINE_SIZE, N_ROWS, fp); 
   fclose(fp);

   #pragma omp parallel shared(found, chunk)
   {
      chunk = N_ROWS / omp_get_num_threads();
      #pragma omp for schedule(dynamic,chunk) nowait
      for (int row = 0; row < N_ROWS; ++row)
      {
     for (int col = 0; col < N_COLS; ++col)
         {
        for (int o = 0; o < 8; ++o)
        {
           int a = row+h_offset[o];
           int b = col+v_offset[o];
           int c = row+h_offset[((7-o))];
           int d = col+v_offset[((7-o))];

           if (a >= 0 && b >= 0 && a < N_ROWS && b < N_COLS && 
           c >= 0 && d >= 0 && c < N_ROWS && d < N_COLS)
           {
          if ('1' == i.data[a][b] && '2' == i.data[row][col] && '3' == i.data[c][d])
          {
             #pragma omp critical
             ++found;
          }
           }
        }
     }
      }
   }

   std::cout << "found = " << found << std::endl;
   return EXIT_SUCCESS;
}

[brama]

Mijn oplossing:

spoiler:

2864 - jawel, weer een ander getal (edit: inmiddels niet meer)

mijn code

Deze code gaat er overigens van uit dat een symmetrisch rijtje 2 keer gevonden wordt, maar dat is toch niet van toepassing in deze vraag (en anders op symmetrie checken en maar in 1 volgorde checken).

De straightforward oplossing leek me wat saai, dus ik ben voor de recursieve oplossing gegaan.

[ Voor 25% gewijzigd door brama op 13-12-2009 13:28 ]

[Verwijderd]

ik wil nogmaals jullie laten herinneren dat het bestand in 8 richtingen ingelezen moet worden.

En dus dit ook voor kan komen:

code:

333
123
111

[ Voor 255% gewijzigd door Verwijderd op 13-12-2009 15:34 ]

[brama]

Verwijderd schreef op zondag 13 december 2009 @ 15:01:
ik wil nogmaals jullie laten herinneren dat het bestand in 8 richtingen ingelezen moet worden.

Ik neem aan dat in deze matrix:

3 0 3
0 2 0
1 0 1

123 *twee* keer voorkomt? (maw 321 telt ook) ?

Afhankelijk van jouw definitie van 'richting' kun je meerdere kanten op namelijk!

Is de juiste oplossing al gegeven?

[ Voor 10% gewijzigd door brama op 13-12-2009 15:35 ]

[Verwijderd]

Nee, de juiste oplossing is niet gegeven. En ja, 321 telt ook.

[brama]

Verwijderd schreef op zondag 13 december 2009 @ 15:01:
ik wil nogmaals jullie laten herinneren dat het bestand in 8 richtingen ingelezen moet worden.

En dus dit ook voor kan komen:

code:

333
123
111

4 Voorkomens dus? Unit test voor deze exacte case toegevoegd, en die komt daarop uit iig. Ik tel er zelf ook 4 Vraag me af of je eigen uitkomst wel klopt dan

[ Voor 19% gewijzigd door brama op 13-12-2009 15:39 ]

[Verwijderd]

brama schreef op zondag 13 december 2009 @ 15:38:
[...]


4 Voorkomens dus? Unit test voor deze exacte case toegevoegd, en die komt daarop uit iig. Ik tel er zelf ook 4 Vraag me af of je eigen uitkomst wel klopt dan

Ga er gewoon vanuit dat de reeks in 8 richtingen voor kan komen, meer niet.

[brama]

Verwijderd schreef op zondag 13 december 2009 @ 15:47:
[...]

Ga er gewoon vanuit dat de reeks in 8 richtingen voor kan komen, meer niet.

Is dat een 'ja, het zijn er 4' ... ???

Ik denk dat mijn programma klopt, en zo niet, dan snap ik de opdracht niet. Dan maar even uitspellen:

Richtingen:

Horizontaal, van links naar rechts
Horizontaal, van rechts naar links
Verticaal, van boven naar onder.
Verticaal, van onder naar boven
Diagonaal, van linksboven naar rechtsonder
Diagonaal, van rechtsonder naar linksboven
Diagonaal, van rechtsboven naar linksonder
Diagonaal, van linksonder naar rechtsboven

Allemaal getest, worden allemaal gevonden.

In de reeks [1,2,3,2,1] komt [1,2,3] 2 keer voor (maw overlapping telt ook)? ja, blijkt al uit gegeven eerste voorbeeld

[ Voor 3% gewijzigd door brama op 13-12-2009 16:03 ]

[Verwijderd]

brama schreef op zondag 13 december 2009 @ 15:55:
[...]


Is dat een 'ja, het zijn er 4' ... ???

Ik denk dat mijn programma klopt, en zo niet, dan snap ik de opdracht niet. Dan maar even uitspellen:

Richtingen:

Horizontaal, van links naar rechts
Horizontaal, van rechts naar links
Verticaal, van boven naar onder.
Verticaal, van onder naar boven
Diagonaal, van linksboven naar rechtsonder
Diagonaal, van rechtsonder naar linksboven
Diagonaal, van rechtsboven naar linksonder
Diagonaal, van linksonder naar rechtsboven

Klopt, want dat is de opdracht.

In de reeks [1,2,3,2,1] komt [1,2,3] 2 keer voor (maw overlapping telt ook)? ja, blijkt al uit gegeven eerste voorbeeld

Als je kijkt naar het bestand en de opdracht dan zie je al dat je niet om de reeks 123,321 heen kan.
Wel lezen..

[brama]

In dat geval ben ik benieuwd met wat voor aantal jij aan komt zetten, want ik kan geen voorbeeld verzinnen wat niet klopt met mijn programma

Het helpt wel als je ook antwoorden op alle vragen geeft ('klopt dit aantal voorkomens in dit voorbeeld'), want daar lees je telkens overheen lijkt het wel.

[Verwijderd]

brama schreef op zondag 13 december 2009 @ 16:16:
In dat geval ben ik benieuwd met wat voor aantal jij aan komt zetten, want ik kan geen voorbeeld verzinnen wat niet klopt met mijn programma

Het helpt wel als je ook antwoorden op alle vragen geeft ('klopt dit aantal voorkomens in dit voorbeeld'), want daar lees je telkens overheen lijkt het wel.

Ik heb op alle vragen een antwoord gegeven. Misschien moet je duidelijker zijn in je vraag want ik kan het niet raden.

[brama]

code:

333
123
111

4 Voorkomens dus?

Die bedoelde ik. Zal wel kloppen, en jij zal wel gedacht hebben 'duh da's toch logisch als je telt', maar ik zit me enkel af te vragen of ik niet consequent iets lompweg over het hoofd zie, en dan is een exact antwoord wel zo prettig. Niets zo frustrerend als moeten gissen naar een bedoeling, dat komt wellicht wat sterk naar boven nu

[Verwijderd]

brama schreef op zondag 13 december 2009 @ 16:44:

code:

333
123
111

4 Voorkomens dus?

Die bedoelde ik. Zal wel kloppen, en jij zal wel gedacht hebben 'duh da's toch logisch als je telt', maar ik zit me enkel af te vragen of ik niet consequent iets lompweg over het hoofd zie, en dan is een exact antwoord wel zo prettig. Niets zo frustrerend als moeten gissen naar een bedoeling, dat komt wellicht wat sterk naar boven nu

Je moet "gewoon" in alle richtingen zoeken naar de reeks 123. En hoe deze gepresenteert worden maakt niet uit.
Zolang je maar in de desbetreffende richting op de reeks 123 uit komt.
Dus of je nu van diagonaal onder naar boven leest: de programma moet de reeks als 123 lezen.
En dat zijn dus geen 4 voorkomens maar 8.

[cfern]

Potjandorie, dat gepiel met indices en array-out-of-bounds was nog best irritant. Ach ja, als bijproduct heb ik er nu wel een aardige sublijstjeszoeker aan overgehouden.

Hier is een prutsel in F#, vindt er 2864:

code:

//Stop alle sublists van lengte n uit een 2D array in een reeks
let subLists n grid = 
    let NRows = Array2D.length1 grid
    let NCols = Array2D.length2 grid
    seq {
      for r in 0..NRows-1 do
        for c in 0..NCols-1 do
            if c>=n-1 then 
                yield [for p in 0..n-1 -> grid.[r,c-p]]            
                yield [for p in 0..n-1 -> grid.[r,c-n+1+p]]
            if r>=n-1 then 
                yield [for p in 0..n-1 -> grid.[r-p,c]]            
                yield [for p in 0..n-1 -> grid.[r-n+1+p,c]]
            if r>=n-1 && c>=n-1 then 
                yield [for p in 0..n-1 -> grid.[r-p,c-p]]
                yield [for p in 0..n-1 -> grid.[r-n+1+p,c-n+1+p]]
            if r>=n-1 && c<NCols-n+1 then 
                yield [for p in 0..n-1 -> grid.[r-p,c+p]]
                yield [for p in 0..n-1 -> grid.[r-n+1+p,c+n-1-p]]
     } 

//Grid inlezen. Error handling doen we niet aan (*kuch*)
let buildGrid (path:string) = 
    let data = [|use reader = new System.IO.StreamReader(path)
                 while not reader.EndOfStream do
                   let line = reader.ReadLine()
                   if line <> "" then yield line|]
    
    Array2D.init data.Length data.[0].Length 
        (fun r c -> data.[r].[c] |> string |> int)

//Voer deze functie uit om te tellen
let count123() = 
    buildGrid @"C:\FSharp\aap.txt"
    |> subLists 3
    |> Seq.sumBy (function [1;2;3] -> 1 | _ -> 0)

[ZpAz]

Verwijderd schreef op zondag 13 december 2009 @ 16:48:
[...]

Je moet "gewoon" in alle richtingen zoeken naar de reeks 123. En hoe deze gepresenteert worden maakt niet uit.
Zolang je maar in de desbetreffende richting op de reeks 123 uit komt.
Dus of je nu van diagonaal onder naar boven leest: de programma moet de reeks als 123 lezen.
En dat zijn dus geen 4 voorkomens maar 8.

Ik kom ook maar bij 4 uit.

Neem jij '321' niet mee, alsook '123'? Immers je moet bij een 1 beginnen, en in een rechte lijn (dan wel diagonaal of niet) kijken.

[ Voor 10% gewijzigd door ZpAz op 13-12-2009 17:08 ]

[brama]

Verwijderd schreef op zondag 13 december 2009 @ 16:48:
[...]

Je moet "gewoon" in alle richtingen zoeken naar de reeks 123. En hoe deze gepresenteert worden maakt niet uit.
Zolang je maar in de desbetreffende richting op de reeks 123 uit komt.
Dus of je nu van diagonaal onder naar boven leest: de programma moet de reeks als 123 lezen.
En dat zijn dus geen 4 voorkomens maar 8.

code:

1 1 3
2 2 3
3 3 3

3 voorkomens dus (je eigen 1e voorbeeld)

code:

3 3 3
1 2 3
1 1 1

8 voorkomens?

Ik kan geen logica verzinnen die deze 2 gevallen zo interpreteert. En als die er al is, dan volgt die logisch gezien niet uit puur dat eerste voorbeeld. Je zult toch echt duidelijker moeten zijn in je opdrachten, want zo 'gewoon' is dit blijkbaar niet (ook getuige 3 oplossingen die allemaal op hetzelfde getal uitkomen)

[Verwijderd]

ZpAz schreef op zondag 13 december 2009 @ 17:07:
[...]


Ik kom ook maar bij 4 uit.

Neem jij '321' niet mee, alsook '123'? Immers je moet bij een 1 beginnen, en in een rechte lijn (dan wel diagonaal of niet) kijken.

Als je van recht naar links leest, hoe lees je de reeks 321?

[Verwijderd]

brama schreef op zondag 13 december 2009 @ 17:10:
[...]

code:

1 1 3
2 2 3
3 3 3

3 voorkomens dus (je eigen 1e voorbeeld)

code:

3 3 3
1 2 3
1 1 1

8 voorkomens?

Ik kan geen logica verzinnen die deze 2 gevallen zo interpreteert. En als die er al is, dan volgt die logisch gezien niet uit puur dat eerste voorbeeld. Je zult toch echt duidelijker moeten zijn in je opdrachten, want zo 'gewoon' is dit blijkbaar niet (ook getuige 3 oplossingen die allemaal op hetzelfde getal uitkomen)

Je hebt je eigen antwoord gegeven. Lees het nog een keer terug.

[brama]

Verwijderd schreef op zondag 13 december 2009 @ 17:19:
[...]

Je hebt je eigen antwoord gegeven. Lees het nog een keer terug.

Hier schiet ik dus ook niets mee op.De lol moet voor mij zitten in het nadenken over de oplossing van de opdracht, niet in het proberen te achterhalen van de daadwerkelijke opdracht. In mijn vrije tijd heb ik in dat laatste niet zoveel zin.

[Verwijderd]

Typnix, in je eerste voorbeeld

code:

1 1 3
2 2 3
3 3 3

komt dan toch de reeks 123 ook 6 keer voor en niet 3 keer zoals je zegt in je eerste post?

[Verwijderd]

Verwijderd schreef op zondag 13 december 2009 @ 17:57:
Typnix, in je eerste voorbeeld

code:

1 1 3
2 2 3
3 3 3

komt dan toch de reeks 123 ook 6 keer voor en niet 3 keer zoals je zegt in je eerste post?

Zo als Brama het al heeft gezegt maar niet vat.. Je moet kijken hoe de situatie is op het moment dat je een bepaalde richting inleest:

brama schreef op zondag 13 december 2009 @ 15:55:
Richtingen:

Horizontaal, van links naar rechts
Horizontaal, van rechts naar links
Verticaal, van boven naar onder.
Verticaal, van onder naar boven
Diagonaal, van linksboven naar rechtsonder
Diagonaal, van rechtsonder naar linksboven
Diagonaal, van rechtsboven naar linksonder
Diagonaal, van linksonder naar rechtsboven

Dit betekent dus zodra je van rechts naar links inleest dan lees je natuurlijk niet 321 maar 123 is.
En dat geldt dus voor alle richtingen, heel 'simpel' gezegt.

En wil dus zeggen dat je in plaats van 4 mogelijkheden hebt om in te lezen en de reeks te vinden het er 8 zijn.

[Onbekend]

Ik heb eventjes gekeken en ik had een tikfoutje gemaakt waardoor hij in de verkeerde kolom keek.
Mijn code geeft nu ook 2864 als antwoord.

PHP:

    $FileLines = file( "aap.txt" );
    
    $Width = strlen( $FileLines[0]);
    $Height = count( $FileLines);
    $Count = 0; 

    for ( $Counter1 = 0; $Counter1 < $Height; $Counter1++ )
        for ( $Counter2 = 0; $Counter2 < $Width; $Counter2++ )
            if ( $FileLines[$Counter1][$Counter2] == "1" )
            {
                // Horizontaal en vertikaal:
                if ( $Counter1 >= 2 )
                    if ( $FileLines[$Counter1 - 1][$Counter2] == "2" && $FileLines[$Counter1 - 2][$Counter2] == "3" )
                        $Count++;   
                if ( $Counter1 < $Height - 2 )
                    if ( $FileLines[$Counter1 + 1][$Counter2] == "2" && $FileLines[$Counter1 + 2][$Counter2] == "3" )
                        $Count++;
                if ( $Counter2 >= 2 )
                    if ( $FileLines[$Counter1][$Counter2 - 1] == "2" && $FileLines[$Counter1][$Counter2 - 2] == "3" )
                        $Count++;   
                if ( $Counter2 < $Width - 2 )
                    if ( $FileLines[$Counter1][$Counter2 + 1] == "2" && $FileLines[$Counter1][$Counter2 + 2] == "3" )
                        $Count++;       

                // En diagonaal:
                if ( $Counter1 >= 2 && $Counter2 >= 2 )
                    if ( $FileLines[$Counter1 - 1][$Counter2 - 1] == "2" && $FileLines[$Counter1 - 2][$Counter2 - 2] == "3" )
                        $Count++;   
                if ( $Counter1 < $Height - 2 && $Counter2 >= 2 )
                    if ( $FileLines[$Counter1 + 1][$Counter2 - 1] == "2" && $FileLines[$Counter1 + 2][$Counter2 - 2] == "3" )
                        $Count++;                       
                if ( $Counter1 >= 2 && $Counter2 < $Width - 2 )
                    if ( $FileLines[$Counter1 - 1][$Counter2 + 1] == "2" && $FileLines[$Counter1 - 2][$Counter2 + 2] == "3" )
                        $Count++;   
                if ( $Counter1 < $Height - 2 && $Counter2 < $Width - 2 )
                    if ( $FileLines[$Counter1 + 1][$Counter2 + 1] == "2" && $FileLines[$Counter1 + 2][$Counter2 + 2] == "3" )
                        $Count++;
            }   

    echo "Width: ".$Width."<br>";
    echo "Height: ".$Height."<br>";
    echo "Count: ".$Count."<br>";

Zoals je ziet heb ik niet bespaart op het aantal regels en heb ik het overzichtelijk gehouden.
De regels 9 t/m 38 had ik op 1 regel kunnen schrijven, maar dan is je overzicht wel weg.

[brama]

Verwijderd schreef op zondag 13 december 2009 @ 18:10:
[...]


Zo als Brama het al heeft gezegt maar niet vat.. Je moet kijken hoe de situatie is op het moment dat je een bepaalde richting inleest:


[...]

Dit betekent dus zodra je van rechts naar links inleest dan lees je natuurlijk niet 321 maar 123 is.
En dat geldt dus voor alle richtingen, heel 'simpel' gezegt.

En wil dus zeggen dat je in plaats van 4 mogelijkheden hebt om in te lezen en de reeks te vinden het er 8 zijn.

Schrijf die 8 mogelijkheden eens letterlijk op? Dus bijvoorbeeld:

"Van linksonder naar rechtsboven"
"Van midden onder naar boven"
"Van rechtsonder naar linksboven"
"Van midden links naar rechts"

Dat zijn de 4 die ik kan vinden. Enige andere 4 die ik kan verzinnen zijn precies diezelfde reeksen andersom ingelezen. Maar als ik dat doe bij je eerste voorbeeld krijg ik er 6. Dus waarom lees je ze daar _niet_ dubbel? Wat is nou precies die logica? Leg dat eens uit aan de hand van wat voorbeeldjes?

Zal zelf ook wat voorbeeldvragen geven waar jij dan per matrix het aantal te tellen reeksen bij zet:

code:

3 2 1
0 0 0
0 0 0

code:

0 0 1
2 3 0
0 0 0

code:

0 1 0
0 0 2
3 0 0

code:

1 1 1
2 2 2
3 3 3

Extra optionele uitdaging: Tel het aantal voorkomens van de reeks ' 1 2 3 2 2' in diezelfde file. Wederom kunnen ze horizontaal, verticaal, diagonaal, en omgekeerd voorkomen. Een reeks die je al geteld hebt, mag je niet nog eens tellen in omgekeerde volgorde! Reeksen mogen elkaar wel gedeeltelijk overlappen, dus in '1 2 3 2 2 3 2 1' komt 'ie 2 keer voor, maar '1 2 3 2 2' is maar 1 voorkomen. Deze is natuurlijk wat moeilijker, aangezien je nu niet makkelijk meer wegkomt met het uitschrijven van alle mogelijkheden

[ Voor 17% gewijzigd door brama op 13-12-2009 19:02 ]

[Verwijderd]

brama schreef op zondag 13 december 2009 @ 18:36:
[...]


Schrijf die 8 mogelijkheden eens letterlijk op? Dus bijvoorbeeld:

"Van linksonder naar rechtsboven"
"Van midden onder naar boven"
"Van rechtsonder naar linksboven"
"Van midden links naar rechts"

Dat zijn de 4 die ik kan vinden. Enige andere 4 die ik kan verzinnen zijn precies diezelfde reeksen andersom ingelezen. Maar als ik dat doe bij je eerste voorbeeld krijg ik er 6. Dus waarom lees je ze daar _niet_ dubbel? Wat is nou precies die logica? Leg dat eens uit aan de hand van wat voorbeeldjes?

Zal zelf ook wat voorbeeldvragen geven waar jij dan per matrix het aantal te tellen reeksen bij zet:

Ik zal de logica uitleggen.

van leesbegin tot eind.

code:

#links - rechts
123

#rechts - links
321

#boven - onder
1
2
3

#onder - boven
3
2
1

#diag linksboven - diag rechtsbeneden
1
  2
   3

#diag rechtsbeneden - diag linksboven
3
  2
   1

#diag linksbeneden - diag rechtsboven
   3
  2
1

#diag rechtsbeneden - diag linksboven
3
  2
   1
#diag rechtsboven - diag linksbeneden.   
   1
  2
3

output:

code:

 111111  
 222232 
 233122
 123321
 233212
 122221
 111111

Nu zou je ongeveer in elke "windrichting" een reeks moeten vinden.
En nu hou ik op want meer is er niet te geven kwa clue's.

[ Voor 8% gewijzigd door Verwijderd op 13-12-2009 19:15 ]

[pythagorasABC]

Is het niet gewoon 5728?

[brama]

Verwijderd schreef op zondag 13 december 2009 @ 19:08:
[...]


Ik zal de logica uitleggen.

van leesbegin tot eind.

code:

#links - rechts
123

#rechts - links
321

#boven - onder
1
2
3

#onder - boven
3
2
1

#diag linksboven - diag rechtsbeneden
1
  2
   3

#diag rechtsbeneden - diag linksboven
3
  2
   1

#diag linksbeneden - diag rechtsboven
   3
  2
1

#diag rechtsbeneden - diag linksboven
3
  2
   1
#diag rechtsboven - diag linksbeneden.   
   1
  2
3

output:

code:

 111111  
 222232 
 233122
 123321
 233212
 122221
 111111

Nu zou je ongeveer in elke "windrichting" een reeks moeten vinden.
En nu hou ik op want meer is er niet te geven kwa clue's.

Drugs are bad, mmmkay.

Ik ga me eens vervelen met mijn eigen extra uitdaging zonder gebruik van recursie.

[Hu9o]

wat een vaag gedoe hier zeg met deze opdracht.

code:

33333
32223
32123
32223
33333

Deze zou toch gewoon 8 reeksen van 1-2-3 moeten hebben. Want als Typnix op een ander getal uit komt dan snapt het hele forum hem niet...

[Verwijderd]

Hu9o schreef op zondag 13 december 2009 @ 19:24:

code:

33333
32223
32123
32223
33333

Deze zou toch gewoon 8 reeksen van 1-2-3 moeten hebben.

Klopt, en er zijn ook reeksen in alle richtingen te lezen.
Je moet denken in leesrichtingen, meer valt er niet van te maken.

offtopic:
Geef ik eens een moeilijke opdracht is het weer niet goed.

[ Voor 85% gewijzigd door Verwijderd op 13-12-2009 19:31 ]

[Onbekend]

pythagorasABC schreef op zondag 13 december 2009 @ 19:21:
Is het niet gewoon 5728?

Klopt. Elke gevonden reeks van 123 bevat andersom ook de reeks 321. Dus elke reeks kan je 2x tellen.
2864 x 2 = 5728

[Verwijderd]

Onbekend schreef op zondag 13 december 2009 @ 19:37:
[...]

Klopt. Elke gevonden reeks van 123 bevat andersom ook de reeks 321. Dus elke reeks kan je 2x tellen.
2864 x 2 = 5728

*KUCH*

[ Voor 4% gewijzigd door Verwijderd op 13-12-2009 19:39 ]

[Verwijderd]

De opdracht is niet moeilijk, de vraagstelling is alleen niet bij iedereen duidelijk. Ik kan van dit voorbeeld

code:

3 3 3
1 2 3
1 1 1

nog steeds niks anders maken dan 4 keer de reeks 123. Want stel dat je leest van rechtsboven naar links onder, dan staat er 321, wat dus niet 123 is. Dus hou je naar mijn idee (en volgens mij dat van iedereen hier) rechtsonder naar linksboven, linksonder naar rechtsboven, tweede rij links naar rechts en tweede kolom van onder naar boven over als goede oplossingen. Please correct me if I'm wrong.

edit: dus het gaat zowel om de leesrichting van het bestand als van de gevraagde reeks.

[ Voor 8% gewijzigd door Verwijderd op 13-12-2009 19:43 . Reden: post hierboven ]

[Hu9o]

Verwijderd schreef op zondag 13 december 2009 @ 19:28:
[...]

Klopt, en er zijn ook reeksen in alle richtingen te lezen.
Je moet denken in leesrichtingen, meer valt er niet van te maken.

offtopic:
Geef ik eens een moeilijke opdracht is het weer niet goed.

Dan is 2864 gewoon het antwoord. Dus de uitkomst keer 2 doen slaat dan nergens op.

[pythagorasABC]

Onbekend schreef op zondag 13 december 2009 @ 19:37:
[...]

Klopt. Elke gevonden reeks van 123 bevat andersom ook de reeks 321. Dus elke reeks kan je 2x tellen.
2864 x 2 = 5728

Dat is ook hoe ik het heb gevonden, ik weet alleen niet of het wel klopt
En betekend *KUCH* dat het goed is of niet?

[brama]

Verwijderd schreef op zondag 13 december 2009 @ 19:28:
[...]

Klopt, en er zijn ook reeksen in alle richtingen te lezen.
Je moet denken in leesrichtingen, meer valt er niet van te maken.

offtopic:
Geef ik eens een moeilijke opdracht is het weer niet goed.

Is 'ie moeilijk dan? Er is niemand die weet wat de opdracht is. Misschien moet je de moeilijkheid niet stoppen in je cryptische uitleg, maar in de moeilijkheid van het algoritme wat nodig is om 'm op te lossen.

Valt ook niet mee, iedereen hier die professioneel met klanten moet werken om een opdracht helder te krijgen kan er over meespreken. Op dit punt had ik de opdracht echter vriendelijk geweigerd, of als implementatie 'random()' opgeleverd, met als uitleg dat als de klant het maar vaak genoeg draait, de juiste oplossing er vanzelf wel een keer tussenzit

[brama]

Hu9o schreef op zondag 13 december 2009 @ 19:42:
[...]


Dan is 2864 gewoon het antwoord. Dus de uitkomst keer 2 doen slaat dan nergens op.

Inderdaad. Bovendien klopt die niet met voorbeeld #1 wat drie op zou moeten leveren.

[Verwijderd]

brama schreef op zondag 13 december 2009 @ 19:44:
[...]


Inderdaad. Bovendien klopt die niet met voorbeeld #1 wat drie op zou moeten leveren.

Niets als je de leesrichting verandert dus, van zowel de input als waar je mee vergelijkt. Ben het ermee eens dat hij dan gewoon een beter voorbeeld had moeten geven waarin ie zijn totale vraagstelling duidelijk maakt.

[ Voor 17% gewijzigd door Verwijderd op 13-12-2009 19:47 ]

[brama]

Verwijderd schreef op zondag 13 december 2009 @ 19:46:
[...]

Niets als je de leesrichting verandert dus, van zowel de input als waar je mee vergelijkt. Ben het ermee eens dat hij dan gewoon een beter voorbeeld had moeten geven waarin ie zijn totale vraagstelling duidelijk maakt.

Dus bij voorbeeld

code:

1 1 3
2 2 3
3 3 3

komt er echt 3 uit? Laat eens een implementatie zien die dat doet, en bij de grote file 2 * 2864 als uitkomst geeft? Misschien dat ik 'm dan vat.

[Verwijderd]

brama schreef op zondag 13 december 2009 @ 20:10:
[...]


Dus bij voorbeeld

code:

1 1 3
2 2 3
3 3 3

komt er echt 3 uit? Laat eens een implementatie zien die dat doet, en bij de grote file 2 * 2864 als uitkomst geeft? Misschien dat ik 'm dan vat.

Zoals ik het begrijp bedoelde hij in zijn voorbeeld alleen de leesrichting van links naar rechts voor de gezochte reeks. Dus hij zoekt alleen naar 123, maar als je hiervan de leesrichting verandert, dus 321, en dan de file nogmaals doorloopt heb je er nog eens 3. Maar in zijn voorbeeld veranderde hij de leesrichting voor die gezochte reeks dus niet. Dit is zoals ik het begrijp. Iets anders kan ik er niet van maken.

[Verwijderd]

Verwijderd schreef op zondag 13 december 2009 @ 20:15:
[...]

Zoals ik het begrijp bedoelde hij in zijn voorbeeld alleen de leesrichting van links naar rechts voor de gezochte reeks. Dus hij zoekt alleen naar 123, maar als je hiervan de leesrichting verandert, dus 321, en dan de file nogmaals doorloopt heb je er nog eens 3. Maar in zijn voorbeeld veranderde hij de leesrichting voor die gezochte reeks dus niet. Dit is zoals ik het begrijp. Iets anders kan ik er niet van maken.

Klopt, de leesrichting verandert maar de gevraagde reeks, 123, verandert inderdaad niet.
Zoals ik al de hele tijd zeg: de leesrichting maakt uit maar de gevraagde reeks niet.

Wat dat betreft heb ik de opdracht letterlijk voorgekauwt. En voorbeelden zijn zoals voorbeelden moeten zijn:
een soort van representatieve stukje waarin de vrager een gedeelte van de logica voorgeschoteld krijgt om een idee te krijgen waarmee de opvrager een idee kan krijgen waarmee hij/zij zijn mee te maken krijgt.
En eerlijk gezegt is dit geen rocketscience...
Als er letterlijk staat: "het bestand moet 8 richtingen ingelezen worden" dan betekend het niet dat je er maar 4 hoeft te doen.

[ Voor 49% gewijzigd door Verwijderd op 13-12-2009 20:30 ]

[Cavalera125]

Als iedereen die deze opdracht probeert te maken met vaagheden omtrent de opdracht blijft zitten dan lijkt me daar toch een kern van waarheid in te zitten. Ik wilde zelf ook even een poging wagen, maar na de vele posts over wat nu eigenlijk de opdracht is, sla ik deze toch maar over...

[brama]

Verwijderd schreef op zondag 13 december 2009 @ 20:17:
[...]

Klopt, de leesrichting verandert maar de gevraagde reeks, 123, verandert inderdaad niet.
Zoals ik al de hele tijd zeg: de leesrichting maakt uit maar de gevraagde reeks niet.

Wat dat betreft heb ik de opdracht letterlijk voorgekauwt. En voorbeelden zijn zoals voorbeelden moeten zijn:
een soort van representatieve stukje waarin de vrager een gedeelte van de logica voorgeschoteld krijgt om een idee te krijgen waarmee de opvrager een idee kan krijgen waarmee hij/zij zijn mee te maken krijgt.
En eerlijk gezegt is dit geen rocketscience...
Als er letterlijk staat: "het bestand moet 8 richtingen ingelezen worden" dan betekend het niet dat je er maar 4 hoeft te doen.

Dan moet je de vraagstelling niet beginnen met een voorbeeld wat een ander resultaat oplevert dan wat je verwacht. Bij dit soort kwesties geldt: garbage in, garbage out.

Ik blijf erbij dat je erg onduidelijk bent in zowel je opdracht als in je vraag-beantwoording. Juist door die onduidelijkheid weet je als programmeur niet waar je het moet zoeken. Misschien dat jij vindt dat het andersom is, maar het zou me verbazen als je iemand hier vindt die het met je eens is.

Niet dat ik je initiatief wil afkraken, maar je zou natuurlijk ook wat van de kritiek aan kunnen trekken. Gedurende deze dag heb ik diverse malen het idee gehad dat het leek alsof we op 2 verschillende planeten waren. Daarbij was het grootste knelpunt voor mij dat je niet letterlijk op vragen ingaat, of gedeelten ervan overslaat. Het voorbeeld wat ik bijv. letterlijk aanhaal waarbij de ene matrix '3' op zou moeten leveren en de andere '8', had je toch kunnen gebruiken om aan te geven dat er bij die eerste '6' uit had moeten komen? Ik zie je daar met geen woord reppen dat je bij het 1e voorbeeld andere logica toepast dan bij het tweede. En zonder glazen bol wordt het dan toch echt moeilijk.

[edit] @ hier beneden

Onbekend schreef op zondag 13 december 2009 @ 20:49:
[...]

Zo moeilijk is het ook niet te begrijpen hoor, maar ik wil het wel in een andere vorm opschrijven:

Tel hoe vaak de combinatie 123 in de tekst-file voor komt, ongeacht de tekstrichting.

Inderdaad.. met als toevoeging dat deze ook diagonaal kan voorkomen. En dan een voorbeeld quoten met een input voorbeeldje, en een output voorbeeldje. Input voorbeeldje op zich was prima, alleen de ouput had 6 moeten zijn, of anders een duidelijke toevoeging dat in dat voorbeeldje maar in 4 richtingen geteld wordt.

[ Voor 14% gewijzigd door brama op 13-12-2009 21:07 ]

[Onbekend]

Cavalera125 schreef op zondag 13 december 2009 @ 20:41:
Als iedereen die deze opdracht probeert te maken met vaagheden omtrent de opdracht blijft zitten dan lijkt me daar toch een kern van waarheid in te zitten. Ik wilde zelf ook even een poging wagen, maar na de vele posts over wat nu eigenlijk de opdracht is, sla ik deze toch maar over...

Zo moeilijk is het ook niet te begrijpen hoor, maar ik wil het wel in een andere vorm opschrijven:

Tel hoe vaak de combinatie 123 in de tekst-file voor komt, ongeacht de tekstrichting.

[Soultaker]

Ook opgelost met Python:

Python:

dirs = [ (dr,dc) for dr in [-1,0,1] for dc in [-1,0,1] if dr or dc ]
grid = [ map(int, line.strip()) for line in file('aap.txt') if line.strip() ]
H, W = len(grid), len(grid[0])
count = 0
for r in range(H):
    for c in range(W):
        for dr,dc in dirs:
            for i in range(3):
                nr, nc = r + i*dr, c + i*dc
                if nr < 0 or nr >= H or nc < 0 or nc >= W or \
                   grid[nr][nc] != [1,2,3][i]: break
            else:
                count += 1
print count

Het antwoord is inderdaad 2864.

[ Voor 15% gewijzigd door Soultaker op 13-12-2009 21:11 ]

[brama]

Soultaker schreef op zondag 13 december 2009 @ 21:09:
Ook opgelost met Python:

Python:

dirs = [ (dr,dc) for dr in [-1,0,1] for dc in [-1,0,1] if dr or dc ]
grid = [ map(int, line.strip()) for line in file('aap.txt') if line.strip() ]
H, W = len(grid), len(grid[0])
count = 0
for r in range(H):
    for c in range(W):
        for dr,dc in dirs:
            for i in range(3):
                nr, nc = r + i*dr, c + i*dc
                if nr < 0 or nr >= H or nc < 0 or nc >= W or \
                   grid[nr][nc] != [1,2,3][i]: break
            else:
                count += 1
print count

Het antwoord is inderdaad 2864.

Nice

[Hu9o]

Ok, ik denk dat het wel duidelijk is dat Typnix wat anders bedoelde dan dat wij begrepen.

Volgende keer beter.


Oh en trouwens, hier is nog een plaatje dat het aantal keer een match weergeeft per richting in de file.

[Verwijderd]

laat maar

[ Voor 98% gewijzigd door Verwijderd op 14-12-2009 09:34 ]

[Silentuz]

Onbekend schreef op zondag 13 december 2009 @ 11:38:
[...]

Moeten de vergelijkingen "y-2 > 0" niet "y-2 >= 0" zijn ?
Jouw array loopt namelijk van 0 t/m lengte - 1.

uhm, ja *schaam*.


dan komt er ws ook 2864 uit, kan het nu een niet testen

edit: 2864 idd -.-

[ Voor 3% gewijzigd door Silentuz op 15-12-2009 09:46 ]

[Verwijderd]

Overlappende vierkanten

Stel voor dat je een vierkant heb van maxN grootte. En je wilt X aantal (eventueel overlappende) vierkanten erin doen. Ga er vanuit dat de randen van de vierkanten parallel lopen met de randen van het raster.

Opdracht

Schrijf een programma:
Die een minimum van 2 vierkanten heeft.
En een max oneindig.

input moet zijn:
grootte van hoofdvierkant en aantal vierkanten die erin komen

# ./a.out (grootte hoofdvierkant) (aantal kleine vierkant)

Aantal: (output)

Het moet mogelijk zijn om door de gebruiker een minimum(die niet kleiner is dan 2) en max aantal vierkanten op te geven en deze in de output een lijst weer geeft.

Zoals:

# ./a.out (grootte hoofdvierkant) (grootte begin kleine vierkant) (min aantal vierkanten) (max aantal vierkanten) 

Lengte(tab)Breedte(spatie)aantal
----------      ------------          ---------
(output)         (output)              (output)
(output)         (output)              (output)

[ Voor 12% gewijzigd door Verwijderd op 16-12-2009 16:20 ]

[CodeCaster]

En N is integer? Dus bij N=2 heb je 5 vierkanten?

[Reptile209]

Verwijderd schreef op woensdag 16 december 2009 @ 15:20:

Overlappende vierkanten

[...]

Volgens mij moet je hier even een plaatje bij maken. * Reptile209 snapt er geen hout van.

[CodeCaster]

Als je een vierkant hebt van zeg 2 bij 2 centimeter (om er maar even een eenheid aan te hangen), passen daar vier vierkanten in van 1 bij 1 centimeter, en één vierkant van 2 bij 2 centimeter.

Dat heb ik nu in één regel code, maar de tweede helft van de opdracht vat ik niet

[Jaap-Jan]

Waarom moet je bij een vierkant een lengte én een breedte opgeven? Die zijn toch per definitie gelijk?

Ik denk dat er rechthoeken bedoeld worden, want met 2 vierkanten die kleiner zijn dan het hoofdvierkant kun je onmogelijk een ander vierkant vullen, dan heb je er minstens 4 nodig.

[ Voor 47% gewijzigd door Jaap-Jan op 16-12-2009 16:02 ]

[Verwijderd]

Ik zou echt graag mee willen doen, maar met de dagen die ik tegenwoordig draai (gisteren van 07:00 tot 18:00, vandaag 08:00 tot 20:00) kom ik er gewoon niet aan toe. Beetje jammer, want het lijkt me juist zo leuk.
Prachtig excuus om C++ of een of ander exotisch taaltje erbij te pakken natuurlijk

[ Voor 5% gewijzigd door Verwijderd op 16-12-2009 16:01 ]

[Verwijderd]

Jaap-Jan schreef op woensdag 16 december 2009 @ 15:58:
Waarom moet je bij een vierkant een lengte én een breedte opgeven? Die zijn toch per definitie gelijk?

Ik denk dat er rechthoeken bedoeld worden, want met 2 vierkanten die kleiner zijn dan het hoofdvierkant kun je onmogelijk een ander vierkant vullen, dan heb je er minstens 4 nodig.

Je hebt gelijk dat ik een foutje heb gemaakt dat had aantal moeten zijn.

CodeCaster schreef op woensdag 16 december 2009 @ 15:24:
En N is integer? Dus bij N=2 heb je 5 vierkanten?

Reptile209 schreef op woensdag 16 december 2009 @ 15:40:
[...]

Volgens mij moet je hier even een plaatje bij maken. * Reptile209 snapt er geen hout van.

Stel jullie voor: 1 vierkant waarvan de maxgrootte N is. Je wilt vierkanten in die vierkant doen waar van het minimum 2 is.

Je moet dus in het begin dus uitgaan rekenen hoe groot die vierkanten zijn die in die vierkant komen. En wat erbij komt is dat ze mogen overlappen.

[ Voor 26% gewijzigd door Verwijderd op 16-12-2009 16:23 ]

[RobIII]

Verwijderd schreef op woensdag 16 december 2009 @ 16:16:

Ik heb 't al eerder gezegd geloof ik, maar je zult toch écht wat meer werk in de opdracht(en) moeten steken. Hier is geen touw aan vast te knopen. Plaatjes helpen. Voorbeelden helpen. Duidelijk afgebakende regels helpen. Voorbeelden van wat niet mag helpen.

[KabouterSuper]

Je zegt dat de grootte van de kleine vierkantjes input is, maar vraagt vervolgens als output zowel de lengte en breedte (die zijn toch gelijk?). En als tip geef je dat je eerst uitrekent hoe groot de kleine vierkanten zijn (de grootte was toch input?). Om het nog mooier te maken noem je de input "grootte begin kleine vierkant"....hoezo "begin"???

Volgens mij heb jij extra informatie die niet in de opdracht staat.

Positief punt: je hebt in elk geval mijn interesse gewekt met je opdracht.

[Verwijderd]

RobIII schreef op woensdag 16 december 2009 @ 16:21:
[...]

Ik heb 't al eerder gezegd geloof ik, maar je zult toch écht wat meer werk in de opdracht(en) moeten steken. Hier is geen touw aan vast te knopen. Plaatjes helpen. Voorbeelden helpen. Duidelijk afgebakende regels helpen. Voorbeelden van wat niet mag helpen.

Dus jij kan niet opmaken dat je een vierkant heb van maxX grootte en dat je Y aantal vierkanten erin wilt hebben van Z grootte, waarbij Y het minimum 2 is?

[Jaap-Jan]

Wat let je om ze allemaal in de linkerbovenhoek te plakken?

code:

--------------------
|         |        |
|         |        |
|         |        |
|---------|        |
|                  |
|                  |
--------------------

[ Voor 61% gewijzigd door Jaap-Jan op 16-12-2009 16:31 ]

[RayNbow]

Verwijderd schreef op woensdag 16 december 2009 @ 16:26:
[...]

Dus jij kan niet opmaken dat je een vierkant heb van maxX grootte en dat je Y aantal vierkanten erin wilt hebben van Z grootte, waarbij Y het minimum 2 is?

Definieer "grootte van een vierkant". Is dat de lengte van 1 zijde? De omtrek? Oppervlakte?

[Verwijderd]

KabouterSuper schreef op woensdag 16 december 2009 @ 16:26:
Je zegt dat de grootte van de kleine vierkantjes input is, maar vraagt vervolgens als output zowel de lengte en breedte (die zijn toch gelijk?). En als tip geef je dat je eerst uitrekent hoe groot de kleine vierkanten zijn (de grootte was toch input?). Om het nog mooier te maken noem je de input "grootte begin kleine vierkant"....hoezo "begin"???

Volgens mij heb jij extra informatie die niet in de opdracht staat.

Positief punt: je hebt in elk geval mijn interesse gewekt met je opdracht.

Crap, verkeert uitgelegd.

Je hebt een vierkant heb van maxX grootte en dat je Y aantal vierkanten erin wilt hebben van Z grootte, waarbij Y het minimum 2.

In het beginsel wil je weten als Y vierkanten hebt met Z grootte in die grote vierkant met X grootte erin past.
of
Hoeveel passen er in X als je verkanten hebt die Z grootte hebben.

offtopic:
Ik moet wat aan met suikergehalte doen

[Verwijderd]

RayNbow schreef op woensdag 16 december 2009 @ 16:30:
[...]

Definieer "grootte van een vierkant". Is dat de lengte van 1 zijde? De omtrek? Oppervlakte?

lengte van 1 zijde

[Creepy]

Kan je het nu nog een keer opnieuw in 1 post uitleggen wat je precies bedoelt, wat de input is en wat de output moet zijn? Er is echt geen touw aan vast te knopen. Neem gelijk ook de vraag van Jaap-Jan mee (aangezien jij zegt dat er vierkanten mogen overlappen)

No offence maar ik kan er nog steeds geen touw aan vast knopen. Ik heb wel een vermoeden maar dat strookt in z'n geheel niet met de overlap.

[ Voor 11% gewijzigd door Creepy op 16-12-2009 16:45 ]

[KabouterSuper]

het wordt maar langzaam duidelijker. Post anders je oplossing eens....reverse engineering vinden we ook machtig mooi

[CodeCaster]

De oplossing is natuurlijk 42, maar ik denk dat ik nu ook een idee heb. Is het de bedoeling dat je met minimaal 2 en maximaal X vierkanten van grootte Y de volledige oppervlakte van een vierkant met zijdelengte Z vult? De output moet dan zijn waar de vierkanten zich bevinden en hoe groot die zijn.

Bij grootte Y < Z heb je hier altijd minimaal 4 vierkanten nodig. Vat ik de opdracht zo een beetje goed samen?

[KabouterSuper]

@Codecaster....is de oplossing dan niet heel simpel?

code:

power(ceil(Z/Y),2)

[Jaap-Jan]

CodeCaster schreef op woensdag 16 december 2009 @ 16:58:
De oplossing is natuurlijk 42, maar ik denk dat ik nu ook een idee heb. Is het de bedoeling dat je met minimaal 2 en maximaal X vierkanten van grootte Y de volledige oppervlakte van een vierkant met zijdelengte Z vult? De output moet dan zijn waar de vierkanten zich bevinden en hoe groot die zijn.

Bij grootte Y < Z heb je hier altijd minimaal 4 vierkanten nodig. Vat ik de opdracht zo een beetje goed samen?

Dat was ook mijn eerste idee, maar zijn tweede reactie bracht me weer aan het twijfelen.

[Verwijderd]

Overlappende vierkanten

Stel voor dat je een vierkant heb van maxX grootte. En je wilt X aantal (eventueel overlappende) vierkanten erin doen met een Z grootte. Ga er vanuit dat de randen van de vierkanten parallel lopen met de randen van het raster.

Grootte van de vierkant wordt bedoeld: de lengte en de breedte van de vierkant. En niet de omtrek.

Opdracht

Schrijf een programma die dus uitrekent hoeveel kleine vierkanten in een grote vierkant past.
Het minimum van aantal kleine vierkanten is 2. En de minimale grootte van de kleine viierkanten is 5.
Grootte van grote vierkant is oneindig.

Wat je ook moet kunnen uitrekenen is wanneer je kleine vierkanten hebt van Z grootte dat je uitrekend hoe groot de grote vierkant moet zijn om een gegeven aantal erin te laten passen.

Wat het programma ook moet kunnen doen is wanneer je een grote vierkant heb die X maat heeft dat je mee kunt aangeven wat het minimum en maximum aantal kleine vierkanten en/of een minimale en maximale maat van de vierkanten die in die vierkant moet kunnen passen. En dit weergeven dmv een lijst

manier van input zou kunnen zijn:

# ./a.out (grootte hoofdvierkant) (aantal kleine vierkanten)

Aantal: (output grootte kleine vierkanten)

Voorbeeld van een lijstje:

# ./a.out (grootte hoofdvierkant) ( min grootte vierkant) (max grootte vierkant) (min aantal vierkanten) (max aantal vierkanten)  

(grootte)(spatie)(aantal)
 -----------           -----------

Regels:

De vierkanten mogen elkaar overlappen maar met een maximum van 5px over elkaar heen

Ruimtelijk VB:

code:

|-----------------|--------------------|
|                 |                    |
|    x           |                    |
|                 |                    |
|--------------------------------------|
|                 |                    |
|                 |  x                |
|                 |                    |
|-----------------|--------------------|

[brama]

Zoiets (tweede voorbeeld, in = <hoofdvierkant grootte> <kleinvierkant min> <kleinvierkant max>) ?

spoiler:

./progsel.py 50 5 10
5 infinite
6 2025
7 484
8 225
9 121
10 81

?

[Verwijderd]

brama schreef op woensdag 16 december 2009 @ 18:09:
Zoiets (tweede voorbeeld, in = <hoofdvierkant grootte> <kleinvierkant min> <kleinvierkant max>) ?

spoiler:

./progsel.py 50 5 10
5 infinite
6 2025
7 484
8 225
9 121
10 81

?

wat stelt die laatste twee voor in de output, grootte of aantal?

[brama]

Output per regel is grootte kleine vierkant en aantal vierkanten wat in het grote vierkant past. Bij dit voorbeeld dus een grootte van het grote vierkant van 50x50

[ Voor 26% gewijzigd door brama op 16-12-2009 18:45 ]

[Verwijderd]

Die opdrachtomschrijving is gewoon compleet nutteloos. Gewoon een voorbeeldje zou al helpen en vierkanten kan je toch specificeren met de lengte van een zijde en niet in grootte (wat niets is wat mij betreft).

[Verwijderd]

Verwijderd schreef op woensdag 16 december 2009 @ 19:30:
Die opdrachtomschrijving is gewoon compleet nutteloos. Gewoon een voorbeeldje zou al helpen en vierkanten kan je toch specificeren met de lengte van een zijde en niet in grootte (wat niets is wat mij betreft).

Vooral niet lezen.

[Verwijderd]

brama schreef op woensdag 16 december 2009 @ 18:44:
Output per regel is grootte kleine vierkant en aantal vierkanten wat in het grote vierkant past. Bij dit voorbeeld dus een grootte van het grote vierkant van 50x50

Maar ik snap die infinite niet

[Verwijderd]

Verwijderd schreef op woensdag 16 december 2009 @ 19:32:
[...]

Vooral niet lezen.

Oh ik vergeet inderdaad te vermelden dat dat voorbeeld natuurlijk nergens op slaat, dat is net zo duidelijk als de rest van het verhaal. Misschien even voorbeeld input, voorbeeld output en dat verduidelijken met een plaatje? En dan niet alleen output specificatie, maar daadwerkelijk iets. Gewoon een simpel voorbeeldje.

[brama]

Verwijderd schreef op woensdag 16 december 2009 @ 19:34:
[...]

Maar ik snap die infinite niet

Bij een maximale overlap van 5 en een vierkant met zijde 5 passen er oneindig veel vierkanten in het vlak gevormd door het grote vierkant. Je stapelt ze dan namelijk gewoon op elkaar, en dat past oneindig vaak.

[edit] de code:

Python:

#!/usr/bin/env python
import sys

def fit(big, min, max):
    print('\n'.join([('%d\t%s' % (small, str(((big-small)/(small-5)+1)**2)
        if small>5 else 'infinite')) for small in range(min, max+1)]))

eval('fit(%s)' % ','.join(sys.argv[1:]))

[ Voor 40% gewijzigd door brama op 16-12-2009 20:12 ]

[Marcks]

Schrijf een programma die dus uitrekent hoeveel kleine vierkanten in een grote vierkant past.
Het minimum van aantal kleine vierkanten is 2. En de minimale grootte van de kleine viierkanten is 5.
Grootte van grote vierkant is oneindig.

Ofwel, hoeveel kleine vierkanten passen er in een groot vierkant, waarbij het kleine vierkant een zijde heeft van 5, en het grote vierkant oneindig groot is? Als ik uit m'n hoofd wist hoe ik het tekentje inklopte, had ik hier zo'n omgekeerde acht neergezet. Maar ze mogen overlappen, dus in werkelijkheid zijn het er nog veel meer. Krijg ik nu een ijsje?

Heb ik het nog steeds niet gesnapt of ***** er nog steeds geen ***** van die ***** opdrachtomschrijving. :þ

[KabouterSuper]

Ik krijg een beetje de indruk dat het de bedoeling is om een "dense packing problem" te programmeren. Echter, de specs zijn dermate vaag dat je er nog niets mee kunt.

Voorbeeld: je gebruikt in je probleemstelling soms de term "grootte", soms "lengte" en soms "maat". Noem dan simpelweg alles "lengte" (de lezer is intelligent genoeg om op te merken dat de lengte en hoogte van een vierkant hetzelfde is).

De regel over overlap is ook vaag....als je twee vierkanten met lengte 5 over elkaar legt, is de overlap dan 5 of 25?

Laat tenslotte overbodige informatie weg. De informatie dat een vierkant lengte oneindig kan hebben is non-informatie, en dus verwarrend. Je kunt ook toevoegen dat de kleine vierkanten rood moeten zijn, en de grote vierkant alle kleuren mag hebben.....dat is ook non-informatie.

Mits goed omschreven is een "dense packing problem" best een interessant probleem.
Neem als voorbeeld het geval dat je twee kleine vierkanten hebt met lengte 5 cm. Je wilt de lengte van de omvattende vierkant minimaliseren, onder de randvoorwaarde dat de twee kleine vierkanten maximaal 5 cm^2 mogen overlappen.

Eerste gok zou zijn om de vierkanten naast elkaar te leggen en de rechterzijde van het eerste vierkant te laten overlappen met de linkerzijde van het tweede vierkant. Je eindigt dan met een groot vierkant ter grootte 9x9.

code:

----------
|   ||   |
|   ||   |
|   ||   |
|   ||   |
---------
|        |
|        |
|        |
----------

Echter, als je de kleine vierkanten met de punten over elkaar heen legt (dus rechtsonder 1e vierkant overlapt met linksboven 2e vierkant), dan kan je het grote vierkant verkleinen tot 8x8. Immers, de overlap kan 2x2 cm^2 zijn.

code:

----------
|   |    |
|   |    |
|   |    |
|  ||----|
-----    |
|  |     |
|  |     |
|  |     |
----------

[Cavalera125]

KabouterSuper schreef op donderdag 17 december 2009 @ 09:58:
Ik krijg een beetje de indruk dat het de bedoeling is om een "dense packing problem" te programmeren. Echter, de specs zijn dermate vaag dat je er nog niets mee kunt.

Ik zelf krijg eigenlijk meer de indruk dat de opdracht niet het programmeren zelf is, maar het achterhalen wat eigenlijk de opdracht is . Natuurlijk is het makkelijk om vanaf de zijlijn kritiek te leveren, maar dit is nu al de 2e opdracht achter elkaar waar niks als onduidelijkheid over is.

Ik zou zeggen, Typnix, doe iets met de kritiek. Als je een opdracht plaatst zorg dan voor duidelijkheid. Een duidelijk input voorbeeld met verwachtte output met duidelijke omschrijving. Dan kan iedereen zich concentreren op het programmeren zelf (wat mij de bedoeling van dit topic lijkt...)

[KabouterSuper]

Wellicht een idee om de opdracht "Overlappende vierkanten" even on hold te zetten. Overigens, voor de geinteresseerden een artikel over het vullen van een vierkant met kleine vierkanten: www.math.ucsd.edu/~fan/wp/square.pdf
Dat Erdos eraan gewerkt heeft, geeft wat mij betreft al aan dat het een pittig probleem is.

[JochemK]

Tip aan Typnix: probeer met je eigen uitleg, en niets meer dan dat, eens tot het gewenste algoritme te komen? Misschien dat je dan inziet waar het onbegrip van onze kant vandaan komt.

[Verwijderd]

Beste mensen,

Gezien het feit dat er weinig gesnapt wordt van de opdracht schort ik de opdracht op.
Nogmaals: als iemand er eentje weet waar geen contest aan vast zit, opper deze gerust.

[Onbekend]

Rekenmachine met grote getallen

De meeste rekenmachines kunnen maximaal 10 cijfers weergeven. Bij resultaten die meer dan 10 cijfers groot zijn, wordt het getal meestal met een exponent getoond en zijn de getallen niet nauwkeurig leesbaar.[list][/list]

Opdracht

Schrijf een programma die eenvoudige berekeningen kan uitvoeren tussen twee grote getallen.
De rekenmachine dient gehele positieve getallen tot en met 48 cijfers te ondersteunen (zowel voor de invoer als voor de uitvoer).

De berekeningen die de rekenmachine moet kunnen maken zijn:

• Optellen ( + )
• Aftrekken ( - )
• Vermenigvuldigen ( * )
• Delen ( - )

[list][/list]

Voorbeelden

Invoer: 333333333333333333333333333333333333333333333333 * 3
Uitvoer: 999999999999999999999999999999999999999999999999

Invoer: 1234567890123456789 + 1234567890123456789
Uitvoer: 2469135780246913578

Invoer: 999999999999999999999999999999999999999999 - 999999999999999999999999999999999999999998
Uitvoer: 1

Invoer: 888888888888888888888888888888888888888888888888 / 4
Uitvoer: 222222222222222222222222222222222222222222222222[list][/list]

Overige aandachtspunten

Indien (bij een deling) de uitkomst een kommagetal zou worden dient deze naar beneden afgerond te worden.

De invoermethode mag zelf gekozen worden, zolang die twee getallen en de rekenbewerking ingevoerd kan worden.

Misschien dubbelop maar toch: De getallen zijn gewone decimale getallen van maximaal 48 cijfers, zonder komma en ze zijn altijd positief.

Indien het uitkomstgetal langer wordt dan 48 cijfers hoeft de berekening ook niet verder uitgevoerd te worden want dat voldoet niet aan de opdracht.

Succes !

[Sebazzz]

.NET 4 BigInteger class hoppa

[Domdo]

Dit is wat ik er van gemaakt heb

Java:

    public String BigInteger calc(String l, char f, String r) throws Exception
    {
    return calc(new BigInteger(l), f, new BigInteger(r)).toString(10);
    }

    public static BigInteger calc(BigInteger l, char f, BigInteger r) throws Exception
    {
    switch (f)
    {
        case '*':
        return l.multiply(r);
        case '/':
        return l.divide(r);
        case '-':
        return l.subtract(r);
        case '+':
        return l.add(r);
    }
    throw new Exception("Blah");
    }

Werkt in ieder geval tot 5000 cijfers en ik denk nog wel tot meer cijfers.

[Onbekend]

't Is natuurlijk wel de bedoeling dat je zelf iets bedenkt hiervoor i.p.v. een bestaande classe te gebruiken.
Als ik had geweten dat .NET 4 die functionaliteit standaard aan boord had, had ik er wel in gezet dat je die niet mocht gebruiken.

[Verwijderd]

Misschien is het een optie om als opdracht erbij dat de calculator ook wetenschappelijke berekeningen moet kunnen?

[CoolGamer]

Een mogelijke oplossing, gewoon het getal meegeven als String.

Java:

public class Calculator {
    public static String add(String numb1, String numb2) {
        int numbLength = Math.max(numb1.length(), numb2.length());
        StringBuilder result = new StringBuilder();
        boolean carry = false;
        for (int i = 0; i <= numbLength; i++) {
            int n1 = readChar(numb1, i);
            int n2 = readChar(numb2, i);
            int subres = n1 + n2;
            if (carry) subres++;
            carry = subres >= 10;
            if (carry) subres -= 10;
            result.insert(0, (char) (subres + '0'));
        }
        return trimZero(result.toString());
    }
    public static String multiply(String numb1, String numb2) {
        String result = "0";
        String counter = trimZero(numb2);
        while (!counter.equals("0")) {
            result = add(result, numb1);
            counter = minus(counter, "1");
        }
        return result;
    }
    public static String minus(String numb1, String numb2) {
        int numbLength = Math.max(numb1.length(), numb2.length());
        StringBuilder result = new StringBuilder();

        boolean carry = false;
        for (int i = 0; i < numbLength; i++) {
            int n1 = readChar(numb1, i);
            int n2 = readChar(numb2, i);
            int subres = n1 - n2;
            if (carry) subres--;            
            carry = subres < 0;
            if (carry) subres += 10;
            result.insert(0, (char) (subres + '0'));
        }
        if (carry) return "negative";
        return trimZero(result.toString());
    }
    public static String divide(String numb1, String numb2) {
        String divisor = trimZero(numb2);
        if (divisor.equals("0")) return "divide by zero";
        String result = "0";
        String counter = numb1;
        while (true) {
            counter = minus(counter, divisor);
            if (counter.equals("negative")) break;
            result = add(result, "1");
        }
        return result;
    }
    private static int readChar(String numb, int pos) {
        if (pos >= numb.length()) return 0;
        return numb.charAt(numb.length() - 1 - pos) - '0';
    }
    private static String trimZero(String str) {
        if (str.length() == 0) return "0";
        if (str.charAt(0) == '0') return trimZero(str.substring(1));
        return str;
    }
}

[Soultaker]

Een oplossing in C: klik (Misschien maak ik 'm morgen nog wat netter.)

@TheCoolGamer: al eens geprobeerd twee getallen van 24 cijfers elk te vermenigvuldigen (of te delen)?

[The Great HooD]

Beste tweakers

Ik zit een soort van vast met Java...
Ik heb een lijst met getallen, nu wil ik deze getallen optellen en dan het gemiddelde ervan uitrekenen.
Is er een manier met java waardoor ik deze lijst bij elkaar kan optellen, want nu is het 1 hele grote string...

[Woy]

The Great HooD schreef op maandag 21 december 2009 @ 15:13:
Beste tweakers

Ik zit een soort van vast met Java...
Ik heb een lijst met getallen, nu wil ik deze getallen optellen en dan het gemiddelde ervan uitrekenen.
Is er een manier met java waardoor ik deze lijst bij elkaar kan optellen, want nu is het 1 hele grote string...

Ja die is er.

Nee deze vraag hoort niet in dit topic thuis! En op de manier dat je hem nu stelt eigenlijk totaal niet op GoT. Je kunt natuurlijk wel een eigen topic starten, maar lees dan wel even het beleid, en De Quickstart door, anders zit je topic zo weer op slot.